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