FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
libx264.c
Go to the documentation of this file.
1 /*
2  * H.264 encoding using the x264 library
3  * Copyright (C) 2005 Mans Rullgard <mans@mansr.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/eval.h"
23 #include "libavutil/internal.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/stereo3d.h"
28 #include "avcodec.h"
29 #include "internal.h"
30 
31 #if defined(_MSC_VER)
32 #define X264_API_IMPORTS 1
33 #endif
34 
35 #include <x264.h>
36 #include <float.h>
37 #include <math.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 
42 typedef struct X264Context {
43  AVClass *class;
44  x264_param_t params;
45  x264_t *enc;
46  x264_picture_t pic;
47  uint8_t *sei;
48  int sei_size;
49  char *preset;
50  char *tune;
51  char *profile;
52  char *level;
53  int fastfirstpass;
54  char *wpredp;
55  char *x264opts;
56  float crf;
57  float crf_max;
58  int cqp;
59  int aq_mode;
60  float aq_strength;
61  char *psy_rd;
62  int psy;
63  int rc_lookahead;
64  int weightp;
65  int weightb;
66  int ssim;
67  int intra_refresh;
68  int bluray_compat;
69  int b_bias;
70  int b_pyramid;
71  int mixed_refs;
72  int dct8x8;
73  int fast_pskip;
74  int aud;
75  int mbtree;
76  char *deblock;
77  float cplxblur;
78  char *partitions;
79  int direct_pred;
80  int slice_max_size;
81  char *stats;
82  int nal_hrd;
83  int avcintra_class;
84  char *x264_params;
85 } X264Context;
86 
87 static void X264_log(void *p, int level, const char *fmt, va_list args)
88 {
89  static const int level_map[] = {
90  [X264_LOG_ERROR] = AV_LOG_ERROR,
91  [X264_LOG_WARNING] = AV_LOG_WARNING,
92  [X264_LOG_INFO] = AV_LOG_INFO,
93  [X264_LOG_DEBUG] = AV_LOG_DEBUG
94  };
95 
96  if (level < 0 || level > X264_LOG_DEBUG)
97  return;
98 
99  av_vlog(p, level_map[level], fmt, args);
100 }
101 
102 
103 static int encode_nals(AVCodecContext *ctx, AVPacket *pkt,
104  const x264_nal_t *nals, int nnal)
105 {
106  X264Context *x4 = ctx->priv_data;
107  uint8_t *p;
108  int i, size = x4->sei_size, ret;
109 
110  if (!nnal)
111  return 0;
112 
113  for (i = 0; i < nnal; i++)
114  size += nals[i].i_payload;
115 
116  if ((ret = ff_alloc_packet2(ctx, pkt, size)) < 0)
117  return ret;
118 
119  p = pkt->data;
120 
121  /* Write the SEI as part of the first frame. */
122  if (x4->sei_size > 0 && nnal > 0) {
123  if (x4->sei_size > size) {
124  av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n");
125  return -1;
126  }
127  memcpy(p, x4->sei, x4->sei_size);
128  p += x4->sei_size;
129  x4->sei_size = 0;
130  av_freep(&x4->sei);
131  }
132 
133  for (i = 0; i < nnal; i++){
134  memcpy(p, nals[i].p_payload, nals[i].i_payload);
135  p += nals[i].i_payload;
136  }
137 
138  return 1;
139 }
140 
141 static int avfmt2_num_planes(int avfmt)
142 {
143  switch (avfmt) {
144  case AV_PIX_FMT_YUV420P:
145  case AV_PIX_FMT_YUVJ420P:
146  case AV_PIX_FMT_YUV420P9:
147  case AV_PIX_FMT_YUV420P10:
148  case AV_PIX_FMT_YUV444P:
149  return 3;
150 
151  case AV_PIX_FMT_BGR24:
152  case AV_PIX_FMT_RGB24:
153  return 1;
154 
155  default:
156  return 3;
157  }
158 }
159 
160 static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
161  int *got_packet)
162 {
163  X264Context *x4 = ctx->priv_data;
164  x264_nal_t *nal;
165  int nnal, i, ret;
166  x264_picture_t pic_out = {0};
167  AVFrameSideData *side_data;
168 
169  x264_picture_init( &x4->pic );
170  x4->pic.img.i_csp = x4->params.i_csp;
171  if (x264_bit_depth > 8)
172  x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
173  x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
174 
175  if (frame) {
176  for (i = 0; i < x4->pic.img.i_plane; i++) {
177  x4->pic.img.plane[i] = frame->data[i];
178  x4->pic.img.i_stride[i] = frame->linesize[i];
179  }
180 
181  x4->pic.i_pts = frame->pts;
182  x4->pic.i_type =
183  frame->pict_type == AV_PICTURE_TYPE_I ? X264_TYPE_KEYFRAME :
184  frame->pict_type == AV_PICTURE_TYPE_P ? X264_TYPE_P :
185  frame->pict_type == AV_PICTURE_TYPE_B ? X264_TYPE_B :
186  X264_TYPE_AUTO;
187 
188  if (x4->avcintra_class < 0) {
189  if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) {
190  x4->params.b_tff = frame->top_field_first;
191  x264_encoder_reconfig(x4->enc, &x4->params);
192  }
193  if (x4->params.vui.i_sar_height != ctx->sample_aspect_ratio.den ||
194  x4->params.vui.i_sar_width != ctx->sample_aspect_ratio.num) {
195  x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;
196  x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;
197  x264_encoder_reconfig(x4->enc, &x4->params);
198  }
199 
200  if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 ||
201  x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) {
202  x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000;
203  x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000;
204  x264_encoder_reconfig(x4->enc, &x4->params);
205  }
206 
207  if (x4->params.rc.i_rc_method == X264_RC_ABR &&
208  x4->params.rc.i_bitrate != ctx->bit_rate / 1000) {
209  x4->params.rc.i_bitrate = ctx->bit_rate / 1000;
210  x264_encoder_reconfig(x4->enc, &x4->params);
211  }
212 
213  if (x4->crf >= 0 &&
214  x4->params.rc.i_rc_method == X264_RC_CRF &&
215  x4->params.rc.f_rf_constant != x4->crf) {
216  x4->params.rc.f_rf_constant = x4->crf;
217  x264_encoder_reconfig(x4->enc, &x4->params);
218  }
219 
220  if (x4->params.rc.i_rc_method == X264_RC_CQP &&
221  x4->cqp >= 0 &&
222  x4->params.rc.i_qp_constant != x4->cqp) {
223  x4->params.rc.i_qp_constant = x4->cqp;
224  x264_encoder_reconfig(x4->enc, &x4->params);
225  }
226 
227  if (x4->crf_max >= 0 &&
228  x4->params.rc.f_rf_constant_max != x4->crf_max) {
229  x4->params.rc.f_rf_constant_max = x4->crf_max;
230  x264_encoder_reconfig(x4->enc, &x4->params);
231  }
232  }
233 
234  side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_STEREO3D);
235  if (side_data) {
236  AVStereo3D *stereo = (AVStereo3D *)side_data->data;
237  int fpa_type;
238 
239  switch (stereo->type) {
240  case AV_STEREO3D_CHECKERBOARD:
241  fpa_type = 0;
242  break;
243  case AV_STEREO3D_COLUMNS:
244  fpa_type = 1;
245  break;
246  case AV_STEREO3D_LINES:
247  fpa_type = 2;
248  break;
249  case AV_STEREO3D_SIDEBYSIDE:
250  fpa_type = 3;
251  break;
252  case AV_STEREO3D_TOPBOTTOM:
253  fpa_type = 4;
254  break;
255  case AV_STEREO3D_FRAMESEQUENCE:
256  fpa_type = 5;
257  break;
258  default:
259  fpa_type = -1;
260  break;
261  }
262 
263  if (fpa_type != x4->params.i_frame_packing) {
264  x4->params.i_frame_packing = fpa_type;
265  x264_encoder_reconfig(x4->enc, &x4->params);
266  }
267  }
268  }
269  do {
270  if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0)
271  return -1;
272 
273  ret = encode_nals(ctx, pkt, nal, nnal);
274  if (ret < 0)
275  return -1;
276  } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc));
277 
278  pkt->pts = pic_out.i_pts;
279  pkt->dts = pic_out.i_dts;
280 
281  switch (pic_out.i_type) {
282  case X264_TYPE_IDR:
283  case X264_TYPE_I:
284  ctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
285  break;
286  case X264_TYPE_P:
287  ctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
288  break;
289  case X264_TYPE_B:
290  case X264_TYPE_BREF:
291  ctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
292  break;
293  }
294 
295  pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe;
296  if (ret)
297  ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
298 
299  *got_packet = ret;
300  return 0;
301 }
302 
303 static av_cold int X264_close(AVCodecContext *avctx)
304 {
305  X264Context *x4 = avctx->priv_data;
306 
307  av_freep(&avctx->extradata);
308  av_freep(&x4->sei);
309 
310  if (x4->enc)
311  x264_encoder_close(x4->enc);
312 
313  av_frame_free(&avctx->coded_frame);
314 
315  return 0;
316 }
317 
318 #define OPT_STR(opt, param) \
319  do { \
320  int ret; \
321  if (param && (ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
322  if(ret == X264_PARAM_BAD_NAME) \
323  av_log(avctx, AV_LOG_ERROR, \
324  "bad option '%s': '%s'\n", opt, param); \
325  else \
326  av_log(avctx, AV_LOG_ERROR, \
327  "bad value for '%s': '%s'\n", opt, param); \
328  return -1; \
329  } \
330  } while (0)
331 
332 static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
333 {
334  switch (pix_fmt) {
335  case AV_PIX_FMT_YUV420P:
336  case AV_PIX_FMT_YUVJ420P:
337  case AV_PIX_FMT_YUV420P9:
338  case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
339  case AV_PIX_FMT_YUV422P:
340  case AV_PIX_FMT_YUVJ422P:
341  case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
342  case AV_PIX_FMT_YUV444P:
343  case AV_PIX_FMT_YUVJ444P:
344  case AV_PIX_FMT_YUV444P9:
345  case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
346 #ifdef X264_CSP_BGR
347  case AV_PIX_FMT_BGR24:
348  return X264_CSP_BGR;
349 
350  case AV_PIX_FMT_RGB24:
351  return X264_CSP_RGB;
352 #endif
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  };
357  return 0;
358 }
359 
360 #define PARSE_X264_OPT(name, var)\
361  if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
362  av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
363  return AVERROR(EINVAL);\
364  }
365 
366 static av_cold int X264_init(AVCodecContext *avctx)
367 {
368  X264Context *x4 = avctx->priv_data;
369  int sw,sh;
370 
371  if (avctx->global_quality > 0)
372  av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n");
373 
374  x264_param_default(&x4->params);
375 
376  x4->params.b_deblocking_filter = avctx->flags & CODEC_FLAG_LOOP_FILTER;
377 
378  if (x4->preset || x4->tune)
379  if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
380  int i;
381  av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
382  av_log(avctx, AV_LOG_INFO, "Possible presets:");
383  for (i = 0; x264_preset_names[i]; i++)
384  av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]);
385  av_log(avctx, AV_LOG_INFO, "\n");
386  av_log(avctx, AV_LOG_INFO, "Possible tunes:");
387  for (i = 0; x264_tune_names[i]; i++)
388  av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]);
389  av_log(avctx, AV_LOG_INFO, "\n");
390  return AVERROR(EINVAL);
391  }
392 
393  if (avctx->level > 0)
394  x4->params.i_level_idc = avctx->level;
395 
396  x4->params.pf_log = X264_log;
397  x4->params.p_log_private = avctx;
398  x4->params.i_log_level = X264_LOG_DEBUG;
399  x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt);
400 
401  OPT_STR("weightp", x4->wpredp);
402 
403  if (avctx->bit_rate) {
404  x4->params.rc.i_bitrate = avctx->bit_rate / 1000;
405  x4->params.rc.i_rc_method = X264_RC_ABR;
406  }
407  x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
408  x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000;
409  x4->params.rc.b_stat_write = avctx->flags & CODEC_FLAG_PASS1;
410  if (avctx->flags & CODEC_FLAG_PASS2) {
411  x4->params.rc.b_stat_read = 1;
412  } else {
413  if (x4->crf >= 0) {
414  x4->params.rc.i_rc_method = X264_RC_CRF;
415  x4->params.rc.f_rf_constant = x4->crf;
416  } else if (x4->cqp >= 0) {
417  x4->params.rc.i_rc_method = X264_RC_CQP;
418  x4->params.rc.i_qp_constant = x4->cqp;
419  }
420 
421  if (x4->crf_max >= 0)
422  x4->params.rc.f_rf_constant_max = x4->crf_max;
423  }
424 
425  if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 &&
426  (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
427  x4->params.rc.f_vbv_buffer_init =
428  (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
429  }
430 
431  OPT_STR("level", x4->level);
432 
433  if (avctx->i_quant_factor > 0)
434  x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor);
435  if (avctx->b_quant_factor > 0)
436  x4->params.rc.f_pb_factor = avctx->b_quant_factor;
437  if (avctx->chromaoffset)
438  x4->params.analyse.i_chroma_qp_offset = avctx->chromaoffset;
439 
440  if (avctx->me_method == ME_EPZS)
441  x4->params.analyse.i_me_method = X264_ME_DIA;
442  else if (avctx->me_method == ME_HEX)
443  x4->params.analyse.i_me_method = X264_ME_HEX;
444  else if (avctx->me_method == ME_UMH)
445  x4->params.analyse.i_me_method = X264_ME_UMH;
446  else if (avctx->me_method == ME_FULL)
447  x4->params.analyse.i_me_method = X264_ME_ESA;
448  else if (avctx->me_method == ME_TESA)
449  x4->params.analyse.i_me_method = X264_ME_TESA;
450 
451  if (avctx->gop_size >= 0)
452  x4->params.i_keyint_max = avctx->gop_size;
453  if (avctx->max_b_frames >= 0)
454  x4->params.i_bframe = avctx->max_b_frames;
455  if (avctx->scenechange_threshold >= 0)
456  x4->params.i_scenecut_threshold = avctx->scenechange_threshold;
457  if (avctx->qmin >= 0)
458  x4->params.rc.i_qp_min = avctx->qmin;
459  if (avctx->qmax >= 0)
460  x4->params.rc.i_qp_max = avctx->qmax;
461  if (avctx->max_qdiff >= 0)
462  x4->params.rc.i_qp_step = avctx->max_qdiff;
463  if (avctx->qblur >= 0)
464  x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */
465  if (avctx->qcompress >= 0)
466  x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
467  if (avctx->refs >= 0)
468  x4->params.i_frame_reference = avctx->refs;
469  else if (x4->level) {
470  int i;
471  int mbn = FF_CEIL_RSHIFT(avctx->width, 4) * FF_CEIL_RSHIFT(avctx->height, 4);
472  int level_id = -1;
473  char *tail;
474  int scale = X264_BUILD < 129 ? 384 : 1;
475 
476  if (!strcmp(x4->level, "1b")) {
477  level_id = 9;
478  } else if (strlen(x4->level) <= 3){
479  level_id = av_strtod(x4->level, &tail) * 10 + 0.5;
480  if (*tail)
481  level_id = -1;
482  }
483  if (level_id <= 0)
484  av_log(avctx, AV_LOG_WARNING, "Failed to parse level\n");
485 
486  for (i = 0; i<x264_levels[i].level_idc; i++)
487  if (x264_levels[i].level_idc == level_id)
488  x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference);
489  }
490 
491  if (avctx->trellis >= 0)
492  x4->params.analyse.i_trellis = avctx->trellis;
493  if (avctx->me_range >= 0)
494  x4->params.analyse.i_me_range = avctx->me_range;
495  if (avctx->noise_reduction >= 0)
496  x4->params.analyse.i_noise_reduction = avctx->noise_reduction;
497  if (avctx->me_subpel_quality >= 0)
498  x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality;
499  if (avctx->b_frame_strategy >= 0)
500  x4->params.i_bframe_adaptive = avctx->b_frame_strategy;
501  if (avctx->keyint_min >= 0)
502  x4->params.i_keyint_min = avctx->keyint_min;
503  if (avctx->coder_type >= 0)
504  x4->params.b_cabac = avctx->coder_type == FF_CODER_TYPE_AC;
505  if (avctx->me_cmp >= 0)
506  x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
507 
508  if (x4->aq_mode >= 0)
509  x4->params.rc.i_aq_mode = x4->aq_mode;
510  if (x4->aq_strength >= 0)
511  x4->params.rc.f_aq_strength = x4->aq_strength;
512  PARSE_X264_OPT("psy-rd", psy_rd);
513  PARSE_X264_OPT("deblock", deblock);
514  PARSE_X264_OPT("partitions", partitions);
515  PARSE_X264_OPT("stats", stats);
516  if (x4->psy >= 0)
517  x4->params.analyse.b_psy = x4->psy;
518  if (x4->rc_lookahead >= 0)
519  x4->params.rc.i_lookahead = x4->rc_lookahead;
520  if (x4->weightp >= 0)
521  x4->params.analyse.i_weighted_pred = x4->weightp;
522  if (x4->weightb >= 0)
523  x4->params.analyse.b_weighted_bipred = x4->weightb;
524  if (x4->cplxblur >= 0)
525  x4->params.rc.f_complexity_blur = x4->cplxblur;
526 
527  if (x4->ssim >= 0)
528  x4->params.analyse.b_ssim = x4->ssim;
529  if (x4->intra_refresh >= 0)
530  x4->params.b_intra_refresh = x4->intra_refresh;
531  if (x4->bluray_compat >= 0) {
532  x4->params.b_bluray_compat = x4->bluray_compat;
533  x4->params.b_vfr_input = 0;
534  }
535  if (x4->avcintra_class >= 0)
536 #if X264_BUILD >= 142
537  x4->params.i_avcintra_class = x4->avcintra_class;
538 #else
539  av_log(avctx, AV_LOG_ERROR,
540  "x264 too old for AVC Intra, at least version 142 needed\n");
541 #endif
542  if (x4->b_bias != INT_MIN)
543  x4->params.i_bframe_bias = x4->b_bias;
544  if (x4->b_pyramid >= 0)
545  x4->params.i_bframe_pyramid = x4->b_pyramid;
546  if (x4->mixed_refs >= 0)
547  x4->params.analyse.b_mixed_references = x4->mixed_refs;
548  if (x4->dct8x8 >= 0)
549  x4->params.analyse.b_transform_8x8 = x4->dct8x8;
550  if (x4->fast_pskip >= 0)
551  x4->params.analyse.b_fast_pskip = x4->fast_pskip;
552  if (x4->aud >= 0)
553  x4->params.b_aud = x4->aud;
554  if (x4->mbtree >= 0)
555  x4->params.rc.b_mb_tree = x4->mbtree;
556  if (x4->direct_pred >= 0)
557  x4->params.analyse.i_direct_mv_pred = x4->direct_pred;
558 
559  if (x4->slice_max_size >= 0)
560  x4->params.i_slice_max_size = x4->slice_max_size;
561  else {
562  /*
563  * Allow x264 to be instructed through AVCodecContext about the maximum
564  * size of the RTP payload. For example, this enables the production of
565  * payload suitable for the H.264 RTP packetization-mode 0 i.e. single
566  * NAL unit per RTP packet.
567  */
568  if (avctx->rtp_payload_size)
569  x4->params.i_slice_max_size = avctx->rtp_payload_size;
570  }
571 
572  if (x4->fastfirstpass)
573  x264_param_apply_fastfirstpass(&x4->params);
574 
575  /* Allow specifying the x264 profile through AVCodecContext. */
576  if (!x4->profile)
577  switch (avctx->profile) {
578  case FF_PROFILE_H264_BASELINE:
579  x4->profile = av_strdup("baseline");
580  break;
581  case FF_PROFILE_H264_HIGH:
582  x4->profile = av_strdup("high");
583  break;
584  case FF_PROFILE_H264_HIGH_10:
585  x4->profile = av_strdup("high10");
586  break;
587  case FF_PROFILE_H264_HIGH_422:
588  x4->profile = av_strdup("high422");
589  break;
590  case FF_PROFILE_H264_HIGH_444:
591  x4->profile = av_strdup("high444");
592  break;
593  case FF_PROFILE_H264_MAIN:
594  x4->profile = av_strdup("main");
595  break;
596  default:
597  break;
598  }
599 
600  if (x4->nal_hrd >= 0)
601  x4->params.i_nal_hrd = x4->nal_hrd;
602 
603  if (x4->profile)
604  if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
605  int i;
606  av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
607  av_log(avctx, AV_LOG_INFO, "Possible profiles:");
608  for (i = 0; x264_profile_names[i]; i++)
609  av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]);
610  av_log(avctx, AV_LOG_INFO, "\n");
611  return AVERROR(EINVAL);
612  }
613 
614  x4->params.i_width = avctx->width;
615  x4->params.i_height = avctx->height;
616  av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
617  x4->params.vui.i_sar_width = sw;
618  x4->params.vui.i_sar_height = sh;
619  x4->params.i_timebase_den = avctx->time_base.den;
620  x4->params.i_timebase_num = avctx->time_base.num;
621  x4->params.i_fps_num = avctx->time_base.den;
622  x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame;
623 
624  x4->params.analyse.b_psnr = avctx->flags & CODEC_FLAG_PSNR;
625 
626  x4->params.i_threads = avctx->thread_count;
627  if (avctx->thread_type)
628  x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE;
629 
630  x4->params.b_interlaced = avctx->flags & CODEC_FLAG_INTERLACED_DCT;
631 
632  x4->params.b_open_gop = !(avctx->flags & CODEC_FLAG_CLOSED_GOP);
633 
634  x4->params.i_slice_count = avctx->slices;
635 
636  x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
637  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
638  avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
639  avctx->color_range == AVCOL_RANGE_JPEG;
640 
641  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
642  x4->params.vui.i_colmatrix = avctx->colorspace;
643  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
644  x4->params.vui.i_colorprim = avctx->color_primaries;
645  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
646  x4->params.vui.i_transfer = avctx->color_trc;
647 
648  if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER)
649  x4->params.b_repeat_headers = 0;
650 
651  if(x4->x264opts){
652  const char *p= x4->x264opts;
653  while(p){
654  char param[256]={0}, val[256]={0};
655  if(sscanf(p, "%255[^:=]=%255[^:]", param, val) == 1){
656  OPT_STR(param, "1");
657  }else
658  OPT_STR(param, val);
659  p= strchr(p, ':');
660  p+=!!p;
661  }
662  }
663 
664  if (x4->x264_params) {
665  AVDictionary *dict = NULL;
666  AVDictionaryEntry *en = NULL;
667 
668  if (!av_dict_parse_string(&dict, x4->x264_params, "=", ":", 0)) {
669  while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) {
670  if (x264_param_parse(&x4->params, en->key, en->value) < 0)
671  av_log(avctx, AV_LOG_WARNING,
672  "Error parsing option '%s = %s'.\n",
673  en->key, en->value);
674  }
675 
676  av_dict_free(&dict);
677  }
678  }
679 
680  // update AVCodecContext with x264 parameters
681  avctx->has_b_frames = x4->params.i_bframe ?
682  x4->params.i_bframe_pyramid ? 2 : 1 : 0;
683  if (avctx->max_b_frames < 0)
684  avctx->max_b_frames = 0;
685 
686  avctx->bit_rate = x4->params.rc.i_bitrate*1000;
687 
688  x4->enc = x264_encoder_open(&x4->params);
689  if (!x4->enc)
690  return -1;
691 
692  avctx->coded_frame = av_frame_alloc();
693  if (!avctx->coded_frame)
694  return AVERROR(ENOMEM);
695 
696  if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
697  x264_nal_t *nal;
698  uint8_t *p;
699  int nnal, s, i;
700 
701  s = x264_encoder_headers(x4->enc, &nal, &nnal);
702  avctx->extradata = p = av_malloc(s);
703 
704  for (i = 0; i < nnal; i++) {
705  /* Don't put the SEI in extradata. */
706  if (nal[i].i_type == NAL_SEI) {
707  av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25);
708  x4->sei_size = nal[i].i_payload;
709  x4->sei = av_malloc(x4->sei_size);
710  memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload);
711  continue;
712  }
713  memcpy(p, nal[i].p_payload, nal[i].i_payload);
714  p += nal[i].i_payload;
715  }
716  avctx->extradata_size = p - avctx->extradata;
717  }
718 
719  return 0;
720 }
721 
722 static const enum AVPixelFormat pix_fmts_8bit[] = {
723  AV_PIX_FMT_YUV420P,
724  AV_PIX_FMT_YUVJ420P,
725  AV_PIX_FMT_YUV422P,
726  AV_PIX_FMT_YUVJ422P,
727  AV_PIX_FMT_YUV444P,
728  AV_PIX_FMT_YUVJ444P,
729  AV_PIX_FMT_NV12,
730  AV_PIX_FMT_NV16,
731  AV_PIX_FMT_NONE
732 };
733 static const enum AVPixelFormat pix_fmts_9bit[] = {
734  AV_PIX_FMT_YUV420P9,
735  AV_PIX_FMT_YUV444P9,
736  AV_PIX_FMT_NONE
737 };
738 static const enum AVPixelFormat pix_fmts_10bit[] = {
739  AV_PIX_FMT_YUV420P10,
740  AV_PIX_FMT_YUV422P10,
741  AV_PIX_FMT_YUV444P10,
742  AV_PIX_FMT_NV20,
743  AV_PIX_FMT_NONE
744 };
745 static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
746 #ifdef X264_CSP_BGR
747  AV_PIX_FMT_BGR24,
748  AV_PIX_FMT_RGB24,
749 #endif
750  AV_PIX_FMT_NONE
751 };
752 
753 static av_cold void X264_init_static(AVCodec *codec)
754 {
755  if (x264_bit_depth == 8)
756  codec->pix_fmts = pix_fmts_8bit;
757  else if (x264_bit_depth == 9)
758  codec->pix_fmts = pix_fmts_9bit;
759  else if (x264_bit_depth == 10)
760  codec->pix_fmts = pix_fmts_10bit;
761 }
762 
763 #define OFFSET(x) offsetof(X264Context, x)
764 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
765 static const AVOption options[] = {
766  { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
767  { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
768  { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
769  { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE},
770  {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
771  {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
772  {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
773  {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
774  { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE },
775  { "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 },
776  { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
777  { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"},
778  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" },
779  { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
780  { "autovariance", "Auto-variance AQ (experimental)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
781  { "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},
782  { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
783  { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE},
784  { "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 },
785  { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
786  { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" },
787  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" },
788  { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
789  { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" },
790  { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
791  { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
792  { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
793  { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE },
794  { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" },
795  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" },
796  { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
797  { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
798  { "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 },
799  { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
800  { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
801  { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
802  { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE},
803  { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
804  { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE},
805  { "partitions", "A comma-separated list of partitions to consider. "
806  "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
807  { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" },
808  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" },
809  { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" },
810  { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
811  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" },
812  { "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 },
813  { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
814  { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
815  "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" },
816  { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" },
817  { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
818  { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" },
819  { "avcintra-class","AVC-Intra class 50/100/200", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE},
820  { "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 },
821  { NULL },
822 };
823 
824 static const AVClass x264_class = {
825  .class_name = "libx264",
826  .item_name = av_default_item_name,
827  .option = options,
828  .version = LIBAVUTIL_VERSION_INT,
829 };
830 
831 static const AVClass rgbclass = {
832  .class_name = "libx264rgb",
833  .item_name = av_default_item_name,
834  .option = options,
835  .version = LIBAVUTIL_VERSION_INT,
836 };
837 
838 static const AVCodecDefault x264_defaults[] = {
839  { "b", "0" },
840  { "bf", "-1" },
841  { "flags2", "0" },
842  { "g", "-1" },
843  { "i_qfactor", "-1" },
844  { "b_qfactor", "-1" },
845  { "qmin", "-1" },
846  { "qmax", "-1" },
847  { "qdiff", "-1" },
848  { "qblur", "-1" },
849  { "qcomp", "-1" },
850 // { "rc_lookahead", "-1" },
851  { "refs", "-1" },
852  { "sc_threshold", "-1" },
853  { "trellis", "-1" },
854  { "nr", "-1" },
855  { "me_range", "-1" },
856  { "me_method", "-1" },
857  { "subq", "-1" },
858  { "b_strategy", "-1" },
859  { "keyint_min", "-1" },
860  { "coder", "-1" },
861  { "cmp", "-1" },
862  { "threads", AV_STRINGIFY(X264_THREADS_AUTO) },
863  { "thread_type", "0" },
864  { "flags", "+cgop" },
865  { "rc_init_occupancy","-1" },
866  { NULL },
867 };
868 
869 AVCodec ff_libx264_encoder = {
870  .name = "libx264",
871  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
872  .type = AVMEDIA_TYPE_VIDEO,
873  .id = AV_CODEC_ID_H264,
874  .priv_data_size = sizeof(X264Context),
875  .init = X264_init,
876  .encode2 = X264_frame,
877  .close = X264_close,
878  .capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
879  .priv_class = &x264_class,
880  .defaults = x264_defaults,
881  .init_static_data = X264_init_static,
882 };
883 
884 AVCodec ff_libx264rgb_encoder = {
885  .name = "libx264rgb",
886  .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
887  .type = AVMEDIA_TYPE_VIDEO,
888  .id = AV_CODEC_ID_H264,
889  .priv_data_size = sizeof(X264Context),
890  .init = X264_init,
891  .encode2 = X264_frame,
892  .close = X264_close,
893  .capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
894  .priv_class = &rgbclass,
895  .defaults = x264_defaults,
896  .pix_fmts = pix_fmts_8bit_rgb,
897 };
Generated on Wed Jan 28 2015 19:21:12 for FFmpeg by   doxygen 1.8.2