Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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/internal.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/stereo3d.h"
27 #include "avcodec.h"
28 #include "internal.h"
29 
30 #if defined(_MSC_VER)
31 #define X264_API_IMPORTS 1
32 #endif
33 
34 #include <x264.h>
35 #include <float.h>
36 #include <math.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 
41 typedef struct X264Context {
42  AVClass *class;
43  x264_param_t params;
44  x264_t *enc;
45  x264_picture_t pic;
47  int sei_size;
48  char *preset;
49  char *tune;
50  char *profile;
52  float crf;
53  float crf_max;
54  int cqp;
55  int aq_mode;
56  float aq_strength;
57  char *psy_rd;
58  int psy;
60  int weightp;
61  int weightb;
62  int ssim;
65  int b_bias;
66  int b_pyramid;
68  int dct8x8;
70  int aud;
71  int mbtree;
72  char *deblock;
73  float cplxblur;
74  char *partitions;
77  char *stats;
78  int nal_hrd;
81  int coder;
86 
87  char *x264_params;
88 } X264Context;
89 
90 static void X264_log(void *p, int level, const char *fmt, va_list args)
91 {
92  static const int level_map[] = {
93  [X264_LOG_ERROR] = AV_LOG_ERROR,
94  [X264_LOG_WARNING] = AV_LOG_WARNING,
95  [X264_LOG_INFO] = AV_LOG_INFO,
96  [X264_LOG_DEBUG] = AV_LOG_DEBUG
97  };
98 
99  if (level < 0 || level > X264_LOG_DEBUG)
100  return;
101 
102  av_vlog(p, level_map[level], fmt, args);
103 }
104 
105 
107  x264_nal_t *nals, int nnal)
108 {
109  X264Context *x4 = ctx->priv_data;
110  uint8_t *p;
111  int i, size = x4->sei_size, ret;
112 
113  if (!nnal)
114  return 0;
115 
116  for (i = 0; i < nnal; i++)
117  size += nals[i].i_payload;
118 
119  if ((ret = ff_alloc_packet(pkt, size)) < 0)
120  return ret;
121 
122  p = pkt->data;
123 
124  /* Write the SEI as part of the first frame. */
125  if (x4->sei_size > 0 && nnal > 0) {
126  memcpy(p, x4->sei, x4->sei_size);
127  p += x4->sei_size;
128  x4->sei_size = 0;
129  }
130 
131  for (i = 0; i < nnal; i++){
132  memcpy(p, nals[i].p_payload, nals[i].i_payload);
133  p += nals[i].i_payload;
134  }
135 
136  return 1;
137 }
138 
139 static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
140 {
141  X264Context *x4 = ctx->priv_data;
142  AVFrameSideData *side_data;
143 
144 
145  if (x4->params.b_tff != frame->top_field_first) {
146  x4->params.b_tff = frame->top_field_first;
147  x264_encoder_reconfig(x4->enc, &x4->params);
148  }
149  if (x4->params.vui.i_sar_height != ctx->sample_aspect_ratio.den ||
150  x4->params.vui.i_sar_width != ctx->sample_aspect_ratio.num) {
151  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
152  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
153  x264_encoder_reconfig(x4->enc, &x4->params);
154  }
155 
156  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
157  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
158  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
159  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
160  x264_encoder_reconfig(x4->enc, &x4->params);
161  }
162 
163  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
164  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
165  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
166  x264_encoder_reconfig(x4->enc, &x4->params);
167  }
168 
169  if (x4->crf >= 0 &&
170  x4->params.rc.i_rc_method == X264_RC_CRF &&
171  x4->params.rc.f_rf_constant != x4->crf) {
172  x4->params.rc.f_rf_constant = x4->crf;
173  x264_encoder_reconfig(x4->enc, &x4->params);
174  }
175 
176  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
177  x4->params.rc.i_qp_constant != x4->cqp) {
178  x4->params.rc.i_qp_constant = x4->cqp;
179  x264_encoder_reconfig(x4->enc, &x4->params);
180  }
181 
182  if (x4->crf_max >= 0 &&
183  x4->params.rc.f_rf_constant_max != x4->crf_max) {
184  x4->params.rc.f_rf_constant_max = x4->crf_max;
185  x264_encoder_reconfig(x4->enc, &x4->params);
186  }
187 
189  if (side_data) {
190  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
191  int fpa_type;
192 
193  switch (stereo->type) {
195  fpa_type = 0;
196  break;
197  case AV_STEREO3D_COLUMNS:
198  fpa_type = 1;
199  break;
200  case AV_STEREO3D_LINES:
201  fpa_type = 2;
202  break;
204  fpa_type = 3;
205  break;
207  fpa_type = 4;
208  break;
210  fpa_type = 5;
211  break;
212 #if X264_BUILD >= 145
213  case AV_STEREO3D_2D:
214  fpa_type = 6;
215  break;
216 #endif
217  default:
218  fpa_type = -1;
219  break;
220  }
221 
222  /* Inverted mode is not supported by x264 */
223  if (stereo->flags & AV_STEREO3D_FLAG_INVERT) {
224  av_log(ctx, AV_LOG_WARNING,
225  "Ignoring unsupported inverted stereo value %d\n", fpa_type);
226  fpa_type = -1;
227  }
228 
229  if (fpa_type != x4->params.i_frame_packing) {
230  x4->params.i_frame_packing = fpa_type;
231  x264_encoder_reconfig(x4->enc, &x4->params);
232  }
233  }
234 }
235 
236 static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
237  int *got_packet)
238 {
239  X264Context *x4 = ctx->priv_data;
240  x264_nal_t *nal;
241  int nnal, i, ret;
242  x264_picture_t pic_out;
243 
244  x264_picture_init( &x4->pic );
245  x4->pic.img.i_csp = x4->params.i_csp;
246  if (x264_bit_depth > 8)
247  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
248  x4->pic.img.i_plane = 3;
249 
250  if (frame) {
251  for (i = 0; i < 3; i++) {
252  x4->pic.img.plane[i] = frame->data[i];
253  x4->pic.img.i_stride[i] = frame->linesize[i];
254  }
255 
256  x4->pic.i_pts = frame->pts;
257 
258  switch (frame->pict_type) {
259  case AV_PICTURE_TYPE_I:
260  x4->pic.i_type = x4->forced_idr ? X264_TYPE_IDR
261  : X264_TYPE_KEYFRAME;
262  break;
263  case AV_PICTURE_TYPE_P:
264  x4->pic.i_type = X264_TYPE_P;
265  break;
266  case AV_PICTURE_TYPE_B:
267  x4->pic.i_type = X264_TYPE_B;
268  break;
269  default:
270  x4->pic.i_type = X264_TYPE_AUTO;
271  break;
272  }
273  reconfig_encoder(ctx, frame);
274  }
275  do {
276  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
277  return AVERROR_UNKNOWN;
278 
279  ret = encode_nals(ctx, pkt, nal, nnal);
280  if (ret < 0)
281  return ret;
282  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
283 
284  pkt->pts = pic_out.i_pts;
285  pkt->dts = pic_out.i_dts;
286 
287 #if FF_API_CODED_FRAME
289  switch (pic_out.i_type) {
290  case X264_TYPE_IDR:
291  case X264_TYPE_I:
293  break;
294  case X264_TYPE_P:
296  break;
297  case X264_TYPE_B:
298  case X264_TYPE_BREF:
300  break;
301  }
303 #endif
304 
305  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
306  if (ret) {
308  sizeof(int));
309  if (!sd)
310  return AVERROR(ENOMEM);
311  *(int *)sd = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
312 
313 #if FF_API_CODED_FRAME
315  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
317 #endif
318  }
319 
320  *got_packet = ret;
321  return 0;
322 }
323 
325 {
326  X264Context *x4 = avctx->priv_data;
327 
328  av_freep(&avctx->extradata);
329  av_freep(&x4->sei);
330 
331  if (x4->enc) {
332  x264_encoder_close(x4->enc);
333  x4->enc = NULL;
334  }
335 
336  return 0;
337 }
338 
340 {
341  switch (pix_fmt) {
342  case AV_PIX_FMT_YUV420P:
343  case AV_PIX_FMT_YUVJ420P:
344  case AV_PIX_FMT_YUV420P9:
345  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
346  case AV_PIX_FMT_YUV422P:
347  case AV_PIX_FMT_YUVJ422P:
348  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
349  case AV_PIX_FMT_YUV444P:
350  case AV_PIX_FMT_YUVJ444P:
351  case AV_PIX_FMT_YUV444P9:
352  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
353  case AV_PIX_FMT_NV12: return X264_CSP_NV12;
354  case AV_PIX_FMT_NV16:
355  case AV_PIX_FMT_NV20: return X264_CSP_NV16;
356 #ifdef X264_CSP_NV21
357  case AV_PIX_FMT_NV21: return X264_CSP_NV21;
358 #endif
359  };
360  return 0;
361 }
362 
363 #define PARSE_X264_OPT(name, var)\
364  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
365  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
366  return AVERROR(EINVAL);\
367  }
368 
369 static av_cold int X264_init(AVCodecContext *avctx)
370 {
371  X264Context *x4 = avctx->priv_data;
372  AVCPBProperties *cpb_props;
373 
374 #if CONFIG_LIBX262_ENCODER
375  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
376  x4->params.b_mpeg2 = 1;
377  x264_param_default_mpeg2(&x4->params);
378  } else
379 #else
380  x264_param_default(&x4->params);
381 #endif
382 
383  x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER;
384 
385  if (x4->preset || x4->tune)
386  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
387  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
388  return AVERROR(EINVAL);
389  }
390 
391  if (avctx->level > 0)
392  x4->params.i_level_idc = avctx->level;
393 
394  x4->params.pf_log = X264_log;
395  x4->params.p_log_private = avctx;
396  x4->params.i_log_level = X264_LOG_DEBUG;
397  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
398 
399  if (avctx->bit_rate) {
400  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
401  x4->params.rc.i_rc_method = X264_RC_ABR;
402  }
403  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
404  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
405  x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1;
406  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
407  x4->params.rc.b_stat_read = 1;
408  } else {
409  if (x4->crf >= 0) {
410  x4->params.rc.i_rc_method = X264_RC_CRF;
411  x4->params.rc.f_rf_constant = x4->crf;
412  } else if (x4->cqp >= 0) {
413  x4->params.rc.i_rc_method = X264_RC_CQP;
414  x4->params.rc.i_qp_constant = x4->cqp;
415  }
416 
417  if (x4->crf_max >= 0)
418  x4->params.rc.f_rf_constant_max = x4->crf_max;
419  }
420 
421  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
422  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
423  x4->params.rc.f_vbv_buffer_init =
424  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
425  }
426 
427  if (avctx->i_quant_factor > 0)
428  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
429  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
430 
431 #if FF_API_PRIVATE_OPT
433  if (avctx->chromaoffset >= 0)
434  x4->chroma_offset = avctx->chromaoffset;
436 #endif
437  if (x4->chroma_offset >= 0)
438  x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset;
439 
440  if (avctx->gop_size >= 0)
441  x4->params.i_keyint_max = avctx->gop_size;
442  if (avctx->max_b_frames >= 0)
443  x4->params.i_bframe = avctx->max_b_frames;
444 
445 #if FF_API_PRIVATE_OPT
447  if (avctx->scenechange_threshold >= 0)
450 #endif
451  if (x4->scenechange_threshold >= 0)
452  x4->params.i_scenecut_threshold = x4->scenechange_threshold;
453 
454  if (avctx->qmin >= 0)
455  x4->params.rc.i_qp_min = avctx->qmin;
456  if (avctx->qmax >= 0)
457  x4->params.rc.i_qp_max = avctx->qmax;
458  if (avctx->max_qdiff >= 0)
459  x4->params.rc.i_qp_step = avctx->max_qdiff;
460  if (avctx->qblur >= 0)
461  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
462  if (avctx->qcompress >= 0)
463  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
464  if (avctx->refs >= 0)
465  x4->params.i_frame_reference = avctx->refs;
466  if (avctx->trellis >= 0)
467  x4->params.analyse.i_trellis = avctx->trellis;
468  if (avctx->me_range >= 0)
469  x4->params.analyse.i_me_range = avctx->me_range;
470 #if FF_API_PRIVATE_OPT
472  if (avctx->noise_reduction >= 0)
473  x4->noise_reduction = avctx->noise_reduction;
475 #endif
476  if (x4->noise_reduction >= 0)
477  x4->params.analyse.i_noise_reduction = x4->noise_reduction;
478  if (avctx->me_subpel_quality >= 0)
479  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
480 #if FF_API_PRIVATE_OPT
482  if (avctx->b_frame_strategy >= 0)
483  x4->b_frame_strategy = avctx->b_frame_strategy;
485 #endif
486  if (avctx->keyint_min >= 0)
487  x4->params.i_keyint_min = avctx->keyint_min;
488 #if FF_API_CODER_TYPE
490  if (avctx->coder_type >= 0)
491  x4->coder = avctx->coder_type == FF_CODER_TYPE_AC;
493 #endif
494  if (avctx->me_cmp >= 0)
495  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
496 
497  if (x4->aq_mode >= 0)
498  x4->params.rc.i_aq_mode = x4->aq_mode;
499  if (x4->aq_strength >= 0)
500  x4->params.rc.f_aq_strength = x4->aq_strength;
501  PARSE_X264_OPT("psy-rd", psy_rd);
502  PARSE_X264_OPT("deblock", deblock);
503  PARSE_X264_OPT("partitions", partitions);
504  PARSE_X264_OPT("stats", stats);
505  if (x4->psy >= 0)
506  x4->params.analyse.b_psy = x4->psy;
507  if (x4->rc_lookahead >= 0)
508  x4->params.rc.i_lookahead = x4->rc_lookahead;
509  if (x4->weightp >= 0)
510  x4->params.analyse.i_weighted_pred = x4->weightp;
511  if (x4->weightb >= 0)
512  x4->params.analyse.b_weighted_bipred = x4->weightb;
513  if (x4->cplxblur >= 0)
514  x4->params.rc.f_complexity_blur = x4->cplxblur;
515 
516  if (x4->ssim >= 0)
517  x4->params.analyse.b_ssim = x4->ssim;
518  if (x4->intra_refresh >= 0)
519  x4->params.b_intra_refresh = x4->intra_refresh;
520  if (x4->bluray_compat >= 0) {
521  x4->params.b_bluray_compat = x4->bluray_compat;
522  x4->params.b_vfr_input = 0;
523  }
524  if (x4->b_bias != INT_MIN)
525  x4->params.i_bframe_bias = x4->b_bias;
526  if (x4->b_pyramid >= 0)
527  x4->params.i_bframe_pyramid = x4->b_pyramid;
528  if (x4->mixed_refs >= 0)
529  x4->params.analyse.b_mixed_references = x4->mixed_refs;
530  if (x4->dct8x8 >= 0)
531  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
532  if (x4->fast_pskip >= 0)
533  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
534  if (x4->aud >= 0)
535  x4->params.b_aud = x4->aud;
536  if (x4->mbtree >= 0)
537  x4->params.rc.b_mb_tree = x4->mbtree;
538  if (x4->direct_pred >= 0)
539  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
540 
541  if (x4->slice_max_size >= 0)
542  x4->params.i_slice_max_size = x4->slice_max_size;
543 
544  if (x4->fastfirstpass)
545  x264_param_apply_fastfirstpass(&x4->params);
546 
547  if (x4->nal_hrd >= 0)
548  x4->params.i_nal_hrd = x4->nal_hrd;
549 
550  if (x4->motion_est >= 0) {
551  x4->params.analyse.i_me_method = x4->motion_est;
552 #if FF_API_MOTION_EST
554  } else {
555  if (avctx->me_method == ME_EPZS)
556  x4->params.analyse.i_me_method = X264_ME_DIA;
557  else if (avctx->me_method == ME_HEX)
558  x4->params.analyse.i_me_method = X264_ME_HEX;
559  else if (avctx->me_method == ME_UMH)
560  x4->params.analyse.i_me_method = X264_ME_UMH;
561  else if (avctx->me_method == ME_FULL)
562  x4->params.analyse.i_me_method = X264_ME_ESA;
563  else if (avctx->me_method == ME_TESA)
564  x4->params.analyse.i_me_method = X264_ME_TESA;
566 #endif
567  }
568 
569  if (x4->coder >= 0)
570  x4->params.b_cabac = x4->coder;
571 
572  if (x4->b_frame_strategy >= 0)
573  x4->params.i_bframe_adaptive = x4->b_frame_strategy;
574 
575  if (x4->profile)
576  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
577  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
578  return AVERROR(EINVAL);
579  }
580 
581  x4->params.i_width = avctx->width;
582  x4->params.i_height = avctx->height;
583  x4->params.vui.i_sar_width = avctx->sample_aspect_ratio.num;
584  x4->params.vui.i_sar_height = avctx->sample_aspect_ratio.den;
585  x4->params.i_fps_num = x4->params.i_timebase_den = avctx->time_base.den;
586  x4->params.i_fps_den = x4->params.i_timebase_num = avctx->time_base.num;
587 
588  x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR;
589 
590  x4->params.i_threads = avctx->thread_count;
591  if (avctx->thread_type)
592  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
593 
594  x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT;
595 
596  x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP);
597 
598  x4->params.i_slice_count = avctx->slices;
599 
600  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
601  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
602  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
603  avctx->color_range == AVCOL_RANGE_JPEG;
604 
605  // x264 validates the values internally
606  x4->params.vui.i_colorprim = avctx->color_primaries;
607  x4->params.vui.i_transfer = avctx->color_trc;
608  x4->params.vui.i_colmatrix = avctx->colorspace;
609 
610  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
611  x4->params.b_repeat_headers = 0;
612 
613  if (x4->x264_params) {
614  AVDictionary *dict = NULL;
615  AVDictionaryEntry *en = NULL;
616 
617  if (!av_dict_parse_string(&dict, x4->x264_params, "=", ":", 0)) {
618  while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {
619  if (x264_param_parse(&x4->params, en->key, en->value) < 0)
620  av_log(avctx, AV_LOG_WARNING,
621  "Error parsing option '%s = %s'.\n",
622  en->key, en->value);
623  }
624 
625  av_dict_free(&dict);
626  }
627  }
628 
629  // update AVCodecContext with x264 parameters
630  avctx->has_b_frames = x4->params.i_bframe ?
631  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
632  if (avctx->max_b_frames < 0)
633  avctx->max_b_frames = 0;
634 
635  avctx->bit_rate = x4->params.rc.i_bitrate*1000;
636 
637  x4->enc = x264_encoder_open(&x4->params);
638  if (!x4->enc)
639  return AVERROR_UNKNOWN;
640 
641  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
642  x264_nal_t *nal;
643  uint8_t *p;
644  int nnal, s, i;
645 
646  s = x264_encoder_headers(x4->enc, &nal, &nnal);
648  if (!p)
649  return AVERROR(ENOMEM);
650 
651  for (i = 0; i < nnal; i++) {
652  /* Don't put the SEI in extradata. */
653  if (nal[i].i_type == NAL_SEI) {
654  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
655  x4->sei_size = nal[i].i_payload;
656  x4->sei = av_malloc(x4->sei_size);
657  if (!x4->sei)
658  return AVERROR(ENOMEM);
659  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
660  continue;
661  }
662  memcpy(p, nal[i].p_payload, nal[i].i_payload);
663  p += nal[i].i_payload;
664  }
665  avctx->extradata_size = p - avctx->extradata;
666  }
667 
668  cpb_props = ff_add_cpb_side_data(avctx);
669  if (!cpb_props)
670  return AVERROR(ENOMEM);
671  cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000;
672  cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000;
673  cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000;
674 
675  return 0;
676 }
677 
678 static const enum AVPixelFormat pix_fmts_8bit[] = {
687 #ifdef X264_CSP_NV21
689 #endif
691 };
692 static const enum AVPixelFormat pix_fmts_9bit[] = {
696 };
697 static const enum AVPixelFormat pix_fmts_10bit[] = {
703 };
704 
705 static av_cold void X264_init_static(AVCodec *codec)
706 {
707  if (x264_bit_depth == 8)
708  codec->pix_fmts = pix_fmts_8bit;
709  else if (x264_bit_depth == 9)
710  codec->pix_fmts = pix_fmts_9bit;
711  else if (x264_bit_depth == 10)
712  codec->pix_fmts = pix_fmts_10bit;
713 }
714 
715 #define OFFSET(x) offsetof(X264Context, x)
716 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
717 static const AVOption options[] = {
718  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
719  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
720  { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
721  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE},
722  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
723  { "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 },
724  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
725  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
726  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
727  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
728  { "autovariance", "Auto-variance AQ (experimental)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
729  { "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},
730  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
731  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
732  { "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 },
733  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
734  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
735  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
736  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
737  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
738  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
739  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
740  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
741  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
742  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
743  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
744  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
745  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
746  { "mixed-refs", "One reference per partition, as opposed to one reference per macroblock", OFFSET(mixed_refs), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 1, VE },
747  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
748  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
749  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
750  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
751  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
752  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
753  { "partitions", "A comma-separated list of partitions to consider. "
754  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
755  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
756  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
757  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
758  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
759  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
760  { "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 },
761  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
762  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
763  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
764  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
765  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
766  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
767  { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"},
768  { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" },
769  { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" },
770  { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" },
771  { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" },
772  { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
773  { "forced-idr", "If forwarding iframes, require them to be IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
774  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
775  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
776  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
777  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
778  { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE },
779  { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
780  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
781  { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE },
782 
783  { "x264-params", "Override the x264 configuration using a :-separated list of key=value parameters", OFFSET(x264_params), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
784  { NULL },
785 };
786 
787 static const AVCodecDefault x264_defaults[] = {
788  { "b", "0" },
789  { "bf", "-1" },
790  { "g", "-1" },
791  { "i_qfactor", "-1" },
792  { "qmin", "-1" },
793  { "qmax", "-1" },
794  { "qdiff", "-1" },
795  { "qblur", "-1" },
796  { "qcomp", "-1" },
797  { "refs", "-1" },
798 #if FF_API_PRIVATE_OPT
799  { "sc_threshold", "-1" },
800 #endif
801  { "trellis", "-1" },
802 #if FF_API_PRIVATE_OPT
803  { "nr", "-1" },
804 #endif
805  { "me_range", "-1" },
806 #if FF_API_MOTION_EST
807  { "me_method", "-1" },
808 #endif
809  { "subq", "-1" },
810 #if FF_API_PRIVATE_OPT
811  { "b_strategy", "-1" },
812 #endif
813  { "keyint_min", "-1" },
814 #if FF_API_CODER_TYPE
815  { "coder", "-1" },
816 #endif
817  { "cmp", "-1" },
818  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
819  { "thread_type", "0" },
820  { "flags", "+cgop" },
821  { "rc_init_occupancy","-1" },
822  { NULL },
823 };
824 
825 #if CONFIG_LIBX264_ENCODER
826 static const AVClass class = {
827  .class_name = "libx264",
828  .item_name = av_default_item_name,
829  .option = options,
830  .version = LIBAVUTIL_VERSION_INT,
831 };
832 
833 AVCodec ff_libx264_encoder = {
834  .name = "libx264",
835  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
836  .type = AVMEDIA_TYPE_VIDEO,
837  .id = AV_CODEC_ID_H264,
838  .priv_data_size = sizeof(X264Context),
839  .init = X264_init,
840  .encode2 = X264_frame,
841  .close = X264_close,
843  .priv_class = &class,
844  .defaults = x264_defaults,
845  .init_static_data = X264_init_static,
846  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
848 };
849 #endif
850 
851 #if CONFIG_LIBX262_ENCODER
852 static const AVClass X262_class = {
853  .class_name = "libx262",
854  .item_name = av_default_item_name,
855  .option = options,
856  .version = LIBAVUTIL_VERSION_INT,
857 };
858 
859 AVCodec ff_libx262_encoder = {
860  .name = "libx262",
861  .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"),
862  .type = AVMEDIA_TYPE_VIDEO,
864  .priv_data_size = sizeof(X264Context),
865  .init = X264_init,
866  .encode2 = X264_frame,
867  .close = X264_close,
869  .priv_class = &X262_class,
870  .defaults = x264_defaults,
872  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
874 };
875 #endif
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
Definition: libx264.c:339
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
Views are packed per line, as if interlaced.
Definition: stereo3d.h:97
char * partitions
Definition: libx264.c:74
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
int dct8x8
Definition: libx264.c:68
AVOption.
Definition: opt.h:234
Views are alternated temporally.
Definition: stereo3d.h:66
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:776
#define AV_CODEC_FLAG_LOOP_FILTER
loop filter.
Definition: avcodec.h:759
float qblur
amount of qscale smoothing over time (0.0-1.0)
Definition: avcodec.h:2323
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:64
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:130
memory handling functions
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1145
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:1679
int noise_reduction
Definition: libx264.c:85
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2426
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2127
int num
numerator
Definition: rational.h:44
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
enhanced predictive zonal search
Definition: avcodec.h:670
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:1804
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1621
int bluray_compat
Definition: libx264.c:64
static void X264_log(void *p, int level, const char *fmt, va_list args)
Definition: libx264.c:90
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:905
AVCodec.
Definition: avcodec.h:3120
static av_cold int X264_init(AVCodecContext *avctx)
Definition: libx264.c:369
attribute_deprecated int me_method
This option does nothing.
Definition: avcodec.h:1628
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1535
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:202
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:501
x264_param_t params
Definition: libx264.c:43
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:39
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:863
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
uint8_t
#define av_cold
Definition: attributes.h:66
AVOptions.
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:123
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:1913
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:1688
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:211
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1523
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1811
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:38
uint8_t * data
Definition: avcodec.h:1346
int b_pyramid
Definition: libx264.c:66
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:72
x264_picture_t pic
Definition: libx264.c:45
float cplxblur
Definition: libx264.c:73
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1161
#define FF_CMP_CHROMA
Definition: avcodec.h:1843
char * stats
Definition: libx264.c:77
int intra_refresh
Definition: libx264.c:63
#define AV_PIX_FMT_NV20
Definition: pixfmt.h:287
int rc_lookahead
Definition: libx264.c:59
hexagon based search
Definition: avcodec.h:672
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1378
static enum AVPixelFormat pix_fmts_10bit[]
Definition: libx264.c:697
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1715
int flags
Additional information about the frame packing.
Definition: stereo3d.h:132
#define AVERROR(e)
Definition: error.h:43
int qmax
maximum quantizer
Definition: avcodec.h:2337
char * profile
Definition: libx264.c:50
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
int coder
Definition: libx264.c:81
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
int fastfirstpass
Definition: libx264.c:51
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:175
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1503
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:86
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2387
int mbtree
Definition: libx264.c:71
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
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:1730
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:265
char * deblock
Definition: libx264.c:72
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:35
transformed exhaustive search algorithm
Definition: avcodec.h:674
int b_frame_strategy
Definition: libx264.c:82
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1352
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:63
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2364
common internal API header
char * psy_rd
Definition: libx264.c:57
as above, but U and V bytes are swapped
Definition: pixfmt.h:87
int refs
number of reference frames
Definition: avcodec.h:2071
int motion_est
Definition: libx264.c:79
static enum AVPixelFormat pix_fmts_9bit[]
Definition: libx264.c:692
#define PARSE_X264_OPT(name, var)
Definition: libx264.c:363
int bit_rate
the average bitrate
Definition: avcodec.h:1473
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3141
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:201
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:71
int width
picture width / height.
Definition: avcodec.h:1580
int cqp
Definition: libx264.c:54
attribute_deprecated int noise_reduction
Definition: avcodec.h:1979
x264_t * enc
Definition: libx264.c:44
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:767
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:114
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:751
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2106
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2818
int level
level
Definition: avcodec.h:2970
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:239
int scenechange_threshold
Definition: libx264.c:84
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1211
int slice_max_size
Definition: libx264.c:76
int nal_hrd
Definition: libx264.c:78
static const AVCodecDefault defaults[]
Definition: libkvazaar.c:278
int max_qdiff
maximum quantizer difference between frames
Definition: avcodec.h:2344
enum AVPixelFormat pix_fmt
Definition: movenc.c:853
int weightp
Definition: libx264.c:60
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:262
attribute_deprecated int coder_type
Definition: avcodec.h:2440
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:198
LIBAVUTIL_VERSION_INT
Definition: eval.c:55
char * x264_params
Definition: libx264.c:87
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2806
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:365
static enum AVPixelFormat pix_fmts_8bit[]
Definition: libx264.c:678
static const AVCodecDefault x264_defaults[]
Definition: libx264.c:787
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add to a dictionary.
Definition: dict.c:152
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1140
NULL
Definition: eval.c:55
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:127
#define AV_LOG_INFO
Standard information.
Definition: log.h:135
Libavcodec external API header.
static av_cold int X264_close(AVCodecContext *avctx)
Definition: libx264.c:324
attribute_deprecated int scenechange_threshold
Definition: avcodec.h:1975
enum AVCodecID codec_id
Definition: avcodec.h:1426
int forced_idr
Definition: libx264.c:80
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:158
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1699
av_default_item_name
Definition: dnxhdenc.c:55
main external API structure.
Definition: avcodec.h:1409
static const AVOption options[]
Definition: libx264.c:717
int qmin
minimum quantizer
Definition: avcodec.h:2330
uint8_t * data
Definition: frame.h:109
#define FF_CODER_TYPE_AC
Definition: avcodec.h:2430
int extradata_size
Definition: avcodec.h:1524
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:263
float crf
Definition: libx264.c:52
int aq_mode
Definition: libx264.c:55
int aud
Definition: libx264.c:70
#define AV_STRINGIFY(s)
Definition: macros.h:36
Describe the class of an AVClass context structure.
Definition: log.h:34
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2120
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2113
uint8_t * sei
Definition: libx264.c:46
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:195
int psy
Definition: libx264.c:58
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:260
attribute_deprecated int chromaoffset
Definition: avcodec.h:2076
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2322
int sei_size
Definition: libx264.c:47
static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame)
Definition: libx264.c:139
char * preset
Definition: libx264.c:48
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:257
Views are on top of each other.
Definition: stereo3d.h:55
This side data contains an integer value representing the quality factor of the compressed frame...
Definition: avcodec.h:1273
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:264
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
uint8_t level
Definition: svq3.c:204
int b_bias
Definition: libx264.c:65
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:784
int fast_pskip
Definition: libx264.c:69
Views are next to each other.
Definition: stereo3d.h:45
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1606
int chroma_offset
Definition: libx264.c:83
static av_cold void X264_init_static(AVCodec *codec)
Definition: libx264.c:705
int mixed_refs
Definition: libx264.c:67
char * tune
Definition: libx264.c:49
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:59
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:77
#define VE
Definition: libx264.c:716
int weightb
Definition: libx264.c:61
float aq_strength
Definition: libx264.c:56
common internal api header.
Bi-dir predicted.
Definition: avutil.h:262
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:73
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2797
char * key
Definition: dict.h:73
int den
denominator
Definition: rational.h:45
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:61
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:192
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
int trellis
trellis RD quantization
Definition: avcodec.h:2486
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2754
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:638
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:755
int slices
Number of slices.
Definition: avcodec.h:2143
void * priv_data
Definition: avcodec.h:1451
char * value
Definition: dict.h:74
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:78
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:268
uneven multi-hexagon search
Definition: avcodec.h:673
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:76
Views are packed per column.
Definition: stereo3d.h:107
int ssim
Definition: libx264.c:62
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:214
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1345
float crf_max
Definition: libx264.c:53
#define OFFSET(x)
Definition: libx264.c:715
int direct_pred
Definition: libx264.c:75
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:60
static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libx264.c:236
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:798
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:263
Stereoscopic 3d metadata.
Definition: frame.h:62
AVPixelFormat
Pixel format.
Definition: pixfmt.h:57
This structure stores compressed data.
Definition: avcodec.h:1323
int me_subpel_quality
subpel ME quality
Definition: avcodec.h:1884
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:211
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1339
Predicted.
Definition: avutil.h:261
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:2816
int keyint_min
minimum GOP size
Definition: avcodec.h:2064
static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, x264_nal_t *nals, int nnal)
Definition: libx264.c:106