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/buffer.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/mastering_display_metadata.h"
29 #include "libavutil/mem.h"
30 #include "libavutil/pixdesc.h"
31 #include "libavutil/stereo3d.h"
32 #include "libavutil/time.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/video_hint.h"
35 #include "avcodec.h"
36 #include "codec_internal.h"
37 #include "encode.h"
38 #include "internal.h"
39 #include "packet_internal.h"
40 #include "atsc_a53.h"
41 #include "sei.h"
42 #include "golomb.h"
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 #define MB_LSIZE 4
55 #define MB_FLOOR(x) ((x) >> (MB_LSIZE))
56 #define MB_CEIL(x) MB_FLOOR((x) + (MB_SIZE - 1))
57 
58 typedef struct X264Opaque {
59  int64_t wallclock;
60  int64_t duration;
61 
62  void *frame_opaque;
63  AVBufferRef *frame_opaque_ref;
64 } X264Opaque;
65 
66 typedef struct X264Context {
67  AVClass *class;
68  x264_param_t params;
69  x264_t *enc;
70  x264_picture_t pic;
71  uint8_t *sei;
72  int sei_size;
73  char *preset;
74  char *tune;
75  const char *profile;
76  char *profile_opt;
77  char *level;
78  int fastfirstpass;
79  char *wpredp;
80  char *x264opts;
81  float crf;
82  float crf_max;
83  int cqp;
84  int aq_mode;
85  float aq_strength;
86  char *psy_rd;
87  int psy;
88  int rc_lookahead;
89  int weightp;
90  int weightb;
91  int ssim;
92  int intra_refresh;
93  int bluray_compat;
94  int b_bias;
95  int b_pyramid;
96  int mixed_refs;
97  int dct8x8;
98  int fast_pskip;
99  int aud;
100  int mbtree;
101  char *deblock;
102  float cplxblur;
103  char *partitions;
104  int direct_pred;
105  int slice_max_size;
106  char *stats;
107  int nal_hrd;
108  int avcintra_class;
109  int motion_est;
110  int forced_idr;
111  int coder;
112  int a53_cc;
113  int b_frame_strategy;
114  int chroma_offset;
115  int scenechange_threshold;
116  int noise_reduction;
117  int udu_sei;
118 
119  AVDictionary *x264_params;
120 
121  int nb_reordered_opaque, next_reordered_opaque;
122  X264Opaque *reordered_opaque;
123 
124  /**
125  * If the encoder does not support ROI then warn the first time we
126  * encounter a frame with ROI side data.
127  */
128  int roi_warned;
129 
130  int mb_info;
131 } X264Context;
132 
133 static void X264_log(void *p, int level, const char *fmt, va_list args)
134 {
135  static const int level_map[] = {
136  [X264_LOG_ERROR] = AV_LOG_ERROR,
137  [X264_LOG_WARNING] = AV_LOG_WARNING,
138  [X264_LOG_INFO] = AV_LOG_INFO,
139  [X264_LOG_DEBUG] = AV_LOG_DEBUG
140  };
141 
142  if (level < 0 || level > X264_LOG_DEBUG)
143  return;
144 
145  av_vlog(p, level_map[level], fmt, args);
146 }
147 
148 static void opaque_uninit(X264Opaque *o)
149 {
150  av_buffer_unref(&o->frame_opaque_ref);
151  memset(o, 0, sizeof(*o));
152 }
153 
154 static int encode_nals(AVCodecContext *ctx, AVPacket *pkt,
155  const x264_nal_t *nals, int nnal)
156 {
157  X264Context *x4 = ctx->priv_data;
158  uint8_t *p;
159  uint64_t size = FFMAX(x4->sei_size, 0);
160  int ret;
161 
162  if (!nnal)
163  return 0;
164 
165  for (int i = 0; i < nnal; i++) {
166  size += nals[i].i_payload;
167  /* ff_get_encode_buffer() accepts an int64_t and
168  * so we need to make sure that no overflow happens before
169  * that. With 32bit ints this is automatically true. */
170 #if INT_MAX > INT64_MAX / INT_MAX - 1
171  if ((int64_t)size < 0)
172  return AVERROR(ERANGE);
173 #endif
174  }
175 
176  if ((ret = ff_get_encode_buffer(ctx, pkt, size, 0)) < 0)
177  return ret;
178 
179  p = pkt->data;
180 
181  /* Write the SEI as part of the first frame. */
182  if (x4->sei_size > 0) {
183  memcpy(p, x4->sei, x4->sei_size);
184  p += x4->sei_size;
185  size -= x4->sei_size;
186  /* Keep the value around in case of flush */
187  x4->sei_size = -x4->sei_size;
188  }
189 
190  /* x264 guarantees the payloads of the NALs
191  * to be sequential in memory. */
192  memcpy(p, nals[0].p_payload, size);
193 
194  return 1;
195 }
196 
197 static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
198 {
199  X264Context *x4 = ctx->priv_data;
200  AVFrameSideData *side_data;
201 
202 
203  if (x4->avcintra_class < 0) {
204  if (x4->params.b_interlaced && x4->params.b_tff != !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST)) {
205 
206  x4->params.b_tff = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
207  x264_encoder_reconfig(x4->enc, &x4->params);
208  }
209  if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
210  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
211  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
212  x264_encoder_reconfig(x4->enc, &x4->params);
213  }
214 
215  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
216  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
217  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
218  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
219  x264_encoder_reconfig(x4->enc, &x4->params);
220  }
221 
222  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
223  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
224  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
225  x264_encoder_reconfig(x4->enc, &x4->params);
226  }
227 
228  if (x4->crf >= 0 &&
229  x4->params.rc.i_rc_method == X264_RC_CRF &&
230  x4->params.rc.f_rf_constant != x4->crf) {
231  x4->params.rc.f_rf_constant = x4->crf;
232  x264_encoder_reconfig(x4->enc, &x4->params);
233  }
234 
235  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
236  x4->cqp >= 0 &&
237  x4->params.rc.i_qp_constant != x4->cqp) {
238  x4->params.rc.i_qp_constant = x4->cqp;
239  x264_encoder_reconfig(x4->enc, &x4->params);
240  }
241 
242  if (x4->crf_max >= 0 &&
243  x4->params.rc.f_rf_constant_max != x4->crf_max) {
244  x4->params.rc.f_rf_constant_max = x4->crf_max;
245  x264_encoder_reconfig(x4->enc, &x4->params);
246  }
247  }
248 
249  side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_STEREO3D);
250  if (side_data) {
251  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
252  int fpa_type;
253 
254  switch (stereo->type) {
255  case AV_STEREO3D_CHECKERBOARD:
256  fpa_type = 0;
257  break;
258  case AV_STEREO3D_COLUMNS:
259  fpa_type = 1;
260  break;
261  case AV_STEREO3D_LINES:
262  fpa_type = 2;
263  break;
264  case AV_STEREO3D_SIDEBYSIDE:
265  fpa_type = 3;
266  break;
267  case AV_STEREO3D_TOPBOTTOM:
268  fpa_type = 4;
269  break;
270  case AV_STEREO3D_FRAMESEQUENCE:
271  fpa_type = 5;
272  break;
273  case AV_STEREO3D_2D:
274  fpa_type = 6;
275  break;
276  default:
277  fpa_type = -1;
278  break;
279  }
280 
281  /* Inverted mode is not supported by x264 */
282  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
283  av_log(ctx, AV_LOG_WARNING,
284  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
285  fpa_type = -1;
286  }
287 
288  if (fpa_type != x4->params.i_frame_packing) {
289  x4->params.i_frame_packing = fpa_type;
290  x264_encoder_reconfig(x4->enc, &x4->params);
291  }
292  }
293 }
294 
295 static void free_picture(x264_picture_t *pic)
296 {
297  for (int i = 0; i < pic->extra_sei.num_payloads; i++)
298  av_free(pic->extra_sei.payloads[i].payload);
299  av_freep(&pic->extra_sei.payloads);
300  av_freep(&pic->prop.quant_offsets);
301  av_freep(&pic->prop.mb_info);
302  pic->extra_sei.num_payloads = 0;
303 }
304 
305 static enum AVPixelFormat csp_to_pixfmt(int csp)
306 {
307  switch (csp) {
308 #ifdef X264_CSP_I400
309  case X264_CSP_I400: return AV_PIX_FMT_GRAY8;
310  case X264_CSP_I400 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_GRAY10;
311 #endif
312  case X264_CSP_I420: return AV_PIX_FMT_YUV420P;
313  case X264_CSP_I420 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV420P10;
314  case X264_CSP_I422: return AV_PIX_FMT_YUV422P;
315  case X264_CSP_I422 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV422P10;
316  case X264_CSP_I444: return AV_PIX_FMT_YUV444P;
317  case X264_CSP_I444 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV444P10;
318  case X264_CSP_NV12: return AV_PIX_FMT_NV12;
319 #ifdef X264_CSP_NV21
320  case X264_CSP_NV21: return AV_PIX_FMT_NV21;
321 #endif
322  case X264_CSP_NV16: return AV_PIX_FMT_NV16;
323  };
324  return AV_PIX_FMT_NONE;
325 }
326 
327 static void av_always_inline mbinfo_compute_changed_coords(const AVVideoRect *rect,
328  int *min_x,
329  int *max_x,
330  int *min_y,
331  int *max_y)
332 {
333  *min_y = MB_FLOOR(rect->y);
334  *max_y = MB_CEIL(rect->y + rect->height);
335  *min_x = MB_FLOOR(rect->x);
336  *max_x = MB_CEIL(rect->x + rect->width);
337 }
338 
339 static void av_always_inline mbinfo_compute_constant_coords(const AVVideoRect *rect,
340  int *min_x,
341  int *max_x,
342  int *min_y,
343  int *max_y)
344 {
345  *min_y = MB_CEIL(rect->y);
346  *max_y = MB_FLOOR(rect->y + rect->height);
347  *min_x = MB_CEIL(rect->x);
348  *max_x = MB_FLOOR(rect->x + rect->width);
349 }
350 
351 static int setup_mb_info(AVCodecContext *ctx, x264_picture_t *pic,
352  const AVFrame *frame,
353  const AVVideoHint *info)
354 {
355  int mb_width = (frame->width + MB_SIZE - 1) / MB_SIZE;
356  int mb_height = (frame->height + MB_SIZE - 1) / MB_SIZE;
357 
358  const AVVideoRect *mbinfo_rects;
359  int nb_rects;
360  uint8_t *mbinfo;
361 
362  mbinfo_rects = (const AVVideoRect *)av_video_hint_rects(info);
363  nb_rects = info->nb_rects;
364 
365  mbinfo = av_calloc(mb_width * mb_height, sizeof(*mbinfo));
366  if (!mbinfo)
367  return AVERROR(ENOMEM);
368 
369 #define COMPUTE_MBINFO(mbinfo_filler_, mbinfo_marker_, compute_coords_fn_) \
370  memset(mbinfo, mbinfo_filler_, sizeof(*mbinfo) * mb_width * mb_height); \
371  \
372  for (int i = 0; i < nb_rects; i++) { \
373  int min_x, max_x, min_y, max_y; \
374  \
375  compute_coords_fn_(mbinfo_rects, &min_x, &max_x, &min_y, &max_y); \
376  for (int mb_y = min_y; mb_y < max_y; ++mb_y) { \
377  memset(mbinfo + mb_y * mb_width + min_x, mbinfo_marker_, max_x - min_x); \
378  } \
379  \
380  mbinfo_rects++; \
381  } \
382 
383  if (info->type == AV_VIDEO_HINT_TYPE_CHANGED) {
384  COMPUTE_MBINFO(X264_MBINFO_CONSTANT, 0, mbinfo_compute_changed_coords);
385  } else /* if (info->type == AV_VIDEO_HINT_TYPE_CHANGED) */ {
386  COMPUTE_MBINFO(0, X264_MBINFO_CONSTANT, mbinfo_compute_constant_coords);
387  }
388 
389  pic->prop.mb_info = mbinfo;
390  pic->prop.mb_info_free = av_free;
391 
392  return 0;
393 }
394 
395 static int setup_roi(AVCodecContext *ctx, x264_picture_t *pic,
396  const AVFrame *frame, const uint8_t *data, size_t size)
397 {
398  X264Context *x4 = ctx->priv_data;
399 
400  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
401  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
402  int qp_range = 51 + 6 * (x4->params.i_bitdepth - 8);
403  int nb_rois;
404  const AVRegionOfInterest *roi;
405  uint32_t roi_size;
406  float *qoffsets;
407 
408  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
409  if (!x4->roi_warned) {
410  x4->roi_warned = 1;
411  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
412  }
413  return 0;
414  } else if (frame->flags & AV_FRAME_FLAG_INTERLACED) {
415  if (!x4->roi_warned) {
416  x4->roi_warned = 1;
417  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
418  }
419  return 0;
420  }
421 
422  roi = (const AVRegionOfInterest*)data;
423  roi_size = roi->self_size;
424  if (!roi_size || size % roi_size != 0) {
425  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
426  return AVERROR(EINVAL);
427  }
428  nb_rois = size / roi_size;
429 
430  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
431  if (!qoffsets)
432  return AVERROR(ENOMEM);
433 
434  // This list must be iterated in reverse because the first
435  // region in the list applies when regions overlap.
436  for (int i = nb_rois - 1; i >= 0; i--) {
437  int startx, endx, starty, endy;
438  float qoffset;
439 
440  roi = (const AVRegionOfInterest*)(data + roi_size * i);
441 
442  starty = FFMIN(mby, roi->top / MB_SIZE);
443  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
444  startx = FFMIN(mbx, roi->left / MB_SIZE);
445  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
446 
447  if (roi->qoffset.den == 0) {
448  av_free(qoffsets);
449  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
450  return AVERROR(EINVAL);
451  }
452  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
453  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
454 
455  for (int y = starty; y < endy; y++) {
456  for (int x = startx; x < endx; x++) {
457  qoffsets[x + y*mbx] = qoffset;
458  }
459  }
460  }
461 
462  pic->prop.quant_offsets = qoffsets;
463  pic->prop.quant_offsets_free = av_free;
464 
465  return 0;
466 }
467 
468 static int setup_frame(AVCodecContext *ctx, const AVFrame *frame,
469  x264_picture_t **ppic)
470 {
471  X264Context *x4 = ctx->priv_data;
472  X264Opaque *opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
473  x264_picture_t *pic = &x4->pic;
474  x264_sei_t *sei = &pic->extra_sei;
475  unsigned int sei_data_size = 0;
476  int64_t wallclock = 0;
477  int ret;
478  AVFrameSideData *sd;
479  AVFrameSideData *mbinfo_sd;
480 
481  *ppic = NULL;
482  if (!frame)
483  return 0;
484 
485  x264_picture_init(pic);
486  pic->img.i_csp = x4->params.i_csp;
487  if (x4->params.i_bitdepth > 8)
488  pic->img.i_csp |= X264_CSP_HIGH_DEPTH;
489  pic->img.i_plane = av_pix_fmt_count_planes(ctx->pix_fmt);
490 
491  for (int i = 0; i < pic->img.i_plane; i++) {
492  pic->img.plane[i] = frame->data[i];
493  pic->img.i_stride[i] = frame->linesize[i];
494  }
495 
496  pic->i_pts = frame->pts;
497 
498  opaque_uninit(opaque);
499 
500  if (ctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
501  opaque->frame_opaque = frame->opaque;
502  ret = av_buffer_replace(&opaque->frame_opaque_ref, frame->opaque_ref);
503  if (ret < 0)
504  goto fail;
505  }
506 
507  opaque->duration = frame->duration;
508  opaque->wallclock = wallclock;
509  if (ctx->export_side_data & AV_CODEC_EXPORT_DATA_PRFT)
510  opaque->wallclock = av_gettime();
511 
512  pic->opaque = opaque;
513 
514  x4->next_reordered_opaque++;
515  x4->next_reordered_opaque %= x4->nb_reordered_opaque;
516 
517  switch (frame->pict_type) {
518  case AV_PICTURE_TYPE_I:
519  pic->i_type = x4->forced_idr > 0 ? X264_TYPE_IDR : X264_TYPE_KEYFRAME;
520  break;
521  case AV_PICTURE_TYPE_P:
522  pic->i_type = X264_TYPE_P;
523  break;
524  case AV_PICTURE_TYPE_B:
525  pic->i_type = X264_TYPE_B;
526  break;
527  default:
528  pic->i_type = X264_TYPE_AUTO;
529  break;
530  }
531  reconfig_encoder(ctx, frame);
532 
533  if (x4->a53_cc) {
534  void *sei_data;
535  size_t sei_size;
536 
537  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
538  if (ret < 0)
539  goto fail;
540 
541  if (sei_data) {
542  sei->payloads = av_mallocz(sizeof(sei->payloads[0]));
543  if (!sei->payloads) {
544  av_free(sei_data);
545  ret = AVERROR(ENOMEM);
546  goto fail;
547  }
548 
549  sei->sei_free = av_free;
550 
551  sei->payloads[0].payload_size = sei_size;
552  sei->payloads[0].payload = sei_data;
553  sei->payloads[0].payload_type = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
554  sei->num_payloads = 1;
555  }
556  }
557 
558  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
559  if (sd) {
560  ret = setup_roi(ctx, pic, frame, sd->data, sd->size);
561  if (ret < 0)
562  goto fail;
563  }
564 
565  mbinfo_sd = av_frame_get_side_data(frame, AV_FRAME_DATA_VIDEO_HINT);
566  if (mbinfo_sd) {
567  int err = setup_mb_info(ctx, pic, frame, (const AVVideoHint *)mbinfo_sd->data);
568  if (err < 0) {
569  /* No need to fail here, this is not fatal. We just proceed with no
570  * mb_info and log a message */
571 
572  av_log(ctx, AV_LOG_WARNING, "setup_mb_info failed with error: %s\n", av_err2str(err));
573  }
574  }
575 
576  if (x4->udu_sei) {
577  for (int j = 0; j < frame->nb_side_data; j++) {
578  AVFrameSideData *side_data = frame->side_data[j];
579  void *tmp;
580  x264_sei_payload_t *sei_payload;
581  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
582  continue;
583  tmp = av_fast_realloc(sei->payloads, &sei_data_size, (sei->num_payloads + 1) * sizeof(*sei_payload));
584  if (!tmp) {
585  ret = AVERROR(ENOMEM);
586  goto fail;
587  }
588  sei->payloads = tmp;
589  sei->sei_free = av_free;
590  sei_payload = &sei->payloads[sei->num_payloads];
591  sei_payload->payload = av_memdup(side_data->data, side_data->size);
592  if (!sei_payload->payload) {
593  ret = AVERROR(ENOMEM);
594  goto fail;
595  }
596  sei_payload->payload_size = side_data->size;
597  sei_payload->payload_type = SEI_TYPE_USER_DATA_UNREGISTERED;
598  sei->num_payloads++;
599  }
600  }
601 
602  *ppic = pic;
603  return 0;
604 
605 fail:
606  free_picture(pic);
607  *ppic = NULL;
608  return ret;
609 }
610 
611 static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
612  int *got_packet)
613 {
614  X264Context *x4 = ctx->priv_data;
615  x264_nal_t *nal;
616  int nnal, ret;
617  x264_picture_t pic_out = {0}, *pic_in;
618  int pict_type;
619  int64_t wallclock = 0;
620  X264Opaque *out_opaque;
621 
622  ret = setup_frame(ctx, frame, &pic_in);
623  if (ret < 0)
624  return ret;
625 
626  do {
627  if (x264_encoder_encode(x4->enc, &nal, &nnal, pic_in, &pic_out) < 0)
628  return AVERROR_EXTERNAL;
629 
630  if (nnal && (ctx->flags & AV_CODEC_FLAG_RECON_FRAME)) {
631  AVCodecInternal *avci = ctx->internal;
632 
633  av_frame_unref(avci->recon_frame);
634 
635  avci->recon_frame->format = csp_to_pixfmt(pic_out.img.i_csp);
636  if (avci->recon_frame->format == AV_PIX_FMT_NONE) {
637  av_log(ctx, AV_LOG_ERROR,
638  "Unhandled reconstructed frame colorspace: %d\n",
639  pic_out.img.i_csp);
640  return AVERROR(ENOSYS);
641  }
642 
643  avci->recon_frame->width = ctx->width;
644  avci->recon_frame->height = ctx->height;
645  for (int i = 0; i < pic_out.img.i_plane; i++) {
646  avci->recon_frame->data[i] = pic_out.img.plane[i];
647  avci->recon_frame->linesize[i] = pic_out.img.i_stride[i];
648  }
649 
650  ret = av_frame_make_writable(avci->recon_frame);
651  if (ret < 0) {
652  av_frame_unref(avci->recon_frame);
653  return ret;
654  }
655  }
656 
657  ret = encode_nals(ctx, pkt, nal, nnal);
658  if (ret < 0)
659  return ret;
660  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
661 
662  if (!ret)
663  return 0;
664 
665  pkt->pts = pic_out.i_pts;
666  pkt->dts = pic_out.i_dts;
667 
668  out_opaque = pic_out.opaque;
669  if (out_opaque >= x4->reordered_opaque &&
670  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
671  wallclock = out_opaque->wallclock;
672  pkt->duration = out_opaque->duration;
673 
674  if (ctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
675  pkt->opaque = out_opaque->frame_opaque;
676  pkt->opaque_ref = out_opaque->frame_opaque_ref;
677  out_opaque->frame_opaque_ref = NULL;
678  }
679 
680  opaque_uninit(out_opaque);
681  } else {
682  // Unexpected opaque pointer on picture output
683  av_log(ctx, AV_LOG_ERROR, "Unexpected opaque pointer; "
684  "this is a bug, please report it.\n");
685  }
686 
687  switch (pic_out.i_type) {
688  case X264_TYPE_IDR:
689  case X264_TYPE_I:
690  pict_type = AV_PICTURE_TYPE_I;
691  break;
692  case X264_TYPE_P:
693  pict_type = AV_PICTURE_TYPE_P;
694  break;
695  case X264_TYPE_B:
696  case X264_TYPE_BREF:
697  pict_type = AV_PICTURE_TYPE_B;
698  break;
699  default:
700  av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
701  return AVERROR_EXTERNAL;
702  }
703 
704  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
705  if (ret) {
706  int error_count = 0;
707  int64_t *errors = NULL;
708  int64_t sse[3] = {0};
709 
710  if (ctx->flags & AV_CODEC_FLAG_PSNR) {
711  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(ctx->pix_fmt);
712  double scale[3] = { 1,
713  (double)(1 << pix_desc->log2_chroma_h) * (1 << pix_desc->log2_chroma_w),
714  (double)(1 << pix_desc->log2_chroma_h) * (1 << pix_desc->log2_chroma_w),
715  };
716 
717  error_count = pix_desc->nb_components;
718 
719  for (int i = 0; i < pix_desc->nb_components; ++i) {
720  double max_value = (double)(1 << pix_desc->comp[i].depth) - 1.0;
721  double plane_size = ctx->width * (double)ctx->height / scale[i];
722 
723  /* psnr = 10 * log10(max_value * max_value / mse) */
724  double mse = (max_value * max_value) / pow(10, pic_out.prop.f_psnr[i] / 10.0);
725 
726  /* SSE = MSE * width * height / scale -> because of possible chroma downsampling */
727  sse[i] = (int64_t)floor(mse * plane_size + .5);
728  }
729 
730  errors = sse;
731  }
732 
733  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA,
734  errors, error_count, pict_type);
735 
736  if (wallclock)
737  ff_side_data_set_prft(pkt, wallclock);
738  }
739 
740  *got_packet = ret;
741  return 0;
742 }
743 
744 static void X264_flush(AVCodecContext *avctx)
745 {
746  X264Context *x4 = avctx->priv_data;
747  x264_nal_t *nal;
748  int nnal, ret;
749  x264_picture_t pic_out = {0};
750 
751  do {
752  ret = x264_encoder_encode(x4->enc, &nal, &nnal, NULL, &pic_out);
753  } while (ret > 0 && x264_encoder_delayed_frames(x4->enc));
754 
755  for (int i = 0; i < x4->nb_reordered_opaque; i++)
756  opaque_uninit(&x4->reordered_opaque[i]);
757 
758  if (x4->sei_size < 0)
759  x4->sei_size = -x4->sei_size;
760 }
761 
762 static av_cold int X264_close(AVCodecContext *avctx)
763 {
764  X264Context *x4 = avctx->priv_data;
765 
766  av_freep(&x4->sei);
767 
768  for (int i = 0; i < x4->nb_reordered_opaque; i++)
769  opaque_uninit(&x4->reordered_opaque[i]);
770  av_freep(&x4->reordered_opaque);
771 
772 #if X264_BUILD >= 161
773  x264_param_cleanup(&x4->params);
774 #endif
775 
776  if (x4->enc) {
777  x264_encoder_close(x4->enc);
778  x4->enc = NULL;
779  }
780 
781  return 0;
782 }
783 
784 static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
785 {
786  X264Context *x4 = avctx->priv_data;
787  int ret;
788 
789  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) {
790  if (ret == X264_PARAM_BAD_NAME) {
791  av_log(avctx, AV_LOG_ERROR,
792  "bad option '%s': '%s'\n", opt, param);
793  ret = AVERROR(EINVAL);
794 #if X264_BUILD >= 161
795  } else if (ret == X264_PARAM_ALLOC_FAILED) {
796  av_log(avctx, AV_LOG_ERROR,
797  "out of memory parsing option '%s': '%s'\n", opt, param);
798  ret = AVERROR(ENOMEM);
799 #endif
800  } else {
801  av_log(avctx, AV_LOG_ERROR,
802  "bad value for '%s': '%s'\n", opt, param);
803  ret = AVERROR(EINVAL);
804  }
805  }
806 
807  return ret;
808 }
809 
810 static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
811 {
812  switch (pix_fmt) {
813  case AV_PIX_FMT_YUV420P:
814  case AV_PIX_FMT_YUVJ420P:
815  case AV_PIX_FMT_YUV420P9:
816  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
817  case AV_PIX_FMT_YUV422P:
818  case AV_PIX_FMT_YUVJ422P:
819  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
820  case AV_PIX_FMT_YUV444P:
821  case AV_PIX_FMT_YUVJ444P:
822  case AV_PIX_FMT_YUV444P9:
823  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
824  case AV_PIX_FMT_BGR0:
825  return X264_CSP_BGRA;
826  case AV_PIX_FMT_BGR24:
827  return X264_CSP_BGR;
828 
829  case AV_PIX_FMT_RGB24:
830  return X264_CSP_RGB;
831  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
832  case AV_PIX_FMT_NV16:
833  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
834 #ifdef X264_CSP_NV21
835  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
836 #endif
837 #ifdef X264_CSP_I400
838  case AV_PIX_FMT_GRAY8:
839  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
840 #endif
841  };
842  return 0;
843 }
844 
845 static int save_sei(AVCodecContext *avctx, x264_nal_t *nal)
846 {
847  X264Context *x4 = avctx->priv_data;
848 
849  av_log(avctx, AV_LOG_INFO, "%s\n", nal->p_payload + 25);
850  x4->sei_size = nal->i_payload;
851  x4->sei = av_malloc(x4->sei_size);
852  if (!x4->sei)
853  return AVERROR(ENOMEM);
854 
855  memcpy(x4->sei, nal->p_payload, nal->i_payload);
856 
857  return 0;
858 }
859 
860 #if CONFIG_LIBX264_ENCODER
861 static int set_avcc_extradata(AVCodecContext *avctx, x264_nal_t *nal, int nnal)
862 {
863  x264_nal_t *sps_nal = NULL;
864  x264_nal_t *pps_nal = NULL;
865  uint8_t *p, *sps;
866  int ret;
867 
868  /* We know it's in the order of SPS/PPS/SEI, but it's not documented in x264 API.
869  * The x264 param i_sps_id implies there is a single pair of SPS/PPS.
870  */
871  for (int i = 0; i < nnal; i++) {
872  switch (nal[i].i_type) {
873  case NAL_SPS:
874  sps_nal = &nal[i];
875  break;
876  case NAL_PPS:
877  pps_nal = &nal[i];
878  break;
879  case NAL_SEI:
880  ret = save_sei(avctx, &nal[i]);
881  if (ret < 0)
882  return ret;
883  break;
884  }
885  }
886  if (!sps_nal || !pps_nal)
887  return AVERROR_EXTERNAL;
888 
889  avctx->extradata_size = sps_nal->i_payload + pps_nal->i_payload + 7;
890  avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
891  if (!avctx->extradata)
892  return AVERROR(ENOMEM);
893 
894  // Now create AVCDecoderConfigurationRecord
895  p = avctx->extradata;
896  // Skip size part
897  sps = sps_nal->p_payload + 4;
898  *p++ = 1; // version
899  *p++ = sps[1]; // AVCProfileIndication
900  *p++ = sps[2]; // profile_compatibility
901  *p++ = sps[3]; // AVCLevelIndication
902  *p++ = 0xFF;
903  *p++ = 0xE0 | 0x01; // 3 bits reserved (111) + 5 bits number of sps
904  memcpy(p, sps_nal->p_payload + 2, sps_nal->i_payload - 2);
905  // Make sps has AV_INPUT_BUFFER_PADDING_SIZE padding, so it can be used
906  // with GetBitContext
907  sps = p + 2;
908  p += sps_nal->i_payload - 2;
909  *p++ = 1;
910  memcpy(p, pps_nal->p_payload + 2, pps_nal->i_payload - 2);
911  p += pps_nal->i_payload - 2;
912 
913  if (sps[3] != 66 && sps[3] != 77 && sps[3] != 88) {
914  GetBitContext gbc;
915  int chroma_format_idc;
916  int bit_depth_luma_minus8, bit_depth_chroma_minus8;
917 
918  /* It's not possible to have emulation prevention byte before
919  * bit_depth_chroma_minus8 due to the range of sps id, chroma_format_idc
920  * and so on. So we can read directly without need to escape emulation
921  * prevention byte.
922  *
923  * +4 to skip until sps id.
924  */
925  ret = init_get_bits8(&gbc, sps + 4, sps_nal->i_payload - 4 - 4);
926  if (ret < 0)
927  return ret;
928  // Skip sps id
929  get_ue_golomb_31(&gbc);
930  chroma_format_idc = get_ue_golomb_31(&gbc);
931  if (chroma_format_idc == 3)
932  skip_bits1(&gbc);
933  bit_depth_luma_minus8 = get_ue_golomb_31(&gbc);
934  bit_depth_chroma_minus8 = get_ue_golomb_31(&gbc);
935 
936  *p++ = 0xFC | chroma_format_idc;
937  *p++ = 0xF8 | bit_depth_luma_minus8;
938  *p++ = 0xF8 | bit_depth_chroma_minus8;
939  *p++ = 0;
940  }
941  av_assert2(avctx->extradata + avctx->extradata_size >= p);
942  avctx->extradata_size = p - avctx->extradata;
943 
944  return 0;
945 }
946 #endif
947 
948 static int set_extradata(AVCodecContext *avctx)
949 {
950  X264Context *x4 = avctx->priv_data;
951  x264_nal_t *nal;
952  uint8_t *p;
953  int nnal, s;
954 
955  s = x264_encoder_headers(x4->enc, &nal, &nnal);
956  if (s < 0)
957  return AVERROR_EXTERNAL;
958 
959 #if CONFIG_LIBX264_ENCODER
960  if (!x4->params.b_annexb)
961  return set_avcc_extradata(avctx, nal, nnal);
962 #endif
963 
964  avctx->extradata = p = av_mallocz(s + AV_INPUT_BUFFER_PADDING_SIZE);
965  if (!p)
966  return AVERROR(ENOMEM);
967 
968  for (int i = 0; i < nnal; i++) {
969  /* Don't put the SEI in extradata. */
970  if (nal[i].i_type == NAL_SEI) {
971  s = save_sei(avctx, &nal[i]);
972  if (s < 0)
973  return s;
974  continue;
975  }
976  memcpy(p, nal[i].p_payload, nal[i].i_payload);
977  p += nal[i].i_payload;
978  }
979  avctx->extradata_size = p - avctx->extradata;
980 
981  return 0;
982 }
983 
984 #define PARSE_X264_OPT(name, var)\
985  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
986  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
987  return AVERROR(EINVAL);\
988  }
989 
990 #if CONFIG_LIBX264_HDR10
991 static void handle_mdcv(x264_param_t *params,
992  const AVMasteringDisplayMetadata *mdcv)
993 {
994  if (!mdcv->has_primaries && !mdcv->has_luminance)
995  return;
996 
997  params->mastering_display.b_mastering_display = 1;
998 
999  if (mdcv->has_primaries) {
1000  int *const points[][2] = {
1001  {
1002  &params->mastering_display.i_red_x,
1003  &params->mastering_display.i_red_y
1004  },
1005  {
1006  &params->mastering_display.i_green_x,
1007  &params->mastering_display.i_green_y
1008  },
1009  {
1010  &params->mastering_display.i_blue_x,
1011  &params->mastering_display.i_blue_y
1012  },
1013  };
1014 
1015  for (int i = 0; i < 3; i++) {
1016  const AVRational *src = mdcv->display_primaries[i];
1017  int *dst[2] = { points[i][0], points[i][1] };
1018 
1019  *dst[0] = av_rescale_q(1, src[0], (AVRational){ 1, 50000 });
1020  *dst[1] = av_rescale_q(1, src[1], (AVRational){ 1, 50000 });
1021  }
1022 
1023  params->mastering_display.i_white_x =
1024  av_rescale_q(1, mdcv->white_point[0], (AVRational){ 1, 50000 });
1025  params->mastering_display.i_white_y =
1026  av_rescale_q(1, mdcv->white_point[1], (AVRational){ 1, 50000 });
1027  }
1028 
1029  if (mdcv->has_luminance) {
1030  params->mastering_display.i_display_max =
1031  av_rescale_q(1, mdcv->max_luminance, (AVRational){ 1, 10000 });
1032  params->mastering_display.i_display_min =
1033  av_rescale_q(1, mdcv->min_luminance, (AVRational){ 1, 10000 });
1034  }
1035 }
1036 #endif // CONFIG_LIBX264_HDR10
1037 
1038 static void handle_side_data(AVCodecContext *avctx, x264_param_t *params)
1039 {
1040 #if CONFIG_LIBX264_HDR10
1041  const AVFrameSideData *cll_sd =
1042  av_frame_side_data_get(avctx->decoded_side_data,
1043  avctx->nb_decoded_side_data, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
1044  const AVFrameSideData *mdcv_sd =
1045  av_frame_side_data_get(avctx->decoded_side_data,
1046  avctx->nb_decoded_side_data,
1047  AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
1048 
1049  if (cll_sd) {
1050  const AVContentLightMetadata *cll =
1051  (AVContentLightMetadata *)cll_sd->data;
1052 
1053  params->content_light_level.i_max_cll = cll->MaxCLL;
1054  params->content_light_level.i_max_fall = cll->MaxFALL;
1055 
1056  params->content_light_level.b_cll = 1;
1057  }
1058 
1059  if (mdcv_sd) {
1060  handle_mdcv(params, (AVMasteringDisplayMetadata *)mdcv_sd->data);
1061  }
1062 #endif // CONFIG_LIBX264_HDR10
1063 }
1064 
1065 static av_cold int X264_init(AVCodecContext *avctx)
1066 {
1067  X264Context *x4 = avctx->priv_data;
1068  AVCPBProperties *cpb_props;
1069  int sw,sh;
1070  int ret;
1071 
1072  if (avctx->global_quality > 0)
1073  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
1074 
1075 #if CONFIG_LIBX262_ENCODER
1076  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1077  x4->params.b_mpeg2 = 1;
1078  x264_param_default_mpeg2(&x4->params);
1079  } else
1080 #endif
1081  x264_param_default(&x4->params);
1082 
1083  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
1084 
1085  if (x4->preset || x4->tune)
1086  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
1087  int i;
1088  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
1089  av_log(avctx, AV_LOG_INFO, "Possible presets:");
1090  for (i = 0; x264_preset_names[i]; i++)
1091  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
1092  av_log(avctx, AV_LOG_INFO, "\n");
1093  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
1094  for (i = 0; x264_tune_names[i]; i++)
1095  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
1096  av_log(avctx, AV_LOG_INFO, "\n");
1097  return AVERROR(EINVAL);
1098  }
1099 
1100  if (avctx->level > 0)
1101  x4->params.i_level_idc = avctx->level;
1102 
1103  x4->params.pf_log = X264_log;
1104  x4->params.p_log_private = avctx;
1105  x4->params.i_log_level = X264_LOG_DEBUG;
1106  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
1107  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
1108 
1109  PARSE_X264_OPT("weightp", wpredp);
1110 
1111  if (avctx->bit_rate) {
1112  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
1113  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
1114  return AVERROR(EINVAL);
1115  }
1116  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
1117  x4->params.rc.i_rc_method = X264_RC_ABR;
1118  }
1119  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
1120  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
1121  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
1122  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
1123  x4->params.rc.b_stat_read = 1;
1124  } else {
1125  if (x4->crf >= 0) {
1126  x4->params.rc.i_rc_method = X264_RC_CRF;
1127  x4->params.rc.f_rf_constant = x4->crf;
1128  } else if (x4->cqp >= 0) {
1129  x4->params.rc.i_rc_method = X264_RC_CQP;
1130  x4->params.rc.i_qp_constant = x4->cqp;
1131  }
1132 
1133  if (x4->crf_max >= 0)
1134  x4->params.rc.f_rf_constant_max = x4->crf_max;
1135  }
1136 
1137  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
1138  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
1139  x4->params.rc.f_vbv_buffer_init =
1140  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
1141  }
1142 
1143  PARSE_X264_OPT("level", level);
1144 
1145  if (avctx->i_quant_factor > 0)
1146  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
1147  if (avctx->b_quant_factor > 0)
1148  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
1149 
1150  if (x4->chroma_offset)
1151  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
1152 
1153  if (avctx->gop_size >= 0)
1154  x4->params.i_keyint_max = avctx->gop_size;
1155  if (avctx->max_b_frames >= 0)
1156  x4->params.i_bframe = avctx->max_b_frames;
1157 
1158  if (x4->scenechange_threshold >= 0)
1159  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
1160 
1161  if (avctx->qmin >= 0)
1162  x4->params.rc.i_qp_min = avctx->qmin;
1163  if (avctx->qmax >= 0)
1164  x4->params.rc.i_qp_max = avctx->qmax;
1165  if (avctx->max_qdiff >= 0)
1166  x4->params.rc.i_qp_step = avctx->max_qdiff;
1167  if (avctx->qblur >= 0)
1168  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
1169  if (avctx->qcompress >= 0)
1170  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
1171  if (avctx->refs >= 0)
1172  x4->params.i_frame_reference = avctx->refs;
1173  else if (x4->params.i_level_idc > 0) {
1174  int i;
1175  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
1176 
1177  for (i = 0; i<x264_levels[i].level_idc; i++)
1178  if (x264_levels[i].level_idc == x4->params.i_level_idc)
1179  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn, 1, x4->params.i_frame_reference);
1180  }
1181 
1182  if (avctx->trellis >= 0)
1183  x4->params.analyse.i_trellis = avctx->trellis;
1184  if (avctx->me_range >= 0)
1185  x4->params.analyse.i_me_range = avctx->me_range;
1186  if (x4->noise_reduction >= 0)
1187  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
1188  if (avctx->me_subpel_quality >= 0)
1189  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
1190  if (avctx->keyint_min >= 0)
1191  x4->params.i_keyint_min = avctx->keyint_min;
1192  if (avctx->me_cmp >= 0)
1193  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
1194 
1195  if (x4->aq_mode >= 0)
1196  x4->params.rc.i_aq_mode = x4->aq_mode;
1197  if (x4->aq_strength >= 0)
1198  x4->params.rc.f_aq_strength = x4->aq_strength;
1199  PARSE_X264_OPT("psy-rd", psy_rd);
1200  PARSE_X264_OPT("deblock", deblock);
1201  PARSE_X264_OPT("partitions", partitions);
1202  PARSE_X264_OPT("stats", stats);
1203  if (x4->psy >= 0)
1204  x4->params.analyse.b_psy = x4->psy;
1205  if (x4->rc_lookahead >= 0)
1206  x4->params.rc.i_lookahead = x4->rc_lookahead;
1207  if (x4->weightp >= 0)
1208  x4->params.analyse.i_weighted_pred = x4->weightp;
1209  if (x4->weightb >= 0)
1210  x4->params.analyse.b_weighted_bipred = x4->weightb;
1211  if (x4->cplxblur >= 0)
1212  x4->params.rc.f_complexity_blur = x4->cplxblur;
1213 
1214  if (x4->ssim >= 0)
1215  x4->params.analyse.b_ssim = x4->ssim;
1216  if (x4->intra_refresh >= 0)
1217  x4->params.b_intra_refresh = x4->intra_refresh;
1218  if (x4->bluray_compat >= 0) {
1219  x4->params.b_bluray_compat = x4->bluray_compat;
1220  x4->params.b_vfr_input = 0;
1221  }
1222  if (x4->avcintra_class >= 0)
1223  x4->params.i_avcintra_class = x4->avcintra_class;
1224 
1225  if (x4->avcintra_class > 200) {
1226 #if X264_BUILD < 164
1227  av_log(avctx, AV_LOG_ERROR,
1228  "x264 too old for AVC Intra 300/480, at least version 164 needed\n");
1229  return AVERROR(EINVAL);
1230 #else
1231  /* AVC-Intra 300/480 only supported by Sony XAVC flavor */
1232  x4->params.i_avcintra_flavor = X264_AVCINTRA_FLAVOR_SONY;
1233 #endif
1234  }
1235 
1236  if (x4->b_bias != INT_MIN)
1237  x4->params.i_bframe_bias = x4->b_bias;
1238  if (x4->b_pyramid >= 0)
1239  x4->params.i_bframe_pyramid = x4->b_pyramid;
1240  if (x4->mixed_refs >= 0)
1241  x4->params.analyse.b_mixed_references = x4->mixed_refs;
1242  if (x4->dct8x8 >= 0)
1243  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
1244  if (x4->fast_pskip >= 0)
1245  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
1246  if (x4->aud >= 0)
1247  x4->params.b_aud = x4->aud;
1248  if (x4->mbtree >= 0)
1249  x4->params.rc.b_mb_tree = x4->mbtree;
1250  if (x4->direct_pred >= 0)
1251  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
1252 
1253  if (x4->slice_max_size >= 0)
1254  x4->params.i_slice_max_size = x4->slice_max_size;
1255 
1256  if (x4->fastfirstpass)
1257  x264_param_apply_fastfirstpass(&x4->params);
1258 
1259  x4->profile = x4->profile_opt;
1260  /* Allow specifying the x264 profile through AVCodecContext. */
1261  if (!x4->profile)
1262  switch (avctx->profile) {
1263  case AV_PROFILE_H264_BASELINE:
1264  x4->profile = "baseline";
1265  break;
1266  case AV_PROFILE_H264_HIGH:
1267  x4->profile = "high";
1268  break;
1269  case AV_PROFILE_H264_HIGH_10:
1270  x4->profile = "high10";
1271  break;
1272  case AV_PROFILE_H264_HIGH_422:
1273  x4->profile = "high422";
1274  break;
1275  case AV_PROFILE_H264_HIGH_444:
1276  x4->profile = "high444";
1277  break;
1278  case AV_PROFILE_H264_MAIN:
1279  x4->profile = "main";
1280  break;
1281  default:
1282  break;
1283  }
1284 
1285  if (x4->nal_hrd >= 0)
1286  x4->params.i_nal_hrd = x4->nal_hrd;
1287 
1288  if (x4->motion_est >= 0)
1289  x4->params.analyse.i_me_method = x4->motion_est;
1290 
1291  if (x4->coder >= 0)
1292  x4->params.b_cabac = x4->coder;
1293 
1294  if (x4->b_frame_strategy >= 0)
1295  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
1296 
1297  if (x4->profile)
1298  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
1299  int i;
1300  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
1301  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
1302  for (i = 0; x264_profile_names[i]; i++)
1303  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
1304  av_log(avctx, AV_LOG_INFO, "\n");
1305  return AVERROR(EINVAL);
1306  }
1307 
1308  x4->params.i_width = avctx->width;
1309  x4->params.i_height = avctx->height;
1310  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
1311  x4->params.vui.i_sar_width = sw;
1312  x4->params.vui.i_sar_height = sh;
1313  x4->params.i_timebase_den = avctx->time_base.den;
1314  x4->params.i_timebase_num = avctx->time_base.num;
1315  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
1316  x4->params.i_fps_num = avctx->framerate.num;
1317  x4->params.i_fps_den = avctx->framerate.den;
1318  } else {
1319  x4->params.i_fps_num = avctx->time_base.den;
1320 FF_DISABLE_DEPRECATION_WARNINGS
1321  x4->params.i_fps_den = avctx->time_base.num
1322 #if FF_API_TICKS_PER_FRAME
1323  * avctx->ticks_per_frame
1324 #endif
1325  ;
1326 FF_ENABLE_DEPRECATION_WARNINGS
1327  }
1328 
1329  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
1330 
1331  x4->params.i_threads = avctx->thread_count;
1332  if (avctx->thread_type)
1333  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
1334 
1335  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
1336 
1337  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
1338 
1339  x4->params.i_slice_count = avctx->slices;
1340 
1341  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
1342  x4->params.vui.b_fullrange = avctx->color_range == AVCOL_RANGE_JPEG;
1343  else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
1344  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
1345  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P)
1346  x4->params.vui.b_fullrange = 1;
1347 
1348  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
1349  x4->params.vui.i_colmatrix = avctx->colorspace;
1350  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
1351  x4->params.vui.i_colorprim = avctx->color_primaries;
1352  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
1353  x4->params.vui.i_transfer = avctx->color_trc;
1354  if (avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
1355  x4->params.vui.i_chroma_loc = avctx->chroma_sample_location - 1;
1356 
1357  handle_side_data(avctx, &x4->params);
1358 
1359  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
1360  x4->params.b_repeat_headers = 0;
1361 
1362  if (avctx->flags & AV_CODEC_FLAG_RECON_FRAME)
1363  x4->params.b_full_recon = 1;
1364 
1365  if(x4->x264opts){
1366  const char *p= x4->x264opts;
1367  while(p){
1368  char param[4096]={0}, val[4096]={0};
1369  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
1370  ret = parse_opts(avctx, param, "1");
1371  if (ret < 0)
1372  return ret;
1373  } else {
1374  ret = parse_opts(avctx, param, val);
1375  if (ret < 0)
1376  return ret;
1377  }
1378  p= strchr(p, ':');
1379  if (p) {
1380  ++p;
1381  }
1382  }
1383  }
1384 
1385  /* Separate headers not supported in AVC-Intra mode */
1386  if (x4->avcintra_class >= 0)
1387  x4->params.b_repeat_headers = 1;
1388 
1389  {
1390  const AVDictionaryEntry *en = NULL;
1391  while (en = av_dict_iterate(x4->x264_params, en)) {
1392  if ((ret = x264_param_parse(&x4->params, en->key, en->value)) < 0) {
1393  av_log(avctx, AV_LOG_WARNING,
1394  "Error parsing option '%s = %s'.\n",
1395  en->key, en->value);
1396 #if X264_BUILD >= 161
1397  if (ret == X264_PARAM_ALLOC_FAILED)
1398  return AVERROR(ENOMEM);
1399 #endif
1400  }
1401  }
1402  }
1403 
1404  x4->params.analyse.b_mb_info = x4->mb_info;
1405 
1406  // update AVCodecContext with x264 parameters
1407  avctx->has_b_frames = x4->params.i_bframe ?
1408  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
1409  if (avctx->max_b_frames < 0)
1410  avctx->max_b_frames = 0;
1411 
1412  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
1413 
1414  x4->enc = x264_encoder_open(&x4->params);
1415  if (!x4->enc)
1416  return AVERROR_EXTERNAL;
1417 
1418  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1419  ret = set_extradata(avctx);
1420  if (ret < 0)
1421  return ret;
1422  }
1423 
1424  cpb_props = ff_encode_add_cpb_side_data(avctx);
1425  if (!cpb_props)
1426  return AVERROR(ENOMEM);
1427  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
1428  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
1429  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
1430 
1431  // Overestimate the reordered opaque buffer size, in case a runtime
1432  // reconfigure would increase the delay (which it shouldn't).
1433  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
1434  x4->reordered_opaque = av_calloc(x4->nb_reordered_opaque,
1435  sizeof(*x4->reordered_opaque));
1436  if (!x4->reordered_opaque) {
1437  x4->nb_reordered_opaque = 0;
1438  return AVERROR(ENOMEM);
1439  }
1440 
1441  return 0;
1442 }
1443 
1444 static const enum AVPixelFormat pix_fmts_8bit[] = {
1445  AV_PIX_FMT_YUV420P,
1446  AV_PIX_FMT_YUVJ420P,
1447  AV_PIX_FMT_YUV422P,
1448  AV_PIX_FMT_YUVJ422P,
1449  AV_PIX_FMT_YUV444P,
1450  AV_PIX_FMT_YUVJ444P,
1451  AV_PIX_FMT_NV12,
1452  AV_PIX_FMT_NV16,
1453 #ifdef X264_CSP_NV21
1454  AV_PIX_FMT_NV21,
1455 #endif
1456  AV_PIX_FMT_NONE
1457 };
1458 static const enum AVPixelFormat pix_fmts_9bit[] = {
1459  AV_PIX_FMT_YUV420P9,
1460  AV_PIX_FMT_YUV444P9,
1461  AV_PIX_FMT_NONE
1462 };
1463 static const enum AVPixelFormat pix_fmts_10bit[] = {
1464  AV_PIX_FMT_YUV420P10,
1465  AV_PIX_FMT_YUV422P10,
1466  AV_PIX_FMT_YUV444P10,
1467  AV_PIX_FMT_NV20,
1468  AV_PIX_FMT_NONE
1469 };
1470 static const enum AVPixelFormat pix_fmts_all[] = {
1471  AV_PIX_FMT_YUV420P,
1472  AV_PIX_FMT_YUVJ420P,
1473  AV_PIX_FMT_YUV422P,
1474  AV_PIX_FMT_YUVJ422P,
1475  AV_PIX_FMT_YUV444P,
1476  AV_PIX_FMT_YUVJ444P,
1477  AV_PIX_FMT_NV12,
1478  AV_PIX_FMT_NV16,
1479 #ifdef X264_CSP_NV21
1480  AV_PIX_FMT_NV21,
1481 #endif
1482  AV_PIX_FMT_YUV420P10,
1483  AV_PIX_FMT_YUV422P10,
1484  AV_PIX_FMT_YUV444P10,
1485  AV_PIX_FMT_NV20,
1486 #ifdef X264_CSP_I400
1487  AV_PIX_FMT_GRAY8,
1488  AV_PIX_FMT_GRAY10,
1489 #endif
1490  AV_PIX_FMT_NONE
1491 };
1492 #if CONFIG_LIBX264RGB_ENCODER
1493 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1494  AV_PIX_FMT_BGR0,
1495  AV_PIX_FMT_BGR24,
1496  AV_PIX_FMT_RGB24,
1497  AV_PIX_FMT_NONE
1498 };
1499 #endif
1500 
1501 #define OFFSET(x) offsetof(X264Context, x)
1502 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1503 static const AVOption options[] = {
1504  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1505  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1506  { "profile", "Set profile restrictions (cf. x264 --fullhelp)", OFFSET(profile_opt), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1507  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1508  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1509  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1510  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1511  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1512  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1513  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1514  { "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 },
1515  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1516  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "aq_mode"},
1517  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, .unit = "aq_mode" },
1518  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, .unit = "aq_mode" },
1519  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, .unit = "aq_mode" },
1520  { "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, .unit = "aq_mode" },
1521  { "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},
1522  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1523  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1524  { "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 },
1525  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1526  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "weightp" },
1527  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, .unit = "weightp" },
1528  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, .unit = "weightp" },
1529  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, .unit = "weightp" },
1530  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1531  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1532  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1533  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1534  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "b_pyramid" },
1535  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, .unit = "b_pyramid" },
1536  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, .unit = "b_pyramid" },
1537  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, .unit = "b_pyramid" },
1538  { "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 },
1539  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1540  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1541  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1542  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1543  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1544  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1545  { "partitions", "A comma-separated list of partitions to consider. "
1546  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1547  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "direct-pred" },
1548  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, .unit = "direct-pred" },
1549  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, .unit = "direct-pred" },
1550  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, .unit = "direct-pred" },
1551  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, .unit = "direct-pred" },
1552  { "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 },
1553  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1554  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1555  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "nal-hrd" },
1556  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, .unit = "nal-hrd" },
1557  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, .unit = "nal-hrd" },
1558  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, .unit = "nal-hrd" },
1559  { "avcintra-class","AVC-Intra class 50/100/200/300/480", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 480 , VE},
1560  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, .unit = "motion-est"},
1561  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, .unit = "motion-est"},
1562  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1563  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1564  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1565  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1566  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1567  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1568  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, .unit = "coder" },
1569  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1570  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1571  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1572  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1573  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1574  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1575  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
1576  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1577  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1578  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1579  { "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 },
1580  { "mb_info", "Set mb_info data through AVSideData, only useful when used from the API", OFFSET(mb_info), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1581  { NULL },
1582 };
1583 
1584 static const FFCodecDefault x264_defaults[] = {
1585  { "b", "0" },
1586  { "bf", "-1" },
1587  { "flags2", "0" },
1588  { "g", "-1" },
1589  { "i_qfactor", "-1" },
1590  { "b_qfactor", "-1" },
1591  { "qmin", "-1" },
1592  { "qmax", "-1" },
1593  { "qdiff", "-1" },
1594  { "qblur", "-1" },
1595  { "qcomp", "-1" },
1596 // { "rc_lookahead", "-1" },
1597  { "refs", "-1" },
1598  { "trellis", "-1" },
1599  { "me_range", "-1" },
1600  { "subq", "-1" },
1601  { "keyint_min", "-1" },
1602  { "cmp", "-1" },
1603  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1604  { "thread_type", "0" },
1605  { "flags", "+cgop" },
1606  { "rc_init_occupancy","-1" },
1607  { NULL },
1608 };
1609 
1610 #if CONFIG_LIBX264_ENCODER
1611 static const AVClass x264_class = {
1612  .class_name = "libx264",
1613  .item_name = av_default_item_name,
1614  .option = options,
1615  .version = LIBAVUTIL_VERSION_INT,
1616 };
1617 
1618 const FFCodec ff_libx264_encoder = {
1619  .p.name = "libx264",
1620  CODEC_LONG_NAME("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1621  .p.type = AVMEDIA_TYPE_VIDEO,
1622  .p.id = AV_CODEC_ID_H264,
1623  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1624  AV_CODEC_CAP_OTHER_THREADS |
1625  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE |
1626  AV_CODEC_CAP_ENCODER_FLUSH |
1627  AV_CODEC_CAP_ENCODER_RECON_FRAME,
1628  .p.priv_class = &x264_class,
1629  .p.wrapper_name = "libx264",
1630  .priv_data_size = sizeof(X264Context),
1631  .init = X264_init,
1632  FF_CODEC_ENCODE_CB(X264_frame),
1633  .flush = X264_flush,
1634  .close = X264_close,
1635  .defaults = x264_defaults,
1636  .p.pix_fmts = pix_fmts_all,
1637  .color_ranges = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
1638  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
1639 #if X264_BUILD < 158
1640  | FF_CODEC_CAP_NOT_INIT_THREADSAFE
1641 #endif
1642  ,
1643 };
1644 #endif
1645 
1646 #if CONFIG_LIBX264RGB_ENCODER
1647 static const AVClass rgbclass = {
1648  .class_name = "libx264rgb",
1649  .item_name = av_default_item_name,
1650  .option = options,
1651  .version = LIBAVUTIL_VERSION_INT,
1652 };
1653 
1654 const FFCodec ff_libx264rgb_encoder = {
1655  .p.name = "libx264rgb",
1656  CODEC_LONG_NAME("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1657  .p.type = AVMEDIA_TYPE_VIDEO,
1658  .p.id = AV_CODEC_ID_H264,
1659  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1660  AV_CODEC_CAP_OTHER_THREADS |
1661  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1662  .p.pix_fmts = pix_fmts_8bit_rgb,
1663  .p.priv_class = &rgbclass,
1664  .p.wrapper_name = "libx264",
1665  .priv_data_size = sizeof(X264Context),
1666  .init = X264_init,
1667  FF_CODEC_ENCODE_CB(X264_frame),
1668  .close = X264_close,
1669  .defaults = x264_defaults,
1670  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
1671 #if X264_BUILD < 158
1672  | FF_CODEC_CAP_NOT_INIT_THREADSAFE
1673 #endif
1674  ,
1675 };
1676 #endif
1677 
1678 #if CONFIG_LIBX262_ENCODER
1679 static const AVClass X262_class = {
1680  .class_name = "libx262",
1681  .item_name = av_default_item_name,
1682  .option = options,
1683  .version = LIBAVUTIL_VERSION_INT,
1684 };
1685 
1686 const FFCodec ff_libx262_encoder = {
1687  .p.name = "libx262",
1688  CODEC_LONG_NAME("libx262 MPEG2VIDEO"),
1689  .p.type = AVMEDIA_TYPE_VIDEO,
1690  .p.id = AV_CODEC_ID_MPEG2VIDEO,
1691  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1692  AV_CODEC_CAP_OTHER_THREADS |
1693  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1694  .p.pix_fmts = pix_fmts_8bit,
1695  .color_ranges = AVCOL_RANGE_MPEG,
1696  .p.priv_class = &X262_class,
1697  .p.wrapper_name = "libx264",
1698  .priv_data_size = sizeof(X264Context),
1699  .init = X264_init,
1700  FF_CODEC_ENCODE_CB(X264_frame),
1701  .close = X264_close,
1702  .defaults = x264_defaults,
1703  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1704  FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS,
1705 };
1706 #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:431
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
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:26
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:100
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:43
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:1030
X264Context
Definition: libx264.c:66
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
errors
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install libraries and programs examples Build all examples located in doc examples checkheaders Check headers dependencies alltools Build all tools in tools directory config Reconfigure the project with the current configuration tools target_dec_< decoder > _fuzzer Build fuzzer to fuzz the specified decoder tools target_bsf_< filter > _fuzzer Build fuzzer to fuzz the specified bitstream filter Useful standard make this is useful to reduce unneeded rebuilding when changing but note that you must force rebuilds of files that actually need it by hand then make j< num > Rebuild with multiple jobs at the same time Faster on multi processor systems make k Continue build in case of errors
Definition: build_system.txt:64
opt.h
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2087
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:951
X264Context::avcintra_class
int avcintra_class
Definition: libx264.c:108
deblock
static void deblock(const RV60Context *s, AVFrame *frame, int xpos, int ypos, int size, int dpos)
Definition: rv60dec.c:2159
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
X264Context::tune
char * tune
Definition: libx264.c:74
AV_PROFILE_H264_MAIN
#define AV_PROFILE_H264_MAIN
Definition: defs.h:112
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
rect
Definition: f_ebur128.c:76
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
int64_t
long long int64_t
Definition: coverity.c:34
X264Context::cplxblur
float cplxblur
Definition: libx264.c:102
rect::y
int y
Definition: f_ebur128.c:76
AV_CODEC_CAP_ENCODER_RECON_FRAME
#define AV_CODEC_CAP_ENCODER_RECON_FRAME
The encoder is able to output reconstructed frame data, i.e.
Definition: codec.h:174
X264Context::fastfirstpass
int fastfirstpass
Definition: libx264.c:78
X264Context::fast_pskip
int fast_pskip
Definition: libx264.c:98
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
X264_log
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:133
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
av_frame_make_writable
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:666
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
AVFrame::width
int width
Definition: frame.h:461
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
ff_libx264rgb_encoder
const FFCodec ff_libx264rgb_encoder
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVVideoRect
Copyright 2023 Elias Carotti <eliascrt at amazon dot it>
Definition: video_hint.h:29
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
level_idc
int level_idc
Definition: h264_levels.c:29
AVOption
AVOption.
Definition: opt.h:429
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
X264Context::stats
char * stats
Definition: libx264.c:106
X264Context::nb_reordered_opaque
int nb_reordered_opaque
Definition: libx264.c:121
data
const char data[16]
Definition: mxf.c:149
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:502
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:35
FFCodec
Definition: codec_internal.h:127
float.h
X264_flush
static void X264_flush(AVCodecContext *avctx)
Definition: libx264.c:744
X264Context::sei_size
int sei_size
Definition: libx264.c:72
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:326
mbinfo_compute_changed_coords
static void av_always_inline mbinfo_compute_changed_coords(const AVVideoRect *rect, int *min_x, int *max_x, int *min_y, int *max_y)
Definition: libx264.c:327
AV_VIDEO_HINT_TYPE_CHANGED
@ AV_VIDEO_HINT_TYPE_CHANGED
Definition: video_hint.h:39
ff_libx264_encoder
const FFCodec ff_libx264_encoder
AVVideoHint
Definition: video_hint.h:42
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1273
X264Context::intra_refresh
int intra_refresh
Definition: libx264.c:92
AVCodecContext::me_subpel_quality
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:952
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
X264Context::cqp
int cqp
Definition: libx264.c:83
X264Context::udu_sei
int udu_sei
Definition: libx264.c:117
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
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:128
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:338
video_hint.h
X264_init
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:1065
X264Context::slice_max_size
int slice_max_size
Definition: libx264.c:105
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:653
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
save_sei
static int save_sei(AVCodecContext *avctx, x264_nal_t *nal)
Definition: libx264.c:845
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
golomb.h
exp golomb vlc stuff
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3210
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
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:826
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
X264Context::chroma_offset
int chroma_offset
Definition: libx264.c:114
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
fail
#define fail()
Definition: checkasm.h:188
AV_PIX_FMT_NV20
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:550
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1593
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:52
X264Context::weightb
int weightb
Definition: libx264.c:90
GetBitContext
Definition: get_bits.h:108
X264Context::pic
x264_picture_t pic
Definition: libx264.c:70
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:721
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
FF_CMP_CHROMA
#define FF_CMP_CHROMA
Definition: avcodec.h:917
val
static double val(void *priv, double ch)
Definition: aeval.c:77
av_video_hint_rects
static av_always_inline AVVideoRect * av_video_hint_rects(const AVVideoHint *hints)
Definition: video_hint.h:67
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:166
X264Context::params
x264_param_t params
Definition: libx264.c:68
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:320
X264Context::nal_hrd
int nal_hrd
Definition: libx264.c:107
AV_CODEC_FLAG_LOOP_FILTER
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:318
X264Context::bluray_compat
int bluray_compat
Definition: libx264.c:93
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:330
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:505
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1442
preset
preset
Definition: vf_curves.c:47
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
AV_STEREO3D_FRAMESEQUENCE
@ AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
Definition: stereo3d.h:89
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AVFrameSideData::size
size_t size
Definition: frame.h:268
av_cold
#define av_cold
Definition: attributes.h:90
pix_fmts_10bit
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:1463
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:315
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
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:1330
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:86
X264Context::b_pyramid
int b_pyramid
Definition: libx264.c:95
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:729
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:497
AV_STEREO3D_LINES
@ AV_STEREO3D_LINES
Views are packed per line, as if interlaced.
Definition: stereo3d.h:126
stereo3d.h
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1249
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:331
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1451
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2088
X264Context::mixed_refs
int mixed_refs
Definition: libx264.c:96
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AV_CODEC_EXPORT_DATA_PRFT
#define AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
Definition: avcodec.h:410
pix_fmts_all
static enum AVPixelFormat pix_fmts_all[]
Definition: libx264.c:1470
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:124
AV_PROFILE_H264_HIGH_10
#define AV_PROFILE_H264_HIGH_10
Definition: defs.h:115
info
MIPS optimizations info
Definition: mips.txt:2
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
AVCodecContext::thread_type
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1603
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:499
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ctx
AVFormatContext * ctx
Definition: movenc.c:49
SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
COMPUTE_MBINFO
#define COMPUTE_MBINFO(mbinfo_filler_, mbinfo_marker_, compute_coords_fn_)
X264Context::weightp
int weightp
Definition: libx264.c:89
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
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:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1302
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
X264Opaque
Definition: libx264.c:58
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
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:87
AV_PROFILE_H264_HIGH_422
#define AV_PROFILE_H264_HIGH_422
Definition: defs.h:118
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
X264Context::noise_reduction
int noise_reduction
Definition: libx264.c:116
setup_roi
static int setup_roi(AVCodecContext *ctx, x264_picture_t *pic, const AVFrame *frame, const uint8_t *data, size_t size)
Definition: libx264.c:395
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:212
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:483
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1287
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
pix_fmts_9bit
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:1458
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
X264Context::crf_max
float crf_max
Definition: libx264.c:82
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
X264Context::forced_idr
int forced_idr
Definition: libx264.c:110
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
X264Context::aud
int aud
Definition: libx264.c:99
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1259
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:85
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Underlying C type is AVDictionary*.
Definition: opt.h:290
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:320
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:279
X264Context::direct_pred
int direct_pred
Definition: libx264.c:104
X264Context::profile_opt
char * profile_opt
Definition: libx264.c:76
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
double
double
Definition: af_crystalizer.c:132
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
time.h
AVCodecContext::me_cmp
int me_cmp
motion estimation comparison function
Definition: avcodec.h:882
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:503
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1337
av_clipf
av_clipf
Definition: af_crystalizer.c:122
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:858
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1794
free_picture
static void free_picture(x264_picture_t *pic)
Definition: libx264.c:295
stats
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
Definition: vp9_superframe.c:34
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:683
X264Context::preset
char * preset
Definition: libx264.c:73
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:164
X264Context::x264_params
AVDictionary * x264_params
Definition: libx264.c:119
PARSE_X264_OPT
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:984
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1258
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:550
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:875
eval.h
mbinfo_compute_constant_coords
static void av_always_inline mbinfo_compute_constant_coords(const AVVideoRect *rect, int *min_x, int *max_x, int *min_y, int *max_y)
Definition: libx264.c:339
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
pix_fmts_8bit
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:1444
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:101
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1037
codec_internal.h
X264_close
static av_cold int X264_close(AVCodecContext *avctx)
Definition: libx264.c:762
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
encode_nals
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
Definition: libx264.c:154
set_extradata
static int set_extradata(AVCodecContext *avctx)
Definition: libx264.c:948
MB_CEIL
#define MB_CEIL(x)
Definition: libx264.c:56
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:961
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1605
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:737
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:476
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:198
buffer.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
X264Context::motion_est
int motion_est
Definition: libx264.c:109
opaque_uninit
static void opaque_uninit(X264Opaque *o)
Definition: libx264.c:148
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:545
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
X264Context::b_bias
int b_bias
Definition: libx264.c:94
AVCodecInternal
Definition: internal.h:49
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:286
AVRegionOfInterest::right
int right
Definition: frame.h:333
rect::x
int x
Definition: f_ebur128.c:76
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:194
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
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:810
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
VE
#define VE
Definition: libx264.c:1502
X264Context::sei
uint8_t * sei
Definition: libx264.c:71
AVRegionOfInterest::left
int left
Definition: frame.h:332
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
X264Context::aq_mode
int aq_mode
Definition: libx264.c:84
X264Opaque::frame_opaque_ref
AVBufferRef * frame_opaque_ref
Definition: libx264.c:63
AV_CODEC_FLAG_RECON_FRAME
#define AV_CODEC_FLAG_RECON_FRAME
Request the encoder to output reconstructed frames, i.e. frames that would be produced by decoding th...
Definition: avcodec.h:264
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
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:330
internal.h
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:76
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:276
X264Context::a53_cc
int a53_cc
Definition: libx264.c:112
setup_mb_info
static int setup_mb_info(AVCodecContext *ctx, x264_picture_t *pic, const AVFrame *frame, const AVVideoHint *info)
Definition: libx264.c:351
x264_defaults
static const FFCodecDefault x264_defaults[]
Definition: libx264.c:1584
av_always_inline
#define av_always_inline
Definition: attributes.h:49
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
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:610
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:708
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
csp_to_pixfmt
static enum AVPixelFormat csp_to_pixfmt(int csp)
Definition: libx264.c:305
options
static const AVOption options[]
Definition: libx264.c:1503
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:501
avcodec.h
X264Context::profile
const char * profile
Definition: libx264.c:75
X264Context::mbtree
int mbtree
Definition: libx264.c:100
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:352
X264Context::mb_info
int mb_info
Definition: libx264.c:130
ret
ret
Definition: filter_design.txt:187
X264Context::reordered_opaque
X264Opaque * reordered_opaque
Definition: libx264.c:122
X264Opaque::frame_opaque
void * frame_opaque
Definition: libx264.c:62
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:96
X264Context::crf
float crf
Definition: libx264.c:81
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:80
X264Context::level
char * level
Definition: libx264.c:77
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:292
AV_STEREO3D_COLUMNS
@ AV_STEREO3D_COLUMNS
Views are packed per column.
Definition: stereo3d.h:138
atsc_a53.h
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
AV_PROFILE_H264_BASELINE
#define AV_PROFILE_H264_BASELINE
Definition: defs.h:110
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
X264Context::wpredp
char * wpredp
Definition: libx264.c:79
AV_FRAME_DATA_VIDEO_HINT
@ AV_FRAME_DATA_VIDEO_HINT
Provide encoder-specific hinting information about changed/unchanged portions of a frame.
Definition: frame.h:230
ff_libx262_encoder
const FFCodec ff_libx262_encoder
X264Context::next_reordered_opaque
int next_reordered_opaque
Definition: libx264.c:121
X264Opaque::wallclock
int64_t wallclock
Definition: libx264.c:59
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:114
X264Context::scenechange_threshold
int scenechange_threshold
Definition: libx264.c:115
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
X264Context::x264opts
char * x264opts
Definition: libx264.c:80
AVCodecContext::max_qdiff
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1280
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVFrame::height
int height
Definition: frame.h:461
reconfig_encoder
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:197
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
AV_PROFILE_H264_HIGH
#define AV_PROFILE_H264_HIGH
Definition: defs.h:114
X264Context::coder
int coder
Definition: libx264.c:111
X264Context::aq_strength
float aq_strength
Definition: libx264.c:85
MB_FLOOR
#define MB_FLOOR(x)
Definition: libx264.c:55
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
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:106
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1266
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
MB_SIZE
#define MB_SIZE
Definition: libx264.c:53
X264Context::rc_lookahead
int rc_lookahead
Definition: libx264.c:88
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:266
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:582
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:76
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
ff_side_data_set_prft
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: packet.c:634
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:78
OFFSET
#define OFFSET(x)
Definition: libx264.c:1501
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
X264Context::dct8x8
int dct8x8
Definition: libx264.c:97
AV_PROFILE_H264_HIGH_444
#define AV_PROFILE_H264_HIGH_444
Definition: defs.h:121
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:77
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:801
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
X264Context::psy_rd
char * psy_rd
Definition: libx264.c:86
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:73
mastering_display_metadata.h
setup_frame
static int setup_frame(AVCodecContext *ctx, const AVFrame *frame, x264_picture_t **ppic)
Definition: libx264.c:468
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
parse_opts
static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
Definition: libx264.c:784
X264Context::deblock
char * deblock
Definition: libx264.c:101
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1053
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
handle_mdcv
static void handle_mdcv(struct EbSvtAv1MasteringDisplayInfo *dst, const AVMasteringDisplayMetadata *mdcv)
Definition: libsvtav1.c:145
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
X264Context::ssim
int ssim
Definition: libx264.c:91
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1158
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
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:87
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:434
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
sse
static int sse(MpegEncContext *s, const uint8_t *src1, const uint8_t *src2, int w, int h, int stride)
Definition: mpegvideo_enc.c:2653
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: packet.c:609
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:909
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
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:69
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
X264_frame
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libx264.c:611
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:357
X264Context::b_frame_strategy
int b_frame_strategy
Definition: libx264.c:113
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1328
mb_info
Definition: cinepakenc.c:87
convert_pix_fmt
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Definition: libx264.c:810
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:648
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
src
#define src
Definition: vp8dsp.c:248
handle_side_data
static void handle_side_data(AVCodecContext *avctx, x264_param_t *params)
Definition: libx264.c:1038
X264Opaque::duration
int64_t duration
Definition: libx264.c:60
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310
X264Context::partitions
char * partitions
Definition: libx264.c:103
Generated on Fri Nov 15 2024 19:21:51 for FFmpeg by   doxygen 1.8.17