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 } X264Context;
103 
104 static void X264_log(void *p, int level, const char *fmt, va_list args)
105 {
106  static const int level_map[] = {
107  [X264_LOG_ERROR] = AV_LOG_ERROR,
108  [X264_LOG_WARNING] = AV_LOG_WARNING,
109  [X264_LOG_INFO] = AV_LOG_INFO,
110  [X264_LOG_DEBUG] = AV_LOG_DEBUG
111  };
112 
113  if (level < 0 || level > X264_LOG_DEBUG)
114  return;
115 
116  av_vlog(p, level_map[level], fmt, args);
117 }
118 
119 
121  const x264_nal_t *nals, int nnal)
122 {
123  X264Context *x4 = ctx->priv_data;
124  uint8_t *p;
125  int i, size = x4->sei_size, ret;
126 
127  if (!nnal)
128  return 0;
129 
130  for (i = 0; i < nnal; i++)
131  size += nals[i].i_payload;
132 
133  if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)
134  return ret;
135 
136  p = pkt->data;
137 
138  /* Write the SEI as part of the first frame. */
139  if (x4->sei_size > 0 && nnal > 0) {
140  if (x4->sei_size > size) {
141  av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");
142  return -1;
143  }
144  memcpy(p, x4->sei, x4->sei_size);
145  p += x4->sei_size;
146  x4->sei_size = 0;
147  av_freep(&x4->sei);
148  }
149 
150  for (i = 0; i < nnal; i++){
151  memcpy(p, nals[i].p_payload, nals[i].i_payload);
152  p += nals[i].i_payload;
153  }
154 
155  return 1;
156 }
157 
158 static int avfmt2_num_planes(int avfmt)
159 {
160  switch (avfmt) {
161  case AV_PIX_FMT_YUV420P:
162  case AV_PIX_FMT_YUVJ420P:
163  case AV_PIX_FMT_YUV420P9:
165  case AV_PIX_FMT_YUV444P:
166  return 3;
167 
168  case AV_PIX_FMT_BGR0:
169  case AV_PIX_FMT_BGR24:
170  case AV_PIX_FMT_RGB24:
171  case AV_PIX_FMT_GRAY8:
172  case AV_PIX_FMT_GRAY10:
173  return 1;
174 
175  default:
176  return 3;
177  }
178 }
179 
181 {
182  X264Context *x4 = ctx->priv_data;
183  AVFrameSideData *side_data;
184 
185 
186  if (x4->avcintra_class < 0) {
187  if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
188 
189  x4->params.b_tff = frame->top_field_first;
190  x264_encoder_reconfig(x4->enc, &x4->params);
191  }
192  if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
193  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
194  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
195  x264_encoder_reconfig(x4->enc, &x4->params);
196  }
197 
198  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
199  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
200  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
201  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
202  x264_encoder_reconfig(x4->enc, &x4->params);
203  }
204 
205  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
206  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
207  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
208  x264_encoder_reconfig(x4->enc, &x4->params);
209  }
210 
211  if (x4->crf >= 0 &&
212  x4->params.rc.i_rc_method == X264_RC_CRF &&
213  x4->params.rc.f_rf_constant != x4->crf) {
214  x4->params.rc.f_rf_constant = x4->crf;
215  x264_encoder_reconfig(x4->enc, &x4->params);
216  }
217 
218  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
219  x4->cqp >= 0 &&
220  x4->params.rc.i_qp_constant != x4->cqp) {
221  x4->params.rc.i_qp_constant = x4->cqp;
222  x264_encoder_reconfig(x4->enc, &x4->params);
223  }
224 
225  if (x4->crf_max >= 0 &&
226  x4->params.rc.f_rf_constant_max != x4->crf_max) {
227  x4->params.rc.f_rf_constant_max = x4->crf_max;
228  x264_encoder_reconfig(x4->enc, &x4->params);
229  }
230  }
231 
233  if (side_data) {
234  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
235  int fpa_type;
236 
237  switch (stereo->type) {
239  fpa_type = 0;
240  break;
241  case AV_STEREO3D_COLUMNS:
242  fpa_type = 1;
243  break;
244  case AV_STEREO3D_LINES:
245  fpa_type = 2;
246  break;
248  fpa_type = 3;
249  break;
251  fpa_type = 4;
252  break;
254  fpa_type = 5;
255  break;
256 #if X264_BUILD >= 145
257  case AV_STEREO3D_2D:
258  fpa_type = 6;
259  break;
260 #endif
261  default:
262  fpa_type = -1;
263  break;
264  }
265 
266  /* Inverted mode is not supported by x264 */
267  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
268  av_log(ctx, AV_LOG_WARNING,
269  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
270  fpa_type = -1;
271  }
272 
273  if (fpa_type != x4->params.i_frame_packing) {
274  x4->params.i_frame_packing = fpa_type;
275  x264_encoder_reconfig(x4->enc, &x4->params);
276  }
277  }
278 }
279 
281  int *got_packet)
282 {
283  X264Context *x4 = ctx->priv_data;
284  x264_nal_t *nal;
285  int nnal, i, ret;
286  x264_picture_t pic_out = {0};
287  int pict_type;
288  int bit_depth;
289  int64_t *out_opaque;
290  AVFrameSideData *sd;
291 
292  x264_picture_init( &x4->pic );
293  x4->pic.img.i_csp = x4->params.i_csp;
294 #if X264_BUILD >= 153
295  bit_depth = x4->params.i_bitdepth;
296 #else
297  bit_depth = x264_bit_depth;
298 #endif
299  if (bit_depth > 8)
300  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
301  x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
302 
303  if (frame) {
304  for (i = 0; i < x4->pic.img.i_plane; i++) {
305  x4->pic.img.plane[i] = frame->data[i];
306  x4->pic.img.i_stride[i] = frame->linesize[i];
307  }
308 
309  x4->pic.i_pts = frame->pts;
310 
312  x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
313  x4->next_reordered_opaque++;
315 
316  switch (frame->pict_type) {
317  case AV_PICTURE_TYPE_I:
318  x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR
319  : X264_TYPE_KEYFRAME;
320  break;
321  case AV_PICTURE_TYPE_P:
322  x4->pic.i_type = X264_TYPE_P;
323  break;
324  case AV_PICTURE_TYPE_B:
325  x4->pic.i_type = X264_TYPE_B;
326  break;
327  default:
328  x4->pic.i_type = X264_TYPE_AUTO;
329  break;
330  }
331  reconfig_encoder(ctx, frame);
332 
333  if (x4->a53_cc) {
334  void *sei_data;
335  size_t sei_size;
336 
337  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
338  if (ret < 0) {
339  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
340  } else if (sei_data) {
341  x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0]));
342  if (x4->pic.extra_sei.payloads == NULL) {
343  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
344  av_free(sei_data);
345  } else {
346  x4->pic.extra_sei.sei_free = av_free;
347 
348  x4->pic.extra_sei.payloads[0].payload_size = sei_size;
349  x4->pic.extra_sei.payloads[0].payload = sei_data;
350  x4->pic.extra_sei.num_payloads = 1;
351  x4->pic.extra_sei.payloads[0].payload_type = 4;
352  }
353  }
354  }
355 
357  if (sd) {
358  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
359  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
360  } else {
361  if (frame->interlaced_frame == 0) {
362  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
363  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
364  int qp_range = 51 + 6 * (bit_depth - 8);
365  int nb_rois;
366  const AVRegionOfInterest *roi;
367  uint32_t roi_size;
368  float *qoffsets;
369 
370  roi = (const AVRegionOfInterest*)sd->data;
371  roi_size = roi->self_size;
372  if (!roi_size || sd->size % roi_size != 0) {
373  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
374  return AVERROR(EINVAL);
375  }
376  nb_rois = sd->size / roi_size;
377 
378  qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
379  if (!qoffsets)
380  return AVERROR(ENOMEM);
381 
382  // This list must be iterated in reverse because the first
383  // region in the list applies when regions overlap.
384  for (int i = nb_rois - 1; i >= 0; i--) {
385  int startx, endx, starty, endy;
386  float qoffset;
387 
388  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
389 
390  starty = FFMIN(mby, roi->top / MB_SIZE);
391  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
392  startx = FFMIN(mbx, roi->left / MB_SIZE);
393  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
394 
395  if (roi->qoffset.den == 0) {
396  av_free(qoffsets);
397  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
398  return AVERROR(EINVAL);
399  }
400  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
401  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
402 
403  for (int y = starty; y < endy; y++) {
404  for (int x = startx; x < endx; x++) {
405  qoffsets[x + y*mbx] = qoffset;
406  }
407  }
408  }
409 
410  x4->pic.prop.quant_offsets = qoffsets;
411  x4->pic.prop.quant_offsets_free = av_free;
412  } else {
413  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
414  }
415  }
416  }
417  }
418 
419  do {
420  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
421  return AVERROR_EXTERNAL;
422 
423  ret = encode_nals(ctx, pkt, nal, nnal);
424  if (ret < 0)
425  return ret;
426  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
427 
428  pkt->pts = pic_out.i_pts;
429  pkt->dts = pic_out.i_dts;
430 
431  out_opaque = pic_out.opaque;
432  if (out_opaque >= x4->reordered_opaque &&
433  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
434  ctx->reordered_opaque = *out_opaque;
435  } else {
436  // Unexpected opaque pointer on picture output
437  ctx->reordered_opaque = 0;
438  }
439 
440  switch (pic_out.i_type) {
441  case X264_TYPE_IDR:
442  case X264_TYPE_I:
443  pict_type = AV_PICTURE_TYPE_I;
444  break;
445  case X264_TYPE_P:
446  pict_type = AV_PICTURE_TYPE_P;
447  break;
448  case X264_TYPE_B:
449  case X264_TYPE_BREF:
450  pict_type = AV_PICTURE_TYPE_B;
451  break;
452  default:
453  pict_type = AV_PICTURE_TYPE_NONE;
454  }
455 #if FF_API_CODED_FRAME
457  ctx->coded_frame->pict_type = pict_type;
459 #endif
460 
461  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
462  if (ret) {
463  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
464 
465 #if FF_API_CODED_FRAME
467  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
469 #endif
470  }
471 
472  *got_packet = ret;
473  return 0;
474 }
475 
477 {
478  X264Context *x4 = avctx->priv_data;
479 
480  av_freep(&avctx->extradata);
481  av_freep(&x4->sei);
483 
484  if (x4->enc) {
485  x264_encoder_close(x4->enc);
486  x4->enc = NULL;
487  }
488 
489  return 0;
490 }
491 
492 #define OPT_STR(opt, param) \
493  do { \
494  int ret; \
495  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
496  if(ret == X264_PARAM_BAD_NAME) \
497  av_log(avctx, AV_LOG_ERROR, \
498  "bad option '%s': '%s'\n", opt, param); \
499  else \
500  av_log(avctx, AV_LOG_ERROR, \
501  "bad value for '%s': '%s'\n", opt, param); \
502  return -1; \
503  } \
504  } while (0)
505 
507 {
508  switch (pix_fmt) {
509  case AV_PIX_FMT_YUV420P:
510  case AV_PIX_FMT_YUVJ420P:
511  case AV_PIX_FMT_YUV420P9:
512  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
513  case AV_PIX_FMT_YUV422P:
514  case AV_PIX_FMT_YUVJ422P:
515  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
516  case AV_PIX_FMT_YUV444P:
517  case AV_PIX_FMT_YUVJ444P:
518  case AV_PIX_FMT_YUV444P9:
519  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
520 #if CONFIG_LIBX264RGB_ENCODER
521  case AV_PIX_FMT_BGR0:
522  return X264_CSP_BGRA;
523  case AV_PIX_FMT_BGR24:
524  return X264_CSP_BGR;
525 
526  case AV_PIX_FMT_RGB24:
527  return X264_CSP_RGB;
528 #endif
529  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
530  case AV_PIX_FMT_NV16:
531  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
532 #ifdef X264_CSP_NV21
533  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
534 #endif
535 #ifdef X264_CSP_I400
536  case AV_PIX_FMT_GRAY8:
537  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
538 #endif
539  };
540  return 0;
541 }
542 
543 #define PARSE_X264_OPT(name, var)\
544  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
545  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
546  return AVERROR(EINVAL);\
547  }
548 
549 static av_cold int X264_init(AVCodecContext *avctx)
550 {
551  X264Context *x4 = avctx->priv_data;
552  AVCPBProperties *cpb_props;
553  int sw,sh;
554 
555  if (avctx->global_quality > 0)
556  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
557 
558 #if CONFIG_LIBX262_ENCODER
559  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
560  x4->params.b_mpeg2 = 1;
561  x264_param_default_mpeg2(&x4->params);
562  } else
563 #endif
564  x264_param_default(&x4->params);
565 
566  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
567 
568  if (x4->preset || x4->tune)
569  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
570  int i;
571  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
572  av_log(avctx, AV_LOG_INFO, "Possible presets:");
573  for (i = 0; x264_preset_names[i]; i++)
574  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
575  av_log(avctx, AV_LOG_INFO, "\n");
576  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
577  for (i = 0; x264_tune_names[i]; i++)
578  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
579  av_log(avctx, AV_LOG_INFO, "\n");
580  return AVERROR(EINVAL);
581  }
582 
583  if (avctx->level > 0)
584  x4->params.i_level_idc = avctx->level;
585 
586  x4->params.pf_log = X264_log;
587  x4->params.p_log_private = avctx;
588  x4->params.i_log_level = X264_LOG_DEBUG;
589  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
590 #if X264_BUILD >= 153
591  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
592 #endif
593 
594  PARSE_X264_OPT("weightp", wpredp);
595 
596  if (avctx->bit_rate) {
597  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
598  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
599  return AVERROR(EINVAL);
600  }
601  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
602  x4->params.rc.i_rc_method = X264_RC_ABR;
603  }
604  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
605  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
606  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
607  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
608  x4->params.rc.b_stat_read = 1;
609  } else {
610  if (x4->crf >= 0) {
611  x4->params.rc.i_rc_method = X264_RC_CRF;
612  x4->params.rc.f_rf_constant = x4->crf;
613  } else if (x4->cqp >= 0) {
614  x4->params.rc.i_rc_method = X264_RC_CQP;
615  x4->params.rc.i_qp_constant = x4->cqp;
616  }
617 
618  if (x4->crf_max >= 0)
619  x4->params.rc.f_rf_constant_max = x4->crf_max;
620  }
621 
622  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
623  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
624  x4->params.rc.f_vbv_buffer_init =
625  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
626  }
627 
628  PARSE_X264_OPT("level", level);
629 
630  if (avctx->i_quant_factor > 0)
631  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
632  if (avctx->b_quant_factor > 0)
633  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
634 
635 #if FF_API_PRIVATE_OPT
637  if (avctx->chromaoffset >= 0)
638  x4->chroma_offset = avctx->chromaoffset;
640 #endif
641  if (x4->chroma_offset >= 0)
642  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
643 
644  if (avctx->gop_size >= 0)
645  x4->params.i_keyint_max = avctx->gop_size;
646  if (avctx->max_b_frames >= 0)
647  x4->params.i_bframe = avctx->max_b_frames;
648 
649 #if FF_API_PRIVATE_OPT
651  if (avctx->scenechange_threshold >= 0)
654 #endif
655  if (x4->scenechange_threshold >= 0)
656  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
657 
658  if (avctx->qmin >= 0)
659  x4->params.rc.i_qp_min = avctx->qmin;
660  if (avctx->qmax >= 0)
661  x4->params.rc.i_qp_max = avctx->qmax;
662  if (avctx->max_qdiff >= 0)
663  x4->params.rc.i_qp_step = avctx->max_qdiff;
664  if (avctx->qblur >= 0)
665  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
666  if (avctx->qcompress >= 0)
667  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
668  if (avctx->refs >= 0)
669  x4->params.i_frame_reference = avctx->refs;
670  else if (x4->level) {
671  int i;
672  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
673  int level_id = -1;
674  char *tail;
675  int scale = X264_BUILD < 129 ? 384 : 1;
676 
677  if (!strcmp(x4->level, "1b")) {
678  level_id = 9;
679  } else if (strlen(x4->level) <= 3){
680  level_id = av_strtod(x4->level, &tail) * 10 + 0.5;
681  if (*tail)
682  level_id = -1;
683  }
684  if (level_id <= 0)
685  av_log(avctx, AV_LOG_WARNING, "Failed to parse level\n");
686 
687  for (i = 0; i<x264_levels[i].level_idc; i++)
688  if (x264_levels[i].level_idc == level_id)
689  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
690  }
691 
692  if (avctx->trellis >= 0)
693  x4->params.analyse.i_trellis = avctx->trellis;
694  if (avctx->me_range >= 0)
695  x4->params.analyse.i_me_range = avctx->me_range;
696 #if FF_API_PRIVATE_OPT
698  if (avctx->noise_reduction >= 0)
699  x4->noise_reduction = avctx->noise_reduction;
701 #endif
702  if (x4->noise_reduction >= 0)
703  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
704  if (avctx->me_subpel_quality >= 0)
705  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
706 #if FF_API_PRIVATE_OPT
708  if (avctx->b_frame_strategy >= 0)
709  x4->b_frame_strategy = avctx->b_frame_strategy;
711 #endif
712  if (avctx->keyint_min >= 0)
713  x4->params.i_keyint_min = avctx->keyint_min;
714 #if FF_API_CODER_TYPE
716  if (avctx->coder_type >= 0)
717  x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
719 #endif
720  if (avctx->me_cmp >= 0)
721  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
722 
723  if (x4->aq_mode >= 0)
724  x4->params.rc.i_aq_mode = x4->aq_mode;
725  if (x4->aq_strength >= 0)
726  x4->params.rc.f_aq_strength = x4->aq_strength;
727  PARSE_X264_OPT("psy-rd", psy_rd);
728  PARSE_X264_OPT("deblock", deblock);
729  PARSE_X264_OPT("partitions", partitions);
730  PARSE_X264_OPT("stats", stats);
731  if (x4->psy >= 0)
732  x4->params.analyse.b_psy = x4->psy;
733  if (x4->rc_lookahead >= 0)
734  x4->params.rc.i_lookahead = x4->rc_lookahead;
735  if (x4->weightp >= 0)
736  x4->params.analyse.i_weighted_pred = x4->weightp;
737  if (x4->weightb >= 0)
738  x4->params.analyse.b_weighted_bipred = x4->weightb;
739  if (x4->cplxblur >= 0)
740  x4->params.rc.f_complexity_blur = x4->cplxblur;
741 
742  if (x4->ssim >= 0)
743  x4->params.analyse.b_ssim = x4->ssim;
744  if (x4->intra_refresh >= 0)
745  x4->params.b_intra_refresh = x4->intra_refresh;
746  if (x4->bluray_compat >= 0) {
747  x4->params.b_bluray_compat = x4->bluray_compat;
748  x4->params.b_vfr_input = 0;
749  }
750  if (x4->avcintra_class >= 0)
751 #if X264_BUILD >= 142
752  x4->params.i_avcintra_class = x4->avcintra_class;
753 #else
754  av_log(avctx, AV_LOG_ERROR,
755  "x264 too old for AVC Intra, at least version 142 needed\n");
756 #endif
757  if (x4->b_bias != INT_MIN)
758  x4->params.i_bframe_bias = x4->b_bias;
759  if (x4->b_pyramid >= 0)
760  x4->params.i_bframe_pyramid = x4->b_pyramid;
761  if (x4->mixed_refs >= 0)
762  x4->params.analyse.b_mixed_references = x4->mixed_refs;
763  if (x4->dct8x8 >= 0)
764  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
765  if (x4->fast_pskip >= 0)
766  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
767  if (x4->aud >= 0)
768  x4->params.b_aud = x4->aud;
769  if (x4->mbtree >= 0)
770  x4->params.rc.b_mb_tree = x4->mbtree;
771  if (x4->direct_pred >= 0)
772  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
773 
774  if (x4->slice_max_size >= 0)
775  x4->params.i_slice_max_size = x4->slice_max_size;
776 
777  if (x4->fastfirstpass)
778  x264_param_apply_fastfirstpass(&x4->params);
779 
780  /* Allow specifying the x264 profile through AVCodecContext. */
781  if (!x4->profile)
782  switch (avctx->profile) {
784  x4->profile = av_strdup("baseline");
785  break;
787  x4->profile = av_strdup("high");
788  break;
790  x4->profile = av_strdup("high10");
791  break;
793  x4->profile = av_strdup("high422");
794  break;
796  x4->profile = av_strdup("high444");
797  break;
799  x4->profile = av_strdup("main");
800  break;
801  default:
802  break;
803  }
804 
805  if (x4->nal_hrd >= 0)
806  x4->params.i_nal_hrd = x4->nal_hrd;
807 
808  if (x4->motion_est >= 0)
809  x4->params.analyse.i_me_method = x4->motion_est;
810 
811  if (x4->coder >= 0)
812  x4->params.b_cabac = x4->coder;
813 
814  if (x4->b_frame_strategy >= 0)
815  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
816 
817  if (x4->profile)
818  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
819  int i;
820  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
821  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
822  for (i = 0; x264_profile_names[i]; i++)
823  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
824  av_log(avctx, AV_LOG_INFO, "\n");
825  return AVERROR(EINVAL);
826  }
827 
828  x4->params.i_width = avctx->width;
829  x4->params.i_height = avctx->height;
830  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
831  x4->params.vui.i_sar_width = sw;
832  x4->params.vui.i_sar_height = sh;
833  x4->params.i_timebase_den = avctx->time_base.den;
834  x4->params.i_timebase_num = avctx->time_base.num;
835  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
836  x4->params.i_fps_num = avctx->framerate.num;
837  x4->params.i_fps_den = avctx->framerate.den;
838  } else {
839  x4->params.i_fps_num = avctx->time_base.den;
840  x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame;
841  }
842 
843  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
844 
845  x4->params.i_threads = avctx->thread_count;
846  if (avctx->thread_type)
847  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
848 
849  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
850 
851  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
852 
853  x4->params.i_slice_count = avctx->slices;
854 
855  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
856  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
857  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
858  avctx->color_range == AVCOL_RANGE_JPEG;
859 
860  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
861  x4->params.vui.i_colmatrix = avctx->colorspace;
863  x4->params.vui.i_colorprim = avctx->color_primaries;
864  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
865  x4->params.vui.i_transfer = avctx->color_trc;
866 
867  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
868  x4->params.b_repeat_headers = 0;
869 
870  if(x4->x264opts){
871  const char *p= x4->x264opts;
872  while(p){
873  char param[4096]={0}, val[4096]={0};
874  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
875  OPT_STR(param, "1");
876  }else
877  OPT_STR(param, val);
878  p= strchr(p, ':');
879  p+=!!p;
880  }
881  }
882 
883  if (x4->x264_params) {
884  AVDictionary *dict = NULL;
885  AVDictionaryEntry *en = NULL;
886 
887  if (!av_dict_parse_string(&dict, x4->x264_params, "=", ":", 0)) {
888  while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {
889  if (x264_param_parse(&x4->params, en->key, en->value) < 0)
890  av_log(avctx, AV_LOG_WARNING,
891  "Error parsing option '%s = %s'.\n",
892  en->key, en->value);
893  }
894 
895  av_dict_free(&dict);
896  }
897  }
898 
899  // update AVCodecContext with x264 parameters
900  avctx->has_b_frames = x4->params.i_bframe ?
901  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
902  if (avctx->max_b_frames < 0)
903  avctx->max_b_frames = 0;
904 
905  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
906 
907  x4->enc = x264_encoder_open(&x4->params);
908  if (!x4->enc)
909  return AVERROR_EXTERNAL;
910 
911  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
912  x264_nal_t *nal;
913  uint8_t *p;
914  int nnal, s, i;
915 
916  s = x264_encoder_headers(x4->enc, &nal, &nnal);
918  if (!p)
919  return AVERROR(ENOMEM);
920 
921  for (i = 0; i < nnal; i++) {
922  /* Don't put the SEI in extradata. */
923  if (nal[i].i_type == NAL_SEI) {
924  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
925  x4->sei_size = nal[i].i_payload;
926  x4->sei = av_malloc(x4->sei_size);
927  if (!x4->sei)
928  return AVERROR(ENOMEM);
929  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
930  continue;
931  }
932  memcpy(p, nal[i].p_payload, nal[i].i_payload);
933  p += nal[i].i_payload;
934  }
935  avctx->extradata_size = p - avctx->extradata;
936  }
937 
938  cpb_props = ff_add_cpb_side_data(avctx);
939  if (!cpb_props)
940  return AVERROR(ENOMEM);
941  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
942  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
943  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
944 
945  // Overestimate the reordered opaque buffer size, in case a runtime
946  // reconfigure would increase the delay (which it shouldn't).
947  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
949  sizeof(*x4->reordered_opaque));
950  if (!x4->reordered_opaque)
951  return AVERROR(ENOMEM);
952 
953  return 0;
954 }
955 
956 static const enum AVPixelFormat pix_fmts_8bit[] = {
965 #ifdef X264_CSP_NV21
967 #endif
969 };
970 static const enum AVPixelFormat pix_fmts_9bit[] = {
974 };
975 static const enum AVPixelFormat pix_fmts_10bit[] = {
981 };
982 static const enum AVPixelFormat pix_fmts_all[] = {
991 #ifdef X264_CSP_NV21
993 #endif
998 #ifdef X264_CSP_I400
1001 #endif
1003 };
1004 #if CONFIG_LIBX264RGB_ENCODER
1005 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1010 };
1011 #endif
1012 
1013 static av_cold void X264_init_static(AVCodec *codec)
1014 {
1015 #if X264_BUILD < 153
1016  if (x264_bit_depth == 8)
1017  codec->pix_fmts = pix_fmts_8bit;
1018  else if (x264_bit_depth == 9)
1019  codec->pix_fmts = pix_fmts_9bit;
1020  else if (x264_bit_depth == 10)
1021  codec->pix_fmts = pix_fmts_10bit;
1022 #else
1023  codec->pix_fmts = pix_fmts_all;
1024 #endif
1025 }
1026 
1027 #define OFFSET(x) offsetof(X264Context, x)
1028 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1029 static const AVOption options[] = {
1030  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1031  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1032  { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1033  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1034  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1035  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1036  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1037  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1038  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1039  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1040  { "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 },
1041  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1042  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
1043  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1044  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1045  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1046 #if X264_BUILD >= 144
1047  { "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" },
1048 #endif
1049  { "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},
1050  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1051  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1052  { "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 },
1053  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1054  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
1055  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
1056  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
1057  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
1058  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1059  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1060  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1061  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1062  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
1063  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1064  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1065  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1066  { "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 },
1067  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1068  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1069  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1070  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1071  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1072  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1073  { "partitions", "A comma-separated list of partitions to consider. "
1074  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1075  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
1076  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
1077  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
1078  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
1079  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
1080  { "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 },
1081  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1082  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1083  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
1084  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1085  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1086  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1087  { "avcintra-class","AVC-Intra class 50/100/200", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE},
1088  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1089  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1090  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
1091  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
1092  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
1093  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1094  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1095  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1096  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
1097  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
1098  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1099  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1100  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1101  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1102  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1103  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1104  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1105  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1106 
1107  { "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 },
1108  { NULL },
1109 };
1110 
1111 static const AVCodecDefault x264_defaults[] = {
1112  { "b", "0" },
1113  { "bf", "-1" },
1114  { "flags2", "0" },
1115  { "g", "-1" },
1116  { "i_qfactor", "-1" },
1117  { "b_qfactor", "-1" },
1118  { "qmin", "-1" },
1119  { "qmax", "-1" },
1120  { "qdiff", "-1" },
1121  { "qblur", "-1" },
1122  { "qcomp", "-1" },
1123 // { "rc_lookahead", "-1" },
1124  { "refs", "-1" },
1125 #if FF_API_PRIVATE_OPT
1126  { "sc_threshold", "-1" },
1127 #endif
1128  { "trellis", "-1" },
1129 #if FF_API_PRIVATE_OPT
1130  { "nr", "-1" },
1131 #endif
1132  { "me_range", "-1" },
1133  { "subq", "-1" },
1134 #if FF_API_PRIVATE_OPT
1135  { "b_strategy", "-1" },
1136 #endif
1137  { "keyint_min", "-1" },
1138 #if FF_API_CODER_TYPE
1139  { "coder", "-1" },
1140 #endif
1141  { "cmp", "-1" },
1142  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1143  { "thread_type", "0" },
1144  { "flags", "+cgop" },
1145  { "rc_init_occupancy","-1" },
1146  { NULL },
1147 };
1148 
1149 #if CONFIG_LIBX264_ENCODER
1150 static const AVClass x264_class = {
1151  .class_name = "libx264",
1152  .item_name = av_default_item_name,
1153  .option = options,
1154  .version = LIBAVUTIL_VERSION_INT,
1155 };
1156 
1158  .name = "libx264",
1159  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1160  .type = AVMEDIA_TYPE_VIDEO,
1161  .id = AV_CODEC_ID_H264,
1162  .priv_data_size = sizeof(X264Context),
1163  .init = X264_init,
1164  .encode2 = X264_frame,
1165  .close = X264_close,
1166  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1168  .priv_class = &x264_class,
1169  .defaults = x264_defaults,
1170  .init_static_data = X264_init_static,
1171  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1172  .wrapper_name = "libx264",
1173 };
1174 #endif
1175 
1176 #if CONFIG_LIBX264RGB_ENCODER
1177 static const AVClass rgbclass = {
1178  .class_name = "libx264rgb",
1179  .item_name = av_default_item_name,
1180  .option = options,
1181  .version = LIBAVUTIL_VERSION_INT,
1182 };
1183 
1185  .name = "libx264rgb",
1186  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1187  .type = AVMEDIA_TYPE_VIDEO,
1188  .id = AV_CODEC_ID_H264,
1189  .priv_data_size = sizeof(X264Context),
1190  .init = X264_init,
1191  .encode2 = X264_frame,
1192  .close = X264_close,
1193  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1195  .priv_class = &rgbclass,
1196  .defaults = x264_defaults,
1197  .pix_fmts = pix_fmts_8bit_rgb,
1198  .wrapper_name = "libx264",
1199 };
1200 #endif
1201 
1202 #if CONFIG_LIBX262_ENCODER
1203 static const AVClass X262_class = {
1204  .class_name = "libx262",
1205  .item_name = av_default_item_name,
1206  .option = options,
1207  .version = LIBAVUTIL_VERSION_INT,
1208 };
1209 
1211  .name = "libx262",
1212  .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
1213  .type = AVMEDIA_TYPE_VIDEO,
1214  .id = AV_CODEC_ID_MPEG2VIDEO,
1215  .priv_data_size = sizeof(X264Context),
1216  .init = X264_init,
1217  .encode2 = X264_frame,
1218  .close = X264_close,
1219  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1221  .priv_class = &X262_class,
1222  .defaults = x264_defaults,
1224  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1225  .wrapper_name = "libx264",
1226 };
1227 #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:2939
#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:506
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3105
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:158
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:896
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:879
const char * fmt
Definition: avisynth_c.h:861
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:2400
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:1615
#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:1134
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:1825
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:2471
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2200
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:1944
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
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:104
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:1049
int profile
profile
Definition: avcodec.h:2898
AVCodec.
Definition: avcodec.h:3481
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:549
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:1688
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:1092
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:1006
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:2937
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:2036
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:1834
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:1666
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1951
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:1477
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:1161
ptrdiff_t size
Definition: opengl_enc.c:100
#define FF_CMP_CHROMA
Definition: avcodec.h:1986
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:982
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:1509
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:975
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:1855
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
int qmax
maximum quantizer
Definition: avcodec.h:2414
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:2945
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:2941
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
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:3488
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:1870
#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:1483
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:2428
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:2153
int motion_est
Definition: libx264.c:89
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:970
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:543
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3502
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define OPT_STR(opt, param)
Definition: libx264.c:492
#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:1738
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:2083
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:887
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:871
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2179
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:2836
int level
level
Definition: avcodec.h:3018
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:2722
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:1697
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:2421
int weightp
Definition: libx264.c:69
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
attribute_deprecated int coder_type
Definition: avcodec.h:2482
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:2824
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:522
if(ret)
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:956
static const AVCodecDefault x264_defaults[]
Definition: libx264.c:1111
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:1128
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:476
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:2079
enum AVCodecID codec_id
Definition: avcodec.h:1575
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:1839
main external API structure.
Definition: avcodec.h:1565
static const AVOption options[]
Definition: libx264.c:1029
int qmin
minimum quantizer
Definition: avcodec.h:2407
uint8_t * data
Definition: frame.h:203
#define FF_CODER_TYPE_AC
Definition: avcodec.h:2475
int extradata_size
Definition: avcodec.h:1667
#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:2193
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2186
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:120
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:2948
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
attribute_deprecated int chromaoffset
Definition: avcodec.h:2158
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2399
int sei_size
Definition: libx264.c:53
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:180
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:1631
#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:904
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:1760
int chroma_offset
Definition: libx264.c:94
static av_cold void X264_init_static(AVCodec *codec)
Definition: libx264.c:1013
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:1028
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:2815
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:2514
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1954
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:875
int slices
Number of slices.
Definition: avcodec.h:2216
void * priv_data
Definition: avcodec.h:1592
#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:1152
#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:1476
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:2153
int height
Definition: frame.h:353
#define OFFSET(x)
Definition: libx264.c:1027
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:280
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:918
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:2942
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:1454
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:2027
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
Predicted.
Definition: avutil.h:275
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:2834
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2443
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:2146