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