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