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 #include "packet_internal.h"
33 
34 #if defined(_MSC_VER)
35 #define X264_API_IMPORTS 1
36 #endif
37 
38 #include <x264.h>
39 #include <float.h>
40 #include <math.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 
45 // from x264.h, for quant_offsets, Macroblocks are 16x16
46 // blocks of pixels (with respect to the luma plane)
47 #define MB_SIZE 16
48 
49 typedef struct X264Opaque {
51  int64_t wallclock;
52 } X264Opaque;
53 
54 typedef struct X264Context {
55  AVClass *class;
56  x264_param_t params;
57  x264_t *enc;
58  x264_picture_t pic;
60  int sei_size;
61  char *preset;
62  char *tune;
63  char *profile;
64  char *level;
66  char *wpredp;
67  char *x264opts;
68  float crf;
69  float crf_max;
70  int cqp;
71  int aq_mode;
72  float aq_strength;
73  char *psy_rd;
74  int psy;
76  int weightp;
77  int weightb;
78  int ssim;
81  int b_bias;
82  int b_pyramid;
84  int dct8x8;
86  int aud;
87  int mbtree;
88  char *deblock;
89  float cplxblur;
90  char *partitions;
93  char *stats;
94  int nal_hrd;
98  int coder;
99  int a53_cc;
104 
106 
107  int nb_reordered_opaque, next_reordered_opaque;
109 
110  /**
111  * If the encoder does not support ROI then warn the first time we
112  * encounter a frame with ROI side data.
113  */
115 } X264Context;
116 
117 static void X264_log(void *p, int level, const char *fmt, va_list args)
118 {
119  static const int level_map[] = {
120  [X264_LOG_ERROR] = AV_LOG_ERROR,
121  [X264_LOG_WARNING] = AV_LOG_WARNING,
122  [X264_LOG_INFO] = AV_LOG_INFO,
123  [X264_LOG_DEBUG] = AV_LOG_DEBUG
124  };
125 
126  if (level < 0 || level > X264_LOG_DEBUG)
127  return;
128 
129  av_vlog(p, level_map[level], fmt, args);
130 }
131 
132 
134  const x264_nal_t *nals, int nnal)
135 {
136  X264Context *x4 = ctx->priv_data;
137  uint8_t *p;
138  int i, size = x4->sei_size, ret;
139 
140  if (!nnal)
141  return 0;
142 
143  for (i = 0; i < nnal; i++)
144  size += nals[i].i_payload;
145 
146  if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0)
147  return ret;
148 
149  p = pkt->data;
150 
151  /* Write the SEI as part of the first frame. */
152  if (x4->sei_size > 0 && nnal > 0) {
153  if (x4->sei_size > size) {
154  av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");
155  return -1;
156  }
157  memcpy(p, x4->sei, x4->sei_size);
158  p += x4->sei_size;
159  x4->sei_size = 0;
160  av_freep(&x4->sei);
161  }
162 
163  for (i = 0; i < nnal; i++){
164  memcpy(p, nals[i].p_payload, nals[i].i_payload);
165  p += nals[i].i_payload;
166  }
167 
168  return 1;
169 }
170 
171 static int avfmt2_num_planes(int avfmt)
172 {
173  switch (avfmt) {
174  case AV_PIX_FMT_YUV420P:
175  case AV_PIX_FMT_YUVJ420P:
176  case AV_PIX_FMT_YUV420P9:
178  case AV_PIX_FMT_YUV444P:
179  return 3;
180 
181  case AV_PIX_FMT_BGR0:
182  case AV_PIX_FMT_BGR24:
183  case AV_PIX_FMT_RGB24:
184  case AV_PIX_FMT_GRAY8:
185  case AV_PIX_FMT_GRAY10:
186  return 1;
187 
188  default:
189  return 3;
190  }
191 }
192 
194 {
195  X264Context *x4 = ctx->priv_data;
196  AVFrameSideData *side_data;
197 
198 
199  if (x4->avcintra_class < 0) {
200  if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
201 
202  x4->params.b_tff = frame->top_field_first;
203  x264_encoder_reconfig(x4->enc, &x4->params);
204  }
205  if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) {
206  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
207  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
208  x264_encoder_reconfig(x4->enc, &x4->params);
209  }
210 
211  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
212  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
213  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  x264_encoder_reconfig(x4->enc, &x4->params);
216  }
217 
218  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
219  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
220  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
221  x264_encoder_reconfig(x4->enc, &x4->params);
222  }
223 
224  if (x4->crf >= 0 &&
225  x4->params.rc.i_rc_method == X264_RC_CRF &&
226  x4->params.rc.f_rf_constant != x4->crf) {
227  x4->params.rc.f_rf_constant = x4->crf;
228  x264_encoder_reconfig(x4->enc, &x4->params);
229  }
230 
231  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
232  x4->cqp >= 0 &&
233  x4->params.rc.i_qp_constant != x4->cqp) {
234  x4->params.rc.i_qp_constant = x4->cqp;
235  x264_encoder_reconfig(x4->enc, &x4->params);
236  }
237 
238  if (x4->crf_max >= 0 &&
239  x4->params.rc.f_rf_constant_max != x4->crf_max) {
240  x4->params.rc.f_rf_constant_max = x4->crf_max;
241  x264_encoder_reconfig(x4->enc, &x4->params);
242  }
243  }
244 
246  if (side_data) {
247  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
248  int fpa_type;
249 
250  switch (stereo->type) {
252  fpa_type = 0;
253  break;
254  case AV_STEREO3D_COLUMNS:
255  fpa_type = 1;
256  break;
257  case AV_STEREO3D_LINES:
258  fpa_type = 2;
259  break;
261  fpa_type = 3;
262  break;
264  fpa_type = 4;
265  break;
267  fpa_type = 5;
268  break;
269 #if X264_BUILD >= 145
270  case AV_STEREO3D_2D:
271  fpa_type = 6;
272  break;
273 #endif
274  default:
275  fpa_type = -1;
276  break;
277  }
278 
279  /* Inverted mode is not supported by x264 */
280  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
281  av_log(ctx, AV_LOG_WARNING,
282  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
283  fpa_type = -1;
284  }
285 
286  if (fpa_type != x4->params.i_frame_packing) {
287  x4->params.i_frame_packing = fpa_type;
288  x264_encoder_reconfig(x4->enc, &x4->params);
289  }
290  }
291 }
292 
294  int *got_packet)
295 {
296  X264Context *x4 = ctx->priv_data;
297  x264_nal_t *nal;
298  int nnal, i, ret;
299  x264_picture_t pic_out = {0};
300  int pict_type;
301  int bit_depth;
302  int64_t wallclock = 0;
303  X264Opaque *out_opaque;
304  AVFrameSideData *sd;
305 
306  x264_picture_init( &x4->pic );
307  x4->pic.img.i_csp = x4->params.i_csp;
308 #if X264_BUILD >= 153
309  bit_depth = x4->params.i_bitdepth;
310 #else
311  bit_depth = x264_bit_depth;
312 #endif
313  if (bit_depth > 8)
314  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
315  x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
316 
317  if (frame) {
318  for (i = 0; i < x4->pic.img.i_plane; i++) {
319  x4->pic.img.plane[i] = frame->data[i];
320  x4->pic.img.i_stride[i] = frame->linesize[i];
321  }
322 
323  x4->pic.i_pts = frame->pts;
324 
329  x4->pic.opaque = &x4->reordered_opaque[x4->next_reordered_opaque];
330  x4->next_reordered_opaque++;
332 
333  switch (frame->pict_type) {
334  case AV_PICTURE_TYPE_I:
335  x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR
336  : X264_TYPE_KEYFRAME;
337  break;
338  case AV_PICTURE_TYPE_P:
339  x4->pic.i_type = X264_TYPE_P;
340  break;
341  case AV_PICTURE_TYPE_B:
342  x4->pic.i_type = X264_TYPE_B;
343  break;
344  default:
345  x4->pic.i_type = X264_TYPE_AUTO;
346  break;
347  }
348  reconfig_encoder(ctx, frame);
349 
350  if (x4->a53_cc) {
351  void *sei_data;
352  size_t sei_size;
353 
354  ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size);
355  if (ret < 0) {
356  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
357  } else if (sei_data) {
358  x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0]));
359  if (x4->pic.extra_sei.payloads == NULL) {
360  av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n");
361  av_free(sei_data);
362  } else {
363  x4->pic.extra_sei.sei_free = av_free;
364 
365  x4->pic.extra_sei.payloads[0].payload_size = sei_size;
366  x4->pic.extra_sei.payloads[0].payload = sei_data;
367  x4->pic.extra_sei.num_payloads = 1;
368  x4->pic.extra_sei.payloads[0].payload_type = 4;
369  }
370  }
371  }
372 
374  if (sd) {
375  if (x4->params.rc.i_aq_mode == X264_AQ_NONE) {
376  if (!x4->roi_warned) {
377  x4->roi_warned = 1;
378  av_log(ctx, AV_LOG_WARNING, "Adaptive quantization must be enabled to use ROI encoding, skipping ROI.\n");
379  }
380  } else {
381  if (frame->interlaced_frame == 0) {
382  int mbx = (frame->width + MB_SIZE - 1) / MB_SIZE;
383  int mby = (frame->height + MB_SIZE - 1) / MB_SIZE;
384  int qp_range = 51 + 6 * (bit_depth - 8);
385  int nb_rois;
386  const AVRegionOfInterest *roi;
387  uint32_t roi_size;
388  float *qoffsets;
389 
390  roi = (const AVRegionOfInterest*)sd->data;
391  roi_size = roi->self_size;
392  if (!roi_size || sd->size % roi_size != 0) {
393  av_log(ctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
394  return AVERROR(EINVAL);
395  }
396  nb_rois = sd->size / roi_size;
397 
398  qoffsets = av_mallocz_array(mbx * mby, sizeof(*qoffsets));
399  if (!qoffsets)
400  return AVERROR(ENOMEM);
401 
402  // This list must be iterated in reverse because the first
403  // region in the list applies when regions overlap.
404  for (int i = nb_rois - 1; i >= 0; i--) {
405  int startx, endx, starty, endy;
406  float qoffset;
407 
408  roi = (const AVRegionOfInterest*)(sd->data + roi_size * i);
409 
410  starty = FFMIN(mby, roi->top / MB_SIZE);
411  endy = FFMIN(mby, (roi->bottom + MB_SIZE - 1)/ MB_SIZE);
412  startx = FFMIN(mbx, roi->left / MB_SIZE);
413  endx = FFMIN(mbx, (roi->right + MB_SIZE - 1)/ MB_SIZE);
414 
415  if (roi->qoffset.den == 0) {
416  av_free(qoffsets);
417  av_log(ctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
418  return AVERROR(EINVAL);
419  }
420  qoffset = roi->qoffset.num * 1.0f / roi->qoffset.den;
421  qoffset = av_clipf(qoffset * qp_range, -qp_range, +qp_range);
422 
423  for (int y = starty; y < endy; y++) {
424  for (int x = startx; x < endx; x++) {
425  qoffsets[x + y*mbx] = qoffset;
426  }
427  }
428  }
429 
430  x4->pic.prop.quant_offsets = qoffsets;
431  x4->pic.prop.quant_offsets_free = av_free;
432  } else {
433  if (!x4->roi_warned) {
434  x4->roi_warned = 1;
435  av_log(ctx, AV_LOG_WARNING, "interlaced_frame not supported for ROI encoding yet, skipping ROI.\n");
436  }
437  }
438  }
439  }
440  }
441 
442  do {
443  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
444  return AVERROR_EXTERNAL;
445 
446  ret = encode_nals(ctx, pkt, nal, nnal);
447  if (ret < 0)
448  return ret;
449  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
450 
451  if (!ret)
452  return 0;
453 
454  pkt->pts = pic_out.i_pts;
455  pkt->dts = pic_out.i_dts;
456 
457  out_opaque = pic_out.opaque;
458  if (out_opaque >= x4->reordered_opaque &&
459  out_opaque < &x4->reordered_opaque[x4->nb_reordered_opaque]) {
460  ctx->reordered_opaque = out_opaque->reordered_opaque;
461  wallclock = out_opaque->wallclock;
462  } else {
463  // Unexpected opaque pointer on picture output
464  ctx->reordered_opaque = 0;
465  }
466 
467  switch (pic_out.i_type) {
468  case X264_TYPE_IDR:
469  case X264_TYPE_I:
470  pict_type = AV_PICTURE_TYPE_I;
471  break;
472  case X264_TYPE_P:
473  pict_type = AV_PICTURE_TYPE_P;
474  break;
475  case X264_TYPE_B:
476  case X264_TYPE_BREF:
477  pict_type = AV_PICTURE_TYPE_B;
478  break;
479  default:
480  av_log(ctx, AV_LOG_ERROR, "Unknown picture type encountered.\n");
481  return AVERROR_EXTERNAL;
482  }
483 #if FF_API_CODED_FRAME
485  ctx->coded_frame->pict_type = pict_type;
487 #endif
488 
489  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
490  if (ret) {
491  ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type);
492  if (wallclock)
493  ff_side_data_set_prft(pkt, wallclock);
494 
495 #if FF_API_CODED_FRAME
497  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
499 #endif
500  }
501 
502  *got_packet = ret;
503  return 0;
504 }
505 
507 {
508  X264Context *x4 = avctx->priv_data;
509 
510  av_freep(&avctx->extradata);
511  av_freep(&x4->sei);
513 
514  if (x4->enc) {
515  x264_encoder_close(x4->enc);
516  x4->enc = NULL;
517  }
518 
519  return 0;
520 }
521 
522 #define OPT_STR(opt, param) \
523  do { \
524  int ret; \
525  if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
526  if(ret == X264_PARAM_BAD_NAME) \
527  av_log(avctx, AV_LOG_ERROR, \
528  "bad option '%s': '%s'\n", opt, param); \
529  else \
530  av_log(avctx, AV_LOG_ERROR, \
531  "bad value for '%s': '%s'\n", opt, param); \
532  return -1; \
533  } \
534  } while (0)
535 
537 {
538  switch (pix_fmt) {
539  case AV_PIX_FMT_YUV420P:
540  case AV_PIX_FMT_YUVJ420P:
541  case AV_PIX_FMT_YUV420P9:
542  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
543  case AV_PIX_FMT_YUV422P:
544  case AV_PIX_FMT_YUVJ422P:
545  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
546  case AV_PIX_FMT_YUV444P:
547  case AV_PIX_FMT_YUVJ444P:
548  case AV_PIX_FMT_YUV444P9:
549  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
550 #if CONFIG_LIBX264RGB_ENCODER
551  case AV_PIX_FMT_BGR0:
552  return X264_CSP_BGRA;
553  case AV_PIX_FMT_BGR24:
554  return X264_CSP_BGR;
555 
556  case AV_PIX_FMT_RGB24:
557  return X264_CSP_RGB;
558 #endif
559  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
560  case AV_PIX_FMT_NV16:
561  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
562 #ifdef X264_CSP_NV21
563  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
564 #endif
565 #ifdef X264_CSP_I400
566  case AV_PIX_FMT_GRAY8:
567  case AV_PIX_FMT_GRAY10: return X264_CSP_I400;
568 #endif
569  };
570  return 0;
571 }
572 
573 #define PARSE_X264_OPT(name, var)\
574  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
575  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
576  return AVERROR(EINVAL);\
577  }
578 
579 static av_cold int X264_init(AVCodecContext *avctx)
580 {
581  X264Context *x4 = avctx->priv_data;
582  AVCPBProperties *cpb_props;
583  int sw,sh;
584 
585  if (avctx->global_quality > 0)
586  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
587 
588 #if CONFIG_LIBX262_ENCODER
589  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
590  x4->params.b_mpeg2 = 1;
591  x264_param_default_mpeg2(&x4->params);
592  } else
593 #endif
594  x264_param_default(&x4->params);
595 
596  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
597 
598  if (x4->preset || x4->tune)
599  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
600  int i;
601  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
602  av_log(avctx, AV_LOG_INFO, "Possible presets:");
603  for (i = 0; x264_preset_names[i]; i++)
604  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
605  av_log(avctx, AV_LOG_INFO, "\n");
606  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
607  for (i = 0; x264_tune_names[i]; i++)
608  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
609  av_log(avctx, AV_LOG_INFO, "\n");
610  return AVERROR(EINVAL);
611  }
612 
613  if (avctx->level > 0)
614  x4->params.i_level_idc = avctx->level;
615 
616  x4->params.pf_log = X264_log;
617  x4->params.p_log_private = avctx;
618  x4->params.i_log_level = X264_LOG_DEBUG;
619  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
620 #if X264_BUILD >= 153
621  x4->params.i_bitdepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
622 #endif
623 
624  PARSE_X264_OPT("weightp", wpredp);
625 
626  if (avctx->bit_rate) {
627  if (avctx->bit_rate / 1000 > INT_MAX || avctx->rc_max_rate / 1000 > INT_MAX) {
628  av_log(avctx, AV_LOG_ERROR, "bit_rate and rc_max_rate > %d000 not supported by libx264\n", INT_MAX);
629  return AVERROR(EINVAL);
630  }
631  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
632  x4->params.rc.i_rc_method = X264_RC_ABR;
633  }
634  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
635  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
636  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
637  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
638  x4->params.rc.b_stat_read = 1;
639  } else {
640  if (x4->crf >= 0) {
641  x4->params.rc.i_rc_method = X264_RC_CRF;
642  x4->params.rc.f_rf_constant = x4->crf;
643  } else if (x4->cqp >= 0) {
644  x4->params.rc.i_rc_method = X264_RC_CQP;
645  x4->params.rc.i_qp_constant = x4->cqp;
646  }
647 
648  if (x4->crf_max >= 0)
649  x4->params.rc.f_rf_constant_max = x4->crf_max;
650  }
651 
652  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
653  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
654  x4->params.rc.f_vbv_buffer_init =
655  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
656  }
657 
658  PARSE_X264_OPT("level", level);
659 
660  if (avctx->i_quant_factor > 0)
661  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
662  if (avctx->b_quant_factor > 0)
663  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
664 
665 #if FF_API_PRIVATE_OPT
667  if (avctx->chromaoffset >= 0)
668  x4->chroma_offset = avctx->chromaoffset;
670 #endif
671  if (x4->chroma_offset >= 0)
672  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
673 
674  if (avctx->gop_size >= 0)
675  x4->params.i_keyint_max = avctx->gop_size;
676  if (avctx->max_b_frames >= 0)
677  x4->params.i_bframe = avctx->max_b_frames;
678 
679 #if FF_API_PRIVATE_OPT
681  if (avctx->scenechange_threshold >= 0)
684 #endif
685  if (x4->scenechange_threshold >= 0)
686  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
687 
688  if (avctx->qmin >= 0)
689  x4->params.rc.i_qp_min = avctx->qmin;
690  if (avctx->qmax >= 0)
691  x4->params.rc.i_qp_max = avctx->qmax;
692  if (avctx->max_qdiff >= 0)
693  x4->params.rc.i_qp_step = avctx->max_qdiff;
694  if (avctx->qblur >= 0)
695  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
696  if (avctx->qcompress >= 0)
697  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
698  if (avctx->refs >= 0)
699  x4->params.i_frame_reference = avctx->refs;
700  else if (x4->params.i_level_idc > 0) {
701  int i;
702  int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4);
703  int scale = X264_BUILD < 129 ? 384 : 1;
704 
705  for (i = 0; i<x264_levels[i].level_idc; i++)
706  if (x264_levels[i].level_idc == x4->params.i_level_idc)
707  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
708  }
709 
710  if (avctx->trellis >= 0)
711  x4->params.analyse.i_trellis = avctx->trellis;
712  if (avctx->me_range >= 0)
713  x4->params.analyse.i_me_range = avctx->me_range;
714 #if FF_API_PRIVATE_OPT
716  if (avctx->noise_reduction >= 0)
717  x4->noise_reduction = avctx->noise_reduction;
719 #endif
720  if (x4->noise_reduction >= 0)
721  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
722  if (avctx->me_subpel_quality >= 0)
723  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
724 #if FF_API_PRIVATE_OPT
726  if (avctx->b_frame_strategy >= 0)
727  x4->b_frame_strategy = avctx->b_frame_strategy;
729 #endif
730  if (avctx->keyint_min >= 0)
731  x4->params.i_keyint_min = avctx->keyint_min;
732 #if FF_API_CODER_TYPE
734  if (avctx->coder_type >= 0)
735  x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
737 #endif
738  if (avctx->me_cmp >= 0)
739  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
740 
741  if (x4->aq_mode >= 0)
742  x4->params.rc.i_aq_mode = x4->aq_mode;
743  if (x4->aq_strength >= 0)
744  x4->params.rc.f_aq_strength = x4->aq_strength;
745  PARSE_X264_OPT("psy-rd", psy_rd);
746  PARSE_X264_OPT("deblock", deblock);
747  PARSE_X264_OPT("partitions", partitions);
748  PARSE_X264_OPT("stats", stats);
749  if (x4->psy >= 0)
750  x4->params.analyse.b_psy = x4->psy;
751  if (x4->rc_lookahead >= 0)
752  x4->params.rc.i_lookahead = x4->rc_lookahead;
753  if (x4->weightp >= 0)
754  x4->params.analyse.i_weighted_pred = x4->weightp;
755  if (x4->weightb >= 0)
756  x4->params.analyse.b_weighted_bipred = x4->weightb;
757  if (x4->cplxblur >= 0)
758  x4->params.rc.f_complexity_blur = x4->cplxblur;
759 
760  if (x4->ssim >= 0)
761  x4->params.analyse.b_ssim = x4->ssim;
762  if (x4->intra_refresh >= 0)
763  x4->params.b_intra_refresh = x4->intra_refresh;
764  if (x4->bluray_compat >= 0) {
765  x4->params.b_bluray_compat = x4->bluray_compat;
766  x4->params.b_vfr_input = 0;
767  }
768  if (x4->avcintra_class >= 0)
769 #if X264_BUILD >= 142
770  x4->params.i_avcintra_class = x4->avcintra_class;
771 #else
772  av_log(avctx, AV_LOG_ERROR,
773  "x264 too old for AVC Intra, at least version 142 needed\n");
774 #endif
775  if (x4->b_bias != INT_MIN)
776  x4->params.i_bframe_bias = x4->b_bias;
777  if (x4->b_pyramid >= 0)
778  x4->params.i_bframe_pyramid = x4->b_pyramid;
779  if (x4->mixed_refs >= 0)
780  x4->params.analyse.b_mixed_references = x4->mixed_refs;
781  if (x4->dct8x8 >= 0)
782  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
783  if (x4->fast_pskip >= 0)
784  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
785  if (x4->aud >= 0)
786  x4->params.b_aud = x4->aud;
787  if (x4->mbtree >= 0)
788  x4->params.rc.b_mb_tree = x4->mbtree;
789  if (x4->direct_pred >= 0)
790  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
791 
792  if (x4->slice_max_size >= 0)
793  x4->params.i_slice_max_size = x4->slice_max_size;
794 
795  if (x4->fastfirstpass)
796  x264_param_apply_fastfirstpass(&x4->params);
797 
798  /* Allow specifying the x264 profile through AVCodecContext. */
799  if (!x4->profile)
800  switch (avctx->profile) {
802  x4->profile = av_strdup("baseline");
803  break;
805  x4->profile = av_strdup("high");
806  break;
808  x4->profile = av_strdup("high10");
809  break;
811  x4->profile = av_strdup("high422");
812  break;
814  x4->profile = av_strdup("high444");
815  break;
817  x4->profile = av_strdup("main");
818  break;
819  default:
820  break;
821  }
822 
823  if (x4->nal_hrd >= 0)
824  x4->params.i_nal_hrd = x4->nal_hrd;
825 
826  if (x4->motion_est >= 0)
827  x4->params.analyse.i_me_method = x4->motion_est;
828 
829  if (x4->coder >= 0)
830  x4->params.b_cabac = x4->coder;
831 
832  if (x4->b_frame_strategy >= 0)
833  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
834 
835  if (x4->profile)
836  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
837  int i;
838  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
839  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
840  for (i = 0; x264_profile_names[i]; i++)
841  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
842  av_log(avctx, AV_LOG_INFO, "\n");
843  return AVERROR(EINVAL);
844  }
845 
846  x4->params.i_width = avctx->width;
847  x4->params.i_height = avctx->height;
848  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
849  x4->params.vui.i_sar_width = sw;
850  x4->params.vui.i_sar_height = sh;
851  x4->params.i_timebase_den = avctx->time_base.den;
852  x4->params.i_timebase_num = avctx->time_base.num;
853  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
854  x4->params.i_fps_num = avctx->framerate.num;
855  x4->params.i_fps_den = avctx->framerate.den;
856  } else {
857  x4->params.i_fps_num = avctx->time_base.den;
858  x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame;
859  }
860 
861  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
862 
863  x4->params.i_threads = avctx->thread_count;
864  if (avctx->thread_type)
865  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
866 
867  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
868 
869  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
870 
871  x4->params.i_slice_count = avctx->slices;
872 
873  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
874  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
875  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
876  avctx->color_range == AVCOL_RANGE_JPEG;
877 
878  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
879  x4->params.vui.i_colmatrix = avctx->colorspace;
881  x4->params.vui.i_colorprim = avctx->color_primaries;
882  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
883  x4->params.vui.i_transfer = avctx->color_trc;
884 
885  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
886  x4->params.b_repeat_headers = 0;
887 
888  if(x4->x264opts){
889  const char *p= x4->x264opts;
890  while(p){
891  char param[4096]={0}, val[4096]={0};
892  if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){
893  OPT_STR(param, "1");
894  }else
895  OPT_STR(param, val);
896  p= strchr(p, ':');
897  p+=!!p;
898  }
899  }
900 
901 
902  {
903  AVDictionaryEntry *en = NULL;
904  while (en = av_dict_get(x4->x264_params, "", en, AV_DICT_IGNORE_SUFFIX)) {
905  if (x264_param_parse(&x4->params, en->key, en->value) < 0)
906  av_log(avctx, AV_LOG_WARNING,
907  "Error parsing option '%s = %s'.\n",
908  en->key, en->value);
909  }
910  }
911 
912  // update AVCodecContext with x264 parameters
913  avctx->has_b_frames = x4->params.i_bframe ?
914  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
915  if (avctx->max_b_frames < 0)
916  avctx->max_b_frames = 0;
917 
918  avctx->bit_rate = x4->params.rc.i_bitrate*1000LL;
919 
920  x4->enc = x264_encoder_open(&x4->params);
921  if (!x4->enc)
922  return AVERROR_EXTERNAL;
923 
924  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
925  x264_nal_t *nal;
926  uint8_t *p;
927  int nnal, s, i;
928 
929  s = x264_encoder_headers(x4->enc, &nal, &nnal);
931  if (!p)
932  return AVERROR(ENOMEM);
933 
934  for (i = 0; i < nnal; i++) {
935  /* Don't put the SEI in extradata. */
936  if (nal[i].i_type == NAL_SEI) {
937  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
938  x4->sei_size = nal[i].i_payload;
939  x4->sei = av_malloc(x4->sei_size);
940  if (!x4->sei)
941  return AVERROR(ENOMEM);
942  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
943  continue;
944  }
945  memcpy(p, nal[i].p_payload, nal[i].i_payload);
946  p += nal[i].i_payload;
947  }
948  avctx->extradata_size = p - avctx->extradata;
949  }
950 
951  cpb_props = ff_add_cpb_side_data(avctx);
952  if (!cpb_props)
953  return AVERROR(ENOMEM);
954  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
955  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000LL;
956  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000LL;
957 
958  // Overestimate the reordered opaque buffer size, in case a runtime
959  // reconfigure would increase the delay (which it shouldn't).
960  x4->nb_reordered_opaque = x264_encoder_maximum_delayed_frames(x4->enc) + 17;
962  sizeof(*x4->reordered_opaque));
963  if (!x4->reordered_opaque)
964  return AVERROR(ENOMEM);
965 
966  return 0;
967 }
968 
969 static const enum AVPixelFormat pix_fmts_8bit[] = {
978 #ifdef X264_CSP_NV21
980 #endif
982 };
983 static const enum AVPixelFormat pix_fmts_9bit[] = {
987 };
988 static const enum AVPixelFormat pix_fmts_10bit[] = {
994 };
995 static const enum AVPixelFormat pix_fmts_all[] = {
1004 #ifdef X264_CSP_NV21
1006 #endif
1011 #ifdef X264_CSP_I400
1014 #endif
1016 };
1017 #if CONFIG_LIBX264RGB_ENCODER
1018 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
1023 };
1024 #endif
1025 
1026 static av_cold void X264_init_static(AVCodec *codec)
1027 {
1028 #if X264_BUILD < 153
1029  if (x264_bit_depth == 8)
1030  codec->pix_fmts = pix_fmts_8bit;
1031  else if (x264_bit_depth == 9)
1032  codec->pix_fmts = pix_fmts_9bit;
1033  else if (x264_bit_depth == 10)
1034  codec->pix_fmts = pix_fmts_10bit;
1035 #else
1036  codec->pix_fmts = pix_fmts_all;
1037 #endif
1038 }
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", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , 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 = -1 }, 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 #if FF_API_PRIVATE_OPT
1139  { "sc_threshold", "-1" },
1140 #endif
1141  { "trellis", "-1" },
1142 #if FF_API_PRIVATE_OPT
1143  { "nr", "-1" },
1144 #endif
1145  { "me_range", "-1" },
1146  { "subq", "-1" },
1147 #if FF_API_PRIVATE_OPT
1148  { "b_strategy", "-1" },
1149 #endif
1150  { "keyint_min", "-1" },
1151 #if FF_API_CODER_TYPE
1152  { "coder", "-1" },
1153 #endif
1154  { "cmp", "-1" },
1155  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
1156  { "thread_type", "0" },
1157  { "flags", "+cgop" },
1158  { "rc_init_occupancy","-1" },
1159  { NULL },
1160 };
1161 
1162 #if CONFIG_LIBX264_ENCODER
1163 static const AVClass x264_class = {
1164  .class_name = "libx264",
1165  .item_name = av_default_item_name,
1166  .option = options,
1167  .version = LIBAVUTIL_VERSION_INT,
1168 };
1169 
1171  .name = "libx264",
1172  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1173  .type = AVMEDIA_TYPE_VIDEO,
1174  .id = AV_CODEC_ID_H264,
1175  .priv_data_size = sizeof(X264Context),
1176  .init = X264_init,
1177  .encode2 = X264_frame,
1178  .close = X264_close,
1179  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1181  .priv_class = &x264_class,
1182  .defaults = x264_defaults,
1184 #if X264_BUILD >= 158
1186 #else
1187  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1188 #endif
1189  .wrapper_name = "libx264",
1190 };
1191 #endif
1192 
1193 #if CONFIG_LIBX264RGB_ENCODER
1194 static const AVClass rgbclass = {
1195  .class_name = "libx264rgb",
1196  .item_name = av_default_item_name,
1197  .option = options,
1198  .version = LIBAVUTIL_VERSION_INT,
1199 };
1200 
1202  .name = "libx264rgb",
1203  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
1204  .type = AVMEDIA_TYPE_VIDEO,
1205  .id = AV_CODEC_ID_H264,
1206  .priv_data_size = sizeof(X264Context),
1207  .init = X264_init,
1208  .encode2 = X264_frame,
1209  .close = X264_close,
1210  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1212  .priv_class = &rgbclass,
1213  .defaults = x264_defaults,
1214  .pix_fmts = pix_fmts_8bit_rgb,
1215 #if X264_BUILD >= 158
1217 #else
1218  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1219 #endif
1220  .wrapper_name = "libx264",
1221 };
1222 #endif
1223 
1224 #if CONFIG_LIBX262_ENCODER
1225 static const AVClass X262_class = {
1226  .class_name = "libx262",
1227  .item_name = av_default_item_name,
1228  .option = options,
1229  .version = LIBAVUTIL_VERSION_INT,
1230 };
1231 
1233  .name = "libx262",
1234  .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
1235  .type = AVMEDIA_TYPE_VIDEO,
1236  .id = AV_CODEC_ID_MPEG2VIDEO,
1237  .priv_data_size = sizeof(X264Context),
1238  .init = X264_init,
1239  .encode2 = X264_frame,
1240  .close = X264_close,
1241  .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS |
1243  .priv_class = &X262_class,
1244  .defaults = x264_defaults,
1246  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1247  .wrapper_name = "libx264",
1248 };
1249 #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:1900
#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:536
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2069
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:248
static int avfmt2_num_planes(int avfmt)
Definition: libx264.c:171
char * partitions
Definition: libx264.c:90
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int dct8x8
Definition: libx264.c:84
AVOption.
Definition: opt.h:248
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:728
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:304
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:1361
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:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#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:454
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:786
AVCodec ff_libx262_encoder
int noise_reduction
Definition: libx264.c:103
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1432
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
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:905
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
int next_reordered_opaque
Definition: libx264.c:107
int bluray_compat
Definition: libx264.c:80
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
char * wpredp
Definition: libx264.c:66
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:117
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: codec.h:118
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:579
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:114
AVRational qoffset
Quantisation offset.
Definition: frame.h:275
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
x264_param_t params
Definition: libx264.c:56
char * x264opts
Definition: libx264.c:67
#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:164
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: codec.h:75
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:33
#define FF_PROFILE_H264_BASELINE
Definition: avcodec.h:1898
#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:2354
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
#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:997
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:795
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
int me_cmp
motion estimation comparison function
Definition: avcodec.h:912
int nb_reordered_opaque
Definition: libx264.c:107
int level_idc
Definition: h264_levels.c:25
Structure to hold side data for an AVFrame.
Definition: frame.h:214
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: packet.h:355
int b_pyramid
Definition: libx264.c:82
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:58
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:455
float cplxblur
Definition: libx264.c:89
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:481
ptrdiff_t size
Definition: opengl_enc.c:100
#define FF_CMP_CHROMA
Definition: avcodec.h:947
char * stats
Definition: libx264.c:93
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:238
static enum AVPixelFormat pix_fmts_all[]
Definition: libx264.c:995
int intra_refresh
Definition: libx264.c:79
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:446
#define av_log(a,...)
int rc_lookahead
Definition: libx264.c:75
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:988
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
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:1375
char * profile
Definition: libx264.c:63
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
int coder
Definition: libx264.c:98
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int fastfirstpass
Definition: libx264.c:65
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:1906
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1902
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
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:87
const char * name
Name of the codec implementation.
Definition: codec.h:197
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:831
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
char * deblock
Definition: libx264.c:88
int b_frame_strategy
Definition: libx264.c:100
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
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:1389
Views are alternated temporally.
Definition: stereo3d.h:92
common internal API header
char * psy_rd
Definition: libx264.c:73
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
int refs
number of reference frames
Definition: avcodec.h:1114
int64_t reordered_opaque
Definition: libx264.c:50
X264Opaque * reordered_opaque
Definition: libx264.c:108
int motion_est
Definition: libx264.c:96
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:983
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:573
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:211
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#define OPT_STR(opt, param)
Definition: libx264.c:522
#define FFMIN(a, b)
Definition: common.h:96
AVDictionary * x264_params
Definition: libx264.c:105
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:699
int cqp
Definition: libx264.c:70
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
static av_cold void init_static_data(void)
Definition: mv30.c:660
attribute_deprecated int noise_reduction
Definition: avcodec.h:1044
x264_t * enc
Definition: libx264.c:57
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:312
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
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:1797
int level
level
Definition: avcodec.h:1982
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
Structure describing a single Region Of Interest.
Definition: frame.h:233
int scenechange_threshold
Definition: libx264.c:102
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:1683
int slice_max_size
Definition: libx264.c:92
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int nal_hrd
Definition: libx264.c:94
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:1382
int weightp
Definition: libx264.c:76
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
attribute_deprecated int coder_type
Definition: avcodec.h:1443
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1785
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:538
if(ret)
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:969
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
static const AVCodecDefault x264_defaults[]
Definition: libx264.c:1124
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:448
int avcintra_class
Definition: libx264.c:95
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
char * level
Definition: libx264.c:64
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
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:506
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:1040
enum AVCodecID codec_id
Definition: avcodec.h:536
int forced_idr
Definition: libx264.c:97
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:800
main external API structure.
Definition: avcodec.h:526
static const AVOption options[]
Definition: libx264.c:1042
int qmin
minimum quantizer
Definition: avcodec.h:1368
uint8_t * data
Definition: frame.h:216
#define FF_CODER_TYPE_AC
Definition: avcodec.h:1436
int extradata_size
Definition: avcodec.h:628
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
float crf
Definition: libx264.c:68
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
int aq_mode
Definition: libx264.c:71
int aud
Definition: libx264.c:86
#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:475
Describe the class of an AVClass context structure.
Definition: log.h:67
int a53_cc
Definition: libx264.c:99
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
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:59
int psy
Definition: libx264.c:74
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, const x264_nal_t *nals, int nnal)
Definition: libx264.c:133
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
#define FF_PROFILE_H264_HIGH_444
Definition: avcodec.h:1909
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
attribute_deprecated int chromaoffset
Definition: avcodec.h:1119
#define AV_CODEC_EXPORT_DATA_PRFT
Export encoder Producer Reference Time through packet side data.
Definition: avcodec.h:407
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1360
int sei_size
Definition: libx264.c:60
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:193
char * preset
Definition: libx264.c:61
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
mfxU16 profile
Definition: qsvenc.c:45
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
uint8_t level
Definition: svq3.c:209
int b_bias
Definition: libx264.c:81
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
int fast_pskip
Definition: libx264.c:85
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
int chroma_offset
Definition: libx264.c:101
static av_cold void X264_init_static(AVCodec *codec)
Definition: libx264.c:1026
int mixed_refs
Definition: libx264.c:83
preset
Definition: vf_curves.c:46
char * tune
Definition: libx264.c:62
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:1041
int weightb
Definition: libx264.c:77
float aq_strength
Definition: libx264.c:72
common internal api header.
int64_t wallclock
Definition: libx264.c:51
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:1776
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:1475
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2001
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
int slices
Number of slices.
Definition: avcodec.h:1177
void * priv_data
Definition: avcodec.h:553
#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:460
int ff_side_data_set_prft(AVPacket *pkt, int64_t timestamp)
Definition: avpacket.c:753
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:472
#define MB_SIZE
Definition: libx264.c:47
AVCodec ff_libx264rgb_encoder
int ssim
Definition: libx264.c:78
#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: packet.h:354
float crf_max
Definition: libx264.c:69
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:2205
int height
Definition: frame.h:366
#define OFFSET(x)
Definition: libx264.c:1040
int direct_pred
Definition: libx264.c:91
#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:293
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:343
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:1903
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
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:332
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:988
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
int i
Definition: input.c:406
Predicted.
Definition: avutil.h:275
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1795
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
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:190
int keyint_min
minimum GOP size
Definition: avcodec.h:1107