FFmpeg
libx264.c
Go to the documentation of this file.
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 "libavutil/eval.h"
23 #include "libavutil/internal.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/stereo3d.h"
28 #include "libavutil/intreadwrite.h"
29 #include "avcodec.h"
30 #include "internal.h"
31 
32 #if defined(_MSC_VER)
33 #define X264_API_IMPORTS 1
34 #endif
35 
36 #include <x264.h>
37 #include <float.h>
38 #include <math.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 
43 // from x264.h, for quant_offsets, Macroblocks are 16x16
44 // blocks of pixels (with respect to the luma plane)
45 #define MB_SIZE 16
46 
47 typedef struct X264Context {
48  AVClass *class;
49  x264_param_t params;
50  x264_t *enc;
51  x264_picture_t pic;
53  int sei_size;
54  char *preset;
55  char *tune;
56  char *profile;
57  char *level;
59  char *wpredp;
60  char *x264opts;
61  float crf;
62  float crf_max;
63  int cqp;
64  int aq_mode;
65  float aq_strength;
66  char *psy_rd;
67  int psy;
69  int weightp;
70  int weightb;
71  int ssim;
74  int b_bias;
75  int b_pyramid;
77  int dct8x8;
79  int aud;
80  int mbtree;
81  char *deblock;
82  float cplxblur;
83  char *partitions;
86  char *stats;
87  int nal_hrd;
91  int coder;
92  int a53_cc;
97 
98  char *x264_params;
99 
102 
103  /**
104  * If the encoder does not support ROI then warn the first time we
105  * encounter a frame with ROI side data.
106  */
108 } X264Context;
109 
110 static void X264_log(void *p, int level, const char *fmt, va_list args)
111 {
112  static const int level_map[] = {
113  [X264_LOG_ERROR] = AV_LOG_ERROR,
114  [X264_LOG_WARNING] = AV_LOG_WARNING,
115  [X264_LOG_INFO] = AV_LOG_INFO,
116  [X264_LOG_DEBUG] = AV_LOG_DEBUG
117  };
118 
119  if (level < 0 || level > X264_LOG_DEBUG)
120  return;
121 
122  av_vlog(p, level_map[level], fmt, args);
123 }
124 
125 
127  const x264_nal_t *nals, int nnal)
128 {
129  X264Context *x4 = ctx->priv_data;
130  uint8_t *p;
131  int i, size = x4->sei_size, ret;
132 
133  if (!nnal)
134  return 0;
135 
136  for (i = 0; i < nnal; i++)
137  size += nals[i].i_payload;
138 
139  if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)
140  return ret;
141 
142  p = pkt->data;
143 
144  /* Write the SEI as part of the first frame. */
145  if (x4->sei_size > 0 && nnal > 0) {
146  if (x4->sei_size > size) {
147  av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");
148  return -1;
149  }
150  memcpy(p, x4->sei, x4->sei_size);
151  p += x4->sei_size;
152  x4->sei_size = 0;
153  av_freep(&x4->sei);
154  }
155 
156  for (i = 0; i < nnal; i++){
157  memcpy(p, nals[i].p_payload, nals[i].i_payload);
158  p += nals[i].i_payload;
159  }
160 
161  return 1;
162 }
163 
164 static int avfmt2_num_planes(int avfmt)
165 {
166  switch (avfmt) {
167  case AV_PIX_FMT_YUV420P:
168  case AV_PIX_FMT_YUVJ420P:
169  case AV_PIX_FMT_YUV420P9:
171  case AV_PIX_FMT_YUV444P:
172  return 3;
173 
174  case AV_PIX_FMT_BGR0:
175  case AV_PIX_FMT_BGR24:
176  case AV_PIX_FMT_RGB24:
177  case AV_PIX_FMT_GRAY8:
178  case AV_PIX_FMT_GRAY10:
179  return 1;
180 
181  default:
182  return 3;
183  }
184 }
185 
187 {
188  X264Context *x4 = ctx->priv_data;
189  AVFrameSideData *side_data;
190 
191 
192  if (x4->avcintra_class < 0) {
193  if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
194 
195  x4->params.b_tff = frame->top_field_first;
196  x264_encoder_reconfig(x4->enc, &x4->params);
197  }
198  if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
199  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
200  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
201  x264_encoder_reconfig(x4->enc, &x4->params);
202  }
203 
204  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
205  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
206  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
207  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
208  x264_encoder_reconfig(x4->enc, &x4->params);
209  }
210 
211  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
212  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
213  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
214  x264_encoder_reconfig(x4->enc, &x4->params);
215  }
216 
217  if (x4->crf >= 0 &&
218  x4->params.rc.i_rc_method == X264_RC_CRF &&
219  x4->params.rc.f_rf_constant != x4->crf) {
220  x4->params.rc.f_rf_constant = x4->crf;
221  x264_encoder_reconfig(x4->enc, &x4->params);
222  }
223 
224  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
225  x4->cqp >= 0 &&
226  x4->params.rc.i_qp_constant != x4->cqp) {
227  x4->params.rc.i_qp_constant = x4->cqp;
228  x264_encoder_reconfig(x4->enc, &x4->params);
229  }
230 
231  if (x4->crf_max >= 0 &&
232  x4->params.rc.f_rf_constant_max != x4->crf_max) {
233  x4->params.rc.f_rf_constant_max = x4->crf_max;
234  x264_encoder_reconfig(x4->enc, &x4->params);
235  }
236  }
237 
239  if (side_data) {
240  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
241  int fpa_type;
242 
243  switch (stereo->type) {
245  fpa_type = 0;
246  break;
247  case AV_STEREO3D_COLUMNS:
248  fpa_type = 1;
249  break;
250  case AV_STEREO3D_LINES:
251  fpa_type = 2;
252  break;
254  fpa_type = 3;
255  break;
257  fpa_type = 4;
258  break;
260  fpa_type = 5;
261  break;
262 #if X264_BUILD >= 145
263  case AV_STEREO3D_2D:
264  fpa_type = 6;
265  break;
266 #endif
267  default:
268  fpa_type = -1;
269  break;
270  }
271 
272  /* Inverted mode is not supported by x264 */
273  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
274  av_log(ctx, AV_LOG_WARNING,
275  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
276  fpa_type = -1;
277  }
278 
279  if (fpa_type != x4->params.i_frame_packing) {
280  x4->params.i_frame_packing = fpa_type;
281  x264_encoder_reconfig(x4->enc, &x4->params);
282  }
283  }
284 }
285 
287  int *got_packet)
288 {
289  X264Context *x4 = ctx->priv_data;
290  x264_nal_t *nal;
291  int nnal, i, ret;
292  x264_picture_t pic_out = {0};
293  int pict_type;
294  int bit_depth;
295  int64_t *out_opaque;
296  AVFrameSideData *sd;
297 
298  x264_picture_init( &x4->pic );
299  x4->pic.img.i_csp = x4->params.i_csp;
300 #if X264_BUILD >= 153
301  bit_depth = x4->params.i_bitdepth;
302 #else
303  bit_depth = x264_bit_depth;
304 #endif
305  if (bit_depth > 8)
306  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
307  x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
308 
309  if (frame) {
310  for (i = 0; i < x4->pic.img.i_plane; i++) {
311  x4->pic.img.plane[i] = frame->data[i];
312  x4->pic.img.i_stride[i] = frame->linesize[i];
313  }
314 
315  x4->pic.i_pts = frame->pts;
316 
318  x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
319  x4->next_reordered_opaque++;
321 
322  switch (frame->pict_type) {
323  case AV_PICTURE_TYPE_I:
324  x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR
325  : X264_TYPE_KEYFRAME;
326  break;
327  case AV_PICTURE_TYPE_P:
328  x4->pic.i_type = X264_TYPE_P;
329  break;
330  case AV_PICTURE_TYPE_B:
331  x4->pic.i_type = X264_TYPE_B;
332  break;
333  default:
334  x4->pic.i_type = X264_TYPE_AUTO;
335  break;
336  }
337  reconfig_encoder(ctx, frame);
338 
339  if (x4->a53_cc) {
340  void *sei_data;
341  size_t sei_size;
342 
343  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
344  if (ret < 0) {
345  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
346  } else if (sei_data) {
347  x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0]));
348  if (x4->pic.extra_sei.payloads == NULL) {
349  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
350  av_free(sei_data);
351  } else {
352  x4->pic.extra_sei.sei_free = av_free;
353 
354  x4->pic.extra_sei.payloads[0].payload_size = sei_size;
355  x4->pic.extra_sei.payloads[0].payload = sei_data;
356  x4->pic.extra_sei.num_payloads = 1;
357  x4->pic.extra_sei.payloads[0].payload_type = 4;
358  }
359  }
360  }
361 
363  if (sd) {
364  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
365  if (!x4->roi_warned) {
366  x4->roi_warned = 1;
367  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
368  }
369  } else {
370  if (frame->interlaced_frame == 0) {
371  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
372  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
373  int qp_range = 51 + 6 * (bit_depth - 8);
374  int nb_rois;
375  const AVRegionOfInterest *roi;
376  uint32_t roi_size;
377  float *qoffsets;
378 
379  roi = (const AVRegionOfInterest*)sd->data;
380  roi_size = roi->self_size;
381  if (!roi_size || sd->size % roi_size != 0) {
382  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
383  return AVERROR(EINVAL);
384  }
385  nb_rois = sd->size / roi_size;
386 
387  qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
388  if (!qoffsets)
389  return AVERROR(ENOMEM);
390 
391  // This list must be iterated in reverse because the first
392  // region in the list applies when regions overlap.
393  for (int i = nb_rois - 1; i >= 0; i--) {
394  int startx, endx, starty, endy;
395  float qoffset;
396 
397  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
398 
399  starty = FFMIN(mby, roi->top / MB_SIZE);
400  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
401  startx = FFMIN(mbx, roi->left / MB_SIZE);
402  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
403 
404  if (roi->qoffset.den == 0) {
405  av_free(qoffsets);
406  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
407  return AVERROR(EINVAL);
408  }
409  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
410  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
411 
412  for (int y = starty; y < endy; y++) {
413  for (int x = startx; x < endx; x++) {
414  qoffsets[x + y*mbx] = qoffset;
415  }
416  }
417  }
418 
419  x4->pic.prop.quant_offsets = qoffsets;
420  x4->pic.prop.quant_offsets_free = av_free;
421  } else {
422  if (!x4->roi_warned) {
423  x4->roi_warned = 1;
424  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
425  }
426  }
427  }
428  }
429  }
430 
431  do {
432  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
433  return AVERROR_EXTERNAL;
434 
435  ret = encode_nals(ctx, pkt, nal, nnal);
436  if (ret < 0)
437  return ret;
438  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
439 
440  pkt->pts = pic_out.i_pts;
441  pkt->dts = pic_out.i_dts;
442 
443  out_opaque = pic_out.opaque;
444  if (out_opaque >= x4->reordered_opaque &&
445  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
446  ctx->reordered_opaque = *out_opaque;
447  } else {
448  // Unexpected opaque pointer on picture output
449  ctx->reordered_opaque = 0;
450  }
451 
452  switch (pic_out.i_type) {
453  case X264_TYPE_IDR:
454  case X264_TYPE_I:
455  pict_type = AV_PICTURE_TYPE_I;
456  break;
457  case X264_TYPE_P:
458  pict_type = AV_PICTURE_TYPE_P;
459  break;
460  case X264_TYPE_B:
461  case X264_TYPE_BREF:
462  pict_type = AV_PICTURE_TYPE_B;
463  break;
464  default:
465  pict_type = AV_PICTURE_TYPE_NONE;
466  }
467 #if FF_API_CODED_FRAME
469  ctx->coded_frame->pict_type = pict_type;
471 #endif
472 
473  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
474  if (ret) {
475  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
476 
477 #if FF_API_CODED_FRAME
479  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
481 #endif
482  }
483 
484  *got_packet = ret;
485  return 0;
486 }
487 
489 {
490  X264Context *x4 = avctx->priv_data;
491 
492  av_freep(&avctx->extradata);
493  av_freep(&x4->sei);
495 
496  if (x4->enc) {
497  x264_encoder_close(x4->enc);
498  x4->enc = NULL;
499  }
500 
501  return 0;
502 }
503 
504 #define OPT_STR(opt, param) \
505  do { \
506  int ret; \
507  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
508  if(ret == X264_PARAM_BAD_NAME) \
509  av_log(avctx, AV_LOG_ERROR, \
510  "bad option '%s': '%s'\n", opt, param); \
511  else \
512  av_log(avctx, AV_LOG_ERROR, \
513  "bad value for '%s': '%s'\n", opt, param); \
514  return -1; \
515  } \
516  } while (0)
517 
519 {
520  switch (pix_fmt) {
521  case AV_PIX_FMT_YUV420P:
522  case AV_PIX_FMT_YUVJ420P:
523  case AV_PIX_FMT_YUV420P9:
524  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
525  case AV_PIX_FMT_YUV422P:
526  case AV_PIX_FMT_YUVJ422P:
527  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
528  case AV_PIX_FMT_YUV444P:
529  case AV_PIX_FMT_YUVJ444P:
530  case AV_PIX_FMT_YUV444P9:
531  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
532 #if CONFIG_LIBX264RGB_ENCODER
533  case AV_PIX_FMT_BGR0:
534  return X264_CSP_BGRA;
535  case AV_PIX_FMT_BGR24:
536  return X264_CSP_BGR;
537 
538  case AV_PIX_FMT_RGB24:
539  return X264_CSP_RGB;
540 #endif
541  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
542  case AV_PIX_FMT_NV16:
543  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
544 #ifdef X264_CSP_NV21
545  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
546 #endif
547 #ifdef X264_CSP_I400
548  case AV_PIX_FMT_GRAY8:
549  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
550 #endif
551  };
552  return 0;
553 }
554 
555 #define PARSE_X264_OPT(name, var)\
556  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
557  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
558  return AVERROR(EINVAL);\
559  }
560 
561 static av_cold int X264_init(AVCodecContext *avctx)
562 {
563  X264Context *x4 = avctx->priv_data;
564  AVCPBProperties *cpb_props;
565  int sw,sh;
566 
567  if (avctx->global_quality > 0)
568  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
569 
570 #if CONFIG_LIBX262_ENCODER
571  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
572  x4->params.b_mpeg2 = 1;
573  x264_param_default_mpeg2(&x4->params);
574  } else
575 #endif
576  x264_param_default(&x4->params);
577 
578  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
579 
580  if (x4->preset || x4->tune)
581  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
582  int i;
583  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
584  av_log(avctx, AV_LOG_INFO, "Possible presets:");
585  for (i = 0; x264_preset_names[i]; i++)
586  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
587  av_log(avctx, AV_LOG_INFO, "\n");
588  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
589  for (i = 0; x264_tune_names[i]; i++)
590  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
591  av_log(avctx, AV_LOG_INFO, "\n");
592  return AVERROR(EINVAL);
593  }
594 
595  if (avctx->level > 0)
596  x4->params.i_level_idc = avctx->level;
597 
598  x4->params.pf_log = X264_log;
599  x4->params.p_log_private = avctx;
600  x4->params.i_log_level = X264_LOG_DEBUG;
601  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
602 #if X264_BUILD >= 153
603  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
604 #endif
605 
606  PARSE_X264_OPT("weightp", wpredp);
607 
608  if (avctx->bit_rate) {
609  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
610  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
611  return AVERROR(EINVAL);
612  }
613  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
614  x4->params.rc.i_rc_method = X264_RC_ABR;
615  }
616  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
617  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
618  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
619  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
620  x4->params.rc.b_stat_read = 1;
621  } else {
622  if (x4->crf >= 0) {
623  x4->params.rc.i_rc_method = X264_RC_CRF;
624  x4->params.rc.f_rf_constant = x4->crf;
625  } else if (x4->cqp >= 0) {
626  x4->params.rc.i_rc_method = X264_RC_CQP;
627  x4->params.rc.i_qp_constant = x4->cqp;
628  }
629 
630  if (x4->crf_max >= 0)
631  x4->params.rc.f_rf_constant_max = x4->crf_max;
632  }
633 
634  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
635  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
636  x4->params.rc.f_vbv_buffer_init =
637  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
638  }
639 
640  PARSE_X264_OPT("level", level);
641 
642  if (avctx->i_quant_factor > 0)
643  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
644  if (avctx->b_quant_factor > 0)
645  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
646 
647 #if FF_API_PRIVATE_OPT
649  if (avctx->chromaoffset >= 0)
650  x4->chroma_offset = avctx->chromaoffset;
652 #endif
653  if (x4->chroma_offset >= 0)
654  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
655 
656  if (avctx->gop_size >= 0)
657  x4->params.i_keyint_max = avctx->gop_size;
658  if (avctx->max_b_frames >= 0)
659  x4->params.i_bframe = avctx->max_b_frames;
660 
661 #if FF_API_PRIVATE_OPT
663  if (avctx->scenechange_threshold >= 0)
666 #endif
667  if (x4->scenechange_threshold >= 0)
668  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
669 
670  if (avctx->qmin >= 0)
671  x4->params.rc.i_qp_min = avctx->qmin;
672  if (avctx->qmax >= 0)
673  x4->params.rc.i_qp_max = avctx->qmax;
674  if (avctx->max_qdiff >= 0)
675  x4->params.rc.i_qp_step = avctx->max_qdiff;
676  if (avctx->qblur >= 0)
677  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
678  if (avctx->qcompress >= 0)
679  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
680  if (avctx->refs >= 0)
681  x4->params.i_frame_reference = avctx->refs;
682  else if (x4->level) {
683  int i;
684  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
685  int level_id = -1;
686  char *tail;
687  int scale = X264_BUILD < 129 ? 384 : 1;
688 
689  if (!strcmp(x4->level, "1b")) {
690  level_id = 9;
691  } else if (strlen(x4->level) <= 3){
692  level_id = av_strtod(x4->level, &tail) * 10 + 0.5;
693  if (*tail)
694  level_id = -1;
695  }
696  if (level_id <= 0)
697  av_log(avctx, AV_LOG_WARNING, "Failed to parse level\n");
698 
699  for (i = 0; i<x264_levels[i].level_idc; i++)
700  if (x264_levels[i].level_idc == level_id)
701  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
702  }
703 
704  if (avctx->trellis >= 0)
705  x4->params.analyse.i_trellis = avctx->trellis;
706  if (avctx->me_range >= 0)
707  x4->params.analyse.i_me_range = avctx->me_range;
708 #if FF_API_PRIVATE_OPT
710  if (avctx->noise_reduction >= 0)
711  x4->noise_reduction = avctx->noise_reduction;
713 #endif
714  if (x4->noise_reduction >= 0)
715  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
716  if (avctx->me_subpel_quality >= 0)
717  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
718 #if FF_API_PRIVATE_OPT
720  if (avctx->b_frame_strategy >= 0)
721  x4->b_frame_strategy = avctx->b_frame_strategy;
723 #endif
724  if (avctx->keyint_min >= 0)
725  x4->params.i_keyint_min = avctx->keyint_min;
726 #if FF_API_CODER_TYPE
728  if (avctx->coder_type >= 0)
729  x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
731 #endif
732  if (avctx->me_cmp >= 0)
733  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
734 
735  if (x4->aq_mode >= 0)
736  x4->params.rc.i_aq_mode = x4->aq_mode;
737  if (x4->aq_strength >= 0)
738  x4->params.rc.f_aq_strength = x4->aq_strength;
739  PARSE_X264_OPT("psy-rd", psy_rd);
740  PARSE_X264_OPT("deblock", deblock);
741  PARSE_X264_OPT("partitions", partitions);
742  PARSE_X264_OPT("stats", stats);
743  if (x4->psy >= 0)
744  x4->params.analyse.b_psy = x4->psy;
745  if (x4->rc_lookahead >= 0)
746  x4->params.rc.i_lookahead = x4->rc_lookahead;
747  if (x4->weightp >= 0)
748  x4->params.analyse.i_weighted_pred = x4->weightp;
749  if (x4->weightb >= 0)
750  x4->params.analyse.b_weighted_bipred = x4->weightb;
751  if (x4->cplxblur >= 0)
752  x4->params.rc.f_complexity_blur = x4->cplxblur;
753 
754  if (x4->ssim >= 0)
755  x4->params.analyse.b_ssim = x4->ssim;
756  if (x4->intra_refresh >= 0)
757  x4->params.b_intra_refresh = x4->intra_refresh;
758  if (x4->bluray_compat >= 0) {
759  x4->params.b_bluray_compat = x4->bluray_compat;
760  x4->params.b_vfr_input = 0;
761  }
762  if (x4->avcintra_class >= 0)
763 #if X264_BUILD >= 142
764  x4->params.i_avcintra_class = x4->avcintra_class;
765 #else
766  av_log(avctx, AV_LOG_ERROR,
767  "x264 too old for AVC Intra, at least version 142 needed\n");
768 #endif
769  if (x4->b_bias != INT_MIN)
770  x4->params.i_bframe_bias = x4->b_bias;
771  if (x4->b_pyramid >= 0)
772  x4->params.i_bframe_pyramid = x4->b_pyramid;
773  if (x4->mixed_refs >= 0)
774  x4->params.analyse.b_mixed_references = x4->mixed_refs;
775  if (x4->dct8x8 >= 0)
776  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
777  if (x4->fast_pskip >= 0)
778  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
779  if (x4->aud >= 0)
780  x4->params.b_aud = x4->aud;
781  if (x4->mbtree >= 0)
782  x4->params.rc.b_mb_tree = x4->mbtree;
783  if (x4->direct_pred >= 0)
784  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
785 
786  if (x4->slice_max_size >= 0)
787  x4->params.i_slice_max_size = x4->slice_max_size;
788 
789  if (x4->fastfirstpass)
790  x264_param_apply_fastfirstpass(&x4->params);
791 
792  /* Allow specifying the x264 profile through AVCodecContext. */
793  if (!x4->profile)
794  switch (avctx->profile) {
796  x4->profile = av_strdup("baseline");
797  break;
799  x4->profile = av_strdup("high");
800  break;
802  x4->profile = av_strdup("high10");
803  break;
805  x4->profile = av_strdup("high422");
806  break;
808  x4->profile = av_strdup("high444");
809  break;
811  x4->profile = av_strdup("main");
812  break;
813  default:
814  break;
815  }
816 
817  if (x4->nal_hrd >= 0)
818  x4->params.i_nal_hrd = x4->nal_hrd;
819 
820  if (x4->motion_est >= 0)
821  x4->params.analyse.i_me_method = x4->motion_est;
822 
823  if (x4->coder >= 0)
824  x4->params.b_cabac = x4->coder;
825 
826  if (x4->b_frame_strategy >= 0)
827  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
828 
829  if (x4->profile)
830  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
831  int i;
832  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
833  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
834  for (i = 0; x264_profile_names[i]; i++)
835  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
836  av_log(avctx, AV_LOG_INFO, "\n");
837  return AVERROR(EINVAL);
838  }
839 
840  x4->params.i_width = avctx->width;
841  x4->params.i_height = avctx->height;
842  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
843  x4->params.vui.i_sar_width = sw;
844  x4->params.vui.i_sar_height = sh;
845  x4->params.i_timebase_den = avctx->time_base.den;
846  x4->params.i_timebase_num = avctx->time_base.num;
847  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
848  x4->params.i_fps_num = avctx->framerate.num;
849  x4->params.i_fps_den = avctx->framerate.den;
850  } else {
851  x4->params.i_fps_num = avctx->time_base.den;
852  x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame;
853  }
854 
855  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
856 
857  x4->params.i_threads = avctx->thread_count;
858  if (avctx->thread_type)
859  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
860 
861  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
862 
863  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
864 
865  x4->params.i_slice_count = avctx->slices;
866 
867  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
868  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
869  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
870  avctx->color_range == AVCOL_RANGE_JPEG;
871 
872  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
873  x4->params.vui.i_colmatrix = avctx->colorspace;
875  x4->params.vui.i_colorprim = avctx->color_primaries;
876  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
877  x4->params.vui.i_transfer = avctx->color_trc;
878 
879  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
880  x4->params.b_repeat_headers = 0;
881 
882  if(x4->x264opts){
883  const char *p= x4->x264opts;
884  while(p){
885  char param[4096]={0}, val[4096]={0};
886  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
887  OPT_STR(param, "1");
888  }else
889  OPT_STR(param, val);
890  p= strchr(p, ':');
891  p+=!!p;
892  }
893  }
894 
895  if (x4->x264_params) {
896  AVDictionary *dict = NULL;
897  AVDictionaryEntry *en = NULL;
898 
899  if (!av_dict_parse_string(&dict, x4->x264_params, "=", ":", 0)) {
900  while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {
901  if (x264_param_parse(&x4->params, en->key, en->value) < 0)
902  av_log(avctx, AV_LOG_WARNING,
903  "Error parsing option '%s = %s'.\n",
904  en->key, en->value);
905  }
906 
907  av_dict_free(&dict);
908  }
909  }
910 
911  // update AVCodecContext with x264 parameters
912  avctx->has_b_frames = x4->params.i_bframe ?
913  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
914  if (avctx->max_b_frames < 0)
915  avctx->max_b_frames = 0;
916 
917  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
918 
919  x4->enc = x264_encoder_open(&x4->params);
920  if (!x4->enc)
921  return AVERROR_EXTERNAL;
922 
923  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
924  x264_nal_t *nal;
925  uint8_t *p;
926  int nnal, s, i;
927 
928  s = x264_encoder_headers(x4->enc, &nal, &nnal);
930  if (!p)
931  return AVERROR(ENOMEM);
932 
933  for (i = 0; i < nnal; i++) {
934  /* Don't put the SEI in extradata. */
935  if (nal[i].i_type == NAL_SEI) {
936  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
937  x4->sei_size = nal[i].i_payload;
938  x4->sei = av_malloc(x4->sei_size);
939  if (!x4->sei)
940  return AVERROR(ENOMEM);
941  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
942  continue;
943  }
944  memcpy(p, nal[i].p_payload, nal[i].i_payload);
945  p += nal[i].i_payload;
946  }
947  avctx->extradata_size = p - avctx->extradata;
948  }
949 
950  cpb_props = ff_add_cpb_side_data(avctx);
951  if (!cpb_props)
952  return AVERROR(ENOMEM);
953  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
954  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
955  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
956 
957  // Overestimate the reordered opaque buffer size, in case a runtime
958  // reconfigure would increase the delay (which it shouldn't).
959  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
961  sizeof(*x4->reordered_opaque));
962  if (!x4->reordered_opaque)
963  return AVERROR(ENOMEM);
964 
965  return 0;
966 }
967 
968 static const enum AVPixelFormat pix_fmts_8bit[] = {
977 #ifdef X264_CSP_NV21
979 #endif
981 };
982 static const enum AVPixelFormat pix_fmts_9bit[] = {
986 };
987 static const enum AVPixelFormat pix_fmts_10bit[] = {
993 };
994 static const enum AVPixelFormat pix_fmts_all[] = {
1003 #ifdef X264_CSP_NV21
1005 #endif
1010 #ifdef X264_CSP_I400
1013 #endif
1015 };
1016 #if CONFIG_LIBX264RGB_ENCODER
1017 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1022 };
1023 #endif
1024 
1025 static av_cold void X264_init_static(AVCodec *codec)
1026 {
1027 #if X264_BUILD < 153
1028  if (x264_bit_depth == 8)
1029  codec->pix_fmts = pix_fmts_8bit;
1030  else if (x264_bit_depth == 9)
1031  codec->pix_fmts = pix_fmts_9bit;
1032  else if (x264_bit_depth == 10)
1033  codec->pix_fmts = pix_fmts_10bit;
1034 #else
1035  codec->pix_fmts = pix_fmts_all;
1036 #endif
1037 }
1038 
1039 #define OFFSET(x) offsetof(X264Context, x)
1040 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1041 static const AVOption options[] = {
1042  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1043  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1044  { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1045  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1046  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1047  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1048  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1049  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1050  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1051  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1052  { "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 },
1053  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1054  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
1055  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1056  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1057  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1058 #if X264_BUILD >= 144
1059  { "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" },
1060 #endif
1061  { "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},
1062  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1063  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1064  { "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 },
1065  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1066  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
1067  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
1068  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
1069  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
1070  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1071  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1072  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1073  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1074  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
1075  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1076  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1077  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1078  { "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 },
1079  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1080  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1081  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1082  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1083  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1084  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1085  { "partitions", "A comma-separated list of partitions to consider. "
1086  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1087  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
1088  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
1089  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
1090  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
1091  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
1092  { "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 },
1093  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1094  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1095  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
1096  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1097  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1098  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1099  { "avcintra-class","AVC-Intra class 50/100/200", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE},
1100  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1101  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1102  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
1103  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
1104  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
1105  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1106  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1107  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1108  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
1109  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
1110  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1111  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1112  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1113  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1114  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1115  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1116  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1117  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1118 
1119  { "x264-params", "Override the x264 configuration using a :-separated list of key=value parameters", OFFSET(x264_params), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1120  { NULL },
1121 };
1122 
1123 static const AVCodecDefault x264_defaults[] = {
1124  { "b", "0" },
1125  { "bf", "-1" },
1126  { "flags2", "0" },
1127  { "g", "-1" },
1128  { "i_qfactor", "-1" },
1129  { "b_qfactor", "-1" },
1130  { "qmin", "-1" },
1131  { "qmax", "-1" },
1132  { "qdiff", "-1" },
1133  { "qblur", "-1" },
1134  { "qcomp", "-1" },
1135 // { "rc_lookahead", "-1" },
1136  { "refs", "-1" },
1137 #if FF_API_PRIVATE_OPT
1138  { "sc_threshold", "-1" },
1139 #endif
1140  { "trellis", "-1" },
1141 #if FF_API_PRIVATE_OPT
1142  { "nr", "-1" },
1143 #endif
1144  { "me_range", "-1" },
1145  { "subq", "-1" },
1146 #if FF_API_PRIVATE_OPT
1147  { "b_strategy", "-1" },
1148 #endif
1149  { "keyint_min", "-1" },
1150 #if FF_API_CODER_TYPE
1151  { "coder", "-1" },
1152 #endif
1153  { "cmp", "-1" },
1154  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1155  { "thread_type", "0" },
1156  { "flags", "+cgop" },
1157  { "rc_init_occupancy","-1" },
1158  { NULL },
1159 };
1160 
1161 #if CONFIG_LIBX264_ENCODER
1162 static const AVClass x264_class = {
1163  .class_name = "libx264",
1164  .item_name = av_default_item_name,
1165  .option = options,
1166  .version = LIBAVUTIL_VERSION_INT,
1167 };
1168 
1170  .name = "libx264",
1171  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1172  .type = AVMEDIA_TYPE_VIDEO,
1173  .id = AV_CODEC_ID_H264,
1174  .priv_data_size = sizeof(X264Context),
1175  .init = X264_init,
1176  .encode2 = X264_frame,
1177  .close = X264_close,
1178  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1180  .priv_class = &x264_class,
1181  .defaults = x264_defaults,
1182  .init_static_data = X264_init_static,
1183 #if X264_BUILD >= 158
1185 #else
1186  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1187 #endif
1188  .wrapper_name = "libx264",
1189 };
1190 #endif
1191 
1192 #if CONFIG_LIBX264RGB_ENCODER
1193 static const AVClass rgbclass = {
1194  .class_name = "libx264rgb",
1195  .item_name = av_default_item_name,
1196  .option = options,
1197  .version = LIBAVUTIL_VERSION_INT,
1198 };
1199 
1201  .name = "libx264rgb",
1202  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1203  .type = AVMEDIA_TYPE_VIDEO,
1204  .id = AV_CODEC_ID_H264,
1205  .priv_data_size = sizeof(X264Context),
1206  .init = X264_init,
1207  .encode2 = X264_frame,
1208  .close = X264_close,
1209  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1211  .priv_class = &rgbclass,
1212  .defaults = x264_defaults,
1213  .pix_fmts = pix_fmts_8bit_rgb,
1214 #if X264_BUILD >= 158
1216 #else
1217  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1218 #endif
1219  .wrapper_name = "libx264",
1220 };
1221 #endif
1222 
1223 #if CONFIG_LIBX262_ENCODER
1224 static const AVClass X262_class = {
1225  .class_name = "libx262",
1226  .item_name = av_default_item_name,
1227  .option = options,
1228  .version = LIBAVUTIL_VERSION_INT,
1229 };
1230 
1232  .name = "libx262",
1233  .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
1234  .type = AVMEDIA_TYPE_VIDEO,
1235  .id = AV_CODEC_ID_MPEG2VIDEO,
1236  .priv_data_size = sizeof(X264Context),
1237  .init = X264_init,
1238  .encode2 = X264_frame,
1239  .close = X264_close,
1240  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1242  .priv_class = &X262_class,
1243  .defaults = x264_defaults,
1245  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1246  .wrapper_name = "libx264",
1247 };
1248 #endif
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:2942
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Definition: libx264.c:518
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3108
const char const char void * val
Definition: avisynth_c.h:863
static enum AVPixelFormat pix_fmt
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:235
static int avfmt2_num_planes(int avfmt)
Definition: libx264.c:164
char * partitions
Definition: libx264.c:83
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int dct8x8
Definition: libx264.c:77
AVOption.
Definition: opt.h:246
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:720
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:899
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:882
const char * fmt
Definition: avisynth_c.h:861
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:2403
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
Memory handling functions.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1137
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1828
AVCodec ff_libx262_encoder
int noise_reduction
Definition: libx264.c:96
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2474
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2203
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1947
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
int next_reordered_opaque
Definition: libx264.c:100
int bluray_compat
Definition: libx264.c:73
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
char * wpredp
Definition: libx264.c:59
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:110
Views are next to each other.
Definition: stereo3d.h:67
static AVPacket pkt
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1052
int profile
profile
Definition: avcodec.h:2901
AVCodec.
Definition: avcodec.h:3492
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:561
int roi_warned
If the encoder does not support ROI then warn the first time we encounter a frame with ROI side data...
Definition: libx264.c:107
AVRational qoffset
Quantisation offset.
Definition: frame.h:262
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1691
Undefined.
Definition: avutil.h:273
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:734
x264_param_t params
Definition: libx264.c:49
char * x264opts
Definition: libx264.c:60
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This codec takes the reordered_opaque field from input AVFrames and returns it in the corresponding f...
Definition: avcodec.h:1095
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1009
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:2940
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:2039
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:1837
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1954
int nb_reordered_opaque
Definition: libx264.c:100
int level_idc
Definition: h264_levels.c:25
Structure to hold side data for an AVFrame.
Definition: frame.h:201
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
uint8_t * data
Definition: avcodec.h:1480
int b_pyramid
Definition: libx264.c:75
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
x264_picture_t pic
Definition: libx264.c:51
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
int64_t * reordered_opaque
Definition: libx264.c:101
float cplxblur
Definition: libx264.c:82
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1164
ptrdiff_t size
Definition: opengl_enc.c:100
#define FF_CMP_CHROMA
Definition: avcodec.h:1989
char * stats
Definition: libx264.c:86
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:225
static enum AVPixelFormat pix_fmts_all[]
Definition: libx264.c:994
int intra_refresh
Definition: libx264.c:72
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:434
#define av_log(a,...)
int rc_lookahead
Definition: libx264.c:68
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:987
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1858
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
int qmax
maximum quantizer
Definition: avcodec.h:2417
char * profile
Definition: libx264.c:56
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
int coder
Definition: libx264.c:91
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int fastfirstpass
Definition: libx264.c:58
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:2948
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:2944
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
int mbtree
Definition: libx264.c:80
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:1873
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
char * deblock
Definition: libx264.c:81
int b_frame_strategy
Definition: libx264.c:93
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2431
Views are alternated temporally.
Definition: stereo3d.h:92
common internal API header
char * psy_rd
Definition: libx264.c:66
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
int refs
number of reference frames
Definition: avcodec.h:2156
int motion_est
Definition: libx264.c:89
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:982
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:555
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3513
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define OPT_STR(opt, param)
Definition: libx264.c:504
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
int width
picture width / height.
Definition: avcodec.h:1741
int cqp
Definition: libx264.c:63
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
attribute_deprecated int noise_reduction
Definition: avcodec.h:2086
x264_t * enc
Definition: libx264.c:50
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:890
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:874
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2182
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2839
int level
level
Definition: avcodec.h:3021
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:418
Structure describing a single Region Of Interest.
Definition: frame.h:220
int scenechange_threshold
Definition: libx264.c:95
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:2725
int slice_max_size
Definition: libx264.c:85
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1700
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int nal_hrd
Definition: libx264.c:87
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:2424
int weightp
Definition: libx264.c:69
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
attribute_deprecated int coder_type
Definition: avcodec.h:2485
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
char * x264_params
Definition: libx264.c:98
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2827
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:523
if(ret)
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:968
static const AVCodecDefault x264_defaults[]
Definition: libx264.c:1123
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1131
int avcintra_class
Definition: libx264.c:88
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
char * level
Definition: libx264.c:57
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
Libavcodec external API header.
Views are on top of each other.
Definition: stereo3d.h:79
static av_cold int X264_close(AVCodecContext *avctx)
Definition: libx264.c:488
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:2082
enum AVCodecID codec_id
Definition: avcodec.h:1578
int forced_idr
Definition: libx264.c:90
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1842
main external API structure.
Definition: avcodec.h:1568
static const AVOption options[]
Definition: libx264.c:1041
int qmin
minimum quantizer
Definition: avcodec.h:2410
uint8_t * data
Definition: frame.h:203
#define FF_CODER_TYPE_AC
Definition: avcodec.h:2478
int extradata_size
Definition: avcodec.h:1670
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
float crf
Definition: libx264.c:61
int aq_mode
Definition: libx264.c:64
int aud
Definition: libx264.c:79
#define AV_STRINGIFY(s)
Definition: macros.h:36
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything)...
Definition: frame.h:462
Describe the class of an AVClass context structure.
Definition: log.h:67
int a53_cc
Definition: libx264.c:92
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2196
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2189
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:181
uint8_t * sei
Definition: libx264.c:52
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level...
Definition: log.c:373
int psy
Definition: libx264.c:67
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
Definition: libx264.c:126
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:2951
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
attribute_deprecated int chromaoffset
Definition: avcodec.h:2161
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2402
int sei_size
Definition: libx264.c:53
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:186
char * preset
Definition: libx264.c:54
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1634
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int b_bias
Definition: libx264.c:74
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:907
int fast_pskip
Definition: libx264.c:78
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1763
int chroma_offset
Definition: libx264.c:94
static av_cold void X264_init_static(AVCodec *codec)
Definition: libx264.c:1025
int mixed_refs
Definition: libx264.c:76
preset
Definition: vf_curves.c:46
char * tune
Definition: libx264.c:55
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define VE
Definition: libx264.c:1040
int weightb
Definition: libx264.c:70
float aq_strength
Definition: libx264.c:65
common internal api header.
Bi-dir predicted.
Definition: avutil.h:276
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
Stereoscopic video.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2818
Views are packed per column.
Definition: stereo3d.h:141
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:201
int trellis
trellis RD quantization
Definition: avcodec.h:2517
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1968
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:878
int slices
Number of slices.
Definition: avcodec.h:2219
void * priv_data
Definition: avcodec.h:1595
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
#define MB_SIZE
Definition: libx264.c:45
AVCodec ff_libx264rgb_encoder
int ssim
Definition: libx264.c:71
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
AVCodec ff_libx264_encoder
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
float crf_max
Definition: libx264.c:62
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
Definition: utils.c:2167
int height
Definition: frame.h:353
#define OFFSET(x)
Definition: libx264.c:1039
int direct_pred
Definition: libx264.c:84
#define av_freep(p)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libx264.c:286
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:921
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:2945
Stereoscopic 3d metadata.
Definition: frame.h:63
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:2030
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
Predicted.
Definition: avutil.h:275
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:2837
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2446
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
int keyint_min
minimum GOP size
Definition: avcodec.h:2149