2 * H.264 encoding using the x264 library
3 * Copyright (C) 2005 Mans Rullgard <mans@mansr.com>
5 * This file is part of Libav.
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.
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.
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
22 #include "libavutil/internal.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/pixdesc.h"
35 typedef struct X264Context
{
76 static void X264_log(void *p
, int level
, const char *fmt
, va_list args
)
78 static const int level_map
[] = {
79 [X264_LOG_ERROR
] = AV_LOG_ERROR
,
80 [X264_LOG_WARNING
] = AV_LOG_WARNING
,
81 [X264_LOG_INFO
] = AV_LOG_INFO
,
82 [X264_LOG_DEBUG
] = AV_LOG_DEBUG
85 if (level
< 0 || level
> X264_LOG_DEBUG
)
88 av_vlog(p
, level_map
[level
], fmt
, args
);
92 static int encode_nals(AVCodecContext
*ctx
, AVPacket
*pkt
,
93 x264_nal_t
*nals
, int nnal
)
95 X264Context
*x4
= ctx
->priv_data
;
97 int i
, size
= x4
->sei_size
, ret
;
102 for (i
= 0; i
< nnal
; i
++)
103 size
+= nals
[i
].i_payload
;
105 if ((ret
= ff_alloc_packet(pkt
, size
)) < 0)
110 /* Write the SEI as part of the first frame. */
111 if (x4
->sei_size
> 0 && nnal
> 0) {
112 memcpy(p
, x4
->sei
, x4
->sei_size
);
117 for (i
= 0; i
< nnal
; i
++){
118 memcpy(p
, nals
[i
].p_payload
, nals
[i
].i_payload
);
119 p
+= nals
[i
].i_payload
;
125 static int X264_frame(AVCodecContext
*ctx
, AVPacket
*pkt
, const AVFrame
*frame
,
128 X264Context
*x4
= ctx
->priv_data
;
131 x264_picture_t pic_out
;
133 x264_picture_init( &x4
->pic
);
134 x4
->pic
.img
.i_csp
= x4
->params
.i_csp
;
135 if (x264_bit_depth
> 8)
136 x4
->pic
.img
.i_csp
|= X264_CSP_HIGH_DEPTH
;
137 x4
->pic
.img
.i_plane
= 3;
140 for (i
= 0; i
< 3; i
++) {
141 x4
->pic
.img
.plane
[i
] = frame
->data
[i
];
142 x4
->pic
.img
.i_stride
[i
] = frame
->linesize
[i
];
145 x4
->pic
.i_pts
= frame
->pts
;
147 frame
->pict_type
== AV_PICTURE_TYPE_I
? X264_TYPE_KEYFRAME
:
148 frame
->pict_type
== AV_PICTURE_TYPE_P
? X264_TYPE_P
:
149 frame
->pict_type
== AV_PICTURE_TYPE_B
? X264_TYPE_B
:
151 if (x4
->params
.b_tff
!= frame
->top_field_first
) {
152 x4
->params
.b_tff
= frame
->top_field_first
;
153 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
155 if (x4
->params
.vui
.i_sar_height
!= ctx
->sample_aspect_ratio
.den
||
156 x4
->params
.vui
.i_sar_width
!= ctx
->sample_aspect_ratio
.num
) {
157 x4
->params
.vui
.i_sar_height
= ctx
->sample_aspect_ratio
.den
;
158 x4
->params
.vui
.i_sar_width
= ctx
->sample_aspect_ratio
.num
;
159 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
164 if (x264_encoder_encode(x4
->enc
, &nal
, &nnal
, frame
? &x4
->pic
: NULL
, &pic_out
) < 0)
167 ret
= encode_nals(ctx
, pkt
, nal
, nnal
);
170 } while (!ret
&& !frame
&& x264_encoder_delayed_frames(x4
->enc
));
172 pkt
->pts
= pic_out
.i_pts
;
173 pkt
->dts
= pic_out
.i_dts
;
175 switch (pic_out
.i_type
) {
178 x4
->out_pic
.pict_type
= AV_PICTURE_TYPE_I
;
181 x4
->out_pic
.pict_type
= AV_PICTURE_TYPE_P
;
185 x4
->out_pic
.pict_type
= AV_PICTURE_TYPE_B
;
189 pkt
->flags
|= AV_PKT_FLAG_KEY
*pic_out
.b_keyframe
;
191 x4
->out_pic
.quality
= (pic_out
.i_qpplus1
- 1) * FF_QP2LAMBDA
;
197 static av_cold
int X264_close(AVCodecContext
*avctx
)
199 X264Context
*x4
= avctx
->priv_data
;
201 av_freep(&avctx
->extradata
);
205 x264_encoder_close(x4
->enc
);
210 static int convert_pix_fmt(enum AVPixelFormat pix_fmt
)
213 case AV_PIX_FMT_YUV420P
:
214 case AV_PIX_FMT_YUVJ420P
:
215 case AV_PIX_FMT_YUV420P9
:
216 case AV_PIX_FMT_YUV420P10
: return X264_CSP_I420
;
217 case AV_PIX_FMT_YUV422P
:
218 case AV_PIX_FMT_YUV422P10
: return X264_CSP_I422
;
219 case AV_PIX_FMT_YUV444P
:
220 case AV_PIX_FMT_YUV444P9
:
221 case AV_PIX_FMT_YUV444P10
: return X264_CSP_I444
;
226 #define PARSE_X264_OPT(name, var)\
227 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
228 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
229 return AVERROR(EINVAL);\
232 static av_cold
int X264_init(AVCodecContext
*avctx
)
234 X264Context
*x4
= avctx
->priv_data
;
236 x264_param_default(&x4
->params
);
238 x4
->params
.b_deblocking_filter
= avctx
->flags
& CODEC_FLAG_LOOP_FILTER
;
240 if (x4
->preset
|| x4
->tune
)
241 if (x264_param_default_preset(&x4
->params
, x4
->preset
, x4
->tune
) < 0) {
242 av_log(avctx
, AV_LOG_ERROR
, "Error setting preset/tune %s/%s.\n", x4
->preset
, x4
->tune
);
243 return AVERROR(EINVAL
);
246 if (avctx
->level
> 0)
247 x4
->params
.i_level_idc
= avctx
->level
;
249 x4
->params
.pf_log
= X264_log
;
250 x4
->params
.p_log_private
= avctx
;
251 x4
->params
.i_log_level
= X264_LOG_DEBUG
;
252 x4
->params
.i_csp
= convert_pix_fmt(avctx
->pix_fmt
);
254 if (avctx
->bit_rate
) {
255 x4
->params
.rc
.i_bitrate
= avctx
->bit_rate
/ 1000;
256 x4
->params
.rc
.i_rc_method
= X264_RC_ABR
;
258 x4
->params
.rc
.i_vbv_buffer_size
= avctx
->rc_buffer_size
/ 1000;
259 x4
->params
.rc
.i_vbv_max_bitrate
= avctx
->rc_max_rate
/ 1000;
260 x4
->params
.rc
.b_stat_write
= avctx
->flags
& CODEC_FLAG_PASS1
;
261 if (avctx
->flags
& CODEC_FLAG_PASS2
) {
262 x4
->params
.rc
.b_stat_read
= 1;
265 x4
->params
.rc
.i_rc_method
= X264_RC_CRF
;
266 x4
->params
.rc
.f_rf_constant
= x4
->crf
;
267 } else if (x4
->cqp
>= 0) {
268 x4
->params
.rc
.i_rc_method
= X264_RC_CQP
;
269 x4
->params
.rc
.i_qp_constant
= x4
->cqp
;
272 if (x4
->crf_max
>= 0)
273 x4
->params
.rc
.f_rf_constant_max
= x4
->crf_max
;
276 if (avctx
->rc_buffer_size
&& avctx
->rc_initial_buffer_occupancy
> 0 &&
277 (avctx
->rc_initial_buffer_occupancy
<= avctx
->rc_buffer_size
)) {
278 x4
->params
.rc
.f_vbv_buffer_init
=
279 (float)avctx
->rc_initial_buffer_occupancy
/ avctx
->rc_buffer_size
;
282 x4
->params
.rc
.f_ip_factor
= 1 / fabs(avctx
->i_quant_factor
);
283 x4
->params
.rc
.f_pb_factor
= avctx
->b_quant_factor
;
284 x4
->params
.analyse
.i_chroma_qp_offset
= avctx
->chromaoffset
;
286 if (avctx
->me_method
== ME_EPZS
)
287 x4
->params
.analyse
.i_me_method
= X264_ME_DIA
;
288 else if (avctx
->me_method
== ME_HEX
)
289 x4
->params
.analyse
.i_me_method
= X264_ME_HEX
;
290 else if (avctx
->me_method
== ME_UMH
)
291 x4
->params
.analyse
.i_me_method
= X264_ME_UMH
;
292 else if (avctx
->me_method
== ME_FULL
)
293 x4
->params
.analyse
.i_me_method
= X264_ME_ESA
;
294 else if (avctx
->me_method
== ME_TESA
)
295 x4
->params
.analyse
.i_me_method
= X264_ME_TESA
;
297 if (avctx
->gop_size
>= 0)
298 x4
->params
.i_keyint_max
= avctx
->gop_size
;
299 if (avctx
->max_b_frames
>= 0)
300 x4
->params
.i_bframe
= avctx
->max_b_frames
;
301 if (avctx
->scenechange_threshold
>= 0)
302 x4
->params
.i_scenecut_threshold
= avctx
->scenechange_threshold
;
303 if (avctx
->qmin
>= 0)
304 x4
->params
.rc
.i_qp_min
= avctx
->qmin
;
305 if (avctx
->qmax
>= 0)
306 x4
->params
.rc
.i_qp_max
= avctx
->qmax
;
307 if (avctx
->max_qdiff
>= 0)
308 x4
->params
.rc
.i_qp_step
= avctx
->max_qdiff
;
309 if (avctx
->qblur
>= 0)
310 x4
->params
.rc
.f_qblur
= avctx
->qblur
; /* temporally blur quants */
311 if (avctx
->qcompress
>= 0)
312 x4
->params
.rc
.f_qcompress
= avctx
->qcompress
; /* 0.0 => cbr, 1.0 => constant qp */
313 if (avctx
->refs
>= 0)
314 x4
->params
.i_frame_reference
= avctx
->refs
;
315 if (avctx
->trellis
>= 0)
316 x4
->params
.analyse
.i_trellis
= avctx
->trellis
;
317 if (avctx
->me_range
>= 0)
318 x4
->params
.analyse
.i_me_range
= avctx
->me_range
;
319 if (avctx
->noise_reduction
>= 0)
320 x4
->params
.analyse
.i_noise_reduction
= avctx
->noise_reduction
;
321 if (avctx
->me_subpel_quality
>= 0)
322 x4
->params
.analyse
.i_subpel_refine
= avctx
->me_subpel_quality
;
323 if (avctx
->b_frame_strategy
>= 0)
324 x4
->params
.i_bframe_adaptive
= avctx
->b_frame_strategy
;
325 if (avctx
->keyint_min
>= 0)
326 x4
->params
.i_keyint_min
= avctx
->keyint_min
;
327 if (avctx
->coder_type
>= 0)
328 x4
->params
.b_cabac
= avctx
->coder_type
== FF_CODER_TYPE_AC
;
329 if (avctx
->me_cmp
>= 0)
330 x4
->params
.analyse
.b_chroma_me
= avctx
->me_cmp
& FF_CMP_CHROMA
;
332 if (x4
->aq_mode
>= 0)
333 x4
->params
.rc
.i_aq_mode
= x4
->aq_mode
;
334 if (x4
->aq_strength
>= 0)
335 x4
->params
.rc
.f_aq_strength
= x4
->aq_strength
;
336 PARSE_X264_OPT("psy-rd", psy_rd
);
337 PARSE_X264_OPT("deblock", deblock
);
338 PARSE_X264_OPT("partitions", partitions
);
339 PARSE_X264_OPT("stats", stats
);
341 x4
->params
.analyse
.b_psy
= x4
->psy
;
342 if (x4
->rc_lookahead
>= 0)
343 x4
->params
.rc
.i_lookahead
= x4
->rc_lookahead
;
344 if (x4
->weightp
>= 0)
345 x4
->params
.analyse
.i_weighted_pred
= x4
->weightp
;
346 if (x4
->weightb
>= 0)
347 x4
->params
.analyse
.b_weighted_bipred
= x4
->weightb
;
348 if (x4
->cplxblur
>= 0)
349 x4
->params
.rc
.f_complexity_blur
= x4
->cplxblur
;
352 x4
->params
.analyse
.b_ssim
= x4
->ssim
;
353 if (x4
->intra_refresh
>= 0)
354 x4
->params
.b_intra_refresh
= x4
->intra_refresh
;
355 if (x4
->b_bias
!= INT_MIN
)
356 x4
->params
.i_bframe_bias
= x4
->b_bias
;
357 if (x4
->b_pyramid
>= 0)
358 x4
->params
.i_bframe_pyramid
= x4
->b_pyramid
;
359 if (x4
->mixed_refs
>= 0)
360 x4
->params
.analyse
.b_mixed_references
= x4
->mixed_refs
;
362 x4
->params
.analyse
.b_transform_8x8
= x4
->dct8x8
;
363 if (x4
->fast_pskip
>= 0)
364 x4
->params
.analyse
.b_fast_pskip
= x4
->fast_pskip
;
366 x4
->params
.b_aud
= x4
->aud
;
368 x4
->params
.rc
.b_mb_tree
= x4
->mbtree
;
369 if (x4
->direct_pred
>= 0)
370 x4
->params
.analyse
.i_direct_mv_pred
= x4
->direct_pred
;
372 if (x4
->slice_max_size
>= 0)
373 x4
->params
.i_slice_max_size
= x4
->slice_max_size
;
375 if (x4
->fastfirstpass
)
376 x264_param_apply_fastfirstpass(&x4
->params
);
378 if (x4
->nal_hrd
>= 0)
379 x4
->params
.i_nal_hrd
= x4
->nal_hrd
;
382 if (x264_param_apply_profile(&x4
->params
, x4
->profile
) < 0) {
383 av_log(avctx
, AV_LOG_ERROR
, "Error setting profile %s.\n", x4
->profile
);
384 return AVERROR(EINVAL
);
387 x4
->params
.i_width
= avctx
->width
;
388 x4
->params
.i_height
= avctx
->height
;
389 x4
->params
.vui
.i_sar_width
= avctx
->sample_aspect_ratio
.num
;
390 x4
->params
.vui
.i_sar_height
= avctx
->sample_aspect_ratio
.den
;
391 x4
->params
.i_fps_num
= x4
->params
.i_timebase_den
= avctx
->time_base
.den
;
392 x4
->params
.i_fps_den
= x4
->params
.i_timebase_num
= avctx
->time_base
.num
;
394 x4
->params
.analyse
.b_psnr
= avctx
->flags
& CODEC_FLAG_PSNR
;
396 x4
->params
.i_threads
= avctx
->thread_count
;
397 if (avctx
->thread_type
)
398 x4
->params
.b_sliced_threads
= avctx
->thread_type
== FF_THREAD_SLICE
;
400 x4
->params
.b_interlaced
= avctx
->flags
& CODEC_FLAG_INTERLACED_DCT
;
402 x4
->params
.b_open_gop
= !(avctx
->flags
& CODEC_FLAG_CLOSED_GOP
);
404 x4
->params
.i_slice_count
= avctx
->slices
;
406 x4
->params
.vui
.b_fullrange
= avctx
->pix_fmt
== AV_PIX_FMT_YUVJ420P
;
408 if (avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
)
409 x4
->params
.b_repeat_headers
= 0;
411 if (x4
->x264_params
) {
412 AVDictionary
*dict
= NULL
;
413 AVDictionaryEntry
*en
= NULL
;
415 if (!av_dict_parse_string(&dict
, x4
->x264_params
, "=", ":", 0)) {
416 while ((en
= av_dict_get(dict
, "", en
, AV_DICT_IGNORE_SUFFIX
))) {
417 if (x264_param_parse(&x4
->params
, en
->key
, en
->value
) < 0)
418 av_log(avctx
, AV_LOG_WARNING
,
419 "Error parsing option '%s = %s'.\n",
427 // update AVCodecContext with x264 parameters
428 avctx
->has_b_frames
= x4
->params
.i_bframe
?
429 x4
->params
.i_bframe_pyramid
? 2 : 1 : 0;
430 if (avctx
->max_b_frames
< 0)
431 avctx
->max_b_frames
= 0;
433 avctx
->bit_rate
= x4
->params
.rc
.i_bitrate
*1000;
435 x4
->enc
= x264_encoder_open(&x4
->params
);
439 avctx
->coded_frame
= &x4
->out_pic
;
441 if (avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
) {
446 s
= x264_encoder_headers(x4
->enc
, &nal
, &nnal
);
447 avctx
->extradata
= p
= av_malloc(s
);
449 for (i
= 0; i
< nnal
; i
++) {
450 /* Don't put the SEI in extradata. */
451 if (nal
[i
].i_type
== NAL_SEI
) {
452 av_log(avctx
, AV_LOG_INFO
, "%s\n", nal
[i
].p_payload
+25);
453 x4
->sei_size
= nal
[i
].i_payload
;
454 x4
->sei
= av_malloc(x4
->sei_size
);
455 memcpy(x4
->sei
, nal
[i
].p_payload
, nal
[i
].i_payload
);
458 memcpy(p
, nal
[i
].p_payload
, nal
[i
].i_payload
);
459 p
+= nal
[i
].i_payload
;
461 avctx
->extradata_size
= p
- avctx
->extradata
;
467 static const enum AVPixelFormat pix_fmts_8bit
[] = {
474 static const enum AVPixelFormat pix_fmts_9bit
[] = {
479 static const enum AVPixelFormat pix_fmts_10bit
[] = {
480 AV_PIX_FMT_YUV420P10
,
481 AV_PIX_FMT_YUV422P10
,
482 AV_PIX_FMT_YUV444P10
,
486 static av_cold
void X264_init_static(AVCodec
*codec
)
488 if (x264_bit_depth
== 8)
489 codec
->pix_fmts
= pix_fmts_8bit
;
490 else if (x264_bit_depth
== 9)
491 codec
->pix_fmts
= pix_fmts_9bit
;
492 else if (x264_bit_depth
== 10)
493 codec
->pix_fmts
= pix_fmts_10bit
;
496 #define OFFSET(x) offsetof(X264Context, x)
497 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
498 static const AVOption options
[] = {
499 { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset
), AV_OPT_TYPE_STRING
, { .str
= "medium" }, 0, 0, VE
},
500 { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
501 { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
502 { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass
), AV_OPT_TYPE_INT
, { .i64
= 1 }, 0, 1, VE
},
503 { "crf", "Select the quality for constant quality mode", OFFSET(crf
), AV_OPT_TYPE_FLOAT
, {.dbl
= -1 }, -1, FLT_MAX
, VE
},
504 { "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
},
505 { "qp", "Constant quantization parameter rate control method",OFFSET(cqp
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
},
506 { "aq-mode", "AQ method", OFFSET(aq_mode
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "aq_mode"},
507 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_AQ_NONE
}, INT_MIN
, INT_MAX
, VE
, "aq_mode" },
508 { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_AQ_VARIANCE
}, INT_MIN
, INT_MAX
, VE
, "aq_mode" },
509 { "autovariance", "Auto-variance AQ (experimental)", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_AQ_AUTOVARIANCE
}, INT_MIN
, INT_MAX
, VE
, "aq_mode" },
510 { "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
},
511 { "psy", "Use psychovisual optimizations.", OFFSET(psy
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
512 { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd
), AV_OPT_TYPE_STRING
, {0 }, 0, 0, VE
},
513 { "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
},
514 { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
515 { "weightp", "Weighted prediction analysis method.", OFFSET(weightp
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "weightp" },
516 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_WEIGHTP_NONE
}, INT_MIN
, INT_MAX
, VE
, "weightp" },
517 { "simple", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_WEIGHTP_SIMPLE
}, INT_MIN
, INT_MAX
, VE
, "weightp" },
518 { "smart", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_WEIGHTP_SMART
}, INT_MIN
, INT_MAX
, VE
, "weightp" },
519 { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
520 { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh
),AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
521 { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias
), AV_OPT_TYPE_INT
, { .i64
= INT_MIN
}, INT_MIN
, INT_MAX
, VE
},
522 { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "b_pyramid" },
523 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_B_PYRAMID_NONE
}, INT_MIN
, INT_MAX
, VE
, "b_pyramid" },
524 { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_B_PYRAMID_STRICT
}, INT_MIN
, INT_MAX
, VE
, "b_pyramid" },
525 { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_B_PYRAMID_NORMAL
}, INT_MIN
, INT_MAX
, VE
, "b_pyramid" },
526 { "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
},
527 { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
528 { "fast-pskip", NULL
, OFFSET(fast_pskip
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
529 { "aud", "Use access unit delimiters.", OFFSET(aud
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
530 { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
531 { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
532 { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur
), AV_OPT_TYPE_FLOAT
, {.dbl
= -1 }, -1, FLT_MAX
, VE
},
533 { "partitions", "A comma-separated list of partitions to consider. "
534 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
535 { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "direct-pred" },
536 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_NONE
}, 0, 0, VE
, "direct-pred" },
537 { "spatial", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_SPATIAL
}, 0, 0, VE
, "direct-pred" },
538 { "temporal", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_TEMPORAL
}, 0, 0, VE
, "direct-pred" },
539 { "auto", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_AUTO
}, 0, 0, VE
, "direct-pred" },
540 { "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
},
541 { "stats", "Filename for 2 pass stats", OFFSET(stats
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
542 { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
543 "cbr not allowed in .mp4)", OFFSET(nal_hrd
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "nal-hrd" },
544 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_NAL_HRD_NONE
}, INT_MIN
, INT_MAX
, VE
, "nal-hrd" },
545 { "vbr", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_NAL_HRD_VBR
}, INT_MIN
, INT_MAX
, VE
, "nal-hrd" },
546 { "cbr", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_NAL_HRD_CBR
}, INT_MIN
, INT_MAX
, VE
, "nal-hrd" },
547 { "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
},
551 static const AVClass
class = {
552 .class_name
= "libx264",
553 .item_name
= av_default_item_name
,
555 .version
= LIBAVUTIL_VERSION_INT
,
558 static const AVCodecDefault x264_defaults
[] = {
568 { "sc_threshold", "-1" },
571 { "me_range", "-1" },
572 { "me_method", "-1" },
574 { "b_strategy", "-1" },
575 { "keyint_min", "-1" },
578 { "threads", AV_STRINGIFY(X264_THREADS_AUTO
) },
579 { "thread_type", "0" },
580 { "flags", "+cgop" },
581 { "rc_init_occupancy","-1" },
585 AVCodec ff_libx264_encoder
= {
587 .type
= AVMEDIA_TYPE_VIDEO
,
588 .id
= AV_CODEC_ID_H264
,
589 .priv_data_size
= sizeof(X264Context
),
591 .encode2
= X264_frame
,
593 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_AUTO_THREADS
,
594 .long_name
= NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
595 .priv_class
= &class,
596 .defaults
= x264_defaults
,
597 .init_static_data
= X264_init_static
,