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"
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;
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;
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;
89  int weightp;
90  int weightb;
91  int ssim;
94  int b_bias;
95  int b_pyramid;
97  int dct8x8;
99  int aud;
100  int mbtree;
101  char *deblock;
102  float cplxblur;
103  char *partitions;
106  char *stats;
107  int nal_hrd;
111  int coder;
112  int a53_cc;
117  int udu_sei;
118 
120 
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  */
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 {
151  memset(o, 0, sizeof(*o));
152 }
153 
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 
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 
250  if (side_data) {
251  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
252  int fpa_type;
253 
254  switch (stereo->type) {
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;
265  fpa_type = 3;
266  break;
268  fpa_type = 4;
269  break;
271  fpa_type = 5;
272  break;
273 #if X264_BUILD >= 145
274  case AV_STEREO3D_2D:
275  fpa_type = 6;
276  break;
277 #endif
278  default:
279  fpa_type = -1;
280  break;
281  }
282 
283  /* Inverted mode is not supported by x264 */
284  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
286  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
287  fpa_type = -1;
288  }
289 
290  if (fpa_type != x4->params.i_frame_packing) {
291  x4->params.i_frame_packing = fpa_type;
292  x264_encoder_reconfig(x4->enc, &x4->params);
293  }
294  }
295 }
296 
297 static void free_picture(x264_picture_t *pic)
298 {
299  for (int i = 0; i < pic->extra_sei.num_payloads; i++)
300  av_free(pic->extra_sei.payloads[i].payload);
301  av_freep(&pic->extra_sei.payloads);
302  av_freep(&pic->prop.quant_offsets);
303  av_freep(&pic->prop.mb_info);
304  pic->extra_sei.num_payloads = 0;
305 }
306 
307 static enum AVPixelFormat csp_to_pixfmt(int csp)
308 {
309  switch (csp) {
310 #ifdef X264_CSP_I400
311  case X264_CSP_I400: return AV_PIX_FMT_GRAY8;
312  case X264_CSP_I400 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_GRAY10;
313 #endif
314  case X264_CSP_I420: return AV_PIX_FMT_YUV420P;
315  case X264_CSP_I420 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV420P10;
316  case X264_CSP_I422: return AV_PIX_FMT_YUV422P;
317  case X264_CSP_I422 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV422P10;
318  case X264_CSP_I444: return AV_PIX_FMT_YUV444P;
319  case X264_CSP_I444 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV444P10;
320  case X264_CSP_NV12: return AV_PIX_FMT_NV12;
321 #ifdef X264_CSP_NV21
322  case X264_CSP_NV21: return AV_PIX_FMT_NV21;
323 #endif
324  case X264_CSP_NV16: return AV_PIX_FMT_NV16;
325  };
326  return AV_PIX_FMT_NONE;
327 }
328 
330  int *min_x,
331  int *max_x,
332  int *min_y,
333  int *max_y)
334 {
335  *min_y = MB_FLOOR(rect->y);
336  *max_y = MB_CEIL(rect->y + rect->height);
337  *min_x = MB_FLOOR(rect->x);
338  *max_x = MB_CEIL(rect->x + rect->width);
339 }
340 
342  int *min_x,
343  int *max_x,
344  int *min_y,
345  int *max_y)
346 {
347  *min_y = MB_CEIL(rect->y);
348  *max_y = MB_FLOOR(rect->y + rect->height);
349  *min_x = MB_CEIL(rect->x);
350  *max_x = MB_FLOOR(rect->x + rect->width);
351 }
352 
353 static int setup_mb_info(AVCodecContext *ctx, x264_picture_t *pic,
354  const AVFrame *frame,
355  const AVVideoHint *info)
356 {
357  int mb_width = (frame->width + MB_SIZE - 1) / MB_SIZE;
358  int mb_height = (frame->height + MB_SIZE - 1) / MB_SIZE;
359 
360  const AVVideoRect *mbinfo_rects;
361  int nb_rects;
362  uint8_t *mbinfo;
363 
364  mbinfo_rects = (const AVVideoRect *)av_video_hint_rects(info);
365  nb_rects = info->nb_rects;
366 
367  mbinfo = av_calloc(mb_width * mb_height, sizeof(*mbinfo));
368  if (!mbinfo)
369  return AVERROR(ENOMEM);
370 
371 #define COMPUTE_MBINFO(mbinfo_filler_, mbinfo_marker_, compute_coords_fn_) \
372  memset(mbinfo, mbinfo_filler_, sizeof(*mbinfo) * mb_width * mb_height); \
373  \
374  for (int i = 0; i < nb_rects; i++) { \
375  int min_x, max_x, min_y, max_y; \
376  \
377  compute_coords_fn_(mbinfo_rects, &min_x, &max_x, &min_y, &max_y); \
378  for (int mb_y = min_y; mb_y < max_y; ++mb_y) { \
379  memset(mbinfo + mb_y * mb_width + min_x, mbinfo_marker_, max_x - min_x); \
380  } \
381  \
382  mbinfo_rects++; \
383  } \
384 
385  if (info->type == AV_VIDEO_HINT_TYPE_CHANGED) {
386  COMPUTE_MBINFO(X264_MBINFO_CONSTANT, 0, mbinfo_compute_changed_coords);
387  } else /* if (info->type == AV_VIDEO_HINT_TYPE_CHANGED) */ {
388  COMPUTE_MBINFO(0, X264_MBINFO_CONSTANT, mbinfo_compute_constant_coords);
389  }
390 
391  pic->prop.mb_info = mbinfo;
392  pic->prop.mb_info_free = av_free;
393 
394  return 0;
395 }
396 
397 static int setup_roi(AVCodecContext *ctx, x264_picture_t *pic, int bit_depth,
398  const AVFrame *frame, const uint8_t *data, size_t size)
399 {
400  X264Context *x4 = ctx->priv_data;
401 
402  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
403  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
404  int qp_range = 51 + 6 * (bit_depth - 8);
405  int nb_rois;
406  const AVRegionOfInterest *roi;
407  uint32_t roi_size;
408  float *qoffsets;
409 
410  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
411  if (!x4->roi_warned) {
412  x4->roi_warned = 1;
413  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
414  }
415  return 0;
416  } else if (frame->flags & AV_FRAME_FLAG_INTERLACED) {
417  if (!x4->roi_warned) {
418  x4->roi_warned = 1;
419  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
420  }
421  return 0;
422  }
423 
424  roi = (const AVRegionOfInterest*)data;
425  roi_size = roi->self_size;
426  if (!roi_size || size % roi_size != 0) {
427  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
428  return AVERROR(EINVAL);
429  }
430  nb_rois = size / roi_size;
431 
432  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
433  if (!qoffsets)
434  return AVERROR(ENOMEM);
435 
436  // This list must be iterated in reverse because the first
437  // region in the list applies when regions overlap.
438  for (int i = nb_rois - 1; i >= 0; i--) {
439  int startx, endx, starty, endy;
440  float qoffset;
441 
442  roi = (const AVRegionOfInterest*)(data + roi_size * i);
443 
444  starty = FFMIN(mby, roi->top / MB_SIZE);
445  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
446  startx = FFMIN(mbx, roi->left / MB_SIZE);
447  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
448 
449  if (roi->qoffset.den == 0) {
450  av_free(qoffsets);
451  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
452  return AVERROR(EINVAL);
453  }
454  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
455  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
456 
457  for (int y = starty; y < endy; y++) {
458  for (int x = startx; x < endx; x++) {
459  qoffsets[x + y*mbx] = qoffset;
460  }
461  }
462  }
463 
464  pic->prop.quant_offsets = qoffsets;
465  pic->prop.quant_offsets_free = av_free;
466 
467  return 0;
468 }
469 
471  x264_picture_t **ppic)
472 {
473  X264Context *x4 = ctx->priv_data;
475  x264_picture_t *pic = &x4->pic;
476  x264_sei_t *sei = &pic->extra_sei;
477  unsigned int sei_data_size = 0;
478  int64_t wallclock = 0;
479  int bit_depth, ret;
480  AVFrameSideData *sd;
481  AVFrameSideData *mbinfo_sd;
482 
483  *ppic = NULL;
484  if (!frame)
485  return 0;
486 
487  x264_picture_init(pic);
488  pic->img.i_csp = x4->params.i_csp;
489 #if X264_BUILD >= 153
490  bit_depth = x4->params.i_bitdepth;
491 #else
492  bit_depth = x264_bit_depth;
493 #endif
494  if (bit_depth > 8)
495  pic->img.i_csp |= X264_CSP_HIGH_DEPTH;
496  pic->img.i_plane = av_pix_fmt_count_planes(ctx->pix_fmt);
497 
498  for (int i = 0; i < pic->img.i_plane; i++) {
499  pic->img.plane[i] = frame->data[i];
500  pic->img.i_stride[i] = frame->linesize[i];
501  }
502 
503  pic->i_pts = frame->pts;
504 
505  opaque_uninit(opaque);
506 
508  opaque->frame_opaque = frame->opaque;
509  ret = av_buffer_replace(&opaque->frame_opaque_ref, frame->opaque_ref);
510  if (ret < 0)
511  goto fail;
512  }
513 
514  opaque->duration = frame->duration;
515  opaque->wallclock = wallclock;
516  if (ctx->export_side_data & AV_CODEC_EXPORT_DATA_PRFT)
517  opaque->wallclock = av_gettime();
518 
519  pic->opaque = opaque;
520 
521  x4->next_reordered_opaque++;
523 
524  switch (frame->pict_type) {
525  case AV_PICTURE_TYPE_I:
526  pic->i_type = x4->forced_idr > 0 ? X264_TYPE_IDR : X264_TYPE_KEYFRAME;
527  break;
528  case AV_PICTURE_TYPE_P:
529  pic->i_type = X264_TYPE_P;
530  break;
531  case AV_PICTURE_TYPE_B:
532  pic->i_type = X264_TYPE_B;
533  break;
534  default:
535  pic->i_type = X264_TYPE_AUTO;
536  break;
537  }
539 
540  if (x4->a53_cc) {
541  void *sei_data;
542  size_t sei_size;
543 
544  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
545  if (ret < 0)
546  goto fail;
547 
548  if (sei_data) {
549  sei->payloads = av_mallocz(sizeof(sei->payloads[0]));
550  if (!sei->payloads) {
551  av_free(sei_data);
552  ret = AVERROR(ENOMEM);
553  goto fail;
554  }
555 
556  sei->sei_free = av_free;
557 
558  sei->payloads[0].payload_size = sei_size;
559  sei->payloads[0].payload = sei_data;
560  sei->payloads[0].payload_type = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
561  sei->num_payloads = 1;
562  }
563  }
564 
566  if (sd) {
567  ret = setup_roi(ctx, pic, bit_depth, frame, sd->data, sd->size);
568  if (ret < 0)
569  goto fail;
570  }
571 
573  if (mbinfo_sd) {
574  int ret = setup_mb_info(ctx, pic, frame, (const AVVideoHint *)mbinfo_sd->data);
575  if (ret < 0) {
576  /* No need to fail here, this is not fatal. We just proceed with no
577  * mb_info and log a message */
578 
579  av_log(ctx, AV_LOG_WARNING, "setup_mb_info failed with error: %s\n", av_err2str(ret));
580  }
581  }
582 
583  if (x4->udu_sei) {
584  for (int j = 0; j < frame->nb_side_data; j++) {
585  AVFrameSideData *side_data = frame->side_data[j];
586  void *tmp;
587  x264_sei_payload_t *sei_payload;
588  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
589  continue;
590  tmp = av_fast_realloc(sei->payloads, &sei_data_size, (sei->num_payloads + 1) * sizeof(*sei_payload));
591  if (!tmp) {
592  ret = AVERROR(ENOMEM);
593  goto fail;
594  }
595  sei->payloads = tmp;
596  sei->sei_free = av_free;
597  sei_payload = &sei->payloads[sei->num_payloads];
598  sei_payload->payload = av_memdup(side_data->data, side_data->size);
599  if (!sei_payload->payload) {
600  ret = AVERROR(ENOMEM);
601  goto fail;
602  }
603  sei_payload->payload_size = side_data->size;
604  sei_payload->payload_type = SEI_TYPE_USER_DATA_UNREGISTERED;
605  sei->num_payloads++;
606  }
607  }
608 
609  *ppic = pic;
610  return 0;
611 
612 fail:
613  free_picture(pic);
614  *ppic = NULL;
615  return ret;
616 }
617 
619  int *got_packet)
620 {
621  X264Context *x4 = ctx->priv_data;
622  x264_nal_t *nal;
623  int nnal, ret;
624  x264_picture_t pic_out = {0}, *pic_in;
625  int pict_type;
626  int64_t wallclock = 0;
627  X264Opaque *out_opaque;
628 
629  ret = setup_frame(ctx, frame, &pic_in);
630  if (ret < 0)
631  return ret;
632 
633  do {
634  if (x264_encoder_encode(x4->enc, &nal, &nnal, pic_in, &pic_out) < 0)
635  return AVERROR_EXTERNAL;
636 
637  if (nnal && (ctx->flags & AV_CODEC_FLAG_RECON_FRAME)) {
638  AVCodecInternal *avci = ctx->internal;
639 
641 
642  avci->recon_frame->format = csp_to_pixfmt(pic_out.img.i_csp);
643  if (avci->recon_frame->format == AV_PIX_FMT_NONE) {
645  "Unhandled reconstructed frame colorspace: %d\n",
646  pic_out.img.i_csp);
647  return AVERROR(ENOSYS);
648  }
649 
650  avci->recon_frame->width = ctx->width;
651  avci->recon_frame->height = ctx->height;
652  for (int i = 0; i < pic_out.img.i_plane; i++) {
653  avci->recon_frame->data[i] = pic_out.img.plane[i];
654  avci->recon_frame->linesize[i] = pic_out.img.i_stride[i];
655  }
656 
658  if (ret < 0) {
660  return ret;
661  }
662  }
663 
664  ret = encode_nals(ctx, pkt, nal, nnal);
665  if (ret < 0)
666  return ret;
667  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
668 
669  if (!ret)
670  return 0;
671 
672  pkt->pts = pic_out.i_pts;
673  pkt->dts = pic_out.i_dts;
674 
675  out_opaque = pic_out.opaque;
676  if (out_opaque >= x4->reordered_opaque &&
677  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
678  wallclock = out_opaque->wallclock;
679  pkt->duration = out_opaque->duration;
680 
682  pkt->opaque = out_opaque->frame_opaque;
683  pkt->opaque_ref = out_opaque->frame_opaque_ref;
684  out_opaque->frame_opaque_ref = NULL;
685  }
686 
687  opaque_uninit(out_opaque);
688  } else {
689  // Unexpected opaque pointer on picture output
690  av_log(ctx, AV_LOG_ERROR, "Unexpected opaque pointer; "
691  "this is a bug, please report it.\n");
692  }
693 
694  switch (pic_out.i_type) {
695  case X264_TYPE_IDR:
696  case X264_TYPE_I:
697  pict_type = AV_PICTURE_TYPE_I;
698  break;
699  case X264_TYPE_P:
700  pict_type = AV_PICTURE_TYPE_P;
701  break;
702  case X264_TYPE_B:
703  case X264_TYPE_BREF:
704  pict_type = AV_PICTURE_TYPE_B;
705  break;
706  default:
707  av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
708  return AVERROR_EXTERNAL;
709  }
710 
711  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
712  if (ret) {
713  int error_count = 0;
714  int64_t *errors = NULL;
715  int64_t sse[3] = {0};
716 
717  if (ctx->flags & AV_CODEC_FLAG_PSNR) {
718  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(ctx->pix_fmt);
719  double scale[3] = { 1,
720  (double)(1 << pix_desc->log2_chroma_h) * (1 << pix_desc->log2_chroma_w),
721  (double)(1 << pix_desc->log2_chroma_h) * (1 << pix_desc->log2_chroma_w),
722  };
723 
724  error_count = pix_desc->nb_components;
725 
726  for (int i = 0; i < pix_desc->nb_components; ++i) {
727  double max_value = (double)(1 << pix_desc->comp[i].depth) - 1.0;
728  double plane_size = ctx->width * (double)ctx->height / scale[i];
729 
730  /* psnr = 10 * log10(max_value * max_value / mse) */
731  double mse = (max_value * max_value) / pow(10, pic_out.prop.f_psnr[i] / 10.0);
732 
733  /* SSE = MSE * width * height / scale -> because of possible chroma downsampling */
734  sse[i] = (int64_t)floor(mse * plane_size + .5);
735  };
736 
737  errors = sse;
738  }
739 
740  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA,
741  errors, error_count, pict_type);
742 
743  if (wallclock)
744  ff_side_data_set_prft(pkt, wallclock);
745  }
746 
747  *got_packet = ret;
748  return 0;
749 }
750 
751 static void X264_flush(AVCodecContext *avctx)
752 {
753  X264Context *x4 = avctx->priv_data;
754  x264_nal_t *nal;
755  int nnal, ret;
756  x264_picture_t pic_out = {0};
757 
758  do {
759  ret = x264_encoder_encode(x4->enc, &nal, &nnal, NULL, &pic_out);
760  } while (ret > 0 && x264_encoder_delayed_frames(x4->enc));
761 
762  for (int i = 0; i < x4->nb_reordered_opaque; i++)
764 
765  if (x4->sei_size < 0)
766  x4->sei_size = -x4->sei_size;
767 }
768 
770 {
771  X264Context *x4 = avctx->priv_data;
772 
773  av_freep(&x4->sei);
774 
775  for (int i = 0; i < x4->nb_reordered_opaque; i++)
778 
779 #if X264_BUILD >= 161
780  x264_param_cleanup(&x4->params);
781 #endif
782 
783  if (x4->enc) {
784  x264_encoder_close(x4->enc);
785  x4->enc = NULL;
786  }
787 
788  return 0;
789 }
790 
791 static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
792 {
793  X264Context *x4 = avctx->priv_data;
794  int ret;
795 
796  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) {
797  if (ret == X264_PARAM_BAD_NAME) {
798  av_log(avctx, AV_LOG_ERROR,
799  "bad option '%s': '%s'\n", opt, param);
800  ret = AVERROR(EINVAL);
801 #if X264_BUILD >= 161
802  } else if (ret == X264_PARAM_ALLOC_FAILED) {
803  av_log(avctx, AV_LOG_ERROR,
804  "out of memory parsing option '%s': '%s'\n", opt, param);
805  ret = AVERROR(ENOMEM);
806 #endif
807  } else {
808  av_log(avctx, AV_LOG_ERROR,
809  "bad value for '%s': '%s'\n", opt, param);
810  ret = AVERROR(EINVAL);
811  }
812  }
813 
814  return ret;
815 }
816 
818 {
819  switch (pix_fmt) {
820  case AV_PIX_FMT_YUV420P:
821  case AV_PIX_FMT_YUVJ420P:
822  case AV_PIX_FMT_YUV420P9:
823  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
824  case AV_PIX_FMT_YUV422P:
825  case AV_PIX_FMT_YUVJ422P:
826  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
827  case AV_PIX_FMT_YUV444P:
828  case AV_PIX_FMT_YUVJ444P:
829  case AV_PIX_FMT_YUV444P9:
830  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
831  case AV_PIX_FMT_BGR0:
832  return X264_CSP_BGRA;
833  case AV_PIX_FMT_BGR24:
834  return X264_CSP_BGR;
835 
836  case AV_PIX_FMT_RGB24:
837  return X264_CSP_RGB;
838  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
839  case AV_PIX_FMT_NV16:
840  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
841 #ifdef X264_CSP_NV21
842  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
843 #endif
844 #ifdef X264_CSP_I400
845  case AV_PIX_FMT_GRAY8:
846  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
847 #endif
848  };
849  return 0;
850 }
851 
852 static int save_sei(AVCodecContext *avctx, x264_nal_t *nal)
853 {
854  X264Context *x4 = avctx->priv_data;
855 
856  av_log(avctx, AV_LOG_INFO, "%s\n", nal->p_payload + 25);
857  x4->sei_size = nal->i_payload;
858  x4->sei = av_malloc(x4->sei_size);
859  if (!x4->sei)
860  return AVERROR(ENOMEM);
861 
862  memcpy(x4->sei, nal->p_payload, nal->i_payload);
863 
864  return 0;
865 }
866 
867 #if CONFIG_LIBX264_ENCODER
868 static int set_avcc_extradata(AVCodecContext *avctx, x264_nal_t *nal, int nnal)
869 {
870  x264_nal_t *sps_nal = NULL;
871  x264_nal_t *pps_nal = NULL;
872  uint8_t *p, *sps;
873  int ret;
874 
875  /* We know it's in the order of SPS/PPS/SEI, but it's not documented in x264 API.
876  * The x264 param i_sps_id implies there is a single pair of SPS/PPS.
877  */
878  for (int i = 0; i < nnal; i++) {
879  switch (nal[i].i_type) {
880  case NAL_SPS:
881  sps_nal = &nal[i];
882  break;
883  case NAL_PPS:
884  pps_nal = &nal[i];
885  break;
886  case NAL_SEI:
887  ret = save_sei(avctx, &nal[i]);
888  if (ret < 0)
889  return ret;
890  break;
891  }
892  }
893  if (!sps_nal || !pps_nal)
894  return AVERROR_EXTERNAL;
895 
896  avctx->extradata_size = sps_nal->i_payload + pps_nal->i_payload + 7;
898  if (!avctx->extradata)
899  return AVERROR(ENOMEM);
900 
901  // Now create AVCDecoderConfigurationRecord
902  p = avctx->extradata;
903  // Skip size part
904  sps = sps_nal->p_payload + 4;
905  *p++ = 1; // version
906  *p++ = sps[1]; // AVCProfileIndication
907  *p++ = sps[2]; // profile_compatibility
908  *p++ = sps[3]; // AVCLevelIndication
909  *p++ = 0xFF;
910  *p++ = 0xE0 | 0x01; // 3 bits reserved (111) + 5 bits number of sps
911  memcpy(p, sps_nal->p_payload + 2, sps_nal->i_payload - 2);
912  // Make sps has AV_INPUT_BUFFER_PADDING_SIZE padding, so it can be used
913  // with GetBitContext
914  sps = p + 2;
915  p += sps_nal->i_payload - 2;
916  *p++ = 1;
917  memcpy(p, pps_nal->p_payload + 2, pps_nal->i_payload - 2);
918  p += pps_nal->i_payload - 2;
919 
920  if (sps[3] != 66 && sps[3] != 77 && sps[3] != 88) {
921  GetBitContext gbc;
922  int chroma_format_idc;
923  int bit_depth_luma_minus8, bit_depth_chroma_minus8;
924 
925  /* It's not possible to have emulation prevention byte before
926  * bit_depth_chroma_minus8 due to the range of sps id, chroma_format_idc
927  * and so on. So we can read directly without need to escape emulation
928  * prevention byte.
929  *
930  * +4 to skip until sps id.
931  */
932  init_get_bits8(&gbc, sps + 4, sps_nal->i_payload - 4 - 4);
933  // Skip sps id
934  get_ue_golomb_31(&gbc);
935  chroma_format_idc = get_ue_golomb_31(&gbc);
936  if (chroma_format_idc == 3)
937  skip_bits1(&gbc);
938  bit_depth_luma_minus8 = get_ue_golomb_31(&gbc);
939  bit_depth_chroma_minus8 = get_ue_golomb_31(&gbc);
940 
941  *p++ = 0xFC | chroma_format_idc;
942  *p++ = 0xF8 | bit_depth_luma_minus8;
943  *p++ = 0xF8 | bit_depth_chroma_minus8;
944  *p++ = 0;
945  }
946  av_assert2(avctx->extradata + avctx->extradata_size >= p);
947  avctx->extradata_size = p - avctx->extradata;
948 
949  return 0;
950 }
951 #endif
952 
953 static int set_extradata(AVCodecContext *avctx)
954 {
955  X264Context *x4 = avctx->priv_data;
956  x264_nal_t *nal;
957  uint8_t *p;
958  int nnal, s;
959 
960  s = x264_encoder_headers(x4->enc, &nal, &nnal);
961  if (s < 0)
962  return AVERROR_EXTERNAL;
963 
964 #if CONFIG_LIBX264_ENCODER
965  if (!x4->params.b_annexb)
966  return set_avcc_extradata(avctx, nal, nnal);
967 #endif
968 
970  if (!p)
971  return AVERROR(ENOMEM);
972 
973  for (int i = 0; i < nnal; i++) {
974  /* Don't put the SEI in extradata. */
975  if (nal[i].i_type == NAL_SEI) {
976  s = save_sei(avctx, &nal[i]);
977  if (s < 0)
978  return s;
979  continue;
980  }
981  memcpy(p, nal[i].p_payload, nal[i].i_payload);
982  p += nal[i].i_payload;
983  }
984  avctx->extradata_size = p - avctx->extradata;
985 
986  return 0;
987 }
988 
989 #define PARSE_X264_OPT(name, var)\
990  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
991  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
992  return AVERROR(EINVAL);\
993  }
994 
995 #if CONFIG_LIBX264_HDR10
996 static void handle_mdcv(x264_param_t *params,
997  const AVMasteringDisplayMetadata *mdcv)
998 {
999  if (!mdcv->has_primaries && !mdcv->has_luminance)
1000  return;
1001 
1002  params->mastering_display.b_mastering_display = 1;
1003 
1004  if (mdcv->has_primaries) {
1005  int *const points[][2] = {
1006  {
1007  &params->mastering_display.i_red_x,
1008  &params->mastering_display.i_red_y
1009  },
1010  {
1011  &params->mastering_display.i_green_x,
1012  &params->mastering_display.i_green_y
1013  },
1014  {
1015  &params->mastering_display.i_blue_x,
1016  &params->mastering_display.i_blue_y
1017  },
1018  };
1019 
1020  for (int i = 0; i < 3; i++) {
1021  const AVRational *src = mdcv->display_primaries[i];
1022  int *dst[2] = { points[i][0], points[i][1] };
1023 
1024  *dst[0] = av_rescale_q(1, src[0], (AVRational){ 1, 50000 });
1025  *dst[1] = av_rescale_q(1, src[1], (AVRational){ 1, 50000 });
1026  }
1027 
1028  params->mastering_display.i_white_x =
1029  av_rescale_q(1, mdcv->white_point[0], (AVRational){ 1, 50000 });
1030  params->mastering_display.i_white_y =
1031  av_rescale_q(1, mdcv->white_point[1], (AVRational){ 1, 50000 });
1032  }
1033 
1034  if (mdcv->has_luminance) {
1035  params->mastering_display.i_display_max =
1036  av_rescale_q(1, mdcv->max_luminance, (AVRational){ 1, 10000 });
1037  params->mastering_display.i_display_min =
1038  av_rescale_q(1, mdcv->min_luminance, (AVRational){ 1, 10000 });
1039  }
1040 }
1041 #endif // CONFIG_LIBX264_HDR10
1042 
1043 static void handle_side_data(AVCodecContext *avctx, x264_param_t *params)
1044 {
1045 #if CONFIG_LIBX264_HDR10
1046  const AVFrameSideData *cll_sd =
1049  const AVFrameSideData *mdcv_sd =
1051  avctx->nb_decoded_side_data,
1053 
1054  if (cll_sd) {
1055  const AVContentLightMetadata *cll =
1056  (AVContentLightMetadata *)cll_sd->data;
1057 
1058  params->content_light_level.i_max_cll = cll->MaxCLL;
1059  params->content_light_level.i_max_fall = cll->MaxFALL;
1060 
1061  params->content_light_level.b_cll = 1;
1062  }
1063 
1064  if (mdcv_sd) {
1065  handle_mdcv(params, (AVMasteringDisplayMetadata *)mdcv_sd->data);
1066  }
1067 #endif // CONFIG_LIBX264_HDR10
1068 }
1069 
1071 {
1072  X264Context *x4 = avctx->priv_data;
1073  AVCPBProperties *cpb_props;
1074  int sw,sh;
1075  int ret;
1076 
1077  if (avctx->global_quality > 0)
1078  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
1079 
1080 #if CONFIG_LIBX262_ENCODER
1081  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1082  x4->params.b_mpeg2 = 1;
1083  x264_param_default_mpeg2(&x4->params);
1084  } else
1085 #endif
1086  x264_param_default(&x4->params);
1087 
1088  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
1089 
1090  if (x4->preset || x4->tune)
1091  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
1092  int i;
1093  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
1094  av_log(avctx, AV_LOG_INFO, "Possible presets:");
1095  for (i = 0; x264_preset_names[i]; i++)
1096  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
1097  av_log(avctx, AV_LOG_INFO, "\n");
1098  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
1099  for (i = 0; x264_tune_names[i]; i++)
1100  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
1101  av_log(avctx, AV_LOG_INFO, "\n");
1102  return AVERROR(EINVAL);
1103  }
1104 
1105  if (avctx->level > 0)
1106  x4->params.i_level_idc = avctx->level;
1107 
1108  x4->params.pf_log = X264_log;
1109  x4->params.p_log_private = avctx;
1110  x4->params.i_log_level = X264_LOG_DEBUG;
1111  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
1112 #if X264_BUILD >= 153
1113  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
1114 #endif
1115 
1116  PARSE_X264_OPT("weightp", wpredp);
1117 
1118  if (avctx->bit_rate) {
1119  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
1120  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
1121  return AVERROR(EINVAL);
1122  }
1123  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
1124  x4->params.rc.i_rc_method = X264_RC_ABR;
1125  }
1126  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
1127  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
1128  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
1129  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
1130  x4->params.rc.b_stat_read = 1;
1131  } else {
1132  if (x4->crf >= 0) {
1133  x4->params.rc.i_rc_method = X264_RC_CRF;
1134  x4->params.rc.f_rf_constant = x4->crf;
1135  } else if (x4->cqp >= 0) {
1136  x4->params.rc.i_rc_method = X264_RC_CQP;
1137  x4->params.rc.i_qp_constant = x4->cqp;
1138  }
1139 
1140  if (x4->crf_max >= 0)
1141  x4->params.rc.f_rf_constant_max = x4->crf_max;
1142  }
1143 
1144  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
1145  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
1146  x4->params.rc.f_vbv_buffer_init =
1148  }
1149 
1150  PARSE_X264_OPT("level", level);
1151 
1152  if (avctx->i_quant_factor > 0)
1153  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
1154  if (avctx->b_quant_factor > 0)
1155  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
1156 
1157  if (x4->chroma_offset)
1158  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
1159 
1160  if (avctx->gop_size >= 0)
1161  x4->params.i_keyint_max = avctx->gop_size;
1162  if (avctx->max_b_frames >= 0)
1163  x4->params.i_bframe = avctx->max_b_frames;
1164 
1165  if (x4->scenechange_threshold >= 0)
1166  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
1167 
1168  if (avctx->qmin >= 0)
1169  x4->params.rc.i_qp_min = avctx->qmin;
1170  if (avctx->qmax >= 0)
1171  x4->params.rc.i_qp_max = avctx->qmax;
1172  if (avctx->max_qdiff >= 0)
1173  x4->params.rc.i_qp_step = avctx->max_qdiff;
1174  if (avctx->qblur >= 0)
1175  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
1176  if (avctx->qcompress >= 0)
1177  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
1178  if (avctx->refs >= 0)
1179  x4->params.i_frame_reference = avctx->refs;
1180  else if (x4->params.i_level_idc > 0) {
1181  int i;
1182  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
1183  int scale = X264_BUILD < 129 ? 384 : 1;
1184 
1185  for (i = 0; i<x264_levels[i].level_idc; i++)
1186  if (x264_levels[i].level_idc == x4->params.i_level_idc)
1187  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
1188  }
1189 
1190  if (avctx->trellis >= 0)
1191  x4->params.analyse.i_trellis = avctx->trellis;
1192  if (avctx->me_range >= 0)
1193  x4->params.analyse.i_me_range = avctx->me_range;
1194  if (x4->noise_reduction >= 0)
1195  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
1196  if (avctx->me_subpel_quality >= 0)
1197  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
1198  if (avctx->keyint_min >= 0)
1199  x4->params.i_keyint_min = avctx->keyint_min;
1200  if (avctx->me_cmp >= 0)
1201  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
1202 
1203  if (x4->aq_mode >= 0)
1204  x4->params.rc.i_aq_mode = x4->aq_mode;
1205  if (x4->aq_strength >= 0)
1206  x4->params.rc.f_aq_strength = x4->aq_strength;
1207  PARSE_X264_OPT("psy-rd", psy_rd);
1208  PARSE_X264_OPT("deblock", deblock);
1209  PARSE_X264_OPT("partitions", partitions);
1210  PARSE_X264_OPT("stats", stats);
1211  if (x4->psy >= 0)
1212  x4->params.analyse.b_psy = x4->psy;
1213  if (x4->rc_lookahead >= 0)
1214  x4->params.rc.i_lookahead = x4->rc_lookahead;
1215  if (x4->weightp >= 0)
1216  x4->params.analyse.i_weighted_pred = x4->weightp;
1217  if (x4->weightb >= 0)
1218  x4->params.analyse.b_weighted_bipred = x4->weightb;
1219  if (x4->cplxblur >= 0)
1220  x4->params.rc.f_complexity_blur = x4->cplxblur;
1221 
1222  if (x4->ssim >= 0)
1223  x4->params.analyse.b_ssim = x4->ssim;
1224  if (x4->intra_refresh >= 0)
1225  x4->params.b_intra_refresh = x4->intra_refresh;
1226  if (x4->bluray_compat >= 0) {
1227  x4->params.b_bluray_compat = x4->bluray_compat;
1228  x4->params.b_vfr_input = 0;
1229  }
1230  if (x4->avcintra_class >= 0)
1231 #if X264_BUILD >= 142
1232  x4->params.i_avcintra_class = x4->avcintra_class;
1233 #else
1234  av_log(avctx, AV_LOG_ERROR,
1235  "x264 too old for AVC Intra, at least version 142 needed\n");
1236 #endif
1237 
1238  if (x4->avcintra_class > 200) {
1239 #if X264_BUILD < 164
1240  av_log(avctx, AV_LOG_ERROR,
1241  "x264 too old for AVC Intra 300/480, at least version 164 needed\n");
1242  return AVERROR(EINVAL);
1243 #else
1244  /* AVC-Intra 300/480 only supported by Sony XAVC flavor */
1245  x4->params.i_avcintra_flavor = X264_AVCINTRA_FLAVOR_SONY;
1246 #endif
1247  }
1248 
1249  if (x4->b_bias != INT_MIN)
1250  x4->params.i_bframe_bias = x4->b_bias;
1251  if (x4->b_pyramid >= 0)
1252  x4->params.i_bframe_pyramid = x4->b_pyramid;
1253  if (x4->mixed_refs >= 0)
1254  x4->params.analyse.b_mixed_references = x4->mixed_refs;
1255  if (x4->dct8x8 >= 0)
1256  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
1257  if (x4->fast_pskip >= 0)
1258  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
1259  if (x4->aud >= 0)
1260  x4->params.b_aud = x4->aud;
1261  if (x4->mbtree >= 0)
1262  x4->params.rc.b_mb_tree = x4->mbtree;
1263  if (x4->direct_pred >= 0)
1264  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
1265 
1266  if (x4->slice_max_size >= 0)
1267  x4->params.i_slice_max_size = x4->slice_max_size;
1268 
1269  if (x4->fastfirstpass)
1270  x264_param_apply_fastfirstpass(&x4->params);
1271 
1272  x4->profile = x4->profile_opt;
1273  /* Allow specifying the x264 profile through AVCodecContext. */
1274  if (!x4->profile)
1275  switch (avctx->profile) {
1277  x4->profile = "baseline";
1278  break;
1279  case AV_PROFILE_H264_HIGH:
1280  x4->profile = "high";
1281  break;
1283  x4->profile = "high10";
1284  break;
1286  x4->profile = "high422";
1287  break;
1289  x4->profile = "high444";
1290  break;
1291  case AV_PROFILE_H264_MAIN:
1292  x4->profile = "main";
1293  break;
1294  default:
1295  break;
1296  }
1297 
1298  if (x4->nal_hrd >= 0)
1299  x4->params.i_nal_hrd = x4->nal_hrd;
1300 
1301  if (x4->motion_est >= 0)
1302  x4->params.analyse.i_me_method = x4->motion_est;
1303 
1304  if (x4->coder >= 0)
1305  x4->params.b_cabac = x4->coder;
1306 
1307  if (x4->b_frame_strategy >= 0)
1308  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
1309 
1310  if (x4->profile)
1311  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
1312  int i;
1313  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
1314  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
1315  for (i = 0; x264_profile_names[i]; i++)
1316  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
1317  av_log(avctx, AV_LOG_INFO, "\n");
1318  return AVERROR(EINVAL);
1319  }
1320 
1321  x4->params.i_width = avctx->width;
1322  x4->params.i_height = avctx->height;
1323  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
1324  x4->params.vui.i_sar_width = sw;
1325  x4->params.vui.i_sar_height = sh;
1326  x4->params.i_timebase_den = avctx->time_base.den;
1327  x4->params.i_timebase_num = avctx->time_base.num;
1328  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
1329  x4->params.i_fps_num = avctx->framerate.num;
1330  x4->params.i_fps_den = avctx->framerate.den;
1331  } else {
1332  x4->params.i_fps_num = avctx->time_base.den;
1334  x4->params.i_fps_den = avctx->time_base.num
1335 #if FF_API_TICKS_PER_FRAME
1336  * avctx->ticks_per_frame
1337 #endif
1338  ;
1340  }
1341 
1342  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
1343 
1344  x4->params.i_threads = avctx->thread_count;
1345  if (avctx->thread_type)
1346  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
1347 
1348  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
1349 
1350  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
1351 
1352  x4->params.i_slice_count = avctx->slices;
1353 
1354  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
1355  x4->params.vui.b_fullrange = avctx->color_range == AVCOL_RANGE_JPEG;
1356  else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
1357  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
1358  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P)
1359  x4->params.vui.b_fullrange = 1;
1360 
1361  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
1362  x4->params.vui.i_colmatrix = avctx->colorspace;
1363  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
1364  x4->params.vui.i_colorprim = avctx->color_primaries;
1365  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
1366  x4->params.vui.i_transfer = avctx->color_trc;
1368  x4->params.vui.i_chroma_loc = avctx->chroma_sample_location - 1;
1369 
1370  handle_side_data(avctx, &x4->params);
1371 
1372  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
1373  x4->params.b_repeat_headers = 0;
1374 
1375  if (avctx->flags & AV_CODEC_FLAG_RECON_FRAME)
1376  x4->params.b_full_recon = 1;
1377 
1378  if(x4->x264opts){
1379  const char *p= x4->x264opts;
1380  while(p){
1381  char param[4096]={0}, val[4096]={0};
1382  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
1383  ret = parse_opts(avctx, param, "1");
1384  if (ret < 0)
1385  return ret;
1386  } else {
1387  ret = parse_opts(avctx, param, val);
1388  if (ret < 0)
1389  return ret;
1390  }
1391  p= strchr(p, ':');
1392  if (p) {
1393  ++p;
1394  }
1395  }
1396  }
1397 
1398 #if X264_BUILD >= 142
1399  /* Separate headers not supported in AVC-Intra mode */
1400  if (x4->avcintra_class >= 0)
1401  x4->params.b_repeat_headers = 1;
1402 #endif
1403 
1404  {
1405  AVDictionaryEntry *en = NULL;
1406  while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) {
1407  if ((ret = x264_param_parse(&x4->params, en->key, en->value)) < 0) {
1408  av_log(avctx, AV_LOG_WARNING,
1409  "Error parsing option '%s = %s'.\n",
1410  en->key, en->value);
1411 #if X264_BUILD >= 161
1412  if (ret == X264_PARAM_ALLOC_FAILED)
1413  return AVERROR(ENOMEM);
1414 #endif
1415  }
1416  }
1417  }
1418 
1419  x4->params.analyse.b_mb_info = x4->mb_info;
1420 
1421  // update AVCodecContext with x264 parameters
1422  avctx->has_b_frames = x4->params.i_bframe ?
1423  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
1424  if (avctx->max_b_frames < 0)
1425  avctx->max_b_frames = 0;
1426 
1427  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
1428 
1429  x4->enc = x264_encoder_open(&x4->params);
1430  if (!x4->enc)
1431  return AVERROR_EXTERNAL;
1432 
1433  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1434  ret = set_extradata(avctx);
1435  if (ret < 0)
1436  return ret;
1437  }
1438 
1439  cpb_props = ff_encode_add_cpb_side_data(avctx);
1440  if (!cpb_props)
1441  return AVERROR(ENOMEM);
1442  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
1443  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
1444  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
1445 
1446  // Overestimate the reordered opaque buffer size, in case a runtime
1447  // reconfigure would increase the delay (which it shouldn't).
1448  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
1450  sizeof(*x4->reordered_opaque));
1451  if (!x4->reordered_opaque) {
1452  x4->nb_reordered_opaque = 0;
1453  return AVERROR(ENOMEM);
1454  }
1455 
1456  return 0;
1457 }
1458 
1459 static const enum AVPixelFormat pix_fmts_8bit[] = {
1468 #ifdef X264_CSP_NV21
1470 #endif
1472 };
1473 static const enum AVPixelFormat pix_fmts_9bit[] = {
1477 };
1478 static const enum AVPixelFormat pix_fmts_10bit[] = {
1484 };
1485 static const enum AVPixelFormat pix_fmts_all[] = {
1494 #ifdef X264_CSP_NV21
1496 #endif
1501 #ifdef X264_CSP_I400
1504 #endif
1506 };
1507 #if CONFIG_LIBX264RGB_ENCODER
1508 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1513 };
1514 #endif
1515 
1516 #if X264_BUILD < 153
1517 static av_cold void X264_init_static(FFCodec *codec)
1518 {
1519  if (x264_bit_depth == 8)
1520  codec->p.pix_fmts = pix_fmts_8bit;
1521  else if (x264_bit_depth == 9)
1522  codec->p.pix_fmts = pix_fmts_9bit;
1523  else if (x264_bit_depth == 10)
1524  codec->p.pix_fmts = pix_fmts_10bit;
1525 }
1526 #endif
1527 
1528 #define OFFSET(x) offsetof(X264Context, x)
1529 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1530 static const AVOption options[] = {
1531  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1532  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1533  { "profile", "Set profile restrictions (cf. x264 --fullhelp)", OFFSET(profile_opt), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1534  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1535  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1536  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1537  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1538  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1539  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1540  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1541  { "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 },
1542  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1543  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "aq_mode"},
1544  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, .unit = "aq_mode" },
1545  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, .unit = "aq_mode" },
1546  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, .unit = "aq_mode" },
1547 #if X264_BUILD >= 144
1548  { "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" },
1549 #endif
1550  { "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},
1551  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1552  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1553  { "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 },
1554  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1555  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "weightp" },
1556  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, .unit = "weightp" },
1557  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, .unit = "weightp" },
1558  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, .unit = "weightp" },
1559  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1560  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1561  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1562  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1563  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "b_pyramid" },
1564  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, .unit = "b_pyramid" },
1565  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, .unit = "b_pyramid" },
1566  { "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" },
1567  { "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 },
1568  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1569  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1570  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1571  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1572  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1573  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1574  { "partitions", "A comma-separated list of partitions to consider. "
1575  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1576  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "direct-pred" },
1577  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, .unit = "direct-pred" },
1578  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, .unit = "direct-pred" },
1579  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, .unit = "direct-pred" },
1580  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, .unit = "direct-pred" },
1581  { "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 },
1582  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1583  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1584  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, .unit = "nal-hrd" },
1585  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, .unit = "nal-hrd" },
1586  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, .unit = "nal-hrd" },
1587  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, .unit = "nal-hrd" },
1588  { "avcintra-class","AVC-Intra class 50/100/200/300/480", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 480 , VE},
1589  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, .unit = "motion-est"},
1590  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, .unit = "motion-est"},
1591  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1592  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1593  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1594  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1595  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, .unit = "motion-est" },
1596  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1597  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, .unit = "coder" },
1598  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1599  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1600  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1601  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1602  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
1603  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1604  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
1605  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1606  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1607  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1608  { "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 },
1609  { "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 },
1610  { NULL },
1611 };
1612 
1613 static const FFCodecDefault x264_defaults[] = {
1614  { "b", "0" },
1615  { "bf", "-1" },
1616  { "flags2", "0" },
1617  { "g", "-1" },
1618  { "i_qfactor", "-1" },
1619  { "b_qfactor", "-1" },
1620  { "qmin", "-1" },
1621  { "qmax", "-1" },
1622  { "qdiff", "-1" },
1623  { "qblur", "-1" },
1624  { "qcomp", "-1" },
1625 // { "rc_lookahead", "-1" },
1626  { "refs", "-1" },
1627  { "trellis", "-1" },
1628  { "me_range", "-1" },
1629  { "subq", "-1" },
1630  { "keyint_min", "-1" },
1631  { "cmp", "-1" },
1632  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1633  { "thread_type", "0" },
1634  { "flags", "+cgop" },
1635  { "rc_init_occupancy","-1" },
1636  { NULL },
1637 };
1638 
1639 #if CONFIG_LIBX264_ENCODER
1640 static const AVClass x264_class = {
1641  .class_name = "libx264",
1642  .item_name = av_default_item_name,
1643  .option = options,
1644  .version = LIBAVUTIL_VERSION_INT,
1645 };
1646 
1647 #if X264_BUILD >= 153
1648 const
1649 #endif
1650 FFCodec ff_libx264_encoder = {
1651  .p.name = "libx264",
1652  CODEC_LONG_NAME("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1653  .p.type = AVMEDIA_TYPE_VIDEO,
1654  .p.id = AV_CODEC_ID_H264,
1655  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1660  .p.priv_class = &x264_class,
1661  .p.wrapper_name = "libx264",
1662  .priv_data_size = sizeof(X264Context),
1663  .init = X264_init,
1665  .flush = X264_flush,
1666  .close = X264_close,
1667  .defaults = x264_defaults,
1668 #if X264_BUILD < 153
1669  .init_static_data = X264_init_static,
1670 #else
1671  .p.pix_fmts = pix_fmts_all,
1672 #endif
1674 #if X264_BUILD < 158
1676 #endif
1677  ,
1678 };
1679 #endif
1680 
1681 #if CONFIG_LIBX264RGB_ENCODER
1682 static const AVClass rgbclass = {
1683  .class_name = "libx264rgb",
1684  .item_name = av_default_item_name,
1685  .option = options,
1686  .version = LIBAVUTIL_VERSION_INT,
1687 };
1688 
1690  .p.name = "libx264rgb",
1691  CODEC_LONG_NAME("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1692  .p.type = AVMEDIA_TYPE_VIDEO,
1693  .p.id = AV_CODEC_ID_H264,
1694  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1697  .p.pix_fmts = pix_fmts_8bit_rgb,
1698  .p.priv_class = &rgbclass,
1699  .p.wrapper_name = "libx264",
1700  .priv_data_size = sizeof(X264Context),
1701  .init = X264_init,
1703  .close = X264_close,
1704  .defaults = x264_defaults,
1706 #if X264_BUILD < 158
1708 #endif
1709  ,
1710 };
1711 #endif
1712 
1713 #if CONFIG_LIBX262_ENCODER
1714 static const AVClass X262_class = {
1715  .class_name = "libx262",
1716  .item_name = av_default_item_name,
1717  .option = options,
1718  .version = LIBAVUTIL_VERSION_INT,
1719 };
1720 
1721 const FFCodec ff_libx262_encoder = {
1722  .p.name = "libx262",
1723  CODEC_LONG_NAME("libx262 MPEG2VIDEO"),
1724  .p.type = AVMEDIA_TYPE_VIDEO,
1725  .p.id = AV_CODEC_ID_MPEG2VIDEO,
1726  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1729  .p.pix_fmts = pix_fmts_8bit,
1730  .p.priv_class = &X262_class,
1731  .p.wrapper_name = "libx264",
1732  .priv_data_size = sizeof(X264Context),
1733  .init = X264_init,
1735  .close = X264_close,
1736  .defaults = x264_defaults,
1737  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1739 };
1740 #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:25
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:204
av_clip
#define av_clip
Definition: common.h:98
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:42
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:1024
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:685
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2076
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:858
X264Context::avcintra_class
int avcintra_class
Definition: libx264.c:108
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:607
X264Context::tune
char * tune
Definition: libx264.c:74
AV_PROFILE_H264_MAIN
#define AV_PROFILE_H264_MAIN
Definition: defs.h:111
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:78
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
X264Context::cplxblur
float cplxblur
Definition: libx264.c:102
rect::y
int y
Definition: f_ebur128.c:78
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
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:209
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
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:375
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:662
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVFrame::width
int width
Definition: frame.h:447
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
ff_libx264rgb_encoder
const FFCodec ff_libx264rgb_encoder
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
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:346
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
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:148
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
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:34
FFCodec
Definition: codec_internal.h:127
float.h
X264_flush
static void X264_flush(AVCodecContext *avctx)
Definition: libx264.c:751
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:540
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:329
AV_VIDEO_HINT_TYPE_CHANGED
@ AV_VIDEO_HINT_TYPE_CHANGED
Definition: video_hint.h:39
AVVideoHint
Definition: video_hint.h:42
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1263
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:245
X264Context::intra_refresh
int intra_refresh
Definition: libx264.c:92
AVCodecContext::me_subpel_quality
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:946
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
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:396
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:1070
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:639
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
save_sei
static int save_sei(AVCodecContext *avctx, x264_nal_t *nal)
Definition: libx264.c:852
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
golomb.h
exp golomb vlc stuff
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
X264_init_static
static av_cold void X264_init_static(FFCodec *codec)
Definition: libx264.c:1517
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3002
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:820
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:558
fail
#define fail()
Definition: checkasm.h:179
AV_PIX_FMT_NV20
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:526
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
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
ff_side_data_set_prft
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:632
X264Context::pic
x264_picture_t pic
Definition: libx264.c:70
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:715
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
FF_CMP_CHROMA
#define FF_CMP_CHROMA
Definition: avcodec.h:911
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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:296
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:481
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1397
preset
preset
Definition: vf_curves.c:46
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_STEREO3D_FRAMESEQUENCE
@ AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
Definition: stereo3d.h:89
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFrameSideData::size
size_t size
Definition: frame.h:253
av_cold
#define av_cold
Definition: attributes.h:90
pix_fmts_10bit
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:1478
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:300
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:1320
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
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:121
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
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:495
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:1239
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:316
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
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:2077
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:1485
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:114
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:1592
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:475
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
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:1292
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:547
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
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:272
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:117
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
setup_roi
static int setup_roi(AVCodecContext *ctx, x264_picture_t *pic, int bit_depth, const AVFrame *frame, const uint8_t *data, size_t size)
Definition: libx264.c:397
X264Context::noise_reduction
int noise_reduction
Definition: libx264.c:116
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:182
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1277
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
pix_fmts_9bit
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:1473
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
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:1249
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:495
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:242
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:305
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:131
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:876
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1327
av_clipf
av_clipf
Definition: af_crystalizer.c:121
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:824
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1783
free_picture
static void free_picture(x264_picture_t *pic)
Definition: libx264.c:297
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:649
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:989
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1248
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:544
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:841
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:341
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:1459
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
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
codec_internal.h
X264_close
static av_cold int X264_close(AVCodecContext *avctx)
Definition: libx264.c:769
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:121
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:953
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:955
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1594
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:703
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:462
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:521
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:528
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:284
AVRegionOfInterest::right
int right
Definition: frame.h:318
rect::x
int x
Definition: f_ebur128.c:78
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:164
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodecContext::b_quant_factor
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:804
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:238
VE
#define VE
Definition: libx264.c:1529
X264Context::sei
uint8_t * sei
Definition: libx264.c:71
AVRegionOfInterest::left
int left
Definition: frame.h:317
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:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
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:315
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:274
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:353
x264_defaults
static const FFCodecDefault x264_defaults[]
Definition: libx264.c:1613
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:606
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:254
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:702
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:307
options
static const AVOption options[]
Definition: libx264.c:1530
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:634
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
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:71
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:290
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:177
AV_PROFILE_H264_BASELINE
#define AV_PROFILE_H264_BASELINE
Definition: defs.h:109
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:105
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:1270
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:447
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:113
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:105
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1256
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
Definition: opt.h:235
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
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:251
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:576
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
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:1528
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:120
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:795
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:470
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
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:791
X264Context::deblock
char * deblock
Definition: libx264.c:101
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1047
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
handle_mdcv
static void handle_mdcv(struct EbSvtAv1MasteringDisplayInfo *dst, const AVMasteringDisplayMetadata *mdcv)
Definition: libsvtav1.c:141
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:1106
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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:420
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:2636
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:879
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:173
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
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:618
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:342
X264Context::b_frame_strategy
int b_frame_strategy
Definition: libx264.c:113
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
mb_info
Definition: cinepakenc.c:88
convert_pix_fmt
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Definition: libx264.c:817
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:642
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
handle_side_data
static void handle_side_data(AVCodecContext *avctx, x264_param_t *params)
Definition: libx264.c:1043
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