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 "libavutil/eval.h"
23 #include "libavutil/internal.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/stereo3d.h"
28 #include "libavutil/time.h"
29 #include "libavutil/intreadwrite.h"
30 #include "avcodec.h"
31 #include "internal.h"
32 
33 #if defined(_MSC_VER)
34 #define X264_API_IMPORTS 1
35 #endif
36 
37 #include <x264.h>
38 #include <float.h>
39 #include <math.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 
44 // from x264.h, for quant_offsets, Macroblocks are 16x16
45 // blocks of pixels (with respect to the luma plane)
46 #define MB_SIZE 16
47 
48 typedef struct X264Opaque {
50  int64_t wallclock;
51 } X264Opaque;
52 
53 typedef struct X264Context {
54  AVClass *class;
55  x264_param_t params;
56  x264_t *enc;
57  x264_picture_t pic;
59  int sei_size;
60  char *preset;
61  char *tune;
62  char *profile;
63  char *level;
65  char *wpredp;
66  char *x264opts;
67  float crf;
68  float crf_max;
69  int cqp;
70  int aq_mode;
71  float aq_strength;
72  char *psy_rd;
73  int psy;
75  int weightp;
76  int weightb;
77  int ssim;
80  int b_bias;
81  int b_pyramid;
83  int dct8x8;
85  int aud;
86  int mbtree;
87  char *deblock;
88  float cplxblur;
89  char *partitions;
92  char *stats;
93  int nal_hrd;
97  int coder;
98  int a53_cc;
103 
105 
106  int nb_reordered_opaque, next_reordered_opaque;
108 
109  /**
110  * If the encoder does not support ROI then warn the first time we
111  * encounter a frame with ROI side data.
112  */
114 } X264Context;
115 
116 static void X264_log(void *p, int level, const char *fmt, va_list args)
117 {
118  static const int level_map[] = {
119  [X264_LOG_ERROR] = AV_LOG_ERROR,
120  [X264_LOG_WARNING] = AV_LOG_WARNING,
121  [X264_LOG_INFO] = AV_LOG_INFO,
122  [X264_LOG_DEBUG] = AV_LOG_DEBUG
123  };
124 
125  if (level < 0 || level > X264_LOG_DEBUG)
126  return;
127 
128  av_vlog(p, level_map[level], fmt, args);
129 }
130 
131 
133  const x264_nal_t *nals, int nnal)
134 {
135  X264Context *x4 = ctx->priv_data;
136  uint8_t *p;
137  int i, size = x4->sei_size, ret;
138 
139  if (!nnal)
140  return 0;
141 
142  for (i = 0; i < nnal; i++)
143  size += nals[i].i_payload;
144 
145  if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)
146  return ret;
147 
148  p = pkt->data;
149 
150  /* Write the SEI as part of the first frame. */
151  if (x4->sei_size > 0 && nnal > 0) {
152  if (x4->sei_size > size) {
153  av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");
154  return -1;
155  }
156  memcpy(p, x4->sei, x4->sei_size);
157  p += x4->sei_size;
158  x4->sei_size = 0;
159  av_freep(&x4->sei);
160  }
161 
162  for (i = 0; i < nnal; i++){
163  memcpy(p, nals[i].p_payload, nals[i].i_payload);
164  p += nals[i].i_payload;
165  }
166 
167  return 1;
168 }
169 
170 static int avfmt2_num_planes(int avfmt)
171 {
172  switch (avfmt) {
173  case AV_PIX_FMT_YUV420P:
174  case AV_PIX_FMT_YUVJ420P:
175  case AV_PIX_FMT_YUV420P9:
177  case AV_PIX_FMT_YUV444P:
178  return 3;
179 
180  case AV_PIX_FMT_BGR0:
181  case AV_PIX_FMT_BGR24:
182  case AV_PIX_FMT_RGB24:
183  case AV_PIX_FMT_GRAY8:
184  case AV_PIX_FMT_GRAY10:
185  return 1;
186 
187  default:
188  return 3;
189  }
190 }
191 
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 
245  if (side_data) {
246  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
247  int fpa_type;
248 
249  switch (stereo->type) {
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;
260  fpa_type = 3;
261  break;
263  fpa_type = 4;
264  break;
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 
293  int *got_packet)
294 {
295  X264Context *x4 = ctx->priv_data;
296  x264_nal_t *nal;
297  int nnal, i, ret;
298  x264_picture_t pic_out = {0};
299  int pict_type;
300  int bit_depth;
301  int64_t wallclock = 0;
302  X264Opaque *out_opaque;
303  AVFrameSideData *sd;
304 
305  x264_picture_init( &x4->pic );
306  x4->pic.img.i_csp = x4->params.i_csp;
307 #if X264_BUILD >= 153
308  bit_depth = x4->params.i_bitdepth;
309 #else
310  bit_depth = x264_bit_depth;
311 #endif
312  if (bit_depth > 8)
313  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
314  x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
315 
316  if (frame) {
317  for (i = 0; i < x4->pic.img.i_plane; i++) {
318  x4->pic.img.plane[i] = frame->data[i];
319  x4->pic.img.i_stride[i] = frame->linesize[i];
320  }
321 
322  x4->pic.i_pts = frame->pts;
323 
328  x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
329  x4->next_reordered_opaque++;
331 
332  switch (frame->pict_type) {
333  case AV_PICTURE_TYPE_I:
334  x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR
335  : X264_TYPE_KEYFRAME;
336  break;
337  case AV_PICTURE_TYPE_P:
338  x4->pic.i_type = X264_TYPE_P;
339  break;
340  case AV_PICTURE_TYPE_B:
341  x4->pic.i_type = X264_TYPE_B;
342  break;
343  default:
344  x4->pic.i_type = X264_TYPE_AUTO;
345  break;
346  }
347  reconfig_encoder(ctx, frame);
348 
349  if (x4->a53_cc) {
350  void *sei_data;
351  size_t sei_size;
352 
353  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
354  if (ret < 0) {
355  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
356  } else if (sei_data) {
357  x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0]));
358  if (x4->pic.extra_sei.payloads == NULL) {
359  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
360  av_free(sei_data);
361  } else {
362  x4->pic.extra_sei.sei_free = av_free;
363 
364  x4->pic.extra_sei.payloads[0].payload_size = sei_size;
365  x4->pic.extra_sei.payloads[0].payload = sei_data;
366  x4->pic.extra_sei.num_payloads = 1;
367  x4->pic.extra_sei.payloads[0].payload_type = 4;
368  }
369  }
370  }
371 
373  if (sd) {
374  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
375  if (!x4->roi_warned) {
376  x4->roi_warned = 1;
377  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
378  }
379  } else {
380  if (frame->interlaced_frame == 0) {
381  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
382  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
383  int qp_range = 51 + 6 * (bit_depth - 8);
384  int nb_rois;
385  const AVRegionOfInterest *roi;
386  uint32_t roi_size;
387  float *qoffsets;
388 
389  roi = (const AVRegionOfInterest*)sd->data;
390  roi_size = roi->self_size;
391  if (!roi_size || sd->size % roi_size != 0) {
392  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
393  return AVERROR(EINVAL);
394  }
395  nb_rois = sd->size / roi_size;
396 
397  qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
398  if (!qoffsets)
399  return AVERROR(ENOMEM);
400 
401  // This list must be iterated in reverse because the first
402  // region in the list applies when regions overlap.
403  for (int i = nb_rois - 1; i >= 0; i--) {
404  int startx, endx, starty, endy;
405  float qoffset;
406 
407  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
408 
409  starty = FFMIN(mby, roi->top / MB_SIZE);
410  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
411  startx = FFMIN(mbx, roi->left / MB_SIZE);
412  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
413 
414  if (roi->qoffset.den == 0) {
415  av_free(qoffsets);
416  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
417  return AVERROR(EINVAL);
418  }
419  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
420  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
421 
422  for (int y = starty; y < endy; y++) {
423  for (int x = startx; x < endx; x++) {
424  qoffsets[x + y*mbx] = qoffset;
425  }
426  }
427  }
428 
429  x4->pic.prop.quant_offsets = qoffsets;
430  x4->pic.prop.quant_offsets_free = av_free;
431  } else {
432  if (!x4->roi_warned) {
433  x4->roi_warned = 1;
434  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
435  }
436  }
437  }
438  }
439  }
440 
441  do {
442  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
443  return AVERROR_EXTERNAL;
444 
445  ret = encode_nals(ctx, pkt, nal, nnal);
446  if (ret < 0)
447  return ret;
448  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
449 
450  pkt->pts = pic_out.i_pts;
451  pkt->dts = pic_out.i_dts;
452 
453  out_opaque = pic_out.opaque;
454  if (out_opaque >= x4->reordered_opaque &&
455  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
456  ctx->reordered_opaque = out_opaque->reordered_opaque;
457  wallclock = out_opaque->wallclock;
458  } else {
459  // Unexpected opaque pointer on picture output
460  ctx->reordered_opaque = 0;
461  }
462 
463  switch (pic_out.i_type) {
464  case X264_TYPE_IDR:
465  case X264_TYPE_I:
466  pict_type = AV_PICTURE_TYPE_I;
467  break;
468  case X264_TYPE_P:
469  pict_type = AV_PICTURE_TYPE_P;
470  break;
471  case X264_TYPE_B:
472  case X264_TYPE_BREF:
473  pict_type = AV_PICTURE_TYPE_B;
474  break;
475  default:
476  pict_type = AV_PICTURE_TYPE_NONE;
477  }
478 #if FF_API_CODED_FRAME
480  ctx->coded_frame->pict_type = pict_type;
482 #endif
483 
484  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
485  if (ret) {
486  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
487  if (wallclock)
488  ff_side_data_set_prft(pkt, wallclock);
489 
490 #if FF_API_CODED_FRAME
492  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
494 #endif
495  }
496 
497  *got_packet = ret;
498  return 0;
499 }
500 
502 {
503  X264Context *x4 = avctx->priv_data;
504 
505  av_freep(&avctx->extradata);
506  av_freep(&x4->sei);
508 
509  if (x4->enc) {
510  x264_encoder_close(x4->enc);
511  x4->enc = NULL;
512  }
513 
514  return 0;
515 }
516 
517 #define OPT_STR(opt, param) \
518  do { \
519  int ret; \
520  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
521  if(ret == X264_PARAM_BAD_NAME) \
522  av_log(avctx, AV_LOG_ERROR, \
523  "bad option '%s': '%s'\n", opt, param); \
524  else \
525  av_log(avctx, AV_LOG_ERROR, \
526  "bad value for '%s': '%s'\n", opt, param); \
527  return -1; \
528  } \
529  } while (0)
530 
532 {
533  switch (pix_fmt) {
534  case AV_PIX_FMT_YUV420P:
535  case AV_PIX_FMT_YUVJ420P:
536  case AV_PIX_FMT_YUV420P9:
537  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
538  case AV_PIX_FMT_YUV422P:
539  case AV_PIX_FMT_YUVJ422P:
540  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
541  case AV_PIX_FMT_YUV444P:
542  case AV_PIX_FMT_YUVJ444P:
543  case AV_PIX_FMT_YUV444P9:
544  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
545 #if CONFIG_LIBX264RGB_ENCODER
546  case AV_PIX_FMT_BGR0:
547  return X264_CSP_BGRA;
548  case AV_PIX_FMT_BGR24:
549  return X264_CSP_BGR;
550 
551  case AV_PIX_FMT_RGB24:
552  return X264_CSP_RGB;
553 #endif
554  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
555  case AV_PIX_FMT_NV16:
556  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
557 #ifdef X264_CSP_NV21
558  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
559 #endif
560 #ifdef X264_CSP_I400
561  case AV_PIX_FMT_GRAY8:
562  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
563 #endif
564  };
565  return 0;
566 }
567 
568 #define PARSE_X264_OPT(name, var)\
569  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
570  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
571  return AVERROR(EINVAL);\
572  }
573 
574 static av_cold int X264_init(AVCodecContext *avctx)
575 {
576  X264Context *x4 = avctx->priv_data;
577  AVCPBProperties *cpb_props;
578  int sw,sh;
579 
580  if (avctx->global_quality > 0)
581  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
582 
583 #if CONFIG_LIBX262_ENCODER
584  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
585  x4->params.b_mpeg2 = 1;
586  x264_param_default_mpeg2(&x4->params);
587  } else
588 #endif
589  x264_param_default(&x4->params);
590 
591  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
592 
593  if (x4->preset || x4->tune)
594  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
595  int i;
596  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
597  av_log(avctx, AV_LOG_INFO, "Possible presets:");
598  for (i = 0; x264_preset_names[i]; i++)
599  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
600  av_log(avctx, AV_LOG_INFO, "\n");
601  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
602  for (i = 0; x264_tune_names[i]; i++)
603  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
604  av_log(avctx, AV_LOG_INFO, "\n");
605  return AVERROR(EINVAL);
606  }
607 
608  if (avctx->level > 0)
609  x4->params.i_level_idc = avctx->level;
610 
611  x4->params.pf_log = X264_log;
612  x4->params.p_log_private = avctx;
613  x4->params.i_log_level = X264_LOG_DEBUG;
614  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
615 #if X264_BUILD >= 153
616  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
617 #endif
618 
619  PARSE_X264_OPT("weightp", wpredp);
620 
621  if (avctx->bit_rate) {
622  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
623  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
624  return AVERROR(EINVAL);
625  }
626  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
627  x4->params.rc.i_rc_method = X264_RC_ABR;
628  }
629  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
630  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
631  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
632  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
633  x4->params.rc.b_stat_read = 1;
634  } else {
635  if (x4->crf >= 0) {
636  x4->params.rc.i_rc_method = X264_RC_CRF;
637  x4->params.rc.f_rf_constant = x4->crf;
638  } else if (x4->cqp >= 0) {
639  x4->params.rc.i_rc_method = X264_RC_CQP;
640  x4->params.rc.i_qp_constant = x4->cqp;
641  }
642 
643  if (x4->crf_max >= 0)
644  x4->params.rc.f_rf_constant_max = x4->crf_max;
645  }
646 
647  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
648  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
649  x4->params.rc.f_vbv_buffer_init =
650  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
651  }
652 
653  PARSE_X264_OPT("level", level);
654 
655  if (avctx->i_quant_factor > 0)
656  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
657  if (avctx->b_quant_factor > 0)
658  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
659 
660 #if FF_API_PRIVATE_OPT
662  if (avctx->chromaoffset >= 0)
663  x4->chroma_offset = avctx->chromaoffset;
665 #endif
666  if (x4->chroma_offset >= 0)
667  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
668 
669  if (avctx->gop_size >= 0)
670  x4->params.i_keyint_max = avctx->gop_size;
671  if (avctx->max_b_frames >= 0)
672  x4->params.i_bframe = avctx->max_b_frames;
673 
674 #if FF_API_PRIVATE_OPT
676  if (avctx->scenechange_threshold >= 0)
679 #endif
680  if (x4->scenechange_threshold >= 0)
681  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
682 
683  if (avctx->qmin >= 0)
684  x4->params.rc.i_qp_min = avctx->qmin;
685  if (avctx->qmax >= 0)
686  x4->params.rc.i_qp_max = avctx->qmax;
687  if (avctx->max_qdiff >= 0)
688  x4->params.rc.i_qp_step = avctx->max_qdiff;
689  if (avctx->qblur >= 0)
690  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
691  if (avctx->qcompress >= 0)
692  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
693  if (avctx->refs >= 0)
694  x4->params.i_frame_reference = avctx->refs;
695  else if (x4->level) {
696  int i;
697  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
698  int level_id = -1;
699  char *tail;
700  int scale = X264_BUILD < 129 ? 384 : 1;
701 
702  if (!strcmp(x4->level, "1b")) {
703  level_id = 9;
704  } else if (strlen(x4->level) <= 3){
705  level_id = av_strtod(x4->level, &tail) * 10 + 0.5;
706  if (*tail)
707  level_id = -1;
708  }
709  if (level_id <= 0)
710  av_log(avctx, AV_LOG_WARNING, "Failed to parse level\n");
711 
712  for (i = 0; i<x264_levels[i].level_idc; i++)
713  if (x264_levels[i].level_idc == level_id)
714  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
715  }
716 
717  if (avctx->trellis >= 0)
718  x4->params.analyse.i_trellis = avctx->trellis;
719  if (avctx->me_range >= 0)
720  x4->params.analyse.i_me_range = avctx->me_range;
721 #if FF_API_PRIVATE_OPT
723  if (avctx->noise_reduction >= 0)
724  x4->noise_reduction = avctx->noise_reduction;
726 #endif
727  if (x4->noise_reduction >= 0)
728  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
729  if (avctx->me_subpel_quality >= 0)
730  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
731 #if FF_API_PRIVATE_OPT
733  if (avctx->b_frame_strategy >= 0)
734  x4->b_frame_strategy = avctx->b_frame_strategy;
736 #endif
737  if (avctx->keyint_min >= 0)
738  x4->params.i_keyint_min = avctx->keyint_min;
739 #if FF_API_CODER_TYPE
741  if (avctx->coder_type >= 0)
742  x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
744 #endif
745  if (avctx->me_cmp >= 0)
746  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
747 
748  if (x4->aq_mode >= 0)
749  x4->params.rc.i_aq_mode = x4->aq_mode;
750  if (x4->aq_strength >= 0)
751  x4->params.rc.f_aq_strength = x4->aq_strength;
752  PARSE_X264_OPT("psy-rd", psy_rd);
753  PARSE_X264_OPT("deblock", deblock);
754  PARSE_X264_OPT("partitions", partitions);
755  PARSE_X264_OPT("stats", stats);
756  if (x4->psy >= 0)
757  x4->params.analyse.b_psy = x4->psy;
758  if (x4->rc_lookahead >= 0)
759  x4->params.rc.i_lookahead = x4->rc_lookahead;
760  if (x4->weightp >= 0)
761  x4->params.analyse.i_weighted_pred = x4->weightp;
762  if (x4->weightb >= 0)
763  x4->params.analyse.b_weighted_bipred = x4->weightb;
764  if (x4->cplxblur >= 0)
765  x4->params.rc.f_complexity_blur = x4->cplxblur;
766 
767  if (x4->ssim >= 0)
768  x4->params.analyse.b_ssim = x4->ssim;
769  if (x4->intra_refresh >= 0)
770  x4->params.b_intra_refresh = x4->intra_refresh;
771  if (x4->bluray_compat >= 0) {
772  x4->params.b_bluray_compat = x4->bluray_compat;
773  x4->params.b_vfr_input = 0;
774  }
775  if (x4->avcintra_class >= 0)
776 #if X264_BUILD >= 142
777  x4->params.i_avcintra_class = x4->avcintra_class;
778 #else
779  av_log(avctx, AV_LOG_ERROR,
780  "x264 too old for AVC Intra, at least version 142 needed\n");
781 #endif
782  if (x4->b_bias != INT_MIN)
783  x4->params.i_bframe_bias = x4->b_bias;
784  if (x4->b_pyramid >= 0)
785  x4->params.i_bframe_pyramid = x4->b_pyramid;
786  if (x4->mixed_refs >= 0)
787  x4->params.analyse.b_mixed_references = x4->mixed_refs;
788  if (x4->dct8x8 >= 0)
789  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
790  if (x4->fast_pskip >= 0)
791  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
792  if (x4->aud >= 0)
793  x4->params.b_aud = x4->aud;
794  if (x4->mbtree >= 0)
795  x4->params.rc.b_mb_tree = x4->mbtree;
796  if (x4->direct_pred >= 0)
797  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
798 
799  if (x4->slice_max_size >= 0)
800  x4->params.i_slice_max_size = x4->slice_max_size;
801 
802  if (x4->fastfirstpass)
803  x264_param_apply_fastfirstpass(&x4->params);
804 
805  /* Allow specifying the x264 profile through AVCodecContext. */
806  if (!x4->profile)
807  switch (avctx->profile) {
809  x4->profile = av_strdup("baseline");
810  break;
812  x4->profile = av_strdup("high");
813  break;
815  x4->profile = av_strdup("high10");
816  break;
818  x4->profile = av_strdup("high422");
819  break;
821  x4->profile = av_strdup("high444");
822  break;
824  x4->profile = av_strdup("main");
825  break;
826  default:
827  break;
828  }
829 
830  if (x4->nal_hrd >= 0)
831  x4->params.i_nal_hrd = x4->nal_hrd;
832 
833  if (x4->motion_est >= 0)
834  x4->params.analyse.i_me_method = x4->motion_est;
835 
836  if (x4->coder >= 0)
837  x4->params.b_cabac = x4->coder;
838 
839  if (x4->b_frame_strategy >= 0)
840  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
841 
842  if (x4->profile)
843  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
844  int i;
845  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
846  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
847  for (i = 0; x264_profile_names[i]; i++)
848  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
849  av_log(avctx, AV_LOG_INFO, "\n");
850  return AVERROR(EINVAL);
851  }
852 
853  x4->params.i_width = avctx->width;
854  x4->params.i_height = avctx->height;
855  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
856  x4->params.vui.i_sar_width = sw;
857  x4->params.vui.i_sar_height = sh;
858  x4->params.i_timebase_den = avctx->time_base.den;
859  x4->params.i_timebase_num = avctx->time_base.num;
860  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
861  x4->params.i_fps_num = avctx->framerate.num;
862  x4->params.i_fps_den = avctx->framerate.den;
863  } else {
864  x4->params.i_fps_num = avctx->time_base.den;
865  x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame;
866  }
867 
868  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
869 
870  x4->params.i_threads = avctx->thread_count;
871  if (avctx->thread_type)
872  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
873 
874  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
875 
876  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
877 
878  x4->params.i_slice_count = avctx->slices;
879 
880  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
881  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
882  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
883  avctx->color_range == AVCOL_RANGE_JPEG;
884 
885  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
886  x4->params.vui.i_colmatrix = avctx->colorspace;
888  x4->params.vui.i_colorprim = avctx->color_primaries;
889  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
890  x4->params.vui.i_transfer = avctx->color_trc;
891 
892  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
893  x4->params.b_repeat_headers = 0;
894 
895  if(x4->x264opts){
896  const char *p= x4->x264opts;
897  while(p){
898  char param[4096]={0}, val[4096]={0};
899  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
900  OPT_STR(param, "1");
901  }else
902  OPT_STR(param, val);
903  p= strchr(p, ':');
904  p+=!!p;
905  }
906  }
907 
908 
909  {
910  AVDictionaryEntry *en = NULL;
911  while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) {
912  if (x264_param_parse(&x4->params, en->key, en->value) < 0)
913  av_log(avctx, AV_LOG_WARNING,
914  "Error parsing option '%s = %s'.\n",
915  en->key, en->value);
916  }
917  }
918 
919  // update AVCodecContext with x264 parameters
920  avctx->has_b_frames = x4->params.i_bframe ?
921  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
922  if (avctx->max_b_frames < 0)
923  avctx->max_b_frames = 0;
924 
925  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
926 
927  x4->enc = x264_encoder_open(&x4->params);
928  if (!x4->enc)
929  return AVERROR_EXTERNAL;
930 
931  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
932  x264_nal_t *nal;
933  uint8_t *p;
934  int nnal, s, i;
935 
936  s = x264_encoder_headers(x4->enc, &nal, &nnal);
938  if (!p)
939  return AVERROR(ENOMEM);
940 
941  for (i = 0; i < nnal; i++) {
942  /* Don't put the SEI in extradata. */
943  if (nal[i].i_type == NAL_SEI) {
944  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
945  x4->sei_size = nal[i].i_payload;
946  x4->sei = av_malloc(x4->sei_size);
947  if (!x4->sei)
948  return AVERROR(ENOMEM);
949  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
950  continue;
951  }
952  memcpy(p, nal[i].p_payload, nal[i].i_payload);
953  p += nal[i].i_payload;
954  }
955  avctx->extradata_size = p - avctx->extradata;
956  }
957 
958  cpb_props = ff_add_cpb_side_data(avctx);
959  if (!cpb_props)
960  return AVERROR(ENOMEM);
961  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
962  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
963  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
964 
965  // Overestimate the reordered opaque buffer size, in case a runtime
966  // reconfigure would increase the delay (which it shouldn't).
967  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
969  sizeof(*x4->reordered_opaque));
970  if (!x4->reordered_opaque)
971  return AVERROR(ENOMEM);
972 
973  return 0;
974 }
975 
976 static const enum AVPixelFormat pix_fmts_8bit[] = {
985 #ifdef X264_CSP_NV21
987 #endif
989 };
990 static const enum AVPixelFormat pix_fmts_9bit[] = {
994 };
995 static const enum AVPixelFormat pix_fmts_10bit[] = {
1001 };
1002 static const enum AVPixelFormat pix_fmts_all[] = {
1011 #ifdef X264_CSP_NV21
1013 #endif
1018 #ifdef X264_CSP_I400
1021 #endif
1023 };
1024 #if CONFIG_LIBX264RGB_ENCODER
1025 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1030 };
1031 #endif
1032 
1033 static av_cold void X264_init_static(AVCodec *codec)
1034 {
1035 #if X264_BUILD < 153
1036  if (x264_bit_depth == 8)
1037  codec->pix_fmts = pix_fmts_8bit;
1038  else if (x264_bit_depth == 9)
1039  codec->pix_fmts = pix_fmts_9bit;
1040  else if (x264_bit_depth == 10)
1041  codec->pix_fmts = pix_fmts_10bit;
1042 #else
1043  codec->pix_fmts = pix_fmts_all;
1044 #endif
1045 }
1046 
1047 #define OFFSET(x) offsetof(X264Context, x)
1048 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1049 static const AVOption options[] = {
1050  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
1051  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1052  { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1053  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE},
1054  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1055  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1056  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1057  {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE},
1058  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
1059  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
1060  { "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 },
1061  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
1062  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
1063  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1064  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1065  { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
1066 #if X264_BUILD >= 144
1067  { "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" },
1068 #endif
1069  { "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},
1070  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1071  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
1072  { "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 },
1073  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1074  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
1075  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
1076  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
1077  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
1078  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1079  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1080  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE },
1081  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
1082  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
1083  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1084  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1085  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
1086  { "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 },
1087  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1088  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1089  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1090  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE},
1091  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1092  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
1093  { "partitions", "A comma-separated list of partitions to consider. "
1094  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
1095  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
1096  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
1097  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
1098  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
1099  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
1100  { "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 },
1101  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
1102  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
1103  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
1104  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1105  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1106  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
1107  { "avcintra-class","AVC-Intra class 50/100/200", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE},
1108  { "me_method", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1109  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
1110  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
1111  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
1112  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
1113  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1114  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
1115  { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
1116  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
1117  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
1118  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1119  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1120  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
1121  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
1122  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
1123  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1124  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1125  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
1126 
1127  { "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 },
1128  { NULL },
1129 };
1130 
1131 static const AVCodecDefault x264_defaults[] = {
1132  { "b", "0" },
1133  { "bf", "-1" },
1134  { "flags2", "0" },
1135  { "g", "-1" },
1136  { "i_qfactor", "-1" },
1137  { "b_qfactor", "-1" },
1138  { "qmin", "-1" },
1139  { "qmax", "-1" },
1140  { "qdiff", "-1" },
1141  { "qblur", "-1" },
1142  { "qcomp", "-1" },
1143 // { "rc_lookahead", "-1" },
1144  { "refs", "-1" },
1145 #if FF_API_PRIVATE_OPT
1146  { "sc_threshold", "-1" },
1147 #endif
1148  { "trellis", "-1" },
1149 #if FF_API_PRIVATE_OPT
1150  { "nr", "-1" },
1151 #endif
1152  { "me_range", "-1" },
1153  { "subq", "-1" },
1154 #if FF_API_PRIVATE_OPT
1155  { "b_strategy", "-1" },
1156 #endif
1157  { "keyint_min", "-1" },
1158 #if FF_API_CODER_TYPE
1159  { "coder", "-1" },
1160 #endif
1161  { "cmp", "-1" },
1162  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1163  { "thread_type", "0" },
1164  { "flags", "+cgop" },
1165  { "rc_init_occupancy","-1" },
1166  { NULL },
1167 };
1168 
1169 #if CONFIG_LIBX264_ENCODER
1170 static const AVClass x264_class = {
1171  .class_name = "libx264",
1172  .item_name = av_default_item_name,
1173  .option = options,
1174  .version = LIBAVUTIL_VERSION_INT,
1175 };
1176 
1178  .name = "libx264",
1179  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1180  .type = AVMEDIA_TYPE_VIDEO,
1181  .id = AV_CODEC_ID_H264,
1182  .priv_data_size = sizeof(X264Context),
1183  .init = X264_init,
1184  .encode2 = X264_frame,
1185  .close = X264_close,
1186  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1188  .priv_class = &x264_class,
1189  .defaults = x264_defaults,
1190  .init_static_data = X264_init_static,
1191 #if X264_BUILD >= 158
1193 #else
1194  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1195 #endif
1196  .wrapper_name = "libx264",
1197 };
1198 #endif
1199 
1200 #if CONFIG_LIBX264RGB_ENCODER
1201 static const AVClass rgbclass = {
1202  .class_name = "libx264rgb",
1203  .item_name = av_default_item_name,
1204  .option = options,
1205  .version = LIBAVUTIL_VERSION_INT,
1206 };
1207 
1209  .name = "libx264rgb",
1210  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1211  .type = AVMEDIA_TYPE_VIDEO,
1212  .id = AV_CODEC_ID_H264,
1213  .priv_data_size = sizeof(X264Context),
1214  .init = X264_init,
1215  .encode2 = X264_frame,
1216  .close = X264_close,
1217  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1219  .priv_class = &rgbclass,
1220  .defaults = x264_defaults,
1221  .pix_fmts = pix_fmts_8bit_rgb,
1222 #if X264_BUILD >= 158
1224 #else
1225  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1226 #endif
1227  .wrapper_name = "libx264",
1228 };
1229 #endif
1230 
1231 #if CONFIG_LIBX262_ENCODER
1232 static const AVClass X262_class = {
1233  .class_name = "libx262",
1234  .item_name = av_default_item_name,
1235  .option = options,
1236  .version = LIBAVUTIL_VERSION_INT,
1237 };
1238 
1240  .name = "libx262",
1241  .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
1242  .type = AVMEDIA_TYPE_VIDEO,
1243  .id = AV_CODEC_ID_MPEG2VIDEO,
1244  .priv_data_size = sizeof(X264Context),
1245  .init = X264_init,
1246  .encode2 = X264_frame,
1247  .close = X264_close,
1248  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1250  .priv_class = &X262_class,
1251  .defaults = x264_defaults,
1253  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1254  .wrapper_name = "libx264",
1255 };
1256 #endif
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:2995
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Definition: libx264.c:531
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3161
const char const char void * val
Definition: avisynth_c.h:863
static enum AVPixelFormat pix_fmt
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:235
static int avfmt2_num_planes(int avfmt)
Definition: libx264.c:170
char * partitions
Definition: libx264.c:89
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int dct8x8
Definition: libx264.c:83
AVOption.
Definition: opt.h:246
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:723
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:914
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:897
const char * fmt
Definition: avisynth_c.h:861
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:2456
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1671
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
Memory handling functions.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1164
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:1881
AVCodec ff_libx262_encoder
int noise_reduction
Definition: libx264.c:102
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2527
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2256
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:2000
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
int next_reordered_opaque
Definition: libx264.c:106
int bluray_compat
Definition: libx264.c:79
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
char * wpredp
Definition: libx264.c:65
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:116
Views are next to each other.
Definition: stereo3d.h:67
static AVPacket pkt
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1067
int profile
profile
Definition: avcodec.h:2954
AVCodec.
Definition: avcodec.h:3555
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:574
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:113
AVRational qoffset
Quantisation offset.
Definition: frame.h:262
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1744
Undefined.
Definition: avutil.h:273
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:378
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
x264_param_t params
Definition: libx264.c:55
char * x264opts
Definition: libx264.c:66
#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: avcodec.h:1110
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:72
#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: avcodec.h:1024
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:2993
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
Definition: avcodec.h:3446
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:2092
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:1890
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1722
int me_cmp
motion estimation comparison function
Definition: avcodec.h:2007
int nb_reordered_opaque
Definition: libx264.c:106
int level_idc
Definition: h264_levels.c:25
Structure to hold side data for an AVFrame.
Definition: frame.h:201
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:40
uint8_t * data
Definition: avcodec.h:1533
int b_pyramid
Definition: libx264.c:81
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
x264_picture_t pic
Definition: libx264.c:57
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
float cplxblur
Definition: libx264.c:88
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1191
ptrdiff_t size
Definition: opengl_enc.c:100
#define FF_CMP_CHROMA
Definition: avcodec.h:2042
char * stats
Definition: libx264.c:92
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
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:225
static enum AVPixelFormat pix_fmts_all[]
Definition: libx264.c:1002
int intra_refresh
Definition: libx264.c:78
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:444
#define av_log(a,...)
int rc_lookahead
Definition: libx264.c:74
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:995
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1911
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
static void dct8x8(int16_t *coef, int bit_depth)
Definition: h264dsp.c:164
int qmax
maximum quantizer
Definition: avcodec.h:2470
char * profile
Definition: libx264.c:62
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
int coder
Definition: libx264.c:97
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int fastfirstpass
Definition: libx264.c:64
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:424
#define FF_PROFILE_H264_HIGH_422
Definition: avcodec.h:3001
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:2997
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1701
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
int mbtree
Definition: libx264.c:86
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
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:1926
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
char * deblock
Definition: libx264.c:87
int b_frame_strategy
Definition: libx264.c:99
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2484
Views are alternated temporally.
Definition: stereo3d.h:92
common internal API header
char * psy_rd
Definition: libx264.c:72
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
int refs
number of reference frames
Definition: avcodec.h:2209
int64_t reordered_opaque
Definition: libx264.c:49
X264Opaque * reordered_opaque
Definition: libx264.c:107
int motion_est
Definition: libx264.c:95
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:990
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:568
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3576
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define OPT_STR(opt, param)
Definition: libx264.c:517
#define FFMIN(a, b)
Definition: common.h:96
AVDictionary * x264_params
Definition: libx264.c:104
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
int width
picture width / height.
Definition: avcodec.h:1794
int cqp
Definition: libx264.c:69
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
attribute_deprecated int noise_reduction
Definition: avcodec.h:2139
x264_t * enc
Definition: libx264.c:56
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:905
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:889
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2235
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
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
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2892
int level
level
Definition: avcodec.h:3074
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:418
Structure describing a single Region Of Interest.
Definition: frame.h:220
int scenechange_threshold
Definition: libx264.c:101
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:2778
int slice_max_size
Definition: libx264.c:91
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1753
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int nal_hrd
Definition: libx264.c:93
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:2477
int weightp
Definition: libx264.c:75
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:396
attribute_deprecated int coder_type
Definition: avcodec.h:2538
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:222
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2880
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
if(ret)
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:976
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
static const AVCodecDefault x264_defaults[]
Definition: libx264.c:1131
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1158
int avcintra_class
Definition: libx264.c:94
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
char * level
Definition: libx264.c:63
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
Libavcodec external API header.
Views are on top of each other.
Definition: stereo3d.h:79
static av_cold int X264_close(AVCodecContext *avctx)
Definition: libx264.c:501
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:2135
enum AVCodecID codec_id
Definition: avcodec.h:1631
int forced_idr
Definition: libx264.c:96
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1895
main external API structure.
Definition: avcodec.h:1621
static const AVOption options[]
Definition: libx264.c:1049
int qmin
minimum quantizer
Definition: avcodec.h:2463
uint8_t * data
Definition: frame.h:203
#define FF_CODER_TYPE_AC
Definition: avcodec.h:2531
int extradata_size
Definition: avcodec.h:1723
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
float crf
Definition: libx264.c:67
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
int aq_mode
Definition: libx264.c:70
int aud
Definition: libx264.c:85
#define AV_STRINGIFY(s)
Definition: macros.h:36
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything)...
Definition: frame.h:462
Describe the class of an AVClass context structure.
Definition: log.h:67
int a53_cc
Definition: libx264.c:98
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2249
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2242
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:181
uint8_t * sei
Definition: libx264.c:58
int psy
Definition: libx264.c:73
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
Definition: libx264.c:132
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:3004
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:394
attribute_deprecated int chromaoffset
Definition: avcodec.h:2214
#define AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
Definition: avcodec.h:1122
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2455
int sei_size
Definition: libx264.c:59
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:192
char * preset
Definition: libx264.c:60
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
mfxU16 profile
Definition: qsvenc.c:44
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1687
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:209
int b_bias
Definition: libx264.c:80
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:922
int fast_pskip
Definition: libx264.c:84
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1816
int chroma_offset
Definition: libx264.c:100
static av_cold void X264_init_static(AVCodec *codec)
Definition: libx264.c:1033
int mixed_refs
Definition: libx264.c:82
preset
Definition: vf_curves.c:46
char * tune
Definition: libx264.c:61
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define VE
Definition: libx264.c:1048
int weightb
Definition: libx264.c:76
float aq_strength
Definition: libx264.c:71
common internal api header.
int64_t wallclock
Definition: libx264.c:50
Bi-dir predicted.
Definition: avutil.h:276
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
Stereoscopic video.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2871
Views are packed per column.
Definition: stereo3d.h:141
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:201
int trellis
trellis RD quantization
Definition: avcodec.h:2570
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1979
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:893
int slices
Number of slices.
Definition: avcodec.h:2272
void * priv_data
Definition: avcodec.h:1648
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:748
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1182
#define MB_SIZE
Definition: libx264.c:46
AVCodec ff_libx264rgb_encoder
int ssim
Definition: libx264.c:77
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
AVCodec ff_libx264_encoder
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
float crf_max
Definition: libx264.c:68
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: utils.c:2183
int height
Definition: frame.h:353
#define OFFSET(x)
Definition: libx264.c:1047
int direct_pred
Definition: libx264.c:90
#define av_freep(p)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libx264.c:292
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:936
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
#define FF_PROFILE_H264_HIGH_10
Definition: avcodec.h:2998
Stereoscopic 3d metadata.
Definition: frame.h:63
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1510
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:2083
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1526
Predicted.
Definition: avutil.h:275
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:2890
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2499
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
int keyint_min
minimum GOP size
Definition: avcodec.h:2202