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