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