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