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