1/* 2 * H.264 encoding using the x264 library 3 * Copyright (C) 2005 Mans Rullgard <mans@mansr.com> 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22#include "config_components.h" 23 24#include "libavutil/eval.h" 25#include "libavutil/internal.h" 26#include "libavutil/opt.h" 27#include "libavutil/mem.h" 28#include "libavutil/pixdesc.h" 29#include "libavutil/stereo3d.h" 30#include "libavutil/time.h" 31#include "libavutil/intreadwrite.h" 32#include "avcodec.h" 33#include "codec_internal.h" 34#include "encode.h" 35#include "internal.h" 36#include "packet_internal.h" 37#include "atsc_a53.h" 38#include "sei.h" 39 40#include <x264.h> 41#include <float.h> 42#include <math.h> 43#include <stdio.h> 44#include <stdlib.h> 45#include <string.h> 46 47// from x264.h, for quant_offsets, Macroblocks are 16x16 48// blocks of pixels (with respect to the luma plane) 49#define MB_SIZE 16 50 51typedef struct X264Opaque { 52 int64_t reordered_opaque; 53 int64_t wallclock; 54} X264Opaque; 55 56typedef struct X264Context { 57 AVClass *class; 58 x264_param_t params; 59 x264_t *enc; 60 x264_picture_t pic; 61 uint8_t *sei; 62 int sei_size; 63 char *preset; 64 char *tune; 65 const char *profile; 66 char *profile_opt; 67 char *level; 68 int fastfirstpass; 69 char *wpredp; 70 char *x264opts; 71 float crf; 72 float crf_max; 73 int cqp; 74 int aq_mode; 75 float aq_strength; 76 char *psy_rd; 77 int psy; 78 int rc_lookahead; 79 int weightp; 80 int weightb; 81 int ssim; 82 int intra_refresh; 83 int bluray_compat; 84 int b_bias; 85 int b_pyramid; 86 int mixed_refs; 87 int dct8x8; 88 int fast_pskip; 89 int aud; 90 int mbtree; 91 char *deblock; 92 float cplxblur; 93 char *partitions; 94 int direct_pred; 95 int slice_max_size; 96 char *stats; 97 int nal_hrd; 98 int avcintra_class; 99 int motion_est; 100 int forced_idr; 101 int coder; 102 int a53_cc; 103 int b_frame_strategy; 104 int chroma_offset; 105 int scenechange_threshold; 106 int noise_reduction; 107 int udu_sei; 108 109 AVDictionary *x264_params; 110 111 int nb_reordered_opaque, next_reordered_opaque; 112 X264Opaque *reordered_opaque; 113 114 /** 115 * If the encoder does not support ROI then warn the first time we 116 * encounter a frame with ROI side data. 117 */ 118 int roi_warned; 119} X264Context; 120 121static void X264_log(void *p, int level, const char *fmt, va_list args) 122{ 123 static const int level_map[] = { 124 [X264_LOG_ERROR] = AV_LOG_ERROR, 125 [X264_LOG_WARNING] = AV_LOG_WARNING, 126 [X264_LOG_INFO] = AV_LOG_INFO, 127 [X264_LOG_DEBUG] = AV_LOG_DEBUG 128 }; 129 130 if (level < 0 || level > X264_LOG_DEBUG) 131 return; 132 133 av_vlog(p, level_map[level], fmt, args); 134} 135 136 137static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, 138 const x264_nal_t *nals, int nnal) 139{ 140 X264Context *x4 = ctx->priv_data; 141 uint8_t *p; 142 uint64_t size = x4->sei_size; 143 int ret; 144 145 if (!nnal) 146 return 0; 147 148 for (int i = 0; i < nnal; i++) { 149 size += nals[i].i_payload; 150 /* ff_get_encode_buffer() accepts an int64_t and 151 * so we need to make sure that no overflow happens before 152 * that. With 32bit ints this is automatically true. */ 153#if INT_MAX > INT64_MAX / INT_MAX - 1 154 if ((int64_t)size < 0) 155 return AVERROR(ERANGE); 156#endif 157 } 158 159 if ((ret = ff_get_encode_buffer(ctx, pkt, size, 0)) < 0) 160 return ret; 161 162 p = pkt->data; 163 164 /* Write the SEI as part of the first frame. */ 165 if (x4->sei_size > 0) { 166 memcpy(p, x4->sei, x4->sei_size); 167 p += x4->sei_size; 168 size -= x4->sei_size; 169 x4->sei_size = 0; 170 av_freep(&x4->sei); 171 } 172 173 /* x264 guarantees the payloads of the NALs 174 * to be sequential in memory. */ 175 memcpy(p, nals[0].p_payload, size); 176 177 return 1; 178} 179 180static int avfmt2_num_planes(int avfmt) 181{ 182 switch (avfmt) { 183 case AV_PIX_FMT_YUV420P: 184 case AV_PIX_FMT_YUVJ420P: 185 case AV_PIX_FMT_YUV420P9: 186 case AV_PIX_FMT_YUV420P10: 187 case AV_PIX_FMT_YUV444P: 188 return 3; 189 190 case AV_PIX_FMT_BGR0: 191 case AV_PIX_FMT_BGR24: 192 case AV_PIX_FMT_RGB24: 193 case AV_PIX_FMT_GRAY8: 194 case AV_PIX_FMT_GRAY10: 195 return 1; 196 197 default: 198 return 3; 199 } 200} 201 202static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame) 203{ 204 X264Context *x4 = ctx->priv_data; 205 AVFrameSideData *side_data; 206 207 208 if (x4->avcintra_class < 0) { 209 if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) { 210 211 x4->params.b_tff = frame->top_field_first; 212 x264_encoder_reconfig(x4->enc, &x4->params); 213 } 214 if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) { 215 x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den; 216 x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num; 217 x264_encoder_reconfig(x4->enc, &x4->params); 218 } 219 220 if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 || 221 x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) { 222 x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000; 223 x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000; 224 x264_encoder_reconfig(x4->enc, &x4->params); 225 } 226 227 if (x4->params.rc.i_rc_method == X264_RC_ABR && 228 x4->params.rc.i_bitrate != ctx->bit_rate / 1000) { 229 x4->params.rc.i_bitrate = ctx->bit_rate / 1000; 230 x264_encoder_reconfig(x4->enc, &x4->params); 231 } 232 233 if (x4->crf >= 0 && 234 x4->params.rc.i_rc_method == X264_RC_CRF && 235 x4->params.rc.f_rf_constant != x4->crf) { 236 x4->params.rc.f_rf_constant = x4->crf; 237 x264_encoder_reconfig(x4->enc, &x4->params); 238 } 239 240 if (x4->params.rc.i_rc_method == X264_RC_CQP && 241 x4->cqp >= 0 && 242 x4->params.rc.i_qp_constant != x4->cqp) { 243 x4->params.rc.i_qp_constant = x4->cqp; 244 x264_encoder_reconfig(x4->enc, &x4->params); 245 } 246 247 if (x4->crf_max >= 0 && 248 x4->params.rc.f_rf_constant_max != x4->crf_max) { 249 x4->params.rc.f_rf_constant_max = x4->crf_max; 250 x264_encoder_reconfig(x4->enc, &x4->params); 251 } 252 } 253 254 side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_STEREO3D); 255 if (side_data) { 256 AVStereo3D *stereo = (AVStereo3D *)side_data->data; 257 int fpa_type; 258 259 switch (stereo->type) { 260 case AV_STEREO3D_CHECKERBOARD: 261 fpa_type = 0; 262 break; 263 case AV_STEREO3D_COLUMNS: 264 fpa_type = 1; 265 break; 266 case AV_STEREO3D_LINES: 267 fpa_type = 2; 268 break; 269 case AV_STEREO3D_SIDEBYSIDE: 270 fpa_type = 3; 271 break; 272 case AV_STEREO3D_TOPBOTTOM: 273 fpa_type = 4; 274 break; 275 case AV_STEREO3D_FRAMESEQUENCE: 276 fpa_type = 5; 277 break; 278#if X264_BUILD >= 145 279 case AV_STEREO3D_2D: 280 fpa_type = 6; 281 break; 282#endif 283 default: 284 fpa_type = -1; 285 break; 286 } 287 288 /* Inverted mode is not supported by x264 */ 289 if (stereo->flags & AV_STEREO3D_FLAG_INVERT) { 290 av_log(ctx, AV_LOG_WARNING, 291 "Ignoring unsupported inverted stereo value %d\n", fpa_type); 292 fpa_type = -1; 293 } 294 295 if (fpa_type != x4->params.i_frame_packing) { 296 x4->params.i_frame_packing = fpa_type; 297 x264_encoder_reconfig(x4->enc, &x4->params); 298 } 299 } 300} 301 302static void free_picture(AVCodecContext *ctx) 303{ 304 X264Context *x4 = ctx->priv_data; 305 x264_picture_t *pic = &x4->pic; 306 307 for (int i = 0; i < pic->extra_sei.num_payloads; i++) 308 av_free(pic->extra_sei.payloads[i].payload); 309 av_freep(&pic->extra_sei.payloads); 310 av_freep(&pic->prop.quant_offsets); 311 pic->extra_sei.num_payloads = 0; 312} 313 314static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, 315 int *got_packet) 316{ 317 X264Context *x4 = ctx->priv_data; 318 x264_nal_t *nal; 319 int nnal, i, ret; 320 x264_picture_t pic_out = {0}; 321 int pict_type; 322 int bit_depth; 323 int64_t wallclock = 0; 324 X264Opaque *out_opaque; 325 AVFrameSideData *sd; 326 327 x264_picture_init( &x4->pic ); 328 x4->pic.img.i_csp = x4->params.i_csp; 329#if X264_BUILD >= 153 330 bit_depth = x4->params.i_bitdepth; 331#else 332 bit_depth = x264_bit_depth; 333#endif 334 if (bit_depth > 8) 335 x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH; 336 x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt); 337 338 if (frame) { 339 x264_sei_t *sei = &x4->pic.extra_sei; 340 unsigned int sei_data_size = 0; 341 342 for (i = 0; i < x4->pic.img.i_plane; i++) { 343 x4->pic.img.plane[i] = frame->data[i]; 344 x4->pic.img.i_stride[i] = frame->linesize[i]; 345 } 346 347 x4->pic.i_pts = frame->pts; 348 349 x4->reordered_opaque[x4->next_reordered_opaque].reordered_opaque = frame->reordered_opaque; 350 x4->reordered_opaque[x4->next_reordered_opaque].wallclock = wallclock; 351 if (ctx->export_side_data & AV_CODEC_EXPORT_DATA_PRFT) 352 x4->reordered_opaque[x4->next_reordered_opaque].wallclock = av_gettime(); 353 x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque]; 354 x4->next_reordered_opaque++; 355 x4->next_reordered_opaque %= x4->nb_reordered_opaque; 356 357 switch (frame->pict_type) { 358 case AV_PICTURE_TYPE_I: 359 x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR 360 : X264_TYPE_KEYFRAME; 361 break; 362 case AV_PICTURE_TYPE_P: 363 x4->pic.i_type = X264_TYPE_P; 364 break; 365 case AV_PICTURE_TYPE_B: 366 x4->pic.i_type = X264_TYPE_B; 367 break; 368 default: 369 x4->pic.i_type = X264_TYPE_AUTO; 370 break; 371 } 372 reconfig_encoder(ctx, frame); 373 374 if (x4->a53_cc) { 375 void *sei_data; 376 size_t sei_size; 377 378 ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size); 379 if (ret < 0) { 380 av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n"); 381 } else if (sei_data) { 382 x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0])); 383 if (x4->pic.extra_sei.payloads == NULL) { 384 av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n"); 385 av_free(sei_data); 386 } else { 387 x4->pic.extra_sei.sei_free = av_free; 388 389 x4->pic.extra_sei.payloads[0].payload_size = sei_size; 390 x4->pic.extra_sei.payloads[0].payload = sei_data; 391 x4->pic.extra_sei.num_payloads = 1; 392 x4->pic.extra_sei.payloads[0].payload_type = 4; 393 } 394 } 395 } 396 397 sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST); 398 if (sd) { 399 if (x4->params.rc.i_aq_mode == X264_AQ_NONE) { 400 if (!x4->roi_warned) { 401 x4->roi_warned = 1; 402 av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n"); 403 } 404 } else { 405 if (frame->interlaced_frame == 0) { 406 int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE; 407 int mby = (frame->height + MB_SIZE - 1) / MB_SIZE; 408 int qp_range = 51 + 6 * (bit_depth - 8); 409 int nb_rois; 410 const AVRegionOfInterest *roi; 411 uint32_t roi_size; 412 float *qoffsets; 413 414 roi = (const AVRegionOfInterest*)sd->data; 415 roi_size = roi->self_size; 416 if (!roi_size || sd->size % roi_size != 0) { 417 free_picture(ctx); 418 av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n"); 419 return AVERROR(EINVAL); 420 } 421 nb_rois = sd->size / roi_size; 422 423 qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets)); 424 if (!qoffsets) { 425 free_picture(ctx); 426 return AVERROR(ENOMEM); 427 } 428 // This list must be iterated in reverse because the first 429 // region in the list applies when regions overlap. 430 for (int i = nb_rois - 1; i >= 0; i--) { 431 int startx, endx, starty, endy; 432 float qoffset; 433 434 roi = (const AVRegionOfInterest*)(sd->data + roi_size * i); 435 436 starty = FFMIN(mby, roi->top / MB_SIZE); 437 endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE); 438 startx = FFMIN(mbx, roi->left / MB_SIZE); 439 endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE); 440 441 if (roi->qoffset.den == 0) { 442 av_free(qoffsets); 443 free_picture(ctx); 444 av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n"); 445 return AVERROR(EINVAL); 446 } 447 qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den; 448 qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range); 449 450 for (int y = starty; y < endy; y++) { 451 for (int x = startx; x < endx; x++) { 452 qoffsets[x + y*mbx] = qoffset; 453 } 454 } 455 } 456 457 x4->pic.prop.quant_offsets = qoffsets; 458 x4->pic.prop.quant_offsets_free = av_free; 459 } else { 460 if (!x4->roi_warned) { 461 x4->roi_warned = 1; 462 av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n"); 463 } 464 } 465 } 466 } 467 468 if (x4->udu_sei) { 469 for (int j = 0; j < frame->nb_side_data; j++) { 470 AVFrameSideData *side_data = frame->side_data[j]; 471 void *tmp; 472 x264_sei_payload_t *sei_payload; 473 if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED) 474 continue; 475 tmp = av_fast_realloc(sei->payloads, &sei_data_size, (sei->num_payloads + 1) * sizeof(*sei_payload)); 476 if (!tmp) { 477 free_picture(ctx); 478 return AVERROR(ENOMEM); 479 } 480 sei->payloads = tmp; 481 sei->sei_free = av_free; 482 sei_payload = &sei->payloads[sei->num_payloads]; 483 sei_payload->payload = av_memdup(side_data->data, side_data->size); 484 if (!sei_payload->payload) { 485 free_picture(ctx); 486 return AVERROR(ENOMEM); 487 } 488 sei_payload->payload_size = side_data->size; 489 sei_payload->payload_type = SEI_TYPE_USER_DATA_UNREGISTERED; 490 sei->num_payloads++; 491 } 492 } 493 } 494 495 do { 496 if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0) 497 return AVERROR_EXTERNAL; 498 499 ret = encode_nals(ctx, pkt, nal, nnal); 500 if (ret < 0) 501 return ret; 502 } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc)); 503 504 if (!ret) 505 return 0; 506 507 pkt->pts = pic_out.i_pts; 508 pkt->dts = pic_out.i_dts; 509 510 out_opaque = pic_out.opaque; 511 if (out_opaque >= x4->reordered_opaque && 512 out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) { 513 ctx->reordered_opaque = out_opaque->reordered_opaque; 514 wallclock = out_opaque->wallclock; 515 } else { 516 // Unexpected opaque pointer on picture output 517 ctx->reordered_opaque = 0; 518 } 519 520 switch (pic_out.i_type) { 521 case X264_TYPE_IDR: 522 case X264_TYPE_I: 523 pict_type = AV_PICTURE_TYPE_I; 524 break; 525 case X264_TYPE_P: 526 pict_type = AV_PICTURE_TYPE_P; 527 break; 528 case X264_TYPE_B: 529 case X264_TYPE_BREF: 530 pict_type = AV_PICTURE_TYPE_B; 531 break; 532 default: 533 av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n"); 534 return AVERROR_EXTERNAL; 535 } 536 537 pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe; 538 if (ret) { 539 ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type); 540 if (wallclock) 541 ff_side_data_set_prft(pkt, wallclock); 542 } 543 544 *got_packet = ret; 545 return 0; 546} 547 548static av_cold int X264_close(AVCodecContext *avctx) 549{ 550 X264Context *x4 = avctx->priv_data; 551 552 av_freep(&x4->sei); 553 av_freep(&x4->reordered_opaque); 554 555#if X264_BUILD >= 161 556 x264_param_cleanup(&x4->params); 557#endif 558 559 if (x4->enc) { 560 x264_encoder_close(x4->enc); 561 x4->enc = NULL; 562 } 563 564 return 0; 565} 566 567static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param) 568{ 569 X264Context *x4 = avctx->priv_data; 570 int ret; 571 572 if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { 573 if (ret == X264_PARAM_BAD_NAME) { 574 av_log(avctx, AV_LOG_ERROR, 575 "bad option '%s': '%s'\n", opt, param); 576 ret = AVERROR(EINVAL); 577#if X264_BUILD >= 161 578 } else if (ret == X264_PARAM_ALLOC_FAILED) { 579 av_log(avctx, AV_LOG_ERROR, 580 "out of memory parsing option '%s': '%s'\n", opt, param); 581 ret = AVERROR(ENOMEM); 582#endif 583 } else { 584 av_log(avctx, AV_LOG_ERROR, 585 "bad value for '%s': '%s'\n", opt, param); 586 ret = AVERROR(EINVAL); 587 } 588 } 589 590 return ret; 591} 592 593static int convert_pix_fmt(enum AVPixelFormat pix_fmt) 594{ 595 switch (pix_fmt) { 596 case AV_PIX_FMT_YUV420P: 597 case AV_PIX_FMT_YUVJ420P: 598 case AV_PIX_FMT_YUV420P9: 599 case AV_PIX_FMT_YUV420P10: return X264_CSP_I420; 600 case AV_PIX_FMT_YUV422P: 601 case AV_PIX_FMT_YUVJ422P: 602 case AV_PIX_FMT_YUV422P10: return X264_CSP_I422; 603 case AV_PIX_FMT_YUV444P: 604 case AV_PIX_FMT_YUVJ444P: 605 case AV_PIX_FMT_YUV444P9: 606 case AV_PIX_FMT_YUV444P10: return X264_CSP_I444; 607 case AV_PIX_FMT_BGR0: 608 return X264_CSP_BGRA; 609 case AV_PIX_FMT_BGR24: 610 return X264_CSP_BGR; 611 612 case AV_PIX_FMT_RGB24: 613 return X264_CSP_RGB; 614 case AV_PIX_FMT_NV12: return X264_CSP_NV12; 615 case AV_PIX_FMT_NV16: 616 case AV_PIX_FMT_NV20: return X264_CSP_NV16; 617#ifdef X264_CSP_NV21 618 case AV_PIX_FMT_NV21: return X264_CSP_NV21; 619#endif 620#ifdef X264_CSP_I400 621 case AV_PIX_FMT_GRAY8: 622 case AV_PIX_FMT_GRAY10: return X264_CSP_I400; 623#endif 624 }; 625 return 0; 626} 627 628#define PARSE_X264_OPT(name, var)\ 629 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\ 630 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\ 631 return AVERROR(EINVAL);\ 632 } 633 634static av_cold int X264_init(AVCodecContext *avctx) 635{ 636 X264Context *x4 = avctx->priv_data; 637 AVCPBProperties *cpb_props; 638 int sw,sh; 639 int ret; 640 641 if (avctx->global_quality > 0) 642 av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n"); 643 644#if CONFIG_LIBX262_ENCODER 645 if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) { 646 x4->params.b_mpeg2 = 1; 647 x264_param_default_mpeg2(&x4->params); 648 } else 649#endif 650 x264_param_default(&x4->params); 651 652 x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER; 653 654 if (x4->preset || x4->tune) 655 if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) { 656 int i; 657 av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune); 658 av_log(avctx, AV_LOG_INFO, "Possible presets:"); 659 for (i = 0; x264_preset_names[i]; i++) 660 av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]); 661 av_log(avctx, AV_LOG_INFO, "\n"); 662 av_log(avctx, AV_LOG_INFO, "Possible tunes:"); 663 for (i = 0; x264_tune_names[i]; i++) 664 av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]); 665 av_log(avctx, AV_LOG_INFO, "\n"); 666 return AVERROR(EINVAL); 667 } 668 669 if (avctx->level > 0) 670 x4->params.i_level_idc = avctx->level; 671 672 x4->params.pf_log = X264_log; 673 x4->params.p_log_private = avctx; 674 x4->params.i_log_level = X264_LOG_DEBUG; 675 x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt); 676#if X264_BUILD >= 153 677 x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth; 678#endif 679 680 PARSE_X264_OPT("weightp", wpredp); 681 682 if (avctx->bit_rate) { 683 if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) { 684 av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX); 685 return AVERROR(EINVAL); 686 } 687 x4->params.rc.i_bitrate = avctx->bit_rate / 1000; 688 x4->params.rc.i_rc_method = X264_RC_ABR; 689 } 690 x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000; 691 x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000; 692 x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1; 693 if (avctx->flags & AV_CODEC_FLAG_PASS2) { 694 x4->params.rc.b_stat_read = 1; 695 } else { 696 if (x4->crf >= 0) { 697 x4->params.rc.i_rc_method = X264_RC_CRF; 698 x4->params.rc.f_rf_constant = x4->crf; 699 } else if (x4->cqp >= 0) { 700 x4->params.rc.i_rc_method = X264_RC_CQP; 701 x4->params.rc.i_qp_constant = x4->cqp; 702 } 703 704 if (x4->crf_max >= 0) 705 x4->params.rc.f_rf_constant_max = x4->crf_max; 706 } 707 708 if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 && 709 (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) { 710 x4->params.rc.f_vbv_buffer_init = 711 (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size; 712 } 713 714 PARSE_X264_OPT("level", level); 715 716 if (avctx->i_quant_factor > 0) 717 x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor); 718 if (avctx->b_quant_factor > 0) 719 x4->params.rc.f_pb_factor = avctx->b_quant_factor; 720 721 if (x4->chroma_offset) 722 x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset; 723 724 if (avctx->gop_size >= 0) 725 x4->params.i_keyint_max = avctx->gop_size; 726 if (avctx->max_b_frames >= 0) 727 x4->params.i_bframe = avctx->max_b_frames; 728 729 if (x4->scenechange_threshold >= 0) 730 x4->params.i_scenecut_threshold = x4->scenechange_threshold; 731 732 if (avctx->qmin >= 0) 733 x4->params.rc.i_qp_min = avctx->qmin; 734 if (avctx->qmax >= 0) 735 x4->params.rc.i_qp_max = avctx->qmax; 736 if (avctx->max_qdiff >= 0) 737 x4->params.rc.i_qp_step = avctx->max_qdiff; 738 if (avctx->qblur >= 0) 739 x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */ 740 if (avctx->qcompress >= 0) 741 x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */ 742 if (avctx->refs >= 0) 743 x4->params.i_frame_reference = avctx->refs; 744 else if (x4->params.i_level_idc > 0) { 745 int i; 746 int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4); 747 int scale = X264_BUILD < 129 ? 384 : 1; 748 749 for (i = 0; i<x264_levels[i].level_idc; i++) 750 if (x264_levels[i].level_idc == x4->params.i_level_idc) 751 x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference); 752 } 753 754 if (avctx->trellis >= 0) 755 x4->params.analyse.i_trellis = avctx->trellis; 756 if (avctx->me_range >= 0) 757 x4->params.analyse.i_me_range = avctx->me_range; 758 if (x4->noise_reduction >= 0) 759 x4->params.analyse.i_noise_reduction = x4->noise_reduction; 760 if (avctx->me_subpel_quality >= 0) 761 x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality; 762 if (avctx->keyint_min >= 0) 763 x4->params.i_keyint_min = avctx->keyint_min; 764 if (avctx->me_cmp >= 0) 765 x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA; 766 767 if (x4->aq_mode >= 0) 768 x4->params.rc.i_aq_mode = x4->aq_mode; 769 if (x4->aq_strength >= 0) 770 x4->params.rc.f_aq_strength = x4->aq_strength; 771 PARSE_X264_OPT("psy-rd", psy_rd); 772 PARSE_X264_OPT("deblock", deblock); 773 PARSE_X264_OPT("partitions", partitions); 774 PARSE_X264_OPT("stats", stats); 775 if (x4->psy >= 0) 776 x4->params.analyse.b_psy = x4->psy; 777 if (x4->rc_lookahead >= 0) 778 x4->params.rc.i_lookahead = x4->rc_lookahead; 779 if (x4->weightp >= 0) 780 x4->params.analyse.i_weighted_pred = x4->weightp; 781 if (x4->weightb >= 0) 782 x4->params.analyse.b_weighted_bipred = x4->weightb; 783 if (x4->cplxblur >= 0) 784 x4->params.rc.f_complexity_blur = x4->cplxblur; 785 786 if (x4->ssim >= 0) 787 x4->params.analyse.b_ssim = x4->ssim; 788 if (x4->intra_refresh >= 0) 789 x4->params.b_intra_refresh = x4->intra_refresh; 790 if (x4->bluray_compat >= 0) { 791 x4->params.b_bluray_compat = x4->bluray_compat; 792 x4->params.b_vfr_input = 0; 793 } 794 if (x4->avcintra_class >= 0) 795#if X264_BUILD >= 142 796 x4->params.i_avcintra_class = x4->avcintra_class; 797#else 798 av_log(avctx, AV_LOG_ERROR, 799 "x264 too old for AVC Intra, at least version 142 needed\n"); 800#endif 801 802 if (x4->avcintra_class > 200) { 803#if X264_BUILD < 164 804 av_log(avctx, AV_LOG_ERROR, 805 "x264 too old for AVC Intra 300/480, at least version 164 needed\n"); 806 return AVERROR(EINVAL); 807#else 808 /* AVC-Intra 300/480 only supported by Sony XAVC flavor */ 809 x4->params.i_avcintra_flavor = X264_AVCINTRA_FLAVOR_SONY; 810#endif 811 } 812 813 if (x4->b_bias != INT_MIN) 814 x4->params.i_bframe_bias = x4->b_bias; 815 if (x4->b_pyramid >= 0) 816 x4->params.i_bframe_pyramid = x4->b_pyramid; 817 if (x4->mixed_refs >= 0) 818 x4->params.analyse.b_mixed_references = x4->mixed_refs; 819 if (x4->dct8x8 >= 0) 820 x4->params.analyse.b_transform_8x8 = x4->dct8x8; 821 if (x4->fast_pskip >= 0) 822 x4->params.analyse.b_fast_pskip = x4->fast_pskip; 823 if (x4->aud >= 0) 824 x4->params.b_aud = x4->aud; 825 if (x4->mbtree >= 0) 826 x4->params.rc.b_mb_tree = x4->mbtree; 827 if (x4->direct_pred >= 0) 828 x4->params.analyse.i_direct_mv_pred = x4->direct_pred; 829 830 if (x4->slice_max_size >= 0) 831 x4->params.i_slice_max_size = x4->slice_max_size; 832 833 if (x4->fastfirstpass) 834 x264_param_apply_fastfirstpass(&x4->params); 835 836 x4->profile = x4->profile_opt; 837 /* Allow specifying the x264 profile through AVCodecContext. */ 838 if (!x4->profile) 839 switch (avctx->profile) { 840 case FF_PROFILE_H264_BASELINE: 841 x4->profile = "baseline"; 842 break; 843 case FF_PROFILE_H264_HIGH: 844 x4->profile = "high"; 845 break; 846 case FF_PROFILE_H264_HIGH_10: 847 x4->profile = "high10"; 848 break; 849 case FF_PROFILE_H264_HIGH_422: 850 x4->profile = "high422"; 851 break; 852 case FF_PROFILE_H264_HIGH_444: 853 x4->profile = "high444"; 854 break; 855 case FF_PROFILE_H264_MAIN: 856 x4->profile = "main"; 857 break; 858 default: 859 break; 860 } 861 862 if (x4->nal_hrd >= 0) 863 x4->params.i_nal_hrd = x4->nal_hrd; 864 865 if (x4->motion_est >= 0) 866 x4->params.analyse.i_me_method = x4->motion_est; 867 868 if (x4->coder >= 0) 869 x4->params.b_cabac = x4->coder; 870 871 if (x4->b_frame_strategy >= 0) 872 x4->params.i_bframe_adaptive = x4->b_frame_strategy; 873 874 if (x4->profile) 875 if (x264_param_apply_profile(&x4->params, x4->profile) < 0) { 876 int i; 877 av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile); 878 av_log(avctx, AV_LOG_INFO, "Possible profiles:"); 879 for (i = 0; x264_profile_names[i]; i++) 880 av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]); 881 av_log(avctx, AV_LOG_INFO, "\n"); 882 return AVERROR(EINVAL); 883 } 884 885 x4->params.i_width = avctx->width; 886 x4->params.i_height = avctx->height; 887 av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096); 888 x4->params.vui.i_sar_width = sw; 889 x4->params.vui.i_sar_height = sh; 890 x4->params.i_timebase_den = avctx->time_base.den; 891 x4->params.i_timebase_num = avctx->time_base.num; 892 if (avctx->framerate.num > 0 && avctx->framerate.den > 0) { 893 x4->params.i_fps_num = avctx->framerate.num; 894 x4->params.i_fps_den = avctx->framerate.den; 895 } else { 896 x4->params.i_fps_num = avctx->time_base.den; 897 x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame; 898 } 899 900 x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR; 901 902 x4->params.i_threads = avctx->thread_count; 903 if (avctx->thread_type) 904 x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE; 905 906 x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT; 907 908 x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP); 909 910 x4->params.i_slice_count = avctx->slices; 911 912 if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED) 913 x4->params.vui.b_fullrange = avctx->color_range == AVCOL_RANGE_JPEG; 914 else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P || 915 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P || 916 avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) 917 x4->params.vui.b_fullrange = 1; 918 919 if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED) 920 x4->params.vui.i_colmatrix = avctx->colorspace; 921 if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) 922 x4->params.vui.i_colorprim = avctx->color_primaries; 923 if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED) 924 x4->params.vui.i_transfer = avctx->color_trc; 925 if (avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED) 926 x4->params.vui.i_chroma_loc = avctx->chroma_sample_location - 1; 927 928 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) 929 x4->params.b_repeat_headers = 0; 930 931 if(x4->x264opts){ 932 const char *p= x4->x264opts; 933 while(p){ 934 char param[4096]={0}, val[4096]={0}; 935 if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){ 936 ret = parse_opts(avctx, param, "1"); 937 if (ret < 0) 938 return ret; 939 } else { 940 ret = parse_opts(avctx, param, val); 941 if (ret < 0) 942 return ret; 943 } 944 p= strchr(p, ':'); 945 if (p) { 946 ++p; 947 } 948 } 949 } 950 951#if X264_BUILD >= 142 952 /* Separate headers not supported in AVC-Intra mode */ 953 if (x4->avcintra_class >= 0) 954 x4->params.b_repeat_headers = 1; 955#endif 956 957 { 958 AVDictionaryEntry *en = NULL; 959 while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) { 960 if ((ret = x264_param_parse(&x4->params, en->key, en->value)) < 0) { 961 av_log(avctx, AV_LOG_WARNING, 962 "Error parsing option '%s = %s'.\n", 963 en->key, en->value); 964#if X264_BUILD >= 161 965 if (ret == X264_PARAM_ALLOC_FAILED) 966 return AVERROR(ENOMEM); 967#endif 968 } 969 } 970 } 971 972 // update AVCodecContext with x264 parameters 973 avctx->has_b_frames = x4->params.i_bframe ? 974 x4->params.i_bframe_pyramid ? 2 : 1 : 0; 975 if (avctx->max_b_frames < 0) 976 avctx->max_b_frames = 0; 977 978 avctx->bit_rate = x4->params.rc.i_bitrate*1000LL; 979 980 x4->enc = x264_encoder_open(&x4->params); 981 if (!x4->enc) 982 return AVERROR_EXTERNAL; 983 984 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) { 985 x264_nal_t *nal; 986 uint8_t *p; 987 int nnal, s, i; 988 989 s = x264_encoder_headers(x4->enc, &nal, &nnal); 990 avctx->extradata = p = av_mallocz(s + AV_INPUT_BUFFER_PADDING_SIZE); 991 if (!p) 992 return AVERROR(ENOMEM); 993 994 for (i = 0; i < nnal; i++) { 995 /* Don't put the SEI in extradata. */ 996 if (nal[i].i_type == NAL_SEI) { 997 av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25); 998 x4->sei_size = nal[i].i_payload; 999 x4->sei = av_malloc(x4->sei_size); 1000 if (!x4->sei) 1001 return AVERROR(ENOMEM); 1002 memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload); 1003 continue; 1004 } 1005 memcpy(p, nal[i].p_payload, nal[i].i_payload); 1006 p += nal[i].i_payload; 1007 } 1008 avctx->extradata_size = p - avctx->extradata; 1009 } 1010 1011 cpb_props = ff_add_cpb_side_data(avctx); 1012 if (!cpb_props) 1013 return AVERROR(ENOMEM); 1014 cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000; 1015 cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL; 1016 cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL; 1017 1018 // Overestimate the reordered opaque buffer size, in case a runtime 1019 // reconfigure would increase the delay (which it shouldn't). 1020 x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17; 1021 x4->reordered_opaque = av_malloc_array(x4->nb_reordered_opaque, 1022 sizeof(*x4->reordered_opaque)); 1023 if (!x4->reordered_opaque) 1024 return AVERROR(ENOMEM); 1025 1026 return 0; 1027} 1028 1029static const enum AVPixelFormat pix_fmts_8bit[] = { 1030 AV_PIX_FMT_YUV420P, 1031 AV_PIX_FMT_YUVJ420P, 1032 AV_PIX_FMT_YUV422P, 1033 AV_PIX_FMT_YUVJ422P, 1034 AV_PIX_FMT_YUV444P, 1035 AV_PIX_FMT_YUVJ444P, 1036 AV_PIX_FMT_NV12, 1037 AV_PIX_FMT_NV16, 1038#ifdef X264_CSP_NV21 1039 AV_PIX_FMT_NV21, 1040#endif 1041 AV_PIX_FMT_NONE 1042}; 1043static const enum AVPixelFormat pix_fmts_9bit[] = { 1044 AV_PIX_FMT_YUV420P9, 1045 AV_PIX_FMT_YUV444P9, 1046 AV_PIX_FMT_NONE 1047}; 1048static const enum AVPixelFormat pix_fmts_10bit[] = { 1049 AV_PIX_FMT_YUV420P10, 1050 AV_PIX_FMT_YUV422P10, 1051 AV_PIX_FMT_YUV444P10, 1052 AV_PIX_FMT_NV20, 1053 AV_PIX_FMT_NONE 1054}; 1055static const enum AVPixelFormat pix_fmts_all[] = { 1056 AV_PIX_FMT_YUV420P, 1057 AV_PIX_FMT_YUVJ420P, 1058 AV_PIX_FMT_YUV422P, 1059 AV_PIX_FMT_YUVJ422P, 1060 AV_PIX_FMT_YUV444P, 1061 AV_PIX_FMT_YUVJ444P, 1062 AV_PIX_FMT_NV12, 1063 AV_PIX_FMT_NV16, 1064#ifdef X264_CSP_NV21 1065 AV_PIX_FMT_NV21, 1066#endif 1067 AV_PIX_FMT_YUV420P10, 1068 AV_PIX_FMT_YUV422P10, 1069 AV_PIX_FMT_YUV444P10, 1070 AV_PIX_FMT_NV20, 1071#ifdef X264_CSP_I400 1072 AV_PIX_FMT_GRAY8, 1073 AV_PIX_FMT_GRAY10, 1074#endif 1075 AV_PIX_FMT_NONE 1076}; 1077#if CONFIG_LIBX264RGB_ENCODER 1078static const enum AVPixelFormat pix_fmts_8bit_rgb[] = { 1079 AV_PIX_FMT_BGR0, 1080 AV_PIX_FMT_BGR24, 1081 AV_PIX_FMT_RGB24, 1082 AV_PIX_FMT_NONE 1083}; 1084#endif 1085 1086#if X264_BUILD < 153 1087static av_cold void X264_init_static(FFCodec *codec) 1088{ 1089 if (x264_bit_depth == 8) 1090 codec->p.pix_fmts = pix_fmts_8bit; 1091 else if (x264_bit_depth == 9) 1092 codec->p.pix_fmts = pix_fmts_9bit; 1093 else if (x264_bit_depth == 10) 1094 codec->p.pix_fmts = pix_fmts_10bit; 1095} 1096#endif 1097 1098#define OFFSET(x) offsetof(X264Context, x) 1099#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1100static const AVOption options[] = { 1101 { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE}, 1102 { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, 1103 { "profile", "Set profile restrictions (cf. x264 --fullhelp)", OFFSET(profile_opt), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, 1104 { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE}, 1105 {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, 1106 {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, 1107 {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, 1108 {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE}, 1109 {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, 1110 { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE }, 1111 { "crf_max", "In CRF mode, prevents VBV from lowering quality beyond this point.",OFFSET(crf_max), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE }, 1112 { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE }, 1113 { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"}, 1114 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" }, 1115 { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" }, 1116 { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" }, 1117#if X264_BUILD >= 144 1118 { "autovariance-biased", "Auto-variance AQ with bias to dark scenes", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE_BIASED}, INT_MIN, INT_MAX, VE, "aq_mode" }, 1119#endif 1120 { "aq-strength", "AQ strength. Reduces blocking and blurring in flat and textured areas.", OFFSET(aq_strength), AV_OPT_TYPE_FLOAT, {.dbl = -1}, -1, FLT_MAX, VE}, 1121 { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, 1122 { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE}, 1123 { "rc-lookahead", "Number of frames to look ahead for frametype and ratecontrol", OFFSET(rc_lookahead), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE }, 1124 { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, 1125 { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" }, 1126 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" }, 1127 { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" }, 1128 { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" }, 1129 { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, 1130 { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, 1131 { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, 1132 { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE }, 1133 { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" }, 1134 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" }, 1135 { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" }, 1136 { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" }, 1137 { "mixed-refs", "One reference per partition, as opposed to one reference per macroblock", OFFSET(mixed_refs), AV_OPT_TYPE_BOOL, { .i64 = -1}, -1, 1, VE }, 1138 { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, 1139 { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, 1140 { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, 1141 { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, 1142 { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, 1143 { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE}, 1144 { "partitions", "A comma-separated list of partitions to consider. " 1145 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, 1146 { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" }, 1147 { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" }, 1148 { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" }, 1149 { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" }, 1150 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" }, 1151 { "slice-max-size","Limit the size of each slice in bytes", OFFSET(slice_max_size),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE }, 1152 { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE }, 1153 { "nal-hrd", "Signal HRD information (requires vbv-bufsize; " 1154 "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" }, 1155 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" }, 1156 { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" }, 1157 { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" }, 1158 { "avcintra-class","AVC-Intra class 50/100/200/300/480", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 480 , VE}, 1159 { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"}, 1160 { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"}, 1161 { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" }, 1162 { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" }, 1163 { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" }, 1164 { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" }, 1165 { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" }, 1166 { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE }, 1167 { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" }, 1168 { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" }, 1169 { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" }, 1170 { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" }, 1171 { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" }, 1172 { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" }, 1173 { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE }, 1174 { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE }, 1175 { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE }, 1176 { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE }, 1177 { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, 1178 { "x264-params", "Override the x264 configuration using a :-separated list of key=value parameters", OFFSET(x264_params), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE }, 1179 { NULL }, 1180}; 1181 1182static const FFCodecDefault x264_defaults[] = { 1183 { "b", "0" }, 1184 { "bf", "-1" }, 1185 { "flags2", "0" }, 1186 { "g", "-1" }, 1187 { "i_qfactor", "-1" }, 1188 { "b_qfactor", "-1" }, 1189 { "qmin", "-1" }, 1190 { "qmax", "-1" }, 1191 { "qdiff", "-1" }, 1192 { "qblur", "-1" }, 1193 { "qcomp", "-1" }, 1194// { "rc_lookahead", "-1" }, 1195 { "refs", "-1" }, 1196 { "trellis", "-1" }, 1197 { "me_range", "-1" }, 1198 { "subq", "-1" }, 1199 { "keyint_min", "-1" }, 1200 { "cmp", "-1" }, 1201 { "threads", AV_STRINGIFY(X264_THREADS_AUTO) }, 1202 { "thread_type", "0" }, 1203 { "flags", "+cgop" }, 1204 { "rc_init_occupancy","-1" }, 1205 { NULL }, 1206}; 1207 1208#if CONFIG_LIBX264_ENCODER 1209static const AVClass x264_class = { 1210 .class_name = "libx264", 1211 .item_name = av_default_item_name, 1212 .option = options, 1213 .version = LIBAVUTIL_VERSION_INT, 1214}; 1215 1216#if X264_BUILD >= 153 1217const 1218#endif 1219FFCodec ff_libx264_encoder = { 1220 .p.name = "libx264", 1221 .p.long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), 1222 .p.type = AVMEDIA_TYPE_VIDEO, 1223 .p.id = AV_CODEC_ID_H264, 1224 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | 1225 AV_CODEC_CAP_OTHER_THREADS | 1226 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, 1227 .p.priv_class = &x264_class, 1228 .p.wrapper_name = "libx264", 1229 .priv_data_size = sizeof(X264Context), 1230 .init = X264_init, 1231 FF_CODEC_ENCODE_CB(X264_frame), 1232 .close = X264_close, 1233 .defaults = x264_defaults, 1234#if X264_BUILD < 153 1235 .init_static_data = X264_init_static, 1236#else 1237 .p.pix_fmts = pix_fmts_all, 1238#endif 1239 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS 1240#if X264_BUILD >= 158 1241 | FF_CODEC_CAP_INIT_THREADSAFE 1242#endif 1243 , 1244}; 1245#endif 1246 1247#if CONFIG_LIBX264RGB_ENCODER 1248static const AVClass rgbclass = { 1249 .class_name = "libx264rgb", 1250 .item_name = av_default_item_name, 1251 .option = options, 1252 .version = LIBAVUTIL_VERSION_INT, 1253}; 1254 1255const FFCodec ff_libx264rgb_encoder = { 1256 .p.name = "libx264rgb", 1257 .p.long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"), 1258 .p.type = AVMEDIA_TYPE_VIDEO, 1259 .p.id = AV_CODEC_ID_H264, 1260 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | 1261 AV_CODEC_CAP_OTHER_THREADS | 1262 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, 1263 .p.pix_fmts = pix_fmts_8bit_rgb, 1264 .p.priv_class = &rgbclass, 1265 .p.wrapper_name = "libx264", 1266 .priv_data_size = sizeof(X264Context), 1267 .init = X264_init, 1268 FF_CODEC_ENCODE_CB(X264_frame), 1269 .close = X264_close, 1270 .defaults = x264_defaults, 1271 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS 1272#if X264_BUILD >= 158 1273 | FF_CODEC_CAP_INIT_THREADSAFE 1274#endif 1275 , 1276}; 1277#endif 1278 1279#if CONFIG_LIBX262_ENCODER 1280static const AVClass X262_class = { 1281 .class_name = "libx262", 1282 .item_name = av_default_item_name, 1283 .option = options, 1284 .version = LIBAVUTIL_VERSION_INT, 1285}; 1286 1287const FFCodec ff_libx262_encoder = { 1288 .p.name = "libx262", 1289 .p.long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"), 1290 .p.type = AVMEDIA_TYPE_VIDEO, 1291 .p.id = AV_CODEC_ID_MPEG2VIDEO, 1292 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | 1293 AV_CODEC_CAP_OTHER_THREADS | 1294 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, 1295 .p.pix_fmts = pix_fmts_8bit, 1296 .p.priv_class = &X262_class, 1297 .p.wrapper_name = "libx264", 1298 .priv_data_size = sizeof(X264Context), 1299 .init = X264_init, 1300 FF_CODEC_ENCODE_CB(X264_frame), 1301 .close = X264_close, 1302 .defaults = x264_defaults, 1303 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS, 1304}; 1305#endif 1306