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/time.h"
29 #include "libavutil/intreadwrite.h"
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "packet_internal.h"
33 #include "atsc_a53.h"
34 
35 #if defined(_MSC_VER)
36 #define X264_API_IMPORTS 1
37 #endif
38 
39 #include <x264.h>
40 #include <float.h>
41 #include <math.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 
46 // from x264.h, for quant_offsets, Macroblocks are 16x16
47 // blocks of pixels (with respect to the luma plane)
48 #define MB_SIZE 16
49 
50 typedef struct X264Opaque {
52  int64_t wallclock;
53 } X264Opaque;
54 
55 typedef struct X264Context {
56  AVClass *class;
57  x264_param_t params;
58  x264_t *enc;
59  x264_picture_t pic;
61  int sei_size;
62  char *preset;
63  char *tune;
64  char *profile;
65  char *level;
67  char *wpredp;
68  char *x264opts;
69  float crf;
70  float crf_max;
71  int cqp;
72  int aq_mode;
73  float aq_strength;
74  char *psy_rd;
75  int psy;
77  int weightp;
78  int weightb;
79  int ssim;
82  int b_bias;
83  int b_pyramid;
85  int dct8x8;
87  int aud;
88  int mbtree;
89  char *deblock;
90  float cplxblur;
91  char *partitions;
94  char *stats;
95  int nal_hrd;
99  int coder;
100  int a53_cc;
105 
107 
108  int nb_reordered_opaque, next_reordered_opaque;
110 
111  /**
112  * If the encoder does not support ROI then warn the first time we
113  * encounter a frame with ROI side data.
114  */
116 } X264Context;
117 
118 static void X264_log(void *p, int level, const char *fmt, va_list args)
119 {
120  static const int level_map[] = {
121  [X264_LOG_ERROR] = AV_LOG_ERROR,
122  [X264_LOG_WARNING] = AV_LOG_WARNING,
123  [X264_LOG_INFO] = AV_LOG_INFO,
124  [X264_LOG_DEBUG] = AV_LOG_DEBUG
125  };
126 
127  if (level < 0 || level > X264_LOG_DEBUG)
128  return;
129 
130  av_vlog(p, level_map[level], fmt, args);
131 }
132 
133 
135  const x264_nal_t *nals, int nnal)
136 {
137  X264Context *x4 = ctx->priv_data;
138  uint8_t *p;
139  int i, size = x4->sei_size, ret;
140 
141  if (!nnal)
142  return 0;
143 
144  for (i = 0; i < nnal; i++)
145  size += nals[i].i_payload;
146 
147  if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)
148  return ret;
149 
150  p = pkt->data;
151 
152  /* Write the SEI as part of the first frame. */
153  if (x4->sei_size > 0 && nnal > 0) {
154  if (x4->sei_size > size) {
155  av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");
156  return -1;
157  }
158  memcpy(p, x4->sei, x4->sei_size);
159  p += x4->sei_size;
160  x4->sei_size = 0;
161  av_freep(&x4->sei);
162  }
163 
164  for (i = 0; i < nnal; i++){
165  memcpy(p, nals[i].p_payload, nals[i].i_payload);
166  p += nals[i].i_payload;
167  }
168 
169  return 1;
170 }
171 
172 static int avfmt2_num_planes(int avfmt)
173 {
174  switch (avfmt) {
175  case AV_PIX_FMT_YUV420P:
176  case AV_PIX_FMT_YUVJ420P:
177  case AV_PIX_FMT_YUV420P9:
179  case AV_PIX_FMT_YUV444P:
180  return 3;
181 
182  case AV_PIX_FMT_BGR0:
183  case AV_PIX_FMT_BGR24:
184  case AV_PIX_FMT_RGB24:
185  case AV_PIX_FMT_GRAY8:
186  case AV_PIX_FMT_GRAY10:
187  return 1;
188 
189  default:
190  return 3;
191  }
192 }
193 
195 {
196  X264Context *x4 = ctx->priv_data;
197  AVFrameSideData *side_data;
198 
199 
200  if (x4->avcintra_class < 0) {
201  if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
202 
203  x4->params.b_tff = frame->top_field_first;
204  x264_encoder_reconfig(x4->enc, &x4->params);
205  }
206  if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
207  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
208  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
209  x264_encoder_reconfig(x4->enc, &x4->params);
210  }
211 
212  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
213  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
214  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
215  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
216  x264_encoder_reconfig(x4->enc, &x4->params);
217  }
218 
219  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
220  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
221  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
222  x264_encoder_reconfig(x4->enc, &x4->params);
223  }
224 
225  if (x4->crf >= 0 &&
226  x4->params.rc.i_rc_method == X264_RC_CRF &&
227  x4->params.rc.f_rf_constant != x4->crf) {
228  x4->params.rc.f_rf_constant = x4->crf;
229  x264_encoder_reconfig(x4->enc, &x4->params);
230  }
231 
232  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
233  x4->cqp >= 0 &&
234  x4->params.rc.i_qp_constant != x4->cqp) {
235  x4->params.rc.i_qp_constant = x4->cqp;
236  x264_encoder_reconfig(x4->enc, &x4->params);
237  }
238 
239  if (x4->crf_max >= 0 &&
240  x4->params.rc.f_rf_constant_max != x4->crf_max) {
241  x4->params.rc.f_rf_constant_max = x4->crf_max;
242  x264_encoder_reconfig(x4->enc, &x4->params);
243  }
244  }
245 
247  if (side_data) {
248  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
249  int fpa_type;
250 
251  switch (stereo->type) {
253  fpa_type = 0;
254  break;
255  case AV_STEREO3D_COLUMNS:
256  fpa_type = 1;
257  break;
258  case AV_STEREO3D_LINES:
259  fpa_type = 2;
260  break;
262  fpa_type = 3;
263  break;
265  fpa_type = 4;
266  break;
268  fpa_type = 5;
269  break;
270 #if X264_BUILD >= 145
271  case AV_STEREO3D_2D:
272  fpa_type = 6;
273  break;
274 #endif
275  default:
276  fpa_type = -1;
277  break;
278  }
279 
280  /* Inverted mode is not supported by x264 */
281  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
282  av_log(ctx, AV_LOG_WARNING,
283  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
284  fpa_type = -1;
285  }
286 
287  if (fpa_type != x4->params.i_frame_packing) {
288  x4->params.i_frame_packing = fpa_type;
289  x264_encoder_reconfig(x4->enc, &x4->params);
290  }
291  }
292 }
293 
295  int *got_packet)
296 {
297  X264Context *x4 = ctx->priv_data;
298  x264_nal_t *nal;
299  int nnal, i, ret;
300  x264_picture_t pic_out = {0};
301  int pict_type;
302  int bit_depth;
303  int64_t wallclock = 0;
304  X264Opaque *out_opaque;
305  AVFrameSideData *sd;
306 
307  x264_picture_init( &x4->pic );
308  x4->pic.img.i_csp = x4->params.i_csp;
309 #if X264_BUILD >= 153
310  bit_depth = x4->params.i_bitdepth;
311 #else
312  bit_depth = x264_bit_depth;
313 #endif
314  if (bit_depth > 8)
315  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
316  x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
317 
318  if (frame) {
319  for (i = 0; i < x4->pic.img.i_plane; i++) {
320  x4->pic.img.plane[i] = frame->data[i];
321  x4->pic.img.i_stride[i] = frame->linesize[i];
322  }
323 
324  x4->pic.i_pts = frame->pts;
325 
330  x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
331  x4->next_reordered_opaque++;
333 
334  switch (frame->pict_type) {
335  case AV_PICTURE_TYPE_I:
336  x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR
337  : X264_TYPE_KEYFRAME;
338  break;
339  case AV_PICTURE_TYPE_P:
340  x4->pic.i_type = X264_TYPE_P;
341  break;
342  case AV_PICTURE_TYPE_B:
343  x4->pic.i_type = X264_TYPE_B;
344  break;
345  default:
346  x4->pic.i_type = X264_TYPE_AUTO;
347  break;
348  }
349  reconfig_encoder(ctx, frame);
350 
351  if (x4->a53_cc) {
352  void *sei_data;
353  size_t sei_size;
354 
355  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
356  if (ret < 0) {
357  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
358  } else if (sei_data) {
359  x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0]));
360  if (x4->pic.extra_sei.payloads == NULL) {
361  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
362  av_free(sei_data);
363  } else {
364  x4->pic.extra_sei.sei_free = av_free;
365 
366  x4->pic.extra_sei.payloads[0].payload_size = sei_size;
367  x4->pic.extra_sei.payloads[0].payload = sei_data;
368  x4->pic.extra_sei.num_payloads = 1;
369  x4->pic.extra_sei.payloads[0].payload_type = 4;
370  }
371  }
372  }
373 
375  if (sd) {
376  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
377  if (!x4->roi_warned) {
378  x4->roi_warned = 1;
379  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
380  }
381  } else {
382  if (frame->interlaced_frame == 0) {
383  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
384  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
385  int qp_range = 51 + 6 * (bit_depth - 8);
386  int nb_rois;
387  const AVRegionOfInterest *roi;
388  uint32_t roi_size;
389  float *qoffsets;
390 
391  roi = (const AVRegionOfInterest*)sd->data;
392  roi_size = roi->self_size;
393  if (!roi_size || sd->size % roi_size != 0) {
394  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
395  return AVERROR(EINVAL);
396  }
397  nb_rois = sd->size / roi_size;
398 
399  qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
400  if (!qoffsets)
401  return AVERROR(ENOMEM);
402 
403  // This list must be iterated in reverse because the first
404  // region in the list applies when regions overlap.
405  for (int i = nb_rois - 1; i >= 0; i--) {
406  int startx, endx, starty, endy;
407  float qoffset;
408 
409  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
410 
411  starty = FFMIN(mby, roi->top / MB_SIZE);
412  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
413  startx = FFMIN(mbx, roi->left / MB_SIZE);
414  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
415 
416  if (roi->qoffset.den == 0) {
417  av_free(qoffsets);
418  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
419  return AVERROR(EINVAL);
420  }
421  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
422  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
423 
424  for (int y = starty; y < endy; y++) {
425  for (int x = startx; x < endx; x++) {
426  qoffsets[x + y*mbx] = qoffset;
427  }
428  }
429  }
430 
431  x4->pic.prop.quant_offsets = qoffsets;
432  x4->pic.prop.quant_offsets_free = av_free;
433  } else {
434  if (!x4->roi_warned) {
435  x4->roi_warned = 1;
436  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
437  }
438  }
439  }
440  }
441  }
442 
443  do {
444  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
445  return AVERROR_EXTERNAL;
446 
447  ret = encode_nals(ctx, pkt, nal, nnal);
448  if (ret < 0)
449  return ret;
450  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
451 
452  if (!ret)
453  return 0;
454 
455  pkt->pts = pic_out.i_pts;
456  pkt->dts = pic_out.i_dts;
457 
458  out_opaque = pic_out.opaque;
459  if (out_opaque >= x4->reordered_opaque &&
460  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
461  ctx->reordered_opaque = out_opaque->reordered_opaque;
462  wallclock = out_opaque->wallclock;
463  } else {
464  // Unexpected opaque pointer on picture output
465  ctx->reordered_opaque = 0;
466  }
467 
468  switch (pic_out.i_type) {
469  case X264_TYPE_IDR:
470  case X264_TYPE_I:
471  pict_type = AV_PICTURE_TYPE_I;
472  break;
473  case X264_TYPE_P:
474  pict_type = AV_PICTURE_TYPE_P;
475  break;
476  case X264_TYPE_B:
477  case X264_TYPE_BREF:
478  pict_type = AV_PICTURE_TYPE_B;
479  break;
480  default:
481  av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
482  return AVERROR_EXTERNAL;
483  }
484 #if FF_API_CODED_FRAME
486  ctx->coded_frame->pict_type = pict_type;
488 #endif
489 
490  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
491  if (ret) {
492  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
493  if (wallclock)
494  ff_side_data_set_prft(pkt, wallclock);
495 
496 #if FF_API_CODED_FRAME
498  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
500 #endif
501  }
502 
503  *got_packet = ret;
504  return 0;
505 }
506 
508 {
509  X264Context *x4 = avctx->priv_data;
510 
511  av_freep(&avctx->extradata);
512  av_freep(&x4->sei);
514 
515 #if X264_BUILD >= 161
516  x264_param_cleanup(&x4->params);
517 #endif
518 
519  if (x4->enc) {
520  x264_encoder_close(x4->enc);
521  x4->enc = NULL;
522  }
523 
524  return 0;
525 }
526 
527 static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
528 {
529  X264Context *x4 = avctx->priv_data;
530  int ret;
531 
532  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) {
533  if (ret == X264_PARAM_BAD_NAME) {
534  av_log(avctx, AV_LOG_ERROR,
535  "bad option '%s': '%s'\n", opt, param);
536  ret = AVERROR(EINVAL);
537 #if X264_BUILD >= 161
538  } else if (ret == X264_PARAM_ALLOC_FAILED) {
539  av_log(avctx, AV_LOG_ERROR,
540  "out of memory parsing option '%s': '%s'\n", opt, param);
541  ret = AVERROR(ENOMEM);
542 #endif
543  } else {
544  av_log(avctx, AV_LOG_ERROR,
545  "bad value for '%s': '%s'\n", opt, param);
546  ret = AVERROR(EINVAL);
547  }
548  }
549 
550  return ret;
551 }
552 
554 {
555  switch (pix_fmt) {
556  case AV_PIX_FMT_YUV420P:
557  case AV_PIX_FMT_YUVJ420P:
558  case AV_PIX_FMT_YUV420P9:
559  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
560  case AV_PIX_FMT_YUV422P:
561  case AV_PIX_FMT_YUVJ422P:
562  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
563  case AV_PIX_FMT_YUV444P:
564  case AV_PIX_FMT_YUVJ444P:
565  case AV_PIX_FMT_YUV444P9:
566  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
567 #if CONFIG_LIBX264RGB_ENCODER
568  case AV_PIX_FMT_BGR0:
569  return X264_CSP_BGRA;
570  case AV_PIX_FMT_BGR24:
571  return X264_CSP_BGR;
572 
573  case AV_PIX_FMT_RGB24:
574  return X264_CSP_RGB;
575 #endif
576  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
577  case AV_PIX_FMT_NV16:
578  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
579 #ifdef X264_CSP_NV21
580  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
581 #endif
582 #ifdef X264_CSP_I400
583  case AV_PIX_FMT_GRAY8:
584  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
585 #endif
586  };
587  return 0;
588 }
589 
590 #define PARSE_X264_OPT(name, var)\
591  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
592  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
593  return AVERROR(EINVAL);\
594  }
595 
596 static av_cold int X264_init(AVCodecContext *avctx)
597 {
598  X264Context *x4 = avctx->priv_data;
599  AVCPBProperties *cpb_props;
600  int sw,sh;
601  int ret;
602 
603  if (avctx->global_quality > 0)
604  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
605 
606 #if CONFIG_LIBX262_ENCODER
607  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
608  x4->params.b_mpeg2 = 1;
609  x264_param_default_mpeg2(&x4->params);
610  } else
611 #endif
612  x264_param_default(&x4->params);
613 
614  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
615 
616  if (x4->preset || x4->tune)
617  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
618  int i;
619  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
620  av_log(avctx, AV_LOG_INFO, "Possible presets:");
621  for (i = 0; x264_preset_names[i]; i++)
622  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
623  av_log(avctx, AV_LOG_INFO, "\n");
624  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
625  for (i = 0; x264_tune_names[i]; i++)
626  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
627  av_log(avctx, AV_LOG_INFO, "\n");
628  return AVERROR(EINVAL);
629  }
630 
631  if (avctx->level > 0)
632  x4->params.i_level_idc = avctx->level;
633 
634  x4->params.pf_log = X264_log;
635  x4->params.p_log_private = avctx;
636  x4->params.i_log_level = X264_LOG_DEBUG;
637  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
638 #if X264_BUILD >= 153
639  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
640 #endif
641 
642  PARSE_X264_OPT("weightp", wpredp);
643 
644  if (avctx->bit_rate) {
645  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
646  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
647  return AVERROR(EINVAL);
648  }
649  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
650  x4->params.rc.i_rc_method = X264_RC_ABR;
651  }
652  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
653  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
654  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
655  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
656  x4->params.rc.b_stat_read = 1;
657  } else {
658  if (x4->crf >= 0) {
659  x4->params.rc.i_rc_method = X264_RC_CRF;
660  x4->params.rc.f_rf_constant = x4->crf;
661  } else if (x4->cqp >= 0) {
662  x4->params.rc.i_rc_method = X264_RC_CQP;
663  x4->params.rc.i_qp_constant = x4->cqp;
664  }
665 
666  if (x4->crf_max >= 0)
667  x4->params.rc.f_rf_constant_max = x4->crf_max;
668  }
669 
670  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
671  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
672  x4->params.rc.f_vbv_buffer_init =
673  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
674  }
675 
676  PARSE_X264_OPT("level", level);
677 
678  if (avctx->i_quant_factor > 0)
679  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
680  if (avctx->b_quant_factor > 0)
681  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
682 
683 #if FF_API_PRIVATE_OPT
685  if (avctx->chromaoffset)
686  x4->chroma_offset = avctx->chromaoffset;
688 #endif
689  if (x4->chroma_offset)
690  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
691 
692  if (avctx->gop_size >= 0)
693  x4->params.i_keyint_max = avctx->gop_size;
694  if (avctx->max_b_frames >= 0)
695  x4->params.i_bframe = avctx->max_b_frames;
696 
697 #if FF_API_PRIVATE_OPT
699  if (avctx->scenechange_threshold >= 0)
702 #endif
703  if (x4->scenechange_threshold >= 0)
704  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
705 
706  if (avctx->qmin >= 0)
707  x4->params.rc.i_qp_min = avctx->qmin;
708  if (avctx->qmax >= 0)
709  x4->params.rc.i_qp_max = avctx->qmax;
710  if (avctx->max_qdiff >= 0)
711  x4->params.rc.i_qp_step = avctx->max_qdiff;
712  if (avctx->qblur >= 0)
713  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
714  if (avctx->qcompress >= 0)
715  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
716  if (avctx->refs >= 0)
717  x4->params.i_frame_reference = avctx->refs;
718  else if (x4->params.i_level_idc > 0) {
719  int i;
720  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
721  int scale = X264_BUILD < 129 ? 384 : 1;
722 
723  for (i = 0; i<x264_levels[i].level_idc; i++)
724  if (x264_levels[i].level_idc == x4->params.i_level_idc)
725  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
726  }
727 
728  if (avctx->trellis >= 0)
729  x4->params.analyse.i_trellis = avctx->trellis;
730  if (avctx->me_range >= 0)
731  x4->params.analyse.i_me_range = avctx->me_range;
732 #if FF_API_PRIVATE_OPT
734  if (avctx->noise_reduction >= 0)
735  x4->noise_reduction = avctx->noise_reduction;
737 #endif
738  if (x4->noise_reduction >= 0)
739  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
740  if (avctx->me_subpel_quality >= 0)
741  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
742 #if FF_API_PRIVATE_OPT
744  if (avctx->b_frame_strategy >= 0)
745  x4->b_frame_strategy = avctx->b_frame_strategy;
747 #endif
748  if (avctx->keyint_min >= 0)
749  x4->params.i_keyint_min = avctx->keyint_min;
750 #if FF_API_CODER_TYPE
752  if (avctx->coder_type >= 0)
753  x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
755 #endif
756  if (avctx->me_cmp >= 0)
757  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
758 
759  if (x4->aq_mode >= 0)
760  x4->params.rc.i_aq_mode = x4->aq_mode;
761  if (x4->aq_strength >= 0)
762  x4->params.rc.f_aq_strength = x4->aq_strength;
763  PARSE_X264_OPT("psy-rd", psy_rd);
764  PARSE_X264_OPT("deblock", deblock);
765  PARSE_X264_OPT("partitions", partitions);
766  PARSE_X264_OPT("stats", stats);
767  if (x4->psy >= 0)
768  x4->params.analyse.b_psy = x4->psy;
769  if (x4->rc_lookahead >= 0)
770  x4->params.rc.i_lookahead = x4->rc_lookahead;
771  if (x4->weightp >= 0)
772  x4->params.analyse.i_weighted_pred = x4->weightp;
773  if (x4->weightb >= 0)
774  x4->params.analyse.b_weighted_bipred = x4->weightb;
775  if (x4->cplxblur >= 0)
776  x4->params.rc.f_complexity_blur = x4->cplxblur;
777 
778  if (x4->ssim >= 0)
779  x4->params.analyse.b_ssim = x4->ssim;
780  if (x4->intra_refresh >= 0)
781  x4->params.b_intra_refresh = x4->intra_refresh;
782  if (x4->bluray_compat >= 0) {
783  x4->params.b_bluray_compat = x4->bluray_compat;
784  x4->params.b_vfr_input = 0;
785  }
786  if (x4->avcintra_class >= 0)
787 #if X264_BUILD >= 142
788  x4->params.i_avcintra_class = x4->avcintra_class;
789 #else
790  av_log(avctx, AV_LOG_ERROR,
791  "x264 too old for AVC Intra, at least version 142 needed\n");
792 #endif
793  if (x4->b_bias != INT_MIN)
794  x4->params.i_bframe_bias = x4->b_bias;
795  if (x4->b_pyramid >= 0)
796  x4->params.i_bframe_pyramid = x4->b_pyramid;
797  if (x4->mixed_refs >= 0)
798  x4->params.analyse.b_mixed_references = x4->mixed_refs;
799  if (x4->dct8x8 >= 0)
800  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
801  if (x4->fast_pskip >= 0)
802  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
803  if (x4->aud >= 0)
804  x4->params.b_aud = x4->aud;
805  if (x4->mbtree >= 0)
806  x4->params.rc.b_mb_tree = x4->mbtree;
807  if (x4->direct_pred >= 0)
808  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
809 
810  if (x4->slice_max_size >= 0)
811  x4->params.i_slice_max_size = x4->slice_max_size;
812 
813  if (x4->fastfirstpass)
814  x264_param_apply_fastfirstpass(&x4->params);
815 
816  /* Allow specifying the x264 profile through AVCodecContext. */
817  if (!x4->profile)
818  switch (avctx->profile) {
820  x4->profile = av_strdup("baseline");
821  break;
823  x4->profile = av_strdup("high");
824  break;
826  x4->profile = av_strdup("high10");
827  break;
829  x4->profile = av_strdup("high422");
830  break;
832  x4->profile = av_strdup("high444");
833  break;
835  x4->profile = av_strdup("main");
836  break;
837  default:
838  break;
839  }
840 
841  if (x4->nal_hrd >= 0)
842  x4->params.i_nal_hrd = x4->nal_hrd;
843 
844  if (x4->motion_est >= 0)
845  x4->params.analyse.i_me_method = x4->motion_est;
846 
847  if (x4->coder >= 0)
848  x4->params.b_cabac = x4->coder;
849 
850  if (x4->b_frame_strategy >= 0)
851  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
852 
853  if (x4->profile)
854  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
855  int i;
856  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
857  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
858  for (i = 0; x264_profile_names[i]; i++)
859  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
860  av_log(avctx, AV_LOG_INFO, "\n");
861  return AVERROR(EINVAL);
862  }
863 
864  x4->params.i_width = avctx->width;
865  x4->params.i_height = avctx->height;
866  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
867  x4->params.vui.i_sar_width = sw;
868  x4->params.vui.i_sar_height = sh;
869  x4->params.i_timebase_den = avctx->time_base.den;
870  x4->params.i_timebase_num = avctx->time_base.num;
871  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
872  x4->params.i_fps_num = avctx->framerate.num;
873  x4->params.i_fps_den = avctx->framerate.den;
874  } else {
875  x4->params.i_fps_num = avctx->time_base.den;
876  x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame;
877  }
878 
879  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
880 
881  x4->params.i_threads = avctx->thread_count;
882  if (avctx->thread_type)
883  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
884 
885  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
886 
887  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
888 
889  x4->params.i_slice_count = avctx->slices;
890 
891  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
892  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
893  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
894  avctx->color_range == AVCOL_RANGE_JPEG;
895 
896  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
897  x4->params.vui.i_colmatrix = avctx->colorspace;
899  x4->params.vui.i_colorprim = avctx->color_primaries;
900  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
901  x4->params.vui.i_transfer = avctx->color_trc;
902 
903  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
904  x4->params.b_repeat_headers = 0;
905 
906  if(x4->x264opts){
907  const char *p= x4->x264opts;
908  while(p){
909  char param[4096]={0}, val[4096]={0};
910  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
911  ret = parse_opts(avctx, param, "1");
912  if (ret < 0)
913  return ret;
914  } else {
915  ret = parse_opts(avctx, param, val);
916  if (ret < 0)
917  return ret;
918  }
919  p= strchr(p, ':');
920  p+=!!p;
921  }
922  }
923 
924 
925  {
926  AVDictionaryEntry *en = NULL;
927  while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) {
928  if ((ret = x264_param_parse(&x4->params, en->key, en->value)) < 0) {
929  av_log(avctx, AV_LOG_WARNING,
930  "Error parsing option '%s = %s'.\n",
931  en->key, en->value);
932 #if X264_BUILD >= 161
933  if (ret == X264_PARAM_ALLOC_FAILED)
934  return AVERROR(ENOMEM);
935 #endif
936  }
937  }
938  }
939 
940  // update AVCodecContext with x264 parameters
941  avctx->has_b_frames = x4->params.i_bframe ?
942  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
943  if (avctx->max_b_frames < 0)
944  avctx->max_b_frames = 0;
945 
946  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
947 
948  x4->enc = x264_encoder_open(&x4->params);
949  if (!x4->enc)
950  return AVERROR_EXTERNAL;
951 
952  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
953  x264_nal_t *nal;
954  uint8_t *p;
955  int nnal, s, i;
956 
957  s = x264_encoder_headers(x4->enc, &nal, &nnal);
959  if (!p)
960  return AVERROR(ENOMEM);
961 
962  for (i = 0; i < nnal; i++) {
963  /* Don't put the SEI in extradata. */
964  if (nal[i].i_type == NAL_SEI) {
965  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
966  x4->sei_size = nal[i].i_payload;
967  x4->sei = av_malloc(x4->sei_size);
968  if (!x4->sei)
969  return AVERROR(ENOMEM);
970  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
971  continue;
972  }
973  memcpy(p, nal[i].p_payload, nal[i].i_payload);
974  p += nal[i].i_payload;
975  }
976  avctx->extradata_size = p - avctx->extradata;
977  }
978 
979  cpb_props = ff_add_cpb_side_data(avctx);
980  if (!cpb_props)
981  return AVERROR(ENOMEM);
982  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
983  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
984  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
985 
986  // Overestimate the reordered opaque buffer size, in case a runtime
987  // reconfigure would increase the delay (which it shouldn't).
988  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
990  sizeof(*x4->reordered_opaque));
991  if (!x4->reordered_opaque)
992  return AVERROR(ENOMEM);
993 
994  return 0;
995 }
996 
997 static const enum AVPixelFormat pix_fmts_8bit[] = {
1006 #ifdef X264_CSP_NV21
1008 #endif
1010 };
1011 static const enum AVPixelFormat pix_fmts_9bit[] = {
1015 };
1016 static const enum AVPixelFormat pix_fmts_10bit[] = {
1022 };
1023 static const enum AVPixelFormat pix_fmts_all[] = {
1032 #ifdef X264_CSP_NV21
1034 #endif
1039 #ifdef X264_CSP_I400
1042 #endif
1044 };
1045 #if CONFIG_LIBX264RGB_ENCODER
1046 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1051 };
1052 #endif
1053 
1054 static av_cold void X264_init_static(AVCodec *codec)
1055 {
1056 #if X264_BUILD < 153
1057  if (x264_bit_depth == 8)
1058  codec->pix_fmts = pix_fmts_8bit;
1059  else if (x264_bit_depth == 9)
1060  codec->pix_fmts = pix_fmts_9bit;
1061  else if (x264_bit_depth == 10)
1062  codec->pix_fmts = pix_fmts_10bit;
1063 #else
1064  codec->pix_fmts = pix_fmts_all;
1065 #endif
1066 }
1067 
1068 #define OFFSET(x) offsetof(X264Context, x)
1069 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1070 static const AVOption options[] = {
1071  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1072  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1073  { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1074  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1075  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1076  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1077  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1078  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1079  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1080  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1081  { "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 },
1082  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1083  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
1084  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1085  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1086  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1087 #if X264_BUILD >= 144
1088  { "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" },
1089 #endif
1090  { "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},
1091  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1092  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1093  { "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 },
1094  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1095  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
1096  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
1097  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
1098  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
1099  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1100  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1101  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1102  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1103  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
1104  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1105  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1106  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1107  { "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 },
1108  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1109  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1110  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1111  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1112  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1113  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1114  { "partitions", "A comma-separated list of partitions to consider. "
1115  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1116  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
1117  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
1118  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
1119  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
1120  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
1121  { "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 },
1122  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1123  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1124  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
1125  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1126  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1127  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1128  { "avcintra-class","AVC-Intra class 50/100/200", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE},
1129  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1130  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1131  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
1132  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
1133  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
1134  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1135  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1136  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1137  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
1138  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
1139  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1140  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1141  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1142  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1143  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1144  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
1145  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1146  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1147 
1148  { "x264-params", "Override the x264 configuration using a :-separated list of key=value parameters", OFFSET(x264_params), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
1149  { NULL },
1150 };
1151 
1152 static const AVCodecDefault x264_defaults[] = {
1153  { "b", "0" },
1154  { "bf", "-1" },
1155  { "flags2", "0" },
1156  { "g", "-1" },
1157  { "i_qfactor", "-1" },
1158  { "b_qfactor", "-1" },
1159  { "qmin", "-1" },
1160  { "qmax", "-1" },
1161  { "qdiff", "-1" },
1162  { "qblur", "-1" },
1163  { "qcomp", "-1" },
1164 // { "rc_lookahead", "-1" },
1165  { "refs", "-1" },
1166 #if FF_API_PRIVATE_OPT
1167  { "sc_threshold", "-1" },
1168 #endif
1169  { "trellis", "-1" },
1170 #if FF_API_PRIVATE_OPT
1171  { "nr", "-1" },
1172 #endif
1173  { "me_range", "-1" },
1174  { "subq", "-1" },
1175 #if FF_API_PRIVATE_OPT
1176  { "b_strategy", "-1" },
1177 #endif
1178  { "keyint_min", "-1" },
1179 #if FF_API_CODER_TYPE
1180  { "coder", "-1" },
1181 #endif
1182  { "cmp", "-1" },
1183  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1184  { "thread_type", "0" },
1185  { "flags", "+cgop" },
1186  { "rc_init_occupancy","-1" },
1187  { NULL },
1188 };
1189 
1190 #if CONFIG_LIBX264_ENCODER
1191 static const AVClass x264_class = {
1192  .class_name = "libx264",
1193  .item_name = av_default_item_name,
1194  .option = options,
1195  .version = LIBAVUTIL_VERSION_INT,
1196 };
1197 
1199  .name = "libx264",
1200  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1201  .type = AVMEDIA_TYPE_VIDEO,
1202  .id = AV_CODEC_ID_H264,
1203  .priv_data_size = sizeof(X264Context),
1204  .init = X264_init,
1205  .encode2 = X264_frame,
1206  .close = X264_close,
1207  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1209  .priv_class = &x264_class,
1210  .defaults = x264_defaults,
1212 #if X264_BUILD >= 158
1214 #else
1215  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1216 #endif
1217  .wrapper_name = "libx264",
1218 };
1219 #endif
1220 
1221 #if CONFIG_LIBX264RGB_ENCODER
1222 static const AVClass rgbclass = {
1223  .class_name = "libx264rgb",
1224  .item_name = av_default_item_name,
1225  .option = options,
1226  .version = LIBAVUTIL_VERSION_INT,
1227 };
1228 
1230  .name = "libx264rgb",
1231  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1232  .type = AVMEDIA_TYPE_VIDEO,
1233  .id = AV_CODEC_ID_H264,
1234  .priv_data_size = sizeof(X264Context),
1235  .init = X264_init,
1236  .encode2 = X264_frame,
1237  .close = X264_close,
1238  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1240  .priv_class = &rgbclass,
1241  .defaults = x264_defaults,
1242  .pix_fmts = pix_fmts_8bit_rgb,
1243 #if X264_BUILD >= 158
1245 #else
1246  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1247 #endif
1248  .wrapper_name = "libx264",
1249 };
1250 #endif
1251 
1252 #if CONFIG_LIBX262_ENCODER
1253 static const AVClass X262_class = {
1254  .class_name = "libx262",
1255  .item_name = av_default_item_name,
1256  .option = options,
1257  .version = LIBAVUTIL_VERSION_INT,
1258 };
1259 
1261  .name = "libx262",
1262  .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
1263  .type = AVMEDIA_TYPE_VIDEO,
1264  .id = AV_CODEC_ID_MPEG2VIDEO,
1265  .priv_data_size = sizeof(X264Context),
1266  .init = X264_init,
1267  .encode2 = X264_frame,
1268  .close = X264_close,
1269  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1271  .priv_class = &X262_class,
1272  .defaults = x264_defaults,
1274  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1275  .wrapper_name = "libx264",
1276 };
1277 #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:1900
#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:553
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2069
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:248
static int avfmt2_num_planes(int avfmt)
Definition: libx264.c:172
char * partitions
Definition: libx264.c:91
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int dct8x8
Definition: libx264.c:85
AVOption.
Definition: opt.h:248
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:796
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:304
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1361
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:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#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:454
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:786
AVCodec ff_libx262_encoder
int noise_reduction
Definition: libx264.c:104
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1432
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:905
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
int next_reordered_opaque
Definition: libx264.c:108
int bluray_compat
Definition: libx264.c:81
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
char * wpredp
Definition: libx264.c:67
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:118
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: codec.h:118
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:596
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:115
AVRational qoffset
Quantisation offset.
Definition: frame.h:275
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:751
x264_param_t params
Definition: libx264.c:57
char * x264opts
Definition: libx264.c:68
#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: codec.h:164
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: codec.h:75
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:33
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:1898
#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
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
Definition: avcodec.h:2354
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
#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:997
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:795
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
int me_cmp
motion estimation comparison function
Definition: avcodec.h:912
int nb_reordered_opaque
Definition: libx264.c:108
int level_idc
Definition: h264_levels.c:25
Structure to hold side data for an AVFrame.
Definition: frame.h:214
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: packet.h:363
int b_pyramid
Definition: libx264.c:83
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:59
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:455
float cplxblur
Definition: libx264.c:90
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:481
ptrdiff_t size
Definition: opengl_enc.c:100
#define FF_CMP_CHROMA
Definition: avcodec.h:947
char * stats
Definition: libx264.c:94
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:238
static enum AVPixelFormat pix_fmts_all[]
Definition: libx264.c:1023
int intra_refresh
Definition: libx264.c:80
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:446
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: atsc_a53.c:25
#define av_log(a,...)
int rc_lookahead
Definition: libx264.c:76
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:1016
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
static void dct8x8(int16_t *coef, int bit_depth)
Definition: h264dsp.c:164
int qmax
maximum quantizer
Definition: avcodec.h:1375
char * profile
Definition: libx264.c:64
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
int coder
Definition: libx264.c:99
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int fastfirstpass
Definition: libx264.c:66
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:424
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:1906
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1902
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
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:88
const char * name
Name of the codec implementation.
Definition: codec.h:197
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:831
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
char * deblock
Definition: libx264.c:89
int b_frame_strategy
Definition: libx264.c:101
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
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:1389
Views are alternated temporally.
Definition: stereo3d.h:92
common internal API header
char * psy_rd
Definition: libx264.c:74
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
int refs
number of reference frames
Definition: avcodec.h:1114
int64_t reordered_opaque
Definition: libx264.c:51
X264Opaque * reordered_opaque
Definition: libx264.c:109
int motion_est
Definition: libx264.c:97
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:1011
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:590
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:211
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#define FFMIN(a, b)
Definition: common.h:96
AVDictionary * x264_params
Definition: libx264.c:106
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:699
int cqp
Definition: libx264.c:71
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
static av_cold void init_static_data(void)
Definition: mv30.c:665
attribute_deprecated int noise_reduction
Definition: avcodec.h:1044
x264_t * enc
Definition: libx264.c:58
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:312
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
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:1797
int level
level
Definition: avcodec.h:1982
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
Structure describing a single Region Of Interest.
Definition: frame.h:233
int scenechange_threshold
Definition: libx264.c:103
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:1683
int slice_max_size
Definition: libx264.c:93
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int nal_hrd
Definition: libx264.c:95
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1382
int weightp
Definition: libx264.c:77
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
attribute_deprecated int coder_type
Definition: avcodec.h:1443
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1785
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:538
if(ret)
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:997
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
static const AVCodecDefault x264_defaults[]
Definition: libx264.c:1152
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:448
int avcintra_class
Definition: libx264.c:96
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
char * level
Definition: libx264.c:65
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
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:507
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:1040
enum AVCodecID codec_id
Definition: avcodec.h:536
int forced_idr
Definition: libx264.c:98
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:800
main external API structure.
Definition: avcodec.h:526
static const AVOption options[]
Definition: libx264.c:1070
int qmin
minimum quantizer
Definition: avcodec.h:1368
uint8_t * data
Definition: frame.h:216
#define FF_CODER_TYPE_AC
Definition: avcodec.h:1436
int extradata_size
Definition: avcodec.h:628
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
float crf
Definition: libx264.c:69
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
int aq_mode
Definition: libx264.c:72
int aud
Definition: libx264.c:87
#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:475
Describe the class of an AVClass context structure.
Definition: log.h:67
int a53_cc
Definition: libx264.c:100
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
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:60
int psy
Definition: libx264.c:75
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
Definition: libx264.c:134
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:1909
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
attribute_deprecated int chromaoffset
Definition: avcodec.h:1119
#define AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
Definition: avcodec.h:407
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1360
int sei_size
Definition: libx264.c:61
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:194
char * preset
Definition: libx264.c:62
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
mfxU16 profile
Definition: qsvenc.c:45
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
uint8_t level
Definition: svq3.c:205
int b_bias
Definition: libx264.c:82
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
int fast_pskip
Definition: libx264.c:86
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
int chroma_offset
Definition: libx264.c:102
static av_cold void X264_init_static(AVCodec *codec)
Definition: libx264.c:1054
int mixed_refs
Definition: libx264.c:84
preset
Definition: vf_curves.c:46
char * tune
Definition: libx264.c:63
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:1069
int weightb
Definition: libx264.c:78
float aq_strength
Definition: libx264.c:73
common internal api header.
int64_t wallclock
Definition: libx264.c:52
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:1776
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
static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
Definition: libx264.c:527
int trellis
trellis RD quantization
Definition: avcodec.h:1475
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2010
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
int slices
Number of slices.
Definition: avcodec.h:1177
void * priv_data
Definition: avcodec.h:553
#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:460
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:821
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:472
#define MB_SIZE
Definition: libx264.c:48
AVCodec ff_libx264rgb_encoder
int ssim
Definition: libx264.c:79
#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: packet.h:362
float crf_max
Definition: libx264.c:70
int height
Definition: frame.h:366
#define OFFSET(x)
Definition: libx264.c:1068
int direct_pred
Definition: libx264.c:92
#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:294
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:343
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:1903
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
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:988
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1795
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
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:190
int keyint_min
minimum GOP size
Definition: avcodec.h:1107