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
{
86 static void X264_log(void *p
, int level
, const char *fmt
, va_list args
)
88 static const int level_map
[] = {
89 [X264_LOG_ERROR
] = AV_LOG_ERROR
,
90 [X264_LOG_WARNING
] = AV_LOG_WARNING
,
91 [X264_LOG_INFO
] = AV_LOG_INFO
,
92 [X264_LOG_DEBUG
] = AV_LOG_DEBUG
95 if (level
< 0 || level
> X264_LOG_DEBUG
)
98 av_vlog(p
, level_map
[level
], fmt
, args
);
102 static int encode_nals(AVCodecContext
*ctx
, AVPacket
*pkt
,
103 x264_nal_t
*nals
, int nnal
)
105 X264Context
*x4
= ctx
->priv_data
;
107 int i
, size
= x4
->sei_size
, ret
;
112 for (i
= 0; i
< nnal
; i
++)
113 size
+= nals
[i
].i_payload
;
115 if ((ret
= ff_alloc_packet2(ctx
, pkt
, size
)) < 0)
120 /* Write the SEI as part of the first frame. */
121 if (x4
->sei_size
> 0 && nnal
> 0) {
122 if (x4
->sei_size
> size
) {
123 av_log(ctx
, AV_LOG_ERROR
, "Error: nal buffer is too small\n");
126 memcpy(p
, x4
->sei
, x4
->sei_size
);
132 for (i
= 0; i
< nnal
; i
++){
133 memcpy(p
, nals
[i
].p_payload
, nals
[i
].i_payload
);
134 p
+= nals
[i
].i_payload
;
140 static int avfmt2_num_planes(int avfmt
)
143 case AV_PIX_FMT_YUV420P
:
144 case AV_PIX_FMT_YUVJ420P
:
145 case AV_PIX_FMT_YUV420P9
:
146 case AV_PIX_FMT_YUV420P10
:
147 case AV_PIX_FMT_YUV444P
:
150 case AV_PIX_FMT_BGR24
:
151 case AV_PIX_FMT_RGB24
:
159 static int X264_frame(AVCodecContext
*ctx
, AVPacket
*pkt
, const AVFrame
*frame
,
162 X264Context
*x4
= ctx
->priv_data
;
165 x264_picture_t pic_out
= {0};
166 AVFrameSideData
*side_data
;
168 x264_picture_init( &x4
->pic
);
169 x4
->pic
.img
.i_csp
= x4
->params
.i_csp
;
170 if (x264_bit_depth
> 8)
171 x4
->pic
.img
.i_csp
|= X264_CSP_HIGH_DEPTH
;
172 x4
->pic
.img
.i_plane
= avfmt2_num_planes(ctx
->pix_fmt
);
175 for (i
= 0; i
< x4
->pic
.img
.i_plane
; i
++) {
176 x4
->pic
.img
.plane
[i
] = frame
->data
[i
];
177 x4
->pic
.img
.i_stride
[i
] = frame
->linesize
[i
];
180 x4
->pic
.i_pts
= frame
->pts
;
182 frame
->pict_type
== AV_PICTURE_TYPE_I
? X264_TYPE_KEYFRAME
:
183 frame
->pict_type
== AV_PICTURE_TYPE_P
? X264_TYPE_P
:
184 frame
->pict_type
== AV_PICTURE_TYPE_B
? X264_TYPE_B
:
186 if (x4
->params
.b_interlaced
&& x4
->params
.b_tff
!= frame
->top_field_first
) {
187 x4
->params
.b_tff
= frame
->top_field_first
;
188 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
190 if (x4
->params
.vui
.i_sar_height
!= ctx
->sample_aspect_ratio
.den
||
191 x4
->params
.vui
.i_sar_width
!= ctx
->sample_aspect_ratio
.num
) {
192 x4
->params
.vui
.i_sar_height
= ctx
->sample_aspect_ratio
.den
;
193 x4
->params
.vui
.i_sar_width
= ctx
->sample_aspect_ratio
.num
;
194 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
197 if (x4
->params
.rc
.i_vbv_buffer_size
!= ctx
->rc_buffer_size
/ 1000 ||
198 x4
->params
.rc
.i_vbv_max_bitrate
!= ctx
->rc_max_rate
/ 1000) {
199 x4
->params
.rc
.i_vbv_buffer_size
= ctx
->rc_buffer_size
/ 1000;
200 x4
->params
.rc
.i_vbv_max_bitrate
= ctx
->rc_max_rate
/ 1000;
201 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
204 if (x4
->params
.rc
.i_rc_method
== X264_RC_ABR
&&
205 x4
->params
.rc
.i_bitrate
!= ctx
->bit_rate
/ 1000) {
206 x4
->params
.rc
.i_bitrate
= ctx
->bit_rate
/ 1000;
207 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
211 x4
->params
.rc
.i_rc_method
== X264_RC_CRF
&&
212 x4
->params
.rc
.f_rf_constant
!= x4
->crf
) {
213 x4
->params
.rc
.f_rf_constant
= x4
->crf
;
214 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
217 if (x4
->params
.rc
.i_rc_method
== X264_RC_CQP
&&
219 x4
->params
.rc
.i_qp_constant
!= x4
->cqp
) {
220 x4
->params
.rc
.i_qp_constant
= x4
->cqp
;
221 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
224 if (x4
->crf_max
>= 0 &&
225 x4
->params
.rc
.f_rf_constant_max
!= x4
->crf_max
) {
226 x4
->params
.rc
.f_rf_constant_max
= x4
->crf_max
;
227 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
230 side_data
= av_frame_get_side_data(frame
, AV_FRAME_DATA_STEREO3D
);
232 AVStereo3D
*stereo
= (AVStereo3D
*)side_data
->data
;
235 switch (stereo
->type
) {
236 case AV_STEREO3D_CHECKERBOARD
:
239 case AV_STEREO3D_COLUMNS
:
242 case AV_STEREO3D_LINES
:
245 case AV_STEREO3D_SIDEBYSIDE
:
248 case AV_STEREO3D_TOPBOTTOM
:
251 case AV_STEREO3D_FRAMESEQUENCE
:
259 if (fpa_type
!= x4
->params
.i_frame_packing
) {
260 x4
->params
.i_frame_packing
= fpa_type
;
261 x264_encoder_reconfig(x4
->enc
, &x4
->params
);
266 if (x264_encoder_encode(x4
->enc
, &nal
, &nnal
, frame
? &x4
->pic
: NULL
, &pic_out
) < 0)
269 ret
= encode_nals(ctx
, pkt
, nal
, nnal
);
272 } while (!ret
&& !frame
&& x264_encoder_delayed_frames(x4
->enc
));
274 pkt
->pts
= pic_out
.i_pts
;
275 pkt
->dts
= pic_out
.i_dts
;
277 switch (pic_out
.i_type
) {
280 ctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
283 ctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_P
;
287 ctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_B
;
291 pkt
->flags
|= AV_PKT_FLAG_KEY
*pic_out
.b_keyframe
;
293 ctx
->coded_frame
->quality
= (pic_out
.i_qpplus1
- 1) * FF_QP2LAMBDA
;
299 static av_cold
int X264_close(AVCodecContext
*avctx
)
301 X264Context
*x4
= avctx
->priv_data
;
303 av_freep(&avctx
->extradata
);
307 x264_encoder_close(x4
->enc
);
309 av_frame_free(&avctx
->coded_frame
);
314 #define OPT_STR(opt, param) \
317 if (param && (ret = x264_param_parse(&x4->params, opt, param)) < 0) { \
318 if(ret == X264_PARAM_BAD_NAME) \
319 av_log(avctx, AV_LOG_ERROR, \
320 "bad option '%s': '%s'\n", opt, param); \
322 av_log(avctx, AV_LOG_ERROR, \
323 "bad value for '%s': '%s'\n", opt, param); \
328 static int convert_pix_fmt(enum AVPixelFormat pix_fmt
)
331 case AV_PIX_FMT_YUV420P
:
332 case AV_PIX_FMT_YUVJ420P
:
333 case AV_PIX_FMT_YUV420P9
:
334 case AV_PIX_FMT_YUV420P10
: return X264_CSP_I420
;
335 case AV_PIX_FMT_YUV422P
:
336 case AV_PIX_FMT_YUVJ422P
:
337 case AV_PIX_FMT_YUV422P10
: return X264_CSP_I422
;
338 case AV_PIX_FMT_YUV444P
:
339 case AV_PIX_FMT_YUVJ444P
:
340 case AV_PIX_FMT_YUV444P9
:
341 case AV_PIX_FMT_YUV444P10
: return X264_CSP_I444
;
343 case AV_PIX_FMT_BGR24
:
346 case AV_PIX_FMT_RGB24
:
349 case AV_PIX_FMT_NV12
: return X264_CSP_NV12
;
350 case AV_PIX_FMT_NV16
:
351 case AV_PIX_FMT_NV20
: return X264_CSP_NV16
;
356 #define PARSE_X264_OPT(name, var)\
357 if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
358 av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
359 return AVERROR(EINVAL);\
362 static av_cold
int X264_init(AVCodecContext
*avctx
)
364 X264Context
*x4
= avctx
->priv_data
;
367 if (avctx
->global_quality
> 0)
368 av_log(avctx
, AV_LOG_WARNING
, "-qscale is ignored, -crf is recommended.\n");
370 x264_param_default(&x4
->params
);
372 x4
->params
.b_deblocking_filter
= avctx
->flags
& CODEC_FLAG_LOOP_FILTER
;
374 if (x4
->preset
|| x4
->tune
)
375 if (x264_param_default_preset(&x4
->params
, x4
->preset
, x4
->tune
) < 0) {
377 av_log(avctx
, AV_LOG_ERROR
, "Error setting preset/tune %s/%s.\n", x4
->preset
, x4
->tune
);
378 av_log(avctx
, AV_LOG_INFO
, "Possible presets:");
379 for (i
= 0; x264_preset_names
[i
]; i
++)
380 av_log(avctx
, AV_LOG_INFO
, " %s", x264_preset_names
[i
]);
381 av_log(avctx
, AV_LOG_INFO
, "\n");
382 av_log(avctx
, AV_LOG_INFO
, "Possible tunes:");
383 for (i
= 0; x264_tune_names
[i
]; i
++)
384 av_log(avctx
, AV_LOG_INFO
, " %s", x264_tune_names
[i
]);
385 av_log(avctx
, AV_LOG_INFO
, "\n");
386 return AVERROR(EINVAL
);
389 if (avctx
->level
> 0)
390 x4
->params
.i_level_idc
= avctx
->level
;
392 x4
->params
.pf_log
= X264_log
;
393 x4
->params
.p_log_private
= avctx
;
394 x4
->params
.i_log_level
= X264_LOG_DEBUG
;
395 x4
->params
.i_csp
= convert_pix_fmt(avctx
->pix_fmt
);
397 OPT_STR("weightp", x4
->wpredp
);
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
;
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
& CODEC_FLAG_PASS1
;
406 if (avctx
->flags
& CODEC_FLAG_PASS2
) {
407 x4
->params
.rc
.b_stat_read
= 1;
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
;
417 if (x4
->crf_max
>= 0)
418 x4
->params
.rc
.f_rf_constant_max
= x4
->crf_max
;
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
;
427 OPT_STR("level", x4
->level
);
429 if (avctx
->i_quant_factor
> 0)
430 x4
->params
.rc
.f_ip_factor
= 1 / fabs(avctx
->i_quant_factor
);
431 if (avctx
->b_quant_factor
> 0)
432 x4
->params
.rc
.f_pb_factor
= avctx
->b_quant_factor
;
433 if (avctx
->chromaoffset
)
434 x4
->params
.analyse
.i_chroma_qp_offset
= avctx
->chromaoffset
;
436 if (avctx
->me_method
== ME_EPZS
)
437 x4
->params
.analyse
.i_me_method
= X264_ME_DIA
;
438 else if (avctx
->me_method
== ME_HEX
)
439 x4
->params
.analyse
.i_me_method
= X264_ME_HEX
;
440 else if (avctx
->me_method
== ME_UMH
)
441 x4
->params
.analyse
.i_me_method
= X264_ME_UMH
;
442 else if (avctx
->me_method
== ME_FULL
)
443 x4
->params
.analyse
.i_me_method
= X264_ME_ESA
;
444 else if (avctx
->me_method
== ME_TESA
)
445 x4
->params
.analyse
.i_me_method
= X264_ME_TESA
;
447 if (avctx
->gop_size
>= 0)
448 x4
->params
.i_keyint_max
= avctx
->gop_size
;
449 if (avctx
->max_b_frames
>= 0)
450 x4
->params
.i_bframe
= avctx
->max_b_frames
;
451 if (avctx
->scenechange_threshold
>= 0)
452 x4
->params
.i_scenecut_threshold
= avctx
->scenechange_threshold
;
453 if (avctx
->qmin
>= 0)
454 x4
->params
.rc
.i_qp_min
= avctx
->qmin
;
455 if (avctx
->qmax
>= 0)
456 x4
->params
.rc
.i_qp_max
= avctx
->qmax
;
457 if (avctx
->max_qdiff
>= 0)
458 x4
->params
.rc
.i_qp_step
= avctx
->max_qdiff
;
459 if (avctx
->qblur
>= 0)
460 x4
->params
.rc
.f_qblur
= avctx
->qblur
; /* temporally blur quants */
461 if (avctx
->qcompress
>= 0)
462 x4
->params
.rc
.f_qcompress
= avctx
->qcompress
; /* 0.0 => cbr, 1.0 => constant qp */
463 if (avctx
->refs
>= 0)
464 x4
->params
.i_frame_reference
= avctx
->refs
;
465 else if (x4
->level
) {
467 int mbn
= FF_CEIL_RSHIFT(avctx
->width
, 4) * FF_CEIL_RSHIFT(avctx
->height
, 4);
470 int scale
= X264_BUILD
< 129 ? 384 : 1;
472 if (!strcmp(x4
->level
, "1b")) {
474 } else if (strlen(x4
->level
) <= 3){
475 level_id
= av_strtod(x4
->level
, &tail
) * 10 + 0.5;
480 av_log(avctx
, AV_LOG_WARNING
, "Failed to parse level\n");
482 for (i
= 0; i
<x264_levels
[i
].level_idc
; i
++)
483 if (x264_levels
[i
].level_idc
== level_id
)
484 x4
->params
.i_frame_reference
= av_clip(x264_levels
[i
].dpb
/ mbn
/ scale
, 1, x4
->params
.i_frame_reference
);
487 if (avctx
->trellis
>= 0)
488 x4
->params
.analyse
.i_trellis
= avctx
->trellis
;
489 if (avctx
->me_range
>= 0)
490 x4
->params
.analyse
.i_me_range
= avctx
->me_range
;
491 if (avctx
->noise_reduction
>= 0)
492 x4
->params
.analyse
.i_noise_reduction
= avctx
->noise_reduction
;
493 if (avctx
->me_subpel_quality
>= 0)
494 x4
->params
.analyse
.i_subpel_refine
= avctx
->me_subpel_quality
;
495 if (avctx
->b_frame_strategy
>= 0)
496 x4
->params
.i_bframe_adaptive
= avctx
->b_frame_strategy
;
497 if (avctx
->keyint_min
>= 0)
498 x4
->params
.i_keyint_min
= avctx
->keyint_min
;
499 if (avctx
->coder_type
>= 0)
500 x4
->params
.b_cabac
= avctx
->coder_type
== FF_CODER_TYPE_AC
;
501 if (avctx
->me_cmp
>= 0)
502 x4
->params
.analyse
.b_chroma_me
= avctx
->me_cmp
& FF_CMP_CHROMA
;
504 if (x4
->aq_mode
>= 0)
505 x4
->params
.rc
.i_aq_mode
= x4
->aq_mode
;
506 if (x4
->aq_strength
>= 0)
507 x4
->params
.rc
.f_aq_strength
= x4
->aq_strength
;
508 PARSE_X264_OPT("psy-rd", psy_rd
);
509 PARSE_X264_OPT("deblock", deblock
);
510 PARSE_X264_OPT("partitions", partitions
);
511 PARSE_X264_OPT("stats", stats
);
513 x4
->params
.analyse
.b_psy
= x4
->psy
;
514 if (x4
->rc_lookahead
>= 0)
515 x4
->params
.rc
.i_lookahead
= x4
->rc_lookahead
;
516 if (x4
->weightp
>= 0)
517 x4
->params
.analyse
.i_weighted_pred
= x4
->weightp
;
518 if (x4
->weightb
>= 0)
519 x4
->params
.analyse
.b_weighted_bipred
= x4
->weightb
;
520 if (x4
->cplxblur
>= 0)
521 x4
->params
.rc
.f_complexity_blur
= x4
->cplxblur
;
524 x4
->params
.analyse
.b_ssim
= x4
->ssim
;
525 if (x4
->intra_refresh
>= 0)
526 x4
->params
.b_intra_refresh
= x4
->intra_refresh
;
527 if (x4
->bluray_compat
>= 0) {
528 x4
->params
.b_bluray_compat
= x4
->bluray_compat
;
529 x4
->params
.b_vfr_input
= 0;
531 if (x4
->b_bias
!= INT_MIN
)
532 x4
->params
.i_bframe_bias
= x4
->b_bias
;
533 if (x4
->b_pyramid
>= 0)
534 x4
->params
.i_bframe_pyramid
= x4
->b_pyramid
;
535 if (x4
->mixed_refs
>= 0)
536 x4
->params
.analyse
.b_mixed_references
= x4
->mixed_refs
;
538 x4
->params
.analyse
.b_transform_8x8
= x4
->dct8x8
;
539 if (x4
->fast_pskip
>= 0)
540 x4
->params
.analyse
.b_fast_pskip
= x4
->fast_pskip
;
542 x4
->params
.b_aud
= x4
->aud
;
544 x4
->params
.rc
.b_mb_tree
= x4
->mbtree
;
545 if (x4
->direct_pred
>= 0)
546 x4
->params
.analyse
.i_direct_mv_pred
= x4
->direct_pred
;
548 if (x4
->slice_max_size
>= 0)
549 x4
->params
.i_slice_max_size
= x4
->slice_max_size
;
552 * Allow x264 to be instructed through AVCodecContext about the maximum
553 * size of the RTP payload. For example, this enables the production of
554 * payload suitable for the H.264 RTP packetization-mode 0 i.e. single
555 * NAL unit per RTP packet.
557 if (avctx
->rtp_payload_size
)
558 x4
->params
.i_slice_max_size
= avctx
->rtp_payload_size
;
561 if (x4
->fastfirstpass
)
562 x264_param_apply_fastfirstpass(&x4
->params
);
564 /* Allow specifying the x264 profile through AVCodecContext. */
566 switch (avctx
->profile
) {
567 case FF_PROFILE_H264_BASELINE
:
568 x4
->profile
= av_strdup("baseline");
570 case FF_PROFILE_H264_HIGH
:
571 x4
->profile
= av_strdup("high");
573 case FF_PROFILE_H264_HIGH_10
:
574 x4
->profile
= av_strdup("high10");
576 case FF_PROFILE_H264_HIGH_422
:
577 x4
->profile
= av_strdup("high422");
579 case FF_PROFILE_H264_HIGH_444
:
580 x4
->profile
= av_strdup("high444");
582 case FF_PROFILE_H264_MAIN
:
583 x4
->profile
= av_strdup("main");
589 if (x4
->nal_hrd
>= 0)
590 x4
->params
.i_nal_hrd
= x4
->nal_hrd
;
593 if (x264_param_apply_profile(&x4
->params
, x4
->profile
) < 0) {
595 av_log(avctx
, AV_LOG_ERROR
, "Error setting profile %s.\n", x4
->profile
);
596 av_log(avctx
, AV_LOG_INFO
, "Possible profiles:");
597 for (i
= 0; x264_profile_names
[i
]; i
++)
598 av_log(avctx
, AV_LOG_INFO
, " %s", x264_profile_names
[i
]);
599 av_log(avctx
, AV_LOG_INFO
, "\n");
600 return AVERROR(EINVAL
);
603 x4
->params
.i_width
= avctx
->width
;
604 x4
->params
.i_height
= avctx
->height
;
605 av_reduce(&sw
, &sh
, avctx
->sample_aspect_ratio
.num
, avctx
->sample_aspect_ratio
.den
, 4096);
606 x4
->params
.vui
.i_sar_width
= sw
;
607 x4
->params
.vui
.i_sar_height
= sh
;
608 x4
->params
.i_timebase_den
= avctx
->time_base
.den
;
609 x4
->params
.i_timebase_num
= avctx
->time_base
.num
;
610 x4
->params
.i_fps_num
= avctx
->time_base
.den
;
611 x4
->params
.i_fps_den
= avctx
->time_base
.num
* avctx
->ticks_per_frame
;
613 x4
->params
.analyse
.b_psnr
= avctx
->flags
& CODEC_FLAG_PSNR
;
615 x4
->params
.i_threads
= avctx
->thread_count
;
616 if (avctx
->thread_type
)
617 x4
->params
.b_sliced_threads
= avctx
->thread_type
== FF_THREAD_SLICE
;
619 x4
->params
.b_interlaced
= avctx
->flags
& CODEC_FLAG_INTERLACED_DCT
;
621 x4
->params
.b_open_gop
= !(avctx
->flags
& CODEC_FLAG_CLOSED_GOP
);
623 x4
->params
.i_slice_count
= avctx
->slices
;
625 x4
->params
.vui
.b_fullrange
= avctx
->pix_fmt
== AV_PIX_FMT_YUVJ420P
||
626 avctx
->pix_fmt
== AV_PIX_FMT_YUVJ422P
||
627 avctx
->pix_fmt
== AV_PIX_FMT_YUVJ444P
||
628 avctx
->color_range
== AVCOL_RANGE_JPEG
;
630 if (avctx
->colorspace
!= AVCOL_SPC_UNSPECIFIED
)
631 x4
->params
.vui
.i_colmatrix
= avctx
->colorspace
;
632 if (avctx
->color_primaries
!= AVCOL_PRI_UNSPECIFIED
)
633 x4
->params
.vui
.i_colorprim
= avctx
->color_primaries
;
634 if (avctx
->color_trc
!= AVCOL_TRC_UNSPECIFIED
)
635 x4
->params
.vui
.i_transfer
= avctx
->color_trc
;
637 if (avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
)
638 x4
->params
.b_repeat_headers
= 0;
641 const char *p
= x4
->x264opts
;
643 char param
[256]={0}, val
[256]={0};
644 if(sscanf(p
, "%255[^:=]=%255[^:]", param
, val
) == 1){
653 if (x4
->x264_params
) {
654 AVDictionary
*dict
= NULL
;
655 AVDictionaryEntry
*en
= NULL
;
657 if (!av_dict_parse_string(&dict
, x4
->x264_params
, "=", ":", 0)) {
658 while ((en
= av_dict_get(dict
, "", en
, AV_DICT_IGNORE_SUFFIX
))) {
659 if (x264_param_parse(&x4
->params
, en
->key
, en
->value
) < 0)
660 av_log(avctx
, AV_LOG_WARNING
,
661 "Error parsing option '%s = %s'.\n",
669 // update AVCodecContext with x264 parameters
670 avctx
->has_b_frames
= x4
->params
.i_bframe
?
671 x4
->params
.i_bframe_pyramid
? 2 : 1 : 0;
672 if (avctx
->max_b_frames
< 0)
673 avctx
->max_b_frames
= 0;
675 avctx
->bit_rate
= x4
->params
.rc
.i_bitrate
*1000;
677 x4
->enc
= x264_encoder_open(&x4
->params
);
681 avctx
->coded_frame
= av_frame_alloc();
682 if (!avctx
->coded_frame
)
683 return AVERROR(ENOMEM
);
685 if (avctx
->flags
& CODEC_FLAG_GLOBAL_HEADER
) {
690 s
= x264_encoder_headers(x4
->enc
, &nal
, &nnal
);
691 avctx
->extradata
= p
= av_malloc(s
);
693 for (i
= 0; i
< nnal
; i
++) {
694 /* Don't put the SEI in extradata. */
695 if (nal
[i
].i_type
== NAL_SEI
) {
696 av_log(avctx
, AV_LOG_INFO
, "%s\n", nal
[i
].p_payload
+25);
697 x4
->sei_size
= nal
[i
].i_payload
;
698 x4
->sei
= av_malloc(x4
->sei_size
);
699 memcpy(x4
->sei
, nal
[i
].p_payload
, nal
[i
].i_payload
);
702 memcpy(p
, nal
[i
].p_payload
, nal
[i
].i_payload
);
703 p
+= nal
[i
].i_payload
;
705 avctx
->extradata_size
= p
- avctx
->extradata
;
711 static const enum AVPixelFormat pix_fmts_8bit
[] = {
722 static const enum AVPixelFormat pix_fmts_9bit
[] = {
727 static const enum AVPixelFormat pix_fmts_10bit
[] = {
728 AV_PIX_FMT_YUV420P10
,
729 AV_PIX_FMT_YUV422P10
,
730 AV_PIX_FMT_YUV444P10
,
734 static const enum AVPixelFormat pix_fmts_8bit_rgb
[] = {
742 static av_cold
void X264_init_static(AVCodec
*codec
)
744 if (x264_bit_depth
== 8)
745 codec
->pix_fmts
= pix_fmts_8bit
;
746 else if (x264_bit_depth
== 9)
747 codec
->pix_fmts
= pix_fmts_9bit
;
748 else if (x264_bit_depth
== 10)
749 codec
->pix_fmts
= pix_fmts_10bit
;
752 #define OFFSET(x) offsetof(X264Context, x)
753 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
754 static const AVOption options
[] = {
755 { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset
), AV_OPT_TYPE_STRING
, { .str
= "medium" }, 0, 0, VE
},
756 { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
757 { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
758 { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass
), AV_OPT_TYPE_INT
, { .i64
= 1 }, 0, 1, VE
},
759 {"level", "Specify level (as defined by Annex A)", OFFSET(level
), AV_OPT_TYPE_STRING
, {.str
=NULL
}, 0, 0, VE
},
760 {"passlogfile", "Filename for 2 pass stats", OFFSET(stats
), AV_OPT_TYPE_STRING
, {.str
=NULL
}, 0, 0, VE
},
761 {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp
), AV_OPT_TYPE_STRING
, {.str
=NULL
}, 0, 0, VE
},
762 {"x264opts", "x264 options", OFFSET(x264opts
), AV_OPT_TYPE_STRING
, {.str
=NULL
}, 0, 0, VE
},
763 { "crf", "Select the quality for constant quality mode", OFFSET(crf
), AV_OPT_TYPE_FLOAT
, {.dbl
= -1 }, -1, FLT_MAX
, VE
},
764 { "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
},
765 { "qp", "Constant quantization parameter rate control method",OFFSET(cqp
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
},
766 { "aq-mode", "AQ method", OFFSET(aq_mode
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "aq_mode"},
767 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_AQ_NONE
}, INT_MIN
, INT_MAX
, VE
, "aq_mode" },
768 { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_AQ_VARIANCE
}, INT_MIN
, INT_MAX
, VE
, "aq_mode" },
769 { "autovariance", "Auto-variance AQ (experimental)", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_AQ_AUTOVARIANCE
}, INT_MIN
, INT_MAX
, VE
, "aq_mode" },
770 { "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
},
771 { "psy", "Use psychovisual optimizations.", OFFSET(psy
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
772 { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd
), AV_OPT_TYPE_STRING
, {0 }, 0, 0, VE
},
773 { "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
},
774 { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
775 { "weightp", "Weighted prediction analysis method.", OFFSET(weightp
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "weightp" },
776 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_WEIGHTP_NONE
}, INT_MIN
, INT_MAX
, VE
, "weightp" },
777 { "simple", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_WEIGHTP_SIMPLE
}, INT_MIN
, INT_MAX
, VE
, "weightp" },
778 { "smart", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_WEIGHTP_SMART
}, INT_MIN
, INT_MAX
, VE
, "weightp" },
779 { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
780 { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh
),AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
781 { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat
) ,AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
782 { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias
), AV_OPT_TYPE_INT
, { .i64
= INT_MIN
}, INT_MIN
, INT_MAX
, VE
},
783 { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "b_pyramid" },
784 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_B_PYRAMID_NONE
}, INT_MIN
, INT_MAX
, VE
, "b_pyramid" },
785 { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_B_PYRAMID_STRICT
}, INT_MIN
, INT_MAX
, VE
, "b_pyramid" },
786 { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST
, {.i64
= X264_B_PYRAMID_NORMAL
}, INT_MIN
, INT_MAX
, VE
, "b_pyramid" },
787 { "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
},
788 { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
789 { "fast-pskip", NULL
, OFFSET(fast_pskip
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
790 { "aud", "Use access unit delimiters.", OFFSET(aud
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
791 { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, 1, VE
},
792 { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
793 { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur
), AV_OPT_TYPE_FLOAT
, {.dbl
= -1 }, -1, FLT_MAX
, VE
},
794 { "partitions", "A comma-separated list of partitions to consider. "
795 "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
796 { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "direct-pred" },
797 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_NONE
}, 0, 0, VE
, "direct-pred" },
798 { "spatial", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_SPATIAL
}, 0, 0, VE
, "direct-pred" },
799 { "temporal", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_TEMPORAL
}, 0, 0, VE
, "direct-pred" },
800 { "auto", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= X264_DIRECT_PRED_AUTO
}, 0, 0, VE
, "direct-pred" },
801 { "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
},
802 { "stats", "Filename for 2 pass stats", OFFSET(stats
), AV_OPT_TYPE_STRING
, { 0 }, 0, 0, VE
},
803 { "nal-hrd", "Signal HRD information (requires vbv-bufsize; "
804 "cbr not allowed in .mp4)", OFFSET(nal_hrd
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, INT_MAX
, VE
, "nal-hrd" },
805 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_NAL_HRD_NONE
}, INT_MIN
, INT_MAX
, VE
, "nal-hrd" },
806 { "vbr", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_NAL_HRD_VBR
}, INT_MIN
, INT_MAX
, VE
, "nal-hrd" },
807 { "cbr", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= X264_NAL_HRD_CBR
}, INT_MIN
, INT_MAX
, VE
, "nal-hrd" },
808 { "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
},
812 static const AVClass x264_class
= {
813 .class_name
= "libx264",
814 .item_name
= av_default_item_name
,
816 .version
= LIBAVUTIL_VERSION_INT
,
819 static const AVClass rgbclass
= {
820 .class_name
= "libx264rgb",
821 .item_name
= av_default_item_name
,
823 .version
= LIBAVUTIL_VERSION_INT
,
826 static const AVCodecDefault x264_defaults
[] = {
831 { "i_qfactor", "-1" },
832 { "b_qfactor", "-1" },
838 // { "rc_lookahead", "-1" },
840 { "sc_threshold", "-1" },
843 { "me_range", "-1" },
844 { "me_method", "-1" },
846 { "b_strategy", "-1" },
847 { "keyint_min", "-1" },
850 { "threads", AV_STRINGIFY(X264_THREADS_AUTO
) },
851 { "thread_type", "0" },
852 { "flags", "+cgop" },
853 { "rc_init_occupancy","-1" },
857 AVCodec ff_libx264_encoder
= {
859 .long_name
= NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
860 .type
= AVMEDIA_TYPE_VIDEO
,
861 .id
= AV_CODEC_ID_H264
,
862 .priv_data_size
= sizeof(X264Context
),
864 .encode2
= X264_frame
,
866 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_AUTO_THREADS
,
867 .priv_class
= &x264_class
,
868 .defaults
= x264_defaults
,
869 .init_static_data
= X264_init_static
,
872 AVCodec ff_libx264rgb_encoder
= {
873 .name
= "libx264rgb",
874 .long_name
= NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
875 .type
= AVMEDIA_TYPE_VIDEO
,
876 .id
= AV_CODEC_ID_H264
,
877 .priv_data_size
= sizeof(X264Context
),
879 .encode2
= X264_frame
,
881 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_AUTO_THREADS
,
882 .priv_class
= &rgbclass
,
883 .defaults
= x264_defaults
,
884 .pix_fmts
= pix_fmts_8bit_rgb
,