2 * H.264 encoding using the x264 library
3 * Copyright (C) 2005 Mans Rullgard <mans@mansr.com>
5 * This file is part of FFmpeg.
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.
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.
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
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"
32 #define X264_API_IMPORTS 1
42 typedef struct X264Context
{
87 static void X264_log(void *p
, int level
, const char *fmt
, va_list args
)
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
96 if (level
< 0 || level
> X264_LOG_DEBUG
)
99 av_vlog(p
, level_map
[level
], fmt
, args
);
103 static int encode_nals(AVCodecContext
*ctx
, AVPacket
*pkt
,
104 const x264_nal_t
*nals
, int nnal
)
106 X264Context
*x4
= ctx
->priv_data
;
108 int i
, size
= x4
->sei_size
, ret
;
113 for (i
= 0; i
< nnal
; i
++)
114 size
+= nals
[i
].i_payload
;
116 if ((ret
= ff_alloc_packet2(ctx
, pkt
, size
)) < 0)
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");
127 memcpy(p
, x4
->sei
, x4
->sei_size
);
133 for (i
= 0; i
< nnal
; i
++){
134 memcpy(p
, nals
[i
].p_payload
, nals
[i
].i_payload
);
135 p
+= nals
[i
].i_payload
;
141 static int avfmt2_num_planes(int 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
:
151 case AV_PIX_FMT_BGR24
:
152 case AV_PIX_FMT_RGB24
:
160 static int X264_frame(AVCodecContext
*ctx
, AVPacket
*pkt
, const AVFrame
*frame
,
163 X264Context
*x4
= ctx
->priv_data
;
166 x264_picture_t pic_out
= {0};
167 AVFrameSideData
*side_data
;
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
);
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
];
181 x4
->pic
.i_pts
= frame
->pts
;
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
:
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
);
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
);
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
);
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
);
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
);
220 if (x4
->params
.rc
.i_rc_method
== X264_RC_CQP
&&
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
);
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
);
234 side_data
= av_frame_get_side_data(frame
, AV_FRAME_DATA_STEREO3D
);
236 AVStereo3D
*stereo
= (AVStereo3D
*)side_data
->data
;
239 switch (stereo
->type
) {
240 case AV_STEREO3D_CHECKERBOARD
:
243 case AV_STEREO3D_COLUMNS
:
246 case AV_STEREO3D_LINES
:
249 case AV_STEREO3D_SIDEBYSIDE
:
252 case AV_STEREO3D_TOPBOTTOM
:
255 case AV_STEREO3D_FRAMESEQUENCE
:
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
);
270 if (x264_encoder_encode(x4
->enc
, &nal
, &nnal
, frame
? &x4
->pic
: NULL
, &pic_out
) < 0)
273 ret
= encode_nals(ctx
, pkt
, nal
, nnal
);
276 } while (!ret
&& !frame
&& x264_encoder_delayed_frames(x4
->enc
));
278 pkt
->pts
= pic_out
.i_pts
;
279 pkt
->dts
= pic_out
.i_dts
;
281 switch (pic_out
.i_type
) {
284 ctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
287 ctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_P
;
291 ctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_B
;
295 pkt
->flags
|= AV_PKT_FLAG_KEY
*pic_out
.b_keyframe
;
297 ctx
->coded_frame
->quality
= (pic_out
.i_qpplus1
- 1) * FF_QP2LAMBDA
;
303 static av_cold
int X264_close(AVCodecContext
*avctx
)
305 X264Context
*x4
= avctx
->priv_data
;
307 av_freep(&avctx
->extradata
);
311 x264_encoder_close(x4
->enc
);
313 av_frame_free(&avctx
->coded_frame
);
318 #define OPT_STR(opt, param) \
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); \
326 av_log(avctx, AV_LOG_ERROR, \
327 "bad value for '%s': '%s'\n", opt, param); \
332 static int convert_pix_fmt(enum AVPixelFormat 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
;
347 case AV_PIX_FMT_BGR24
:
350 case AV_PIX_FMT_RGB24
:
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
;
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);\
366 static av_cold
int X264_init(AVCodecContext
*avctx
)
368 X264Context
*x4
= avctx
->priv_data
;
371 if (avctx
->global_quality
> 0)
372 av_log(avctx
, AV_LOG_WARNING
, "-qscale is ignored, -crf is recommended.\n");
374 x264_param_default(&x4
->params
);
376 x4
->params
.b_deblocking_filter
= avctx
->flags
& CODEC_FLAG_LOOP_FILTER
;
378 if (x4
->preset
|| x4
->tune
)
379 if (x264_param_default_preset(&x4
->params
, x4
->preset
, x4
->tune
) < 0) {
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
);
393 if (avctx
->level
> 0)
394 x4
->params
.i_level_idc
= avctx
->level
;
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
);
401 OPT_STR("weightp", x4
->wpredp
);
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
;
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;
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
;
421 if (x4
->crf_max
>= 0)
422 x4
->params
.rc
.f_rf_constant_max
= x4
->crf_max
;
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
;
431 OPT_STR("level", x4
->level
);
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
;
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
;
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
) {
471 int mbn
= FF_CEIL_RSHIFT(avctx
->width
, 4) * FF_CEIL_RSHIFT(avctx
->height
, 4);
474 int scale
= X264_BUILD
< 129 ? 384 : 1;
476 if (!strcmp(x4
->level
, "1b")) {
478 } else if (strlen(x4
->level
) <= 3){
479 level_id
= av_strtod(x4
->level
, &tail
) * 10 + 0.5;
484 av_log(avctx
, AV_LOG_WARNING
, "Failed to parse level\n");
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
);
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
;
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
);
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
;
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;
535 if (x4
->avcintra_class
>= 0)
536 #if X264_BUILD >= 142
537 x4
->params
.i_avcintra_class
= x4
->avcintra_class
;
539 av_log(avctx
, AV_LOG_ERROR
,
540 "x264 too old for AVC Intra, at least version 142 needed\n");
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
;
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
;
553 x4
->params
.b_aud
= x4
->aud
;
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
;
559 if (x4
->slice_max_size
>= 0)
560 x4
->params
.i_slice_max_size
= x4
->slice_max_size
;
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.
568 if (avctx
->rtp_payload_size
)
569 x4
->params
.i_slice_max_size
= avctx
->rtp_payload_size
;
572 if (x4
->fastfirstpass
)
573 x264_param_apply_fastfirstpass(&x4
->params
);
575 /* Allow specifying the x264 profile through AVCodecContext. */
577 switch (avctx
->profile
) {
578 case FF_PROFILE_H264_BASELINE
:
579 x4
->profile
= av_strdup("baseline");
581 case FF_PROFILE_H264_HIGH
:
582 x4
->profile
= av_strdup("high");
584 case FF_PROFILE_H264_HIGH_10
:
585 x4
->profile
= av_strdup("high10");
587 case FF_PROFILE_H264_HIGH_422
:
588 x4
->profile
= av_strdup("high422");
590 case FF_PROFILE_H264_HIGH_444
:
591 x4
->profile
= av_strdup("high444");
593 case FF_PROFILE_H264_MAIN
:
594 x4
->profile
= av_strdup("main");
600 if (x4
->nal_hrd
>= 0)
601 x4
->params
.i_nal_hrd
= x4
->nal_hrd
;
604 if (x264_param_apply_profile(&x4
->params
, x4
->profile
) < 0) {
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
);
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
;
624 x4
->params
.analyse
.b_psnr
= avctx
->flags
& CODEC_FLAG_PSNR
;
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
;
630 x4
->params
.b_interlaced
= avctx
->flags
& CODEC_FLAG_INTERLACED_DCT
;
632 x4
->params
.b_open_gop
= !(avctx
->flags
& CODEC_FLAG_CLOSED_GOP
);
634 x4
->params
.i_slice_count
= avctx
->slices
;
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
;
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
;
648 if (avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
)
649 x4
->params
.b_repeat_headers
= 0;
652 const char *p
= x4
->x264opts
;
654 char param
[256]={0}, val
[256]={0};
655 if(sscanf(p
, "%255[^:=]=%255[^:]", param
, val
) == 1){
664 if (x4
->x264_params
) {
665 AVDictionary
*dict
= NULL
;
666 AVDictionaryEntry
*en
= NULL
;
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",
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;
686 avctx
->bit_rate
= x4
->params
.rc
.i_bitrate
*1000;
688 x4
->enc
= x264_encoder_open(&x4
->params
);
692 avctx
->coded_frame
= av_frame_alloc();
693 if (!avctx
->coded_frame
)
694 return AVERROR(ENOMEM
);
696 if (avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
) {
701 s
= x264_encoder_headers(x4
->enc
, &nal
, &nnal
);
702 avctx
->extradata
= p
= av_malloc(s
);
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
);
713 memcpy(p
, nal
[i
].p_payload
, nal
[i
].i_payload
);
714 p
+= nal
[i
].i_payload
;
716 avctx
->extradata_size
= p
- avctx
->extradata
;
722 static const enum AVPixelFormat pix_fmts_8bit
[] = {
733 static const enum AVPixelFormat pix_fmts_9bit
[] = {
738 static const enum AVPixelFormat pix_fmts_10bit
[] = {
739 AV_PIX_FMT_YUV420P10
,
740 AV_PIX_FMT_YUV422P10
,
741 AV_PIX_FMT_YUV444P10
,
745 static const enum AVPixelFormat pix_fmts_8bit_rgb
[] = {
753 static av_cold
void X264_init_static(AVCodec
*codec
)
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
;
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
},
824 static const AVClass x264_class
= {
825 .class_name
= "libx264",
826 .item_name
= av_default_item_name
,
828 .version
= LIBAVUTIL_VERSION_INT
,
831 static const AVClass rgbclass
= {
832 .class_name
= "libx264rgb",
833 .item_name
= av_default_item_name
,
835 .version
= LIBAVUTIL_VERSION_INT
,
838 static const AVCodecDefault x264_defaults
[] = {
843 { "i_qfactor", "-1" },
844 { "b_qfactor", "-1" },
850 // { "rc_lookahead", "-1" },
852 { "sc_threshold", "-1" },
855 { "me_range", "-1" },
856 { "me_method", "-1" },
858 { "b_strategy", "-1" },
859 { "keyint_min", "-1" },
862 { "threads", AV_STRINGIFY(X264_THREADS_AUTO
) },
863 { "thread_type", "0" },
864 { "flags", "+cgop" },
865 { "rc_init_occupancy","-1" },
869 AVCodec ff_libx264_encoder
= {
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
),
876 .encode2
= X264_frame
,
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
,
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
),
891 .encode2
= X264_frame
,
893 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_AUTO_THREADS
,
894 .priv_class
= &rgbclass
,
895 .defaults
= x264_defaults
,
896 .pix_fmts
= pix_fmts_8bit_rgb
,