FFmpeg
libx264.c
Go to the documentation of this file.
1 /*
2  * H.264 encoding using the x264 library
3  * Copyright (C) 2005 Mans Rullgard <mans@mansr.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "config_components.h"
23 
24 #include "libavutil/buffer.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/mem.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/stereo3d.h"
31 #include "libavutil/time.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/video_hint.h"
34 #include "avcodec.h"
35 #include "codec_internal.h"
36 #include "encode.h"
37 #include "internal.h"
38 #include "packet_internal.h"
39 #include "atsc_a53.h"
40 #include "sei.h"
41 
42 #include <x264.h>
43 #include <float.h>
44 #include <math.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 
49 // from x264.h, for quant_offsets, Macroblocks are 16x16
50 // blocks of pixels (with respect to the luma plane)
51 #define MB_SIZE 16
52 #define MB_LSIZE 4
53 #define MB_FLOOR(x) ((x) >> (MB_LSIZE))
54 #define MB_CEIL(x) MB_FLOOR((x) + (MB_SIZE - 1))
55 
56 typedef struct X264Opaque {
57 #if FF_API_REORDERED_OPAQUE
58  int64_t reordered_opaque;
59 #endif
60  int64_t wallclock;
61  int64_t duration;
62 
63  void *frame_opaque;
64  AVBufferRef *frame_opaque_ref;
65 } X264Opaque;
66 
67 typedef struct X264Context {
68  AVClass *class;
69  x264_param_t params;
70  x264_t *enc;
71  x264_picture_t pic;
72  uint8_t *sei;
73  int sei_size;
74  char *preset;
75  char *tune;
76  const char *profile;
77  char *profile_opt;
78  char *level;
79  int fastfirstpass;
80  char *wpredp;
81  char *x264opts;
82  float crf;
83  float crf_max;
84  int cqp;
85  int aq_mode;
86  float aq_strength;
87  char *psy_rd;
88  int psy;
89  int rc_lookahead;
90  int weightp;
91  int weightb;
92  int ssim;
93  int intra_refresh;
94  int bluray_compat;
95  int b_bias;
96  int b_pyramid;
97  int mixed_refs;
98  int dct8x8;
99  int fast_pskip;
100  int aud;
101  int mbtree;
102  char *deblock;
103  float cplxblur;
104  char *partitions;
105  int direct_pred;
106  int slice_max_size;
107  char *stats;
108  int nal_hrd;
109  int avcintra_class;
110  int motion_est;
111  int forced_idr;
112  int coder;
113  int a53_cc;
114  int b_frame_strategy;
115  int chroma_offset;
116  int scenechange_threshold;
117  int noise_reduction;
118  int udu_sei;
119 
120  AVDictionary *x264_params;
121 
122  int nb_reordered_opaque, next_reordered_opaque;
123  X264Opaque *reordered_opaque;
124 
125  /**
126  * If the encoder does not support ROI then warn the first time we
127  * encounter a frame with ROI side data.
128  */
129  int roi_warned;
130 
131  int mb_info;
132 } X264Context;
133 
134 static void X264_log(void *p, int level, const char *fmt, va_list args)
135 {
136  static const int level_map[] = {
137  [X264_LOG_ERROR] = AV_LOG_ERROR,
138  [X264_LOG_WARNING] = AV_LOG_WARNING,
139  [X264_LOG_INFO] = AV_LOG_INFO,
140  [X264_LOG_DEBUG] = AV_LOG_DEBUG
141  };
142 
143  if (level < 0 || level > X264_LOG_DEBUG)
144  return;
145 
146  av_vlog(p, level_map[level], fmt, args);
147 }
148 
149 static void opaque_uninit(X264Opaque *o)
150 {
151  av_buffer_unref(&o->frame_opaque_ref);
152  memset(o, 0, sizeof(*o));
153 }
154 
155 static int encode_nals(AVCodecContext *ctx, AVPacket *pkt,
156  const x264_nal_t *nals, int nnal)
157 {
158  X264Context *x4 = ctx->priv_data;
159  uint8_t *p;
160  uint64_t size = FFMAX(x4->sei_size, 0);
161  int ret;
162 
163  if (!nnal)
164  return 0;
165 
166  for (int i = 0; i < nnal; i++) {
167  size += nals[i].i_payload;
168  /* ff_get_encode_buffer() accepts an int64_t and
169  * so we need to make sure that no overflow happens before
170  * that. With 32bit ints this is automatically true. */
171 #if INT_MAX > INT64_MAX / INT_MAX - 1
172  if ((int64_t)size < 0)
173  return AVERROR(ERANGE);
174 #endif
175  }
176 
177  if ((ret = ff_get_encode_buffer(ctx, pkt, size, 0)) < 0)
178  return ret;
179 
180  p = pkt->data;
181 
182  /* Write the SEI as part of the first frame. */
183  if (x4->sei_size > 0) {
184  memcpy(p, x4->sei, x4->sei_size);
185  p += x4->sei_size;
186  size -= x4->sei_size;
187  /* Keep the value around in case of flush */
188  x4->sei_size = -x4->sei_size;
189  }
190 
191  /* x264 guarantees the payloads of the NALs
192  * to be sequential in memory. */
193  memcpy(p, nals[0].p_payload, size);
194 
195  return 1;
196 }
197 
198 static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
199 {
200  X264Context *x4 = ctx->priv_data;
201  AVFrameSideData *side_data;
202 
203 
204  if (x4->avcintra_class < 0) {
205  if (x4->params.b_interlaced && x4->params.b_tff != !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST)) {
206 
207  x4->params.b_tff = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
208  x264_encoder_reconfig(x4->enc, &x4->params);
209  }
210  if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
211  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
212  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
213  x264_encoder_reconfig(x4->enc, &x4->params);
214  }
215 
216  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
217  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
218  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
219  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
220  x264_encoder_reconfig(x4->enc, &x4->params);
221  }
222 
223  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
224  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
225  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
226  x264_encoder_reconfig(x4->enc, &x4->params);
227  }
228 
229  if (x4->crf >= 0 &&
230  x4->params.rc.i_rc_method == X264_RC_CRF &&
231  x4->params.rc.f_rf_constant != x4->crf) {
232  x4->params.rc.f_rf_constant = x4->crf;
233  x264_encoder_reconfig(x4->enc, &x4->params);
234  }
235 
236  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
237  x4->cqp >= 0 &&
238  x4->params.rc.i_qp_constant != x4->cqp) {
239  x4->params.rc.i_qp_constant = x4->cqp;
240  x264_encoder_reconfig(x4->enc, &x4->params);
241  }
242 
243  if (x4->crf_max >= 0 &&
244  x4->params.rc.f_rf_constant_max != x4->crf_max) {
245  x4->params.rc.f_rf_constant_max = x4->crf_max;
246  x264_encoder_reconfig(x4->enc, &x4->params);
247  }
248  }
249 
250  side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_STEREO3D);
251  if (side_data) {
252  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
253  int fpa_type;
254 
255  switch (stereo->type) {
256  case AV_STEREO3D_CHECKERBOARD:
257  fpa_type = 0;
258  break;
259  case AV_STEREO3D_COLUMNS:
260  fpa_type = 1;
261  break;
262  case AV_STEREO3D_LINES:
263  fpa_type = 2;
264  break;
265  case AV_STEREO3D_SIDEBYSIDE:
266  fpa_type = 3;
267  break;
268  case AV_STEREO3D_TOPBOTTOM:
269  fpa_type = 4;
270  break;
271  case AV_STEREO3D_FRAMESEQUENCE:
272  fpa_type = 5;
273  break;
274 #if X264_BUILD >= 145
275  case AV_STEREO3D_2D:
276  fpa_type = 6;
277  break;
278 #endif
279  default:
280  fpa_type = -1;
281  break;
282  }
283 
284  /* Inverted mode is not supported by x264 */
285  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
286  av_log(ctx, AV_LOG_WARNING,
287  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
288  fpa_type = -1;
289  }
290 
291  if (fpa_type != x4->params.i_frame_packing) {
292  x4->params.i_frame_packing = fpa_type;
293  x264_encoder_reconfig(x4->enc, &x4->params);
294  }
295  }
296 }
297 
298 static void free_picture(x264_picture_t *pic)
299 {
300  for (int i = 0; i < pic->extra_sei.num_payloads; i++)
301  av_free(pic->extra_sei.payloads[i].payload);
302  av_freep(&pic->extra_sei.payloads);
303  av_freep(&pic->prop.quant_offsets);
304  av_freep(&pic->prop.mb_info);
305  pic->extra_sei.num_payloads = 0;
306 }
307 
308 static enum AVPixelFormat csp_to_pixfmt(int csp)
309 {
310  switch (csp) {
311 #ifdef X264_CSP_I400
312  case X264_CSP_I400: return AV_PIX_FMT_GRAY8;
313  case X264_CSP_I400 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_GRAY10;
314 #endif
315  case X264_CSP_I420: return AV_PIX_FMT_YUV420P;
316  case X264_CSP_I420 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV420P10;
317  case X264_CSP_I422: return AV_PIX_FMT_YUV422P;
318  case X264_CSP_I422 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV422P10;
319  case X264_CSP_I444: return AV_PIX_FMT_YUV444P;
320  case X264_CSP_I444 | X264_CSP_HIGH_DEPTH: return AV_PIX_FMT_YUV444P10;
321  case X264_CSP_NV12: return AV_PIX_FMT_NV12;
322 #ifdef X264_CSP_NV21
323  case X264_CSP_NV21: return AV_PIX_FMT_NV21;
324 #endif
325  case X264_CSP_NV16: return AV_PIX_FMT_NV16;
326  };
327  return AV_PIX_FMT_NONE;
328 }
329 
330 static void av_always_inline mbinfo_compute_changed_coords(const AVVideoRect *rect,
331  int *min_x,
332  int *max_x,
333  int *min_y,
334  int *max_y)
335 {
336  *min_y = MB_FLOOR(rect->y);
337  *max_y = MB_CEIL(rect->y + rect->height);
338  *min_x = MB_FLOOR(rect->x);
339  *max_x = MB_CEIL(rect->x + rect->width);
340 }
341 
342 static void av_always_inline mbinfo_compute_constant_coords(const AVVideoRect *rect,
343  int *min_x,
344  int *max_x,
345  int *min_y,
346  int *max_y)
347 {
348  *min_y = MB_CEIL(rect->y);
349  *max_y = MB_FLOOR(rect->y + rect->height);
350  *min_x = MB_CEIL(rect->x);
351  *max_x = MB_FLOOR(rect->x + rect->width);
352 }
353 
354 static int setup_mb_info(AVCodecContext *ctx, x264_picture_t *pic,
355  const AVFrame *frame,
356  const AVVideoHint *info)
357 {
358  int mb_width = (frame->width + MB_SIZE - 1) / MB_SIZE;
359  int mb_height = (frame->height + MB_SIZE - 1) / MB_SIZE;
360 
361  const AVVideoRect *mbinfo_rects;
362  int nb_rects;
363  uint8_t *mbinfo;
364 
365  mbinfo_rects = (const AVVideoRect *)av_video_hint_rects(info);
366  nb_rects = info->nb_rects;
367 
368  mbinfo = av_calloc(mb_width * mb_height, sizeof(*mbinfo));
369  if (!mbinfo)
370  return AVERROR(ENOMEM);
371 
372 #define COMPUTE_MBINFO(mbinfo_filler_, mbinfo_marker_, compute_coords_fn_) \
373  memset(mbinfo, mbinfo_filler_, sizeof(*mbinfo) * mb_width * mb_height); \
374  \
375  for (int i = 0; i < nb_rects; i++) { \
376  int min_x, max_x, min_y, max_y; \
377  \
378  compute_coords_fn_(mbinfo_rects, &min_x, &max_x, &min_y, &max_y); \
379  for (int mb_y = min_y; mb_y < max_y; ++mb_y) { \
380  memset(mbinfo + mb_y * mb_width + min_x, mbinfo_marker_, max_x - min_x); \
381  } \
382  \
383  mbinfo_rects++; \
384  } \
385 
386  if (info->type == AV_VIDEO_HINT_TYPE_CHANGED) {
387  COMPUTE_MBINFO(X264_MBINFO_CONSTANT, 0, mbinfo_compute_changed_coords);
388  } else /* if (info->type == AV_VIDEO_HINT_TYPE_CHANGED) */ {
389  COMPUTE_MBINFO(0, X264_MBINFO_CONSTANT, mbinfo_compute_constant_coords);
390  }
391 
392  pic->prop.mb_info = mbinfo;
393  pic->prop.mb_info_free = av_free;
394 
395  return 0;
396 }
397 
398 static int setup_roi(AVCodecContext *ctx, x264_picture_t *pic, int bit_depth,
399  const AVFrame *frame, const uint8_t *data, size_t size)
400 {
401  X264Context *x4 = ctx->priv_data;
402 
403  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
404  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
405  int qp_range = 51 + 6 * (bit_depth - 8);
406  int nb_rois;
407  const AVRegionOfInterest *roi;
408  uint32_t roi_size;
409  float *qoffsets;
410 
411  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
412  if (!x4->roi_warned) {
413  x4->roi_warned = 1;
414  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
415  }
416  return 0;
417  } else if (frame->flags & AV_FRAME_FLAG_INTERLACED) {
418  if (!x4->roi_warned) {
419  x4->roi_warned = 1;
420  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
421  }
422  return 0;
423  }
424 
425  roi = (const AVRegionOfInterest*)data;
426  roi_size = roi->self_size;
427  if (!roi_size || size % roi_size != 0) {
428  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
429  return AVERROR(EINVAL);
430  }
431  nb_rois = size / roi_size;
432 
433  qoffsets = av_calloc(mbx * mby, sizeof(*qoffsets));
434  if (!qoffsets)
435  return AVERROR(ENOMEM);
436 
437  // This list must be iterated in reverse because the first
438  // region in the list applies when regions overlap.
439  for (int i = nb_rois - 1; i >= 0; i--) {
440  int startx, endx, starty, endy;
441  float qoffset;
442 
443  roi = (const AVRegionOfInterest*)(data + roi_size * i);
444 
445  starty = FFMIN(mby, roi->top / MB_SIZE);
446  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
447  startx = FFMIN(mbx, roi->left / MB_SIZE);
448  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
449 
450  if (roi->qoffset.den == 0) {
451  av_free(qoffsets);
452  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
453  return AVERROR(EINVAL);
454  }
455  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
456  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
457 
458  for (int y = starty; y < endy; y++) {
459  for (int x = startx; x < endx; x++) {
460  qoffsets[x + y*mbx] = qoffset;
461  }
462  }
463  }
464 
465  pic->prop.quant_offsets = qoffsets;
466  pic->prop.quant_offsets_free = av_free;
467 
468  return 0;
469 }
470 
471 static int setup_frame(AVCodecContext *ctx, const AVFrame *frame,
472  x264_picture_t **ppic)
473 {
474  X264Context *x4 = ctx->priv_data;
475  X264Opaque *opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
476  x264_picture_t *pic = &x4->pic;
477  x264_sei_t *sei = &pic->extra_sei;
478  unsigned int sei_data_size = 0;
479  int64_t wallclock = 0;
480  int bit_depth, ret;
481  AVFrameSideData *sd;
482  AVFrameSideData *mbinfo_sd;
483 
484  *ppic = NULL;
485  if (!frame)
486  return 0;
487 
488  x264_picture_init(pic);
489  pic->img.i_csp = x4->params.i_csp;
490 #if X264_BUILD >= 153
491  bit_depth = x4->params.i_bitdepth;
492 #else
493  bit_depth = x264_bit_depth;
494 #endif
495  if (bit_depth > 8)
496  pic->img.i_csp |= X264_CSP_HIGH_DEPTH;
497  pic->img.i_plane = av_pix_fmt_count_planes(ctx->pix_fmt);
498 
499  for (int i = 0; i < pic->img.i_plane; i++) {
500  pic->img.plane[i] = frame->data[i];
501  pic->img.i_stride[i] = frame->linesize[i];
502  }
503 
504  pic->i_pts = frame->pts;
505 
506  opaque_uninit(opaque);
507 
508  if (ctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
509  opaque->frame_opaque = frame->opaque;
510  ret = av_buffer_replace(&opaque->frame_opaque_ref, frame->opaque_ref);
511  if (ret < 0)
512  goto fail;
513  }
514 
515 #if FF_API_REORDERED_OPAQUE
516 FF_DISABLE_DEPRECATION_WARNINGS
517  opaque->reordered_opaque = frame->reordered_opaque;
518 FF_ENABLE_DEPRECATION_WARNINGS
519 #endif
520  opaque->duration = frame->duration;
521  opaque->wallclock = wallclock;
522  if (ctx->export_side_data & AV_CODEC_EXPORT_DATA_PRFT)
523  opaque->wallclock = av_gettime();
524 
525  pic->opaque = opaque;
526 
527  x4->next_reordered_opaque++;
528  x4->next_reordered_opaque %= x4->nb_reordered_opaque;
529 
530  switch (frame->pict_type) {
531  case AV_PICTURE_TYPE_I:
532  pic->i_type = x4->forced_idr > 0 ? X264_TYPE_IDR : X264_TYPE_KEYFRAME;
533  break;
534  case AV_PICTURE_TYPE_P:
535  pic->i_type = X264_TYPE_P;
536  break;
537  case AV_PICTURE_TYPE_B:
538  pic->i_type = X264_TYPE_B;
539  break;
540  default:
541  pic->i_type = X264_TYPE_AUTO;
542  break;
543  }
544  reconfig_encoder(ctx, frame);
545 
546  if (x4->a53_cc) {
547  void *sei_data;
548  size_t sei_size;
549 
550  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
551  if (ret < 0)
552  goto fail;
553 
554  if (sei_data) {
555  sei->payloads = av_mallocz(sizeof(sei->payloads[0]));
556  if (!sei->payloads) {
557  av_free(sei_data);
558  ret = AVERROR(ENOMEM);
559  goto fail;
560  }
561 
562  sei->sei_free = av_free;
563 
564  sei->payloads[0].payload_size = sei_size;
565  sei->payloads[0].payload = sei_data;
566  sei->payloads[0].payload_type = SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35;
567  sei->num_payloads = 1;
568  }
569  }
570 
571  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
572  if (sd) {
573  ret = setup_roi(ctx, pic, bit_depth, frame, sd->data, sd->size);
574  if (ret < 0)
575  goto fail;
576  }
577 
578  mbinfo_sd = av_frame_get_side_data(frame, AV_FRAME_DATA_VIDEO_HINT);
579  if (mbinfo_sd) {
580  int ret = setup_mb_info(ctx, pic, frame, (const AVVideoHint *)mbinfo_sd->data);
581  if (ret < 0) {
582  /* No need to fail here, this is not fatal. We just proceed with no
583  * mb_info and log a message */
584 
585  av_log(ctx, AV_LOG_WARNING, "setup_mb_info failed with error: %s\n", av_err2str(ret));
586  }
587  }
588 
589  if (x4->udu_sei) {
590  for (int j = 0; j < frame->nb_side_data; j++) {
591  AVFrameSideData *side_data = frame->side_data[j];
592  void *tmp;
593  x264_sei_payload_t *sei_payload;
594  if (side_data->type != AV_FRAME_DATA_SEI_UNREGISTERED)
595  continue;
596  tmp = av_fast_realloc(sei->payloads, &sei_data_size, (sei->num_payloads + 1) * sizeof(*sei_payload));
597  if (!tmp) {
598  ret = AVERROR(ENOMEM);
599  goto fail;
600  }
601  sei->payloads = tmp;
602  sei->sei_free = av_free;
603  sei_payload = &sei->payloads[sei->num_payloads];
604  sei_payload->payload = av_memdup(side_data->data, side_data->size);
605  if (!sei_payload->payload) {
606  ret = AVERROR(ENOMEM);
607  goto fail;
608  }
609  sei_payload->payload_size = side_data->size;
610  sei_payload->payload_type = SEI_TYPE_USER_DATA_UNREGISTERED;
611  sei->num_payloads++;
612  }
613  }
614 
615  *ppic = pic;
616  return 0;
617 
618 fail:
619  free_picture(pic);
620  *ppic = NULL;
621  return ret;
622 }
623 
624 static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
625  int *got_packet)
626 {
627  X264Context *x4 = ctx->priv_data;
628  x264_nal_t *nal;
629  int nnal, ret;
630  x264_picture_t pic_out = {0}, *pic_in;
631  int pict_type;
632  int64_t wallclock = 0;
633  X264Opaque *out_opaque;
634 
635  ret = setup_frame(ctx, frame, &pic_in);
636  if (ret < 0)
637  return ret;
638 
639  do {
640  if (x264_encoder_encode(x4->enc, &nal, &nnal, pic_in, &pic_out) < 0)
641  return AVERROR_EXTERNAL;
642 
643  if (nnal && (ctx->flags & AV_CODEC_FLAG_RECON_FRAME)) {
644  AVCodecInternal *avci = ctx->internal;
645 
646  av_frame_unref(avci->recon_frame);
647 
648  avci->recon_frame->format = csp_to_pixfmt(pic_out.img.i_csp);
649  if (avci->recon_frame->format == AV_PIX_FMT_NONE) {
650  av_log(ctx, AV_LOG_ERROR,
651  "Unhandled reconstructed frame colorspace: %d\n",
652  pic_out.img.i_csp);
653  return AVERROR(ENOSYS);
654  }
655 
656  avci->recon_frame->width = ctx->width;
657  avci->recon_frame->height = ctx->height;
658  for (int i = 0; i < pic_out.img.i_plane; i++) {
659  avci->recon_frame->data[i] = pic_out.img.plane[i];
660  avci->recon_frame->linesize[i] = pic_out.img.i_stride[i];
661  }
662 
663  ret = av_frame_make_writable(avci->recon_frame);
664  if (ret < 0) {
665  av_frame_unref(avci->recon_frame);
666  return ret;
667  }
668  }
669 
670  ret = encode_nals(ctx, pkt, nal, nnal);
671  if (ret < 0)
672  return ret;
673  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
674 
675  if (!ret)
676  return 0;
677 
678  pkt->pts = pic_out.i_pts;
679  pkt->dts = pic_out.i_dts;
680 
681  out_opaque = pic_out.opaque;
682  if (out_opaque >= x4->reordered_opaque &&
683  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
684 #if FF_API_REORDERED_OPAQUE
685 FF_DISABLE_DEPRECATION_WARNINGS
686  ctx->reordered_opaque = out_opaque->reordered_opaque;
687 FF_ENABLE_DEPRECATION_WARNINGS
688 #endif
689  wallclock = out_opaque->wallclock;
690  pkt->duration = out_opaque->duration;
691 
692  if (ctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
693  pkt->opaque = out_opaque->frame_opaque;
694  pkt->opaque_ref = out_opaque->frame_opaque_ref;
695  out_opaque->frame_opaque_ref = NULL;
696  }
697 
698  opaque_uninit(out_opaque);
699  } else {
700  // Unexpected opaque pointer on picture output
701  av_log(ctx, AV_LOG_ERROR, "Unexpected opaque pointer; "
702  "this is a bug, please report it.\n");
703 #if FF_API_REORDERED_OPAQUE
704 FF_DISABLE_DEPRECATION_WARNINGS
705  ctx->reordered_opaque = 0;
706 FF_ENABLE_DEPRECATION_WARNINGS
707 #endif
708  }
709 
710  switch (pic_out.i_type) {
711  case X264_TYPE_IDR:
712  case X264_TYPE_I:
713  pict_type = AV_PICTURE_TYPE_I;
714  break;
715  case X264_TYPE_P:
716  pict_type = AV_PICTURE_TYPE_P;
717  break;
718  case X264_TYPE_B:
719  case X264_TYPE_BREF:
720  pict_type = AV_PICTURE_TYPE_B;
721  break;
722  default:
723  av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
724  return AVERROR_EXTERNAL;
725  }
726 
727  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
728  if (ret) {
729  int error_count = 0;
730  int64_t *errors = NULL;
731  int64_t sse[3] = {0};
732 
733  if (ctx->flags & AV_CODEC_FLAG_PSNR) {
734  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(ctx->pix_fmt);
735  double scale[3] = { 1,
736  (double)(1 << pix_desc->log2_chroma_h) * (1 << pix_desc->log2_chroma_w),
737  (double)(1 << pix_desc->log2_chroma_h) * (1 << pix_desc->log2_chroma_w),
738  };
739 
740  error_count = pix_desc->nb_components;
741 
742  for (int i = 0; i < pix_desc->nb_components; ++i) {
743  double max_value = (double)(1 << pix_desc->comp[i].depth) - 1.0;
744  double plane_size = ctx->width * (double)ctx->height / scale[i];
745 
746  /* psnr = 10 * log10(max_value * max_value / mse) */
747  double mse = (max_value * max_value) / pow(10, pic_out.prop.f_psnr[i] / 10.0);
748 
749  /* SSE = MSE * width * height / scale -> because of possible chroma downsampling */
750  sse[i] = (int64_t)floor(mse * plane_size + .5);
751  };
752 
753  errors = sse;
754  }
755 
756  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA,
757  errors, error_count, pict_type);
758 
759  if (wallclock)
760  ff_side_data_set_prft(pkt, wallclock);
761  }
762 
763  *got_packet = ret;
764  return 0;
765 }
766 
767 static void X264_flush(AVCodecContext *avctx)
768 {
769  X264Context *x4 = avctx->priv_data;
770  x264_nal_t *nal;
771  int nnal, ret;
772  x264_picture_t pic_out = {0};
773 
774  do {
775  ret = x264_encoder_encode(x4->enc, &nal, &nnal, NULL, &pic_out);
776  } while (ret > 0 && x264_encoder_delayed_frames(x4->enc));
777 
778  for (int i = 0; i < x4->nb_reordered_opaque; i++)
779  opaque_uninit(&x4->reordered_opaque[i]);
780 
781  if (x4->sei_size < 0)
782  x4->sei_size = -x4->sei_size;
783 }
784 
785 static av_cold int X264_close(AVCodecContext *avctx)
786 {
787  X264Context *x4 = avctx->priv_data;
788 
789  av_freep(&x4->sei);
790 
791  for (int i = 0; i < x4->nb_reordered_opaque; i++)
792  opaque_uninit(&x4->reordered_opaque[i]);
793  av_freep(&x4->reordered_opaque);
794 
795 #if X264_BUILD >= 161
796  x264_param_cleanup(&x4->params);
797 #endif
798 
799  if (x4->enc) {
800  x264_encoder_close(x4->enc);
801  x4->enc = NULL;
802  }
803 
804  return 0;
805 }
806 
807 static int parse_opts(AVCodecContext *avctx, const char *opt, const char *param)
808 {
809  X264Context *x4 = avctx->priv_data;
810  int ret;
811 
812  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) {
813  if (ret == X264_PARAM_BAD_NAME) {
814  av_log(avctx, AV_LOG_ERROR,
815  "bad option '%s': '%s'\n", opt, param);
816  ret = AVERROR(EINVAL);
817 #if X264_BUILD >= 161
818  } else if (ret == X264_PARAM_ALLOC_FAILED) {
819  av_log(avctx, AV_LOG_ERROR,
820  "out of memory parsing option '%s': '%s'\n", opt, param);
821  ret = AVERROR(ENOMEM);
822 #endif
823  } else {
824  av_log(avctx, AV_LOG_ERROR,
825  "bad value for '%s': '%s'\n", opt, param);
826  ret = AVERROR(EINVAL);
827  }
828  }
829 
830  return ret;
831 }
832 
833 static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
834 {
835  switch (pix_fmt) {
836  case AV_PIX_FMT_YUV420P:
837  case AV_PIX_FMT_YUVJ420P:
838  case AV_PIX_FMT_YUV420P9:
839  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
840  case AV_PIX_FMT_YUV422P:
841  case AV_PIX_FMT_YUVJ422P:
842  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
843  case AV_PIX_FMT_YUV444P:
844  case AV_PIX_FMT_YUVJ444P:
845  case AV_PIX_FMT_YUV444P9:
846  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
847  case AV_PIX_FMT_BGR0:
848  return X264_CSP_BGRA;
849  case AV_PIX_FMT_BGR24:
850  return X264_CSP_BGR;
851 
852  case AV_PIX_FMT_RGB24:
853  return X264_CSP_RGB;
854  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
855  case AV_PIX_FMT_NV16:
856  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
857 #ifdef X264_CSP_NV21
858  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
859 #endif
860 #ifdef X264_CSP_I400
861  case AV_PIX_FMT_GRAY8:
862  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
863 #endif
864  };
865  return 0;
866 }
867 
868 #define PARSE_X264_OPT(name, var)\
869  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
870  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
871  return AVERROR(EINVAL);\
872  }
873 
874 static av_cold int X264_init(AVCodecContext *avctx)
875 {
876  X264Context *x4 = avctx->priv_data;
877  AVCPBProperties *cpb_props;
878  int sw,sh;
879  int ret;
880 
881  if (avctx->global_quality > 0)
882  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
883 
884 #if CONFIG_LIBX262_ENCODER
885  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
886  x4->params.b_mpeg2 = 1;
887  x264_param_default_mpeg2(&x4->params);
888  } else
889 #endif
890  x264_param_default(&x4->params);
891 
892  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
893 
894  if (x4->preset || x4->tune)
895  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
896  int i;
897  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
898  av_log(avctx, AV_LOG_INFO, "Possible presets:");
899  for (i = 0; x264_preset_names[i]; i++)
900  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
901  av_log(avctx, AV_LOG_INFO, "\n");
902  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
903  for (i = 0; x264_tune_names[i]; i++)
904  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
905  av_log(avctx, AV_LOG_INFO, "\n");
906  return AVERROR(EINVAL);
907  }
908 
909  if (avctx->level > 0)
910  x4->params.i_level_idc = avctx->level;
911 
912  x4->params.pf_log = X264_log;
913  x4->params.p_log_private = avctx;
914  x4->params.i_log_level = X264_LOG_DEBUG;
915  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
916 #if X264_BUILD >= 153
917  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
918 #endif
919 
920  PARSE_X264_OPT("weightp", wpredp);
921 
922  if (avctx->bit_rate) {
923  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
924  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
925  return AVERROR(EINVAL);
926  }
927  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
928  x4->params.rc.i_rc_method = X264_RC_ABR;
929  }
930  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
931  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
932  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
933  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
934  x4->params.rc.b_stat_read = 1;
935  } else {
936  if (x4->crf >= 0) {
937  x4->params.rc.i_rc_method = X264_RC_CRF;
938  x4->params.rc.f_rf_constant = x4->crf;
939  } else if (x4->cqp >= 0) {
940  x4->params.rc.i_rc_method = X264_RC_CQP;
941  x4->params.rc.i_qp_constant = x4->cqp;
942  }
943 
944  if (x4->crf_max >= 0)
945  x4->params.rc.f_rf_constant_max = x4->crf_max;
946  }
947 
948  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
949  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
950  x4->params.rc.f_vbv_buffer_init =
951  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
952  }
953 
954  PARSE_X264_OPT("level", level);
955 
956  if (avctx->i_quant_factor > 0)
957  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
958  if (avctx->b_quant_factor > 0)
959  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
960 
961  if (x4->chroma_offset)
962  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
963 
964  if (avctx->gop_size >= 0)
965  x4->params.i_keyint_max = avctx->gop_size;
966  if (avctx->max_b_frames >= 0)
967  x4->params.i_bframe = avctx->max_b_frames;
968 
969  if (x4->scenechange_threshold >= 0)
970  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
971 
972  if (avctx->qmin >= 0)
973  x4->params.rc.i_qp_min = avctx->qmin;
974  if (avctx->qmax >= 0)
975  x4->params.rc.i_qp_max = avctx->qmax;
976  if (avctx->max_qdiff >= 0)
977  x4->params.rc.i_qp_step = avctx->max_qdiff;
978  if (avctx->qblur >= 0)
979  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
980  if (avctx->qcompress >= 0)
981  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
982  if (avctx->refs >= 0)
983  x4->params.i_frame_reference = avctx->refs;
984  else if (x4->params.i_level_idc > 0) {
985  int i;
986  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
987  int scale = X264_BUILD < 129 ? 384 : 1;
988 
989  for (i = 0; i<x264_levels[i].level_idc; i++)
990  if (x264_levels[i].level_idc == x4->params.i_level_idc)
991  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
992  }
993 
994  if (avctx->trellis >= 0)
995  x4->params.analyse.i_trellis = avctx->trellis;
996  if (avctx->me_range >= 0)
997  x4->params.analyse.i_me_range = avctx->me_range;
998  if (x4->noise_reduction >= 0)
999  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
1000  if (avctx->me_subpel_quality >= 0)
1001  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
1002  if (avctx->keyint_min >= 0)
1003  x4->params.i_keyint_min = avctx->keyint_min;
1004  if (avctx->me_cmp >= 0)
1005  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
1006 
1007  if (x4->aq_mode >= 0)
1008  x4->params.rc.i_aq_mode = x4->aq_mode;
1009  if (x4->aq_strength >= 0)
1010  x4->params.rc.f_aq_strength = x4->aq_strength;
1011  PARSE_X264_OPT("psy-rd", psy_rd);
1012  PARSE_X264_OPT("deblock", deblock);
1013  PARSE_X264_OPT("partitions", partitions);
1014  PARSE_X264_OPT("stats", stats);
1015  if (x4->psy >= 0)
1016  x4->params.analyse.b_psy = x4->psy;
1017  if (x4->rc_lookahead >= 0)
1018  x4->params.rc.i_lookahead = x4->rc_lookahead;
1019  if (x4->weightp >= 0)
1020  x4->params.analyse.i_weighted_pred = x4->weightp;
1021  if (x4->weightb >= 0)
1022  x4->params.analyse.b_weighted_bipred = x4->weightb;
1023  if (x4->cplxblur >= 0)
1024  x4->params.rc.f_complexity_blur = x4->cplxblur;
1025 
1026  if (x4->ssim >= 0)
1027  x4->params.analyse.b_ssim = x4->ssim;
1028  if (x4->intra_refresh >= 0)
1029  x4->params.b_intra_refresh = x4->intra_refresh;
1030  if (x4->bluray_compat >= 0) {
1031  x4->params.b_bluray_compat = x4->bluray_compat;
1032  x4->params.b_vfr_input = 0;
1033  }
1034  if (x4->avcintra_class >= 0)
1035 #if X264_BUILD >= 142
1036  x4->params.i_avcintra_class = x4->avcintra_class;
1037 #else
1038  av_log(avctx, AV_LOG_ERROR,
1039  "x264 too old for AVC Intra, at least version 142 needed\n");
1040 #endif
1041 
1042  if (x4->avcintra_class > 200) {
1043 #if X264_BUILD < 164
1044  av_log(avctx, AV_LOG_ERROR,
1045  "x264 too old for AVC Intra 300/480, at least version 164 needed\n");
1046  return AVERROR(EINVAL);
1047 #else
1048  /* AVC-Intra 300/480 only supported by Sony XAVC flavor */
1049  x4->params.i_avcintra_flavor = X264_AVCINTRA_FLAVOR_SONY;
1050 #endif
1051  }
1052 
1053  if (x4->b_bias != INT_MIN)
1054  x4->params.i_bframe_bias = x4->b_bias;
1055  if (x4->b_pyramid >= 0)
1056  x4->params.i_bframe_pyramid = x4->b_pyramid;
1057  if (x4->mixed_refs >= 0)
1058  x4->params.analyse.b_mixed_references = x4->mixed_refs;
1059  if (x4->dct8x8 >= 0)
1060  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
1061  if (x4->fast_pskip >= 0)
1062  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
1063  if (x4->aud >= 0)
1064  x4->params.b_aud = x4->aud;
1065  if (x4->mbtree >= 0)
1066  x4->params.rc.b_mb_tree = x4->mbtree;
1067  if (x4->direct_pred >= 0)
1068  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
1069 
1070  if (x4->slice_max_size >= 0)
1071  x4->params.i_slice_max_size = x4->slice_max_size;
1072 
1073  if (x4->fastfirstpass)
1074  x264_param_apply_fastfirstpass(&x4->params);
1075 
1076  x4->profile = x4->profile_opt;
1077  /* Allow specifying the x264 profile through AVCodecContext. */
1078  if (!x4->profile)
1079  switch (avctx->profile) {
1080  case AV_PROFILE_H264_BASELINE:
1081  x4->profile = "baseline";
1082  break;
1083  case AV_PROFILE_H264_HIGH:
1084  x4->profile = "high";
1085  break;
1086  case AV_PROFILE_H264_HIGH_10:
1087  x4->profile = "high10";
1088  break;
1089  case AV_PROFILE_H264_HIGH_422:
1090  x4->profile = "high422";
1091  break;
1092  case AV_PROFILE_H264_HIGH_444:
1093  x4->profile = "high444";
1094  break;
1095  case AV_PROFILE_H264_MAIN:
1096  x4->profile = "main";
1097  break;
1098  default:
1099  break;
1100  }
1101 
1102  if (x4->nal_hrd >= 0)
1103  x4->params.i_nal_hrd = x4->nal_hrd;
1104 
1105  if (x4->motion_est >= 0)
1106  x4->params.analyse.i_me_method = x4->motion_est;
1107 
1108  if (x4->coder >= 0)
1109  x4->params.b_cabac = x4->coder;
1110 
1111  if (x4->b_frame_strategy >= 0)
1112  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
1113 
1114  if (x4->profile)
1115  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
1116  int i;
1117  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
1118  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
1119  for (i = 0; x264_profile_names[i]; i++)
1120  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
1121  av_log(avctx, AV_LOG_INFO, "\n");
1122  return AVERROR(EINVAL);
1123  }
1124 
1125  x4->params.i_width = avctx->width;
1126  x4->params.i_height = avctx->height;
1127  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
1128  x4->params.vui.i_sar_width = sw;
1129  x4->params.vui.i_sar_height = sh;
1130  x4->params.i_timebase_den = avctx->time_base.den;
1131  x4->params.i_timebase_num = avctx->time_base.num;
1132  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
1133  x4->params.i_fps_num = avctx->framerate.num;
1134  x4->params.i_fps_den = avctx->framerate.den;
1135  } else {
1136  x4->params.i_fps_num = avctx->time_base.den;
1137 FF_DISABLE_DEPRECATION_WARNINGS
1138  x4->params.i_fps_den = avctx->time_base.num
1139 #if FF_API_TICKS_PER_FRAME
1140  * avctx->ticks_per_frame
1141 #endif
1142  ;
1143 FF_ENABLE_DEPRECATION_WARNINGS
1144  }
1145 
1146  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
1147 
1148  x4->params.i_threads = avctx->thread_count;
1149  if (avctx->thread_type)
1150  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
1151 
1152  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
1153 
1154  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
1155 
1156  x4->params.i_slice_count = avctx->slices;
1157 
1158  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
1159  x4->params.vui.b_fullrange = avctx->color_range == AVCOL_RANGE_JPEG;
1160  else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
1161  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
1162  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P)
1163  x4->params.vui.b_fullrange = 1;
1164 
1165  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
1166  x4->params.vui.i_colmatrix = avctx->colorspace;
1167  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
1168  x4->params.vui.i_colorprim = avctx->color_primaries;
1169  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
1170  x4->params.vui.i_transfer = avctx->color_trc;
1171  if (avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
1172  x4->params.vui.i_chroma_loc = avctx->chroma_sample_location - 1;
1173 
1174  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
1175  x4->params.b_repeat_headers = 0;
1176 
1177  if (avctx->flags & AV_CODEC_FLAG_RECON_FRAME)
1178  x4->params.b_full_recon = 1;
1179 
1180  if(x4->x264opts){
1181  const char *p= x4->x264opts;
1182  while(p){
1183  char param[4096]={0}, val[4096]={0};
1184  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
1185  ret = parse_opts(avctx, param, "1");
1186  if (ret < 0)
1187  return ret;
1188  } else {
1189  ret = parse_opts(avctx, param, val);
1190  if (ret < 0)
1191  return ret;
1192  }
1193  p= strchr(p, ':');
1194  if (p) {
1195  ++p;
1196  }
1197  }
1198  }
1199 
1200 #if X264_BUILD >= 142
1201  /* Separate headers not supported in AVC-Intra mode */
1202  if (x4->avcintra_class >= 0)
1203  x4->params.b_repeat_headers = 1;
1204 #endif
1205 
1206  {
1207  AVDictionaryEntry *en = NULL;
1208  while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) {
1209  if ((ret = x264_param_parse(&x4->params, en->key, en->value)) < 0) {
1210  av_log(avctx, AV_LOG_WARNING,
1211  "Error parsing option '%s = %s'.\n",
1212  en->key, en->value);
1213 #if X264_BUILD >= 161
1214  if (ret == X264_PARAM_ALLOC_FAILED)
1215  return AVERROR(ENOMEM);
1216 #endif
1217  }
1218  }
1219  }
1220 
1221  x4->params.analyse.b_mb_info = x4->mb_info;
1222 
1223  // update AVCodecContext with x264 parameters
1224  avctx->has_b_frames = x4->params.i_bframe ?
1225  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
1226  if (avctx->max_b_frames < 0)
1227  avctx->max_b_frames = 0;
1228 
1229  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
1230 
1231  x4->enc = x264_encoder_open(&x4->params);
1232  if (!x4->enc)
1233  return AVERROR_EXTERNAL;
1234 
1235  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1236  x264_nal_t *nal;
1237  uint8_t *p;
1238  int nnal, s, i;
1239 
1240  s = x264_encoder_headers(x4->enc, &nal, &nnal);
1241  avctx->extradata = p = av_mallocz(s + AV_INPUT_BUFFER_PADDING_SIZE);
1242  if (!p)
1243  return AVERROR(ENOMEM);
1244 
1245  for (i = 0; i < nnal; i++) {
1246  /* Don't put the SEI in extradata. */
1247  if (nal[i].i_type == NAL_SEI) {
1248  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
1249  x4->sei_size = nal[i].i_payload;
1250  x4->sei = av_malloc(x4->sei_size);
1251  if (!x4->sei)
1252  return AVERROR(ENOMEM);
1253  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
1254  continue;
1255  }
1256  memcpy(p, nal[i].p_payload, nal[i].i_payload);
1257  p += nal[i].i_payload;
1258  }
1259  avctx->extradata_size = p - avctx->extradata;
1260  }
1261 
1262  cpb_props = ff_encode_add_cpb_side_data(avctx);
1263  if (!cpb_props)
1264  return AVERROR(ENOMEM);
1265  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
1266  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
1267  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
1268 
1269  // Overestimate the reordered opaque buffer size, in case a runtime
1270  // reconfigure would increase the delay (which it shouldn't).
1271  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
1272  x4->reordered_opaque = av_calloc(x4->nb_reordered_opaque,
1273  sizeof(*x4->reordered_opaque));
1274  if (!x4->reordered_opaque) {
1275  x4->nb_reordered_opaque = 0;
1276  return AVERROR(ENOMEM);
1277  }
1278 
1279  return 0;
1280 }
1281 
1282 static const enum AVPixelFormat pix_fmts_8bit[] = {
1283  AV_PIX_FMT_YUV420P,
1284  AV_PIX_FMT_YUVJ420P,
1285  AV_PIX_FMT_YUV422P,
1286  AV_PIX_FMT_YUVJ422P,
1287  AV_PIX_FMT_YUV444P,
1288  AV_PIX_FMT_YUVJ444P,
1289  AV_PIX_FMT_NV12,
1290  AV_PIX_FMT_NV16,
1291 #ifdef X264_CSP_NV21
1292  AV_PIX_FMT_NV21,
1293 #endif
1294  AV_PIX_FMT_NONE
1295 };
1296 static const enum AVPixelFormat pix_fmts_9bit[] = {
1297  AV_PIX_FMT_YUV420P9,
1298  AV_PIX_FMT_YUV444P9,
1299  AV_PIX_FMT_NONE
1300 };
1301 static const enum AVPixelFormat pix_fmts_10bit[] = {
1302  AV_PIX_FMT_YUV420P10,
1303  AV_PIX_FMT_YUV422P10,
1304  AV_PIX_FMT_YUV444P10,
1305  AV_PIX_FMT_NV20,
1306  AV_PIX_FMT_NONE
1307 };
1308 static const enum AVPixelFormat pix_fmts_all[] = {
1309  AV_PIX_FMT_YUV420P,
1310  AV_PIX_FMT_YUVJ420P,
1311  AV_PIX_FMT_YUV422P,
1312  AV_PIX_FMT_YUVJ422P,
1313  AV_PIX_FMT_YUV444P,
1314  AV_PIX_FMT_YUVJ444P,
1315  AV_PIX_FMT_NV12,
1316  AV_PIX_FMT_NV16,
1317 #ifdef X264_CSP_NV21
1318  AV_PIX_FMT_NV21,
1319 #endif
1320  AV_PIX_FMT_YUV420P10,
1321  AV_PIX_FMT_YUV422P10,
1322  AV_PIX_FMT_YUV444P10,
1323  AV_PIX_FMT_NV20,
1324 #ifdef X264_CSP_I400
1325  AV_PIX_FMT_GRAY8,
1326  AV_PIX_FMT_GRAY10,
1327 #endif
1328  AV_PIX_FMT_NONE
1329 };
1330 #if CONFIG_LIBX264RGB_ENCODER
1331 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1332  AV_PIX_FMT_BGR0,
1333  AV_PIX_FMT_BGR24,
1334  AV_PIX_FMT_RGB24,
1335  AV_PIX_FMT_NONE
1336 };
1337 #endif
1338 
1339 #if X264_BUILD < 153
1340 static av_cold void X264_init_static(FFCodec *codec)
1341 {
1342  if (x264_bit_depth == 8)
1343  codec->p.pix_fmts = pix_fmts_8bit;
1344  else if (x264_bit_depth == 9)
1345  codec->p.pix_fmts = pix_fmts_9bit;
1346  else if (x264_bit_depth == 10)
1347  codec->p.pix_fmts = pix_fmts_10bit;
1348 }
1349 #endif
1350 
1351 #define OFFSET(x) offsetof(X264Context, x)
1352 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1353 static const AVOption options[] = {
1354  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1355  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1356  { "profile", "Set profile restrictions (cf. x264 --fullhelp)", OFFSET(profile_opt), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1357  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1358  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1359  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1360  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1361  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1362  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1363  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1364  { "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 },
1365  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1366  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
1367  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1368  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1369  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1370 #if X264_BUILD >= 144
1371  { "autovariance-biased", "Auto-variance AQ with bias to dark scenes", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE_BIASED}, INT_MIN, INT_MAX, VE, "aq_mode" },
1372 #endif
1373  { "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},
1374  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1375  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1376  { "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 },
1377  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1378  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
1379  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
1380  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
1381  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
1382  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1383  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1384  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1385  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1386  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
1387  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1388  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1389  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1390  { "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 },
1391  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1392  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1393  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1394  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1395  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1396  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1397  { "partitions", "A comma-separated list of partitions to consider. "
1398  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1399  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
1400  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
1401  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
1402  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
1403  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
1404  { "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 },
1405  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1406  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1407  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
1408  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1409  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1410  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1411  { "avcintra-class","AVC-Intra class 50/100/200/300/480", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 480 , VE},
1412  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1413  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1414  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
1415  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
1416  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
1417  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1418  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1419  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1420  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
1421  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
1422  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1423  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1424  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1425  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1426  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1427  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
1428  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1429  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1430  { "udu_sei", "Use user data unregistered SEI if available", OFFSET(udu_sei), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1431  { "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 },
1432  { "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 },
1433  { NULL },
1434 };
1435 
1436 static const FFCodecDefault x264_defaults[] = {
1437  { "b", "0" },
1438  { "bf", "-1" },
1439  { "flags2", "0" },
1440  { "g", "-1" },
1441  { "i_qfactor", "-1" },
1442  { "b_qfactor", "-1" },
1443  { "qmin", "-1" },
1444  { "qmax", "-1" },
1445  { "qdiff", "-1" },
1446  { "qblur", "-1" },
1447  { "qcomp", "-1" },
1448 // { "rc_lookahead", "-1" },
1449  { "refs", "-1" },
1450  { "trellis", "-1" },
1451  { "me_range", "-1" },
1452  { "subq", "-1" },
1453  { "keyint_min", "-1" },
1454  { "cmp", "-1" },
1455  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1456  { "thread_type", "0" },
1457  { "flags", "+cgop" },
1458  { "rc_init_occupancy","-1" },
1459  { NULL },
1460 };
1461 
1462 #if CONFIG_LIBX264_ENCODER
1463 static const AVClass x264_class = {
1464  .class_name = "libx264",
1465  .item_name = av_default_item_name,
1466  .option = options,
1467  .version = LIBAVUTIL_VERSION_INT,
1468 };
1469 
1470 #if X264_BUILD >= 153
1471 const
1472 #endif
1473 FFCodec ff_libx264_encoder = {
1474  .p.name = "libx264",
1475  CODEC_LONG_NAME("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1476  .p.type = AVMEDIA_TYPE_VIDEO,
1477  .p.id = AV_CODEC_ID_H264,
1478  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1479  AV_CODEC_CAP_OTHER_THREADS |
1480  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE |
1481  AV_CODEC_CAP_ENCODER_FLUSH |
1482  AV_CODEC_CAP_ENCODER_RECON_FRAME,
1483  .p.priv_class = &x264_class,
1484  .p.wrapper_name = "libx264",
1485  .priv_data_size = sizeof(X264Context),
1486  .init = X264_init,
1487  FF_CODEC_ENCODE_CB(X264_frame),
1488  .flush = X264_flush,
1489  .close = X264_close,
1490  .defaults = x264_defaults,
1491 #if X264_BUILD < 153
1492  .init_static_data = X264_init_static,
1493 #else
1494  .p.pix_fmts = pix_fmts_all,
1495 #endif
1496  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
1497 #if X264_BUILD < 158
1498  | FF_CODEC_CAP_NOT_INIT_THREADSAFE
1499 #endif
1500  ,
1501 };
1502 #endif
1503 
1504 #if CONFIG_LIBX264RGB_ENCODER
1505 static const AVClass rgbclass = {
1506  .class_name = "libx264rgb",
1507  .item_name = av_default_item_name,
1508  .option = options,
1509  .version = LIBAVUTIL_VERSION_INT,
1510 };
1511 
1512 const FFCodec ff_libx264rgb_encoder = {
1513  .p.name = "libx264rgb",
1514  CODEC_LONG_NAME("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1515  .p.type = AVMEDIA_TYPE_VIDEO,
1516  .p.id = AV_CODEC_ID_H264,
1517  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1518  AV_CODEC_CAP_OTHER_THREADS |
1519  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1520  .p.pix_fmts = pix_fmts_8bit_rgb,
1521  .p.priv_class = &rgbclass,
1522  .p.wrapper_name = "libx264",
1523  .priv_data_size = sizeof(X264Context),
1524  .init = X264_init,
1525  FF_CODEC_ENCODE_CB(X264_frame),
1526  .close = X264_close,
1527  .defaults = x264_defaults,
1528  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
1529 #if X264_BUILD < 158
1530  | FF_CODEC_CAP_NOT_INIT_THREADSAFE
1531 #endif
1532  ,
1533 };
1534 #endif
1535 
1536 #if CONFIG_LIBX262_ENCODER
1537 static const AVClass X262_class = {
1538  .class_name = "libx262",
1539  .item_name = av_default_item_name,
1540  .option = options,
1541  .version = LIBAVUTIL_VERSION_INT,
1542 };
1543 
1544 const FFCodec ff_libx262_encoder = {
1545  .p.name = "libx262",
1546  CODEC_LONG_NAME("libx262 MPEG2VIDEO"),
1547  .p.type = AVMEDIA_TYPE_VIDEO,
1548  .p.id = AV_CODEC_ID_MPEG2VIDEO,
1549  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1550  AV_CODEC_CAP_OTHER_THREADS |
1551  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1552  .p.pix_fmts = pix_fmts_8bit,
1553  .p.priv_class = &X262_class,
1554  .p.wrapper_name = "libx264",
1555  .priv_data_size = sizeof(X264Context),
1556  .init = X264_init,
1557  FF_CODEC_ENCODE_CB(X264_frame),
1558  .close = X264_close,
1559  .defaults = x264_defaults,
1560  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1561  FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS,
1562 };
1563 #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
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
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:96
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:994
X264Context
Definition: libx264.c:67
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:1029
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:824
X264Context::avcintra_class
int avcintra_class
Definition: libx264.c:109
stats
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
Definition: vp9_superframe_bsf.c:34
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:807
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2964
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:603
X264Context::tune
char * tune
Definition: libx264.c:75
AV_PROFILE_H264_MAIN
#define AV_PROFILE_H264_MAIN
Definition: defs.h:111
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:611
rect
Definition: f_ebur128.c:78
X264Context::cplxblur
float cplxblur
Definition: libx264.c:103
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:79
X264Context::fast_pskip
int fast_pskip
Definition: libx264.c:99
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
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:501
X264_log
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:134
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
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:683
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1022
AVFrame::width
int width
Definition: frame.h:412
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:673
ff_libx264rgb_encoder
const FFCodec ff_libx264rgb_encoder
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:491
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:251
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:573
X264Context::stats
char * stats
Definition: libx264.c:107
X264Context::nb_reordered_opaque
int nb_reordered_opaque
Definition: libx264.c:122
data
const char data[16]
Definition: mxf.c:148
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:468
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:767
X264Context::sei_size
int sei_size
Definition: libx264.c:73
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:509
AVDictionary
Definition: dict.c:34
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
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:322
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:330
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:1255
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:93
AVCodecContext::me_subpel_quality
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:899
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:546
X264Context::cqp
int cqp
Definition: libx264.c:84
X264Context::udu_sei
int udu_sei
Definition: libx264.c:118
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
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:129
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:334
video_hint.h
X264_init
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:874
X264Context::slice_max_size
int slice_max_size
Definition: libx264.c:106
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:641
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:768
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1803
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:1340
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3004
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:295
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:753
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:115
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:527
fail
#define fail()
Definition: checkasm.h:142
AV_PIX_FMT_NV20
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:516
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1532
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:91
ff_side_data_set_prft
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:628
X264Context::pic
x264_picture_t pic
Definition: libx264.c:71
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1001
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:521
FF_CMP_CHROMA
#define FF_CMP_CHROMA
Definition: avcodec.h:864
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
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:69
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:315
X264Context::nal_hrd
int nal_hrd
Definition: libx264.c:108
AV_CODEC_FLAG_LOOP_FILTER
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:314
X264Context::bluray_compat
int bluray_compat
Definition: libx264.c:94
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:326
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:471
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1224
preset
preset
Definition: vf_curves.c:46
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1015
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:249
av_cold
#define av_cold
Definition: attributes.h:90
pix_fmts_10bit
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:1301
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:265
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:1312
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:79
X264Context::b_pyramid
int b_pyramid
Definition: libx264.c:96
float
float
Definition: af_crystalizer.c:121
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:543
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:744
AVFrame::reordered_opaque
attribute_deprecated int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything).
Definition: frame.h:561
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
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:507
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:281
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1233
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
X264Context::mixed_refs
int mixed_refs
Definition: libx264.c:97
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:406
pix_fmts_all
static enum AVPixelFormat pix_fmts_all[]
Definition: libx264.c:1308
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
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
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:1542
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:465
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
COMPUTE_MBINFO
#define COMPUTE_MBINFO(mbinfo_filler_, mbinfo_marker_, compute_coords_fn_)
X264Context::weightp
int weightp
Definition: libx264.c:90
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:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1284
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:516
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:548
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
X264Opaque
Definition: libx264.c:56
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:80
AV_PROFILE_H264_HIGH_422
#define AV_PROFILE_H264_HIGH_422
Definition: defs.h:117
frame
static AVFrame * frame
Definition: demux_decode.c:54
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:451
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:398
X264Context::noise_reduction
int noise_reduction
Definition: libx264.c:117
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:449
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1269
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:1296
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1039
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:83
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:111
X264Context::aud
int aud
Definition: libx264.c:100
AVCodecContext::qblur
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1241
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:491
sei.h
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:232
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:270
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:105
X264Context::profile_opt
char * profile_opt
Definition: libx264.c:77
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:258
time.h
AVCodecContext::me_cmp
int me_cmp
motion estimation comparison function
Definition: avcodec.h:829
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:469
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1319
av_clipf
av_clipf
Definition: af_crystalizer.c:121
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:825
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1740
free_picture
static void free_picture(x264_picture_t *pic)
Definition: libx264.c:298
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:639
X264Context::preset
char * preset
Definition: libx264.c:74
AV_FRAME_DATA_SEI_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:178
dct8x8
static void dct8x8(int16_t *coef, int bit_depth)
Definition: h264dsp.c:166
X264Context::x264_params
AVDictionary * x264_params
Definition: libx264.c:120
PARSE_X264_OPT
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:868
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1240
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:563
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:842
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:342
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
pix_fmts_8bit
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:1282
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_STEREO3D_CHECKERBOARD
@ AV_STEREO3D_CHECKERBOARD
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:101
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:643
codec_internal.h
X264_close
static av_cold int X264_close(AVCodecContext *avctx)
Definition: libx264.c:785
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:155
MB_CEIL
#define MB_CEIL(x)
Definition: libx264.c:54
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:908
AVFrameSideData::data
uint8_t * data
Definition: frame.h:248
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1544
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:693
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
AV_PIX_FMT_NV16
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:191
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:490
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:310
X264Context::motion_est
int motion_est
Definition: libx264.c:110
opaque_uninit
static void opaque_uninit(X264Opaque *o)
Definition: libx264.c:149
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:497
X264Context::b_bias
int b_bias
Definition: libx264.c:95
AVCodecInternal
Definition: internal.h:52
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:283
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:729
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
VE
#define VE
Definition: libx264.c:1352
X264Context::sei
uint8_t * sei
Definition: libx264.c:72
AVRegionOfInterest::left
int left
Definition: frame.h:282
X264Context::aq_mode
int aq_mode
Definition: libx264.c:85
X264Opaque::frame_opaque_ref
AVBufferRef * frame_opaque_ref
Definition: libx264.c:64
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:260
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:484
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:542
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:280
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:113
setup_mb_info
static int setup_mb_info(AVCodecContext *ctx, x264_picture_t *pic, const AVFrame *frame, const AVVideoHint *info)
Definition: libx264.c:354
x264_defaults
static const FFCodecDefault x264_defaults[]
Definition: libx264.c:1436
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:622
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:1046
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:610
csp_to_pixfmt
static enum AVPixelFormat csp_to_pixfmt(int csp)
Definition: libx264.c:308
options
static const AVOption options[]
Definition: libx264.c:1353
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:602
AVCodecContext::height
int height
Definition: avcodec.h:621
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:636
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:467
avcodec.h
X264Context::profile
const char * profile
Definition: libx264.c:76
X264Context::mbtree
int mbtree
Definition: libx264.c:101
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:348
X264Context::mb_info
int mb_info
Definition: libx264.c:131
ret
ret
Definition: filter_design.txt:187
X264Context::reordered_opaque
X264Opaque * reordered_opaque
Definition: libx264.c:123
X264Opaque::frame_opaque
void * frame_opaque
Definition: libx264.c:63
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
X264Context::crf
float crf
Definition: libx264.c:82
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:78
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
X264Context::wpredp
char * wpredp
Definition: libx264.c:80
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:226
ff_libx262_encoder
const FFCodec ff_libx262_encoder
X264Context::next_reordered_opaque
int next_reordered_opaque
Definition: libx264.c:122
X264Opaque::wallclock
int64_t wallclock
Definition: libx264.c:60
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:108
X264Context::scenechange_threshold
int scenechange_threshold
Definition: libx264.c:116
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
X264Context::x264opts
char * x264opts
Definition: libx264.c:81
AVCodecContext::max_qdiff
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1262
AVCodecContext
main external API structure.
Definition: avcodec.h:441
AVFrame::height
int height
Definition: frame.h:412
reconfig_encoder
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:198
AV_PROFILE_H264_HIGH
#define AV_PROFILE_H264_HIGH
Definition: defs.h:113
X264Context::coder
int coder
Definition: libx264.c:112
X264Context::aq_strength
float aq_strength
Definition: libx264.c:86
MB_FLOOR
#define MB_FLOOR(x)
Definition: libx264.c:53
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:1248
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1596
MB_SIZE
#define MB_SIZE
Definition: libx264.c:51
X264Context::rc_lookahead
int rc_lookahead
Definition: libx264.c:89
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:247
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:579
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
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
OFFSET
#define OFFSET(x)
Definition: libx264.c:1351
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:98
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:70
mem.h
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:720
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
X264Context::psy_rd
char * psy_rd
Definition: libx264.c:87
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
setup_frame
static int setup_frame(AVCodecContext *ctx, const AVFrame *frame, x264_picture_t **ppic)
Definition: libx264.c:471
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:246
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:807
X264Context::deblock
char * deblock
Definition: libx264.c:102
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:1055
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
AVPacket
This structure stores compressed data.
Definition: packet.h:468
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
X264Context::ssim
int ssim
Definition: libx264.c:92
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:621
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:88
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:385
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:870
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:229
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
X264Context::enc
x264_t * enc
Definition: libx264.c:70
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:624
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:307
X264Context::b_frame_strategy
int b_frame_strategy
Definition: libx264.c:114
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1143
mb_info
Definition: cinepakenc.c:88
convert_pix_fmt
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Definition: libx264.c:833
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:822
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
X264Opaque::duration
int64_t duration
Definition: libx264.c:61
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:306
X264Context::partitions
char * partitions
Definition: libx264.c:104
Generated on Mon Dec 4 2023 19:21:29 for FFmpeg by   doxygen 1.8.17