blob: b11ede61988639ea82f7f8f378ef45792fda779d
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 "libavutil/intreadwrite.h" |
29 | #include "avcodec.h" |
30 | #include "internal.h" |
31 | |
32 | #if defined(_MSC_VER) |
33 | #define X264_API_IMPORTS 1 |
34 | #endif |
35 | |
36 | #include <x264.h> |
37 | #include <float.h> |
38 | #include <math.h> |
39 | #include <stdio.h> |
40 | #include <stdlib.h> |
41 | #include <string.h> |
42 | |
43 | typedef struct X264Context { |
44 | AVClass *class; |
45 | x264_param_t params; |
46 | x264_t *enc; |
47 | x264_picture_t pic; |
48 | uint8_t *sei; |
49 | int sei_size; |
50 | char *preset; |
51 | char *tune; |
52 | char *profile; |
53 | char *level; |
54 | int fastfirstpass; |
55 | char *wpredp; |
56 | char *x264opts; |
57 | float crf; |
58 | float crf_max; |
59 | int cqp; |
60 | int aq_mode; |
61 | float aq_strength; |
62 | char *psy_rd; |
63 | int psy; |
64 | int rc_lookahead; |
65 | int weightp; |
66 | int weightb; |
67 | int ssim; |
68 | int intra_refresh; |
69 | int bluray_compat; |
70 | int b_bias; |
71 | int b_pyramid; |
72 | int mixed_refs; |
73 | int dct8x8; |
74 | int fast_pskip; |
75 | int aud; |
76 | int mbtree; |
77 | char *deblock; |
78 | float cplxblur; |
79 | char *partitions; |
80 | int direct_pred; |
81 | int slice_max_size; |
82 | char *stats; |
83 | int nal_hrd; |
84 | int avcintra_class; |
85 | int motion_est; |
86 | int forced_idr; |
87 | int coder; |
88 | int a53_cc; |
89 | int b_frame_strategy; |
90 | int chroma_offset; |
91 | int scenechange_threshold; |
92 | int noise_reduction; |
93 | |
94 | char *x264_params; |
95 | } X264Context; |
96 | |
97 | static void X264_log(void *p, int level, const char *fmt, va_list args) |
98 | { |
99 | static const int level_map[] = { |
100 | [X264_LOG_ERROR] = AV_LOG_ERROR, |
101 | [X264_LOG_WARNING] = AV_LOG_WARNING, |
102 | [X264_LOG_INFO] = AV_LOG_INFO, |
103 | [X264_LOG_DEBUG] = AV_LOG_DEBUG |
104 | }; |
105 | |
106 | if (level < 0 || level > X264_LOG_DEBUG) |
107 | return; |
108 | |
109 | av_vlog(p, level_map[level], fmt, args); |
110 | } |
111 | |
112 | |
113 | static int encode_nals(AVCodecContext *ctx, AVPacket *pkt, |
114 | const x264_nal_t *nals, int nnal) |
115 | { |
116 | X264Context *x4 = ctx->priv_data; |
117 | uint8_t *p; |
118 | int i, size = x4->sei_size, ret; |
119 | |
120 | if (!nnal) |
121 | return 0; |
122 | |
123 | for (i = 0; i < nnal; i++) |
124 | size += nals[i].i_payload; |
125 | |
126 | if ((ret = ff_alloc_packet2(ctx, pkt, size, 0)) < 0) |
127 | return ret; |
128 | |
129 | p = pkt->data; |
130 | |
131 | /* Write the SEI as part of the first frame. */ |
132 | if (x4->sei_size > 0 && nnal > 0) { |
133 | if (x4->sei_size > size) { |
134 | av_log(ctx, AV_LOG_ERROR, "Error: nal buffer is too small\n"); |
135 | return -1; |
136 | } |
137 | memcpy(p, x4->sei, x4->sei_size); |
138 | p += x4->sei_size; |
139 | x4->sei_size = 0; |
140 | av_freep(&x4->sei); |
141 | } |
142 | |
143 | for (i = 0; i < nnal; i++){ |
144 | memcpy(p, nals[i].p_payload, nals[i].i_payload); |
145 | p += nals[i].i_payload; |
146 | } |
147 | |
148 | return 1; |
149 | } |
150 | |
151 | static int avfmt2_num_planes(int avfmt) |
152 | { |
153 | switch (avfmt) { |
154 | case AV_PIX_FMT_YUV420P: |
155 | case AV_PIX_FMT_YUVJ420P: |
156 | case AV_PIX_FMT_YUV420P9: |
157 | case AV_PIX_FMT_YUV420P10: |
158 | case AV_PIX_FMT_YUV444P: |
159 | return 3; |
160 | |
161 | case AV_PIX_FMT_BGR0: |
162 | case AV_PIX_FMT_BGR24: |
163 | case AV_PIX_FMT_RGB24: |
164 | return 1; |
165 | |
166 | default: |
167 | return 3; |
168 | } |
169 | } |
170 | |
171 | static void reconfig_encoder(AVCodecContext *ctx, const AVFrame *frame) |
172 | { |
173 | X264Context *x4 = ctx->priv_data; |
174 | AVFrameSideData *side_data; |
175 | |
176 | |
177 | if (x4->avcintra_class < 0) { |
178 | if (x4->params.b_interlaced && x4->params.b_tff != frame->top_field_first) { |
179 | |
180 | x4->params.b_tff = frame->top_field_first; |
181 | x264_encoder_reconfig(x4->enc, &x4->params); |
182 | } |
183 | if (x4->params.vui.i_sar_height*ctx->sample_aspect_ratio.num != ctx->sample_aspect_ratio.den * x4->params.vui.i_sar_width) { |
184 | x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den; |
185 | x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num; |
186 | x264_encoder_reconfig(x4->enc, &x4->params); |
187 | } |
188 | |
189 | if (x4->params.rc.i_vbv_buffer_size != ctx->rc_buffer_size / 1000 || |
190 | x4->params.rc.i_vbv_max_bitrate != ctx->rc_max_rate / 1000) { |
191 | x4->params.rc.i_vbv_buffer_size = ctx->rc_buffer_size / 1000; |
192 | x4->params.rc.i_vbv_max_bitrate = ctx->rc_max_rate / 1000; |
193 | x264_encoder_reconfig(x4->enc, &x4->params); |
194 | } |
195 | |
196 | if (x4->params.rc.i_rc_method == X264_RC_ABR && |
197 | x4->params.rc.i_bitrate != ctx->bit_rate / 1000) { |
198 | x4->params.rc.i_bitrate = ctx->bit_rate / 1000; |
199 | x264_encoder_reconfig(x4->enc, &x4->params); |
200 | } |
201 | |
202 | if (x4->crf >= 0 && |
203 | x4->params.rc.i_rc_method == X264_RC_CRF && |
204 | x4->params.rc.f_rf_constant != x4->crf) { |
205 | x4->params.rc.f_rf_constant = x4->crf; |
206 | x264_encoder_reconfig(x4->enc, &x4->params); |
207 | } |
208 | |
209 | if (x4->params.rc.i_rc_method == X264_RC_CQP && |
210 | x4->cqp >= 0 && |
211 | x4->params.rc.i_qp_constant != x4->cqp) { |
212 | x4->params.rc.i_qp_constant = x4->cqp; |
213 | x264_encoder_reconfig(x4->enc, &x4->params); |
214 | } |
215 | |
216 | if (x4->crf_max >= 0 && |
217 | x4->params.rc.f_rf_constant_max != x4->crf_max) { |
218 | x4->params.rc.f_rf_constant_max = x4->crf_max; |
219 | x264_encoder_reconfig(x4->enc, &x4->params); |
220 | } |
221 | } |
222 | |
223 | side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_STEREO3D); |
224 | if (side_data) { |
225 | AVStereo3D *stereo = (AVStereo3D *)side_data->data; |
226 | int fpa_type; |
227 | |
228 | switch (stereo->type) { |
229 | case AV_STEREO3D_CHECKERBOARD: |
230 | fpa_type = 0; |
231 | break; |
232 | case AV_STEREO3D_COLUMNS: |
233 | fpa_type = 1; |
234 | break; |
235 | case AV_STEREO3D_LINES: |
236 | fpa_type = 2; |
237 | break; |
238 | case AV_STEREO3D_SIDEBYSIDE: |
239 | fpa_type = 3; |
240 | break; |
241 | case AV_STEREO3D_TOPBOTTOM: |
242 | fpa_type = 4; |
243 | break; |
244 | case AV_STEREO3D_FRAMESEQUENCE: |
245 | fpa_type = 5; |
246 | break; |
247 | #if X264_BUILD >= 145 |
248 | case AV_STEREO3D_2D: |
249 | fpa_type = 6; |
250 | break; |
251 | #endif |
252 | default: |
253 | fpa_type = -1; |
254 | break; |
255 | } |
256 | |
257 | /* Inverted mode is not supported by x264 */ |
258 | if (stereo->flags & AV_STEREO3D_FLAG_INVERT) { |
259 | av_log(ctx, AV_LOG_WARNING, |
260 | "Ignoring unsupported inverted stereo value %d\n", fpa_type); |
261 | fpa_type = -1; |
262 | } |
263 | |
264 | if (fpa_type != x4->params.i_frame_packing) { |
265 | x4->params.i_frame_packing = fpa_type; |
266 | x264_encoder_reconfig(x4->enc, &x4->params); |
267 | } |
268 | } |
269 | } |
270 | |
271 | static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, |
272 | int *got_packet) |
273 | { |
274 | X264Context *x4 = ctx->priv_data; |
275 | x264_nal_t *nal; |
276 | int nnal, i, ret; |
277 | x264_picture_t pic_out = {0}; |
278 | int pict_type; |
279 | |
280 | x264_picture_init( &x4->pic ); |
281 | x4->pic.img.i_csp = x4->params.i_csp; |
282 | if (x264_bit_depth > 8) |
283 | x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH; |
284 | x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt); |
285 | |
286 | if (frame) { |
287 | for (i = 0; i < x4->pic.img.i_plane; i++) { |
288 | x4->pic.img.plane[i] = frame->data[i]; |
289 | x4->pic.img.i_stride[i] = frame->linesize[i]; |
290 | } |
291 | |
292 | x4->pic.i_pts = frame->pts; |
293 | |
294 | switch (frame->pict_type) { |
295 | case AV_PICTURE_TYPE_I: |
296 | x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR |
297 | : X264_TYPE_KEYFRAME; |
298 | break; |
299 | case AV_PICTURE_TYPE_P: |
300 | x4->pic.i_type = X264_TYPE_P; |
301 | break; |
302 | case AV_PICTURE_TYPE_B: |
303 | x4->pic.i_type = X264_TYPE_B; |
304 | break; |
305 | default: |
306 | x4->pic.i_type = X264_TYPE_AUTO; |
307 | break; |
308 | } |
309 | reconfig_encoder(ctx, frame); |
310 | |
311 | if (x4->a53_cc) { |
312 | void *sei_data; |
313 | size_t sei_size; |
314 | |
315 | ret = ff_alloc_a53_sei(frame, 0, &sei_data, &sei_size); |
316 | if (ret < 0) { |
317 | av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n"); |
318 | } else if (sei_data) { |
319 | x4->pic.extra_sei.payloads = av_mallocz(sizeof(x4->pic.extra_sei.payloads[0])); |
320 | if (x4->pic.extra_sei.payloads == NULL) { |
321 | av_log(ctx, AV_LOG_ERROR, "Not enough memory for closed captions, skipping\n"); |
322 | av_free(sei_data); |
323 | } else { |
324 | x4->pic.extra_sei.sei_free = av_free; |
325 | |
326 | x4->pic.extra_sei.payloads[0].payload_size = sei_size; |
327 | x4->pic.extra_sei.payloads[0].payload = sei_data; |
328 | x4->pic.extra_sei.num_payloads = 1; |
329 | x4->pic.extra_sei.payloads[0].payload_type = 4; |
330 | } |
331 | } |
332 | } |
333 | } |
334 | |
335 | do { |
336 | if (x264_encoder_encode(x4->enc, &nal, &nnal, frame? &x4->pic: NULL, &pic_out) < 0) |
337 | return AVERROR_EXTERNAL; |
338 | |
339 | ret = encode_nals(ctx, pkt, nal, nnal); |
340 | if (ret < 0) |
341 | return ret; |
342 | } while (!ret && !frame && x264_encoder_delayed_frames(x4->enc)); |
343 | |
344 | pkt->pts = pic_out.i_pts; |
345 | pkt->dts = pic_out.i_dts; |
346 | |
347 | |
348 | switch (pic_out.i_type) { |
349 | case X264_TYPE_IDR: |
350 | case X264_TYPE_I: |
351 | pict_type = AV_PICTURE_TYPE_I; |
352 | break; |
353 | case X264_TYPE_P: |
354 | pict_type = AV_PICTURE_TYPE_P; |
355 | break; |
356 | case X264_TYPE_B: |
357 | case X264_TYPE_BREF: |
358 | pict_type = AV_PICTURE_TYPE_B; |
359 | break; |
360 | default: |
361 | pict_type = AV_PICTURE_TYPE_NONE; |
362 | } |
363 | #if FF_API_CODED_FRAME |
364 | FF_DISABLE_DEPRECATION_WARNINGS |
365 | ctx->coded_frame->pict_type = pict_type; |
366 | FF_ENABLE_DEPRECATION_WARNINGS |
367 | #endif |
368 | |
369 | pkt->flags |= AV_PKT_FLAG_KEY*pic_out.b_keyframe; |
370 | if (ret) { |
371 | ff_side_data_set_encoder_stats(pkt, (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA, NULL, 0, pict_type); |
372 | |
373 | #if FF_API_CODED_FRAME |
374 | FF_DISABLE_DEPRECATION_WARNINGS |
375 | ctx->coded_frame->quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA; |
376 | FF_ENABLE_DEPRECATION_WARNINGS |
377 | #endif |
378 | } |
379 | |
380 | *got_packet = ret; |
381 | return 0; |
382 | } |
383 | |
384 | static av_cold int X264_close(AVCodecContext *avctx) |
385 | { |
386 | X264Context *x4 = avctx->priv_data; |
387 | |
388 | av_freep(&avctx->extradata); |
389 | av_freep(&x4->sei); |
390 | |
391 | if (x4->enc) { |
392 | x264_encoder_close(x4->enc); |
393 | x4->enc = NULL; |
394 | } |
395 | |
396 | return 0; |
397 | } |
398 | |
399 | #define OPT_STR(opt, param) \ |
400 | do { \ |
401 | int ret; \ |
402 | if ((ret = x264_param_parse(&x4->params, opt, param)) < 0) { \ |
403 | if(ret == X264_PARAM_BAD_NAME) \ |
404 | av_log(avctx, AV_LOG_ERROR, \ |
405 | "bad option '%s': '%s'\n", opt, param); \ |
406 | else \ |
407 | av_log(avctx, AV_LOG_ERROR, \ |
408 | "bad value for '%s': '%s'\n", opt, param); \ |
409 | return -1; \ |
410 | } \ |
411 | } while (0) |
412 | |
413 | static int convert_pix_fmt(enum AVPixelFormat pix_fmt) |
414 | { |
415 | switch (pix_fmt) { |
416 | case AV_PIX_FMT_YUV420P: |
417 | case AV_PIX_FMT_YUVJ420P: |
418 | case AV_PIX_FMT_YUV420P9: |
419 | case AV_PIX_FMT_YUV420P10: return X264_CSP_I420; |
420 | case AV_PIX_FMT_YUV422P: |
421 | case AV_PIX_FMT_YUVJ422P: |
422 | case AV_PIX_FMT_YUV422P10: return X264_CSP_I422; |
423 | case AV_PIX_FMT_YUV444P: |
424 | case AV_PIX_FMT_YUVJ444P: |
425 | case AV_PIX_FMT_YUV444P9: |
426 | case AV_PIX_FMT_YUV444P10: return X264_CSP_I444; |
427 | #if CONFIG_LIBX264RGB_ENCODER |
428 | case AV_PIX_FMT_BGR0: |
429 | return X264_CSP_BGRA; |
430 | case AV_PIX_FMT_BGR24: |
431 | return X264_CSP_BGR; |
432 | |
433 | case AV_PIX_FMT_RGB24: |
434 | return X264_CSP_RGB; |
435 | #endif |
436 | case AV_PIX_FMT_NV12: return X264_CSP_NV12; |
437 | case AV_PIX_FMT_NV16: |
438 | case AV_PIX_FMT_NV20: return X264_CSP_NV16; |
439 | #ifdef X264_CSP_NV21 |
440 | case AV_PIX_FMT_NV21: return X264_CSP_NV21; |
441 | #endif |
442 | }; |
443 | return 0; |
444 | } |
445 | |
446 | #define PARSE_X264_OPT(name, var)\ |
447 | if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\ |
448 | av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\ |
449 | return AVERROR(EINVAL);\ |
450 | } |
451 | |
452 | static av_cold int X264_init(AVCodecContext *avctx) |
453 | { |
454 | X264Context *x4 = avctx->priv_data; |
455 | AVCPBProperties *cpb_props; |
456 | int sw,sh; |
457 | |
458 | if (avctx->global_quality > 0) |
459 | av_log(avctx, AV_LOG_WARNING, "-qscale is ignored, -crf is recommended.\n"); |
460 | |
461 | #if CONFIG_LIBX262_ENCODER |
462 | if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO) { |
463 | x4->params.b_mpeg2 = 1; |
464 | x264_param_default_mpeg2(&x4->params); |
465 | } else |
466 | #endif |
467 | x264_param_default(&x4->params); |
468 | |
469 | x4->params.b_deblocking_filter = avctx->flags & AV_CODEC_FLAG_LOOP_FILTER; |
470 | |
471 | if (x4->preset || x4->tune) |
472 | if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) { |
473 | int i; |
474 | av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune); |
475 | av_log(avctx, AV_LOG_INFO, "Possible presets:"); |
476 | for (i = 0; x264_preset_names[i]; i++) |
477 | av_log(avctx, AV_LOG_INFO, " %s", x264_preset_names[i]); |
478 | av_log(avctx, AV_LOG_INFO, "\n"); |
479 | av_log(avctx, AV_LOG_INFO, "Possible tunes:"); |
480 | for (i = 0; x264_tune_names[i]; i++) |
481 | av_log(avctx, AV_LOG_INFO, " %s", x264_tune_names[i]); |
482 | av_log(avctx, AV_LOG_INFO, "\n"); |
483 | return AVERROR(EINVAL); |
484 | } |
485 | |
486 | if (avctx->level > 0) |
487 | x4->params.i_level_idc = avctx->level; |
488 | |
489 | x4->params.pf_log = X264_log; |
490 | x4->params.p_log_private = avctx; |
491 | x4->params.i_log_level = X264_LOG_DEBUG; |
492 | x4->params.i_csp = convert_pix_fmt(avctx->pix_fmt); |
493 | |
494 | PARSE_X264_OPT("weightp", wpredp); |
495 | |
496 | if (avctx->bit_rate) { |
497 | x4->params.rc.i_bitrate = avctx->bit_rate / 1000; |
498 | x4->params.rc.i_rc_method = X264_RC_ABR; |
499 | } |
500 | x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000; |
501 | x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate / 1000; |
502 | x4->params.rc.b_stat_write = avctx->flags & AV_CODEC_FLAG_PASS1; |
503 | if (avctx->flags & AV_CODEC_FLAG_PASS2) { |
504 | x4->params.rc.b_stat_read = 1; |
505 | } else { |
506 | if (x4->crf >= 0) { |
507 | x4->params.rc.i_rc_method = X264_RC_CRF; |
508 | x4->params.rc.f_rf_constant = x4->crf; |
509 | } else if (x4->cqp >= 0) { |
510 | x4->params.rc.i_rc_method = X264_RC_CQP; |
511 | x4->params.rc.i_qp_constant = x4->cqp; |
512 | } |
513 | |
514 | if (x4->crf_max >= 0) |
515 | x4->params.rc.f_rf_constant_max = x4->crf_max; |
516 | } |
517 | |
518 | if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy > 0 && |
519 | (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) { |
520 | x4->params.rc.f_vbv_buffer_init = |
521 | (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size; |
522 | } |
523 | |
524 | PARSE_X264_OPT("level", level); |
525 | |
526 | if (avctx->i_quant_factor > 0) |
527 | x4->params.rc.f_ip_factor = 1 / fabs(avctx->i_quant_factor); |
528 | if (avctx->b_quant_factor > 0) |
529 | x4->params.rc.f_pb_factor = avctx->b_quant_factor; |
530 | |
531 | #if FF_API_PRIVATE_OPT |
532 | FF_DISABLE_DEPRECATION_WARNINGS |
533 | if (avctx->chromaoffset >= 0) |
534 | x4->chroma_offset = avctx->chromaoffset; |
535 | FF_ENABLE_DEPRECATION_WARNINGS |
536 | #endif |
537 | if (x4->chroma_offset >= 0) |
538 | x4->params.analyse.i_chroma_qp_offset = x4->chroma_offset; |
539 | |
540 | if (avctx->gop_size >= 0) |
541 | x4->params.i_keyint_max = avctx->gop_size; |
542 | if (avctx->max_b_frames >= 0) |
543 | x4->params.i_bframe = avctx->max_b_frames; |
544 | |
545 | #if FF_API_PRIVATE_OPT |
546 | FF_DISABLE_DEPRECATION_WARNINGS |
547 | if (avctx->scenechange_threshold >= 0) |
548 | x4->scenechange_threshold = avctx->scenechange_threshold; |
549 | FF_ENABLE_DEPRECATION_WARNINGS |
550 | #endif |
551 | if (x4->scenechange_threshold >= 0) |
552 | x4->params.i_scenecut_threshold = x4->scenechange_threshold; |
553 | |
554 | if (avctx->qmin >= 0) |
555 | x4->params.rc.i_qp_min = avctx->qmin; |
556 | if (avctx->qmax >= 0) |
557 | x4->params.rc.i_qp_max = avctx->qmax; |
558 | if (avctx->max_qdiff >= 0) |
559 | x4->params.rc.i_qp_step = avctx->max_qdiff; |
560 | if (avctx->qblur >= 0) |
561 | x4->params.rc.f_qblur = avctx->qblur; /* temporally blur quants */ |
562 | if (avctx->qcompress >= 0) |
563 | x4->params.rc.f_qcompress = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */ |
564 | if (avctx->refs >= 0) |
565 | x4->params.i_frame_reference = avctx->refs; |
566 | else if (x4->level) { |
567 | int i; |
568 | int mbn = AV_CEIL_RSHIFT(avctx->width, 4) * AV_CEIL_RSHIFT(avctx->height, 4); |
569 | int level_id = -1; |
570 | char *tail; |
571 | int scale = X264_BUILD < 129 ? 384 : 1; |
572 | |
573 | if (!strcmp(x4->level, "1b")) { |
574 | level_id = 9; |
575 | } else if (strlen(x4->level) <= 3){ |
576 | level_id = av_strtod(x4->level, &tail) * 10 + 0.5; |
577 | if (*tail) |
578 | level_id = -1; |
579 | } |
580 | if (level_id <= 0) |
581 | av_log(avctx, AV_LOG_WARNING, "Failed to parse level\n"); |
582 | |
583 | for (i = 0; i<x264_levels[i].level_idc; i++) |
584 | if (x264_levels[i].level_idc == level_id) |
585 | x4->params.i_frame_reference = av_clip(x264_levels[i].dpb / mbn / scale, 1, x4->params.i_frame_reference); |
586 | } |
587 | |
588 | if (avctx->trellis >= 0) |
589 | x4->params.analyse.i_trellis = avctx->trellis; |
590 | if (avctx->me_range >= 0) |
591 | x4->params.analyse.i_me_range = avctx->me_range; |
592 | #if FF_API_PRIVATE_OPT |
593 | FF_DISABLE_DEPRECATION_WARNINGS |
594 | if (avctx->noise_reduction >= 0) |
595 | x4->noise_reduction = avctx->noise_reduction; |
596 | FF_ENABLE_DEPRECATION_WARNINGS |
597 | #endif |
598 | if (x4->noise_reduction >= 0) |
599 | x4->params.analyse.i_noise_reduction = x4->noise_reduction; |
600 | if (avctx->me_subpel_quality >= 0) |
601 | x4->params.analyse.i_subpel_refine = avctx->me_subpel_quality; |
602 | #if FF_API_PRIVATE_OPT |
603 | FF_DISABLE_DEPRECATION_WARNINGS |
604 | if (avctx->b_frame_strategy >= 0) |
605 | x4->b_frame_strategy = avctx->b_frame_strategy; |
606 | FF_ENABLE_DEPRECATION_WARNINGS |
607 | #endif |
608 | if (avctx->keyint_min >= 0) |
609 | x4->params.i_keyint_min = avctx->keyint_min; |
610 | #if FF_API_CODER_TYPE |
611 | FF_DISABLE_DEPRECATION_WARNINGS |
612 | if (avctx->coder_type >= 0) |
613 | x4->coder = avctx->coder_type == FF_CODER_TYPE_AC; |
614 | FF_ENABLE_DEPRECATION_WARNINGS |
615 | #endif |
616 | if (avctx->me_cmp >= 0) |
617 | x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA; |
618 | |
619 | if (x4->aq_mode >= 0) |
620 | x4->params.rc.i_aq_mode = x4->aq_mode; |
621 | if (x4->aq_strength >= 0) |
622 | x4->params.rc.f_aq_strength = x4->aq_strength; |
623 | PARSE_X264_OPT("psy-rd", psy_rd); |
624 | PARSE_X264_OPT("deblock", deblock); |
625 | PARSE_X264_OPT("partitions", partitions); |
626 | PARSE_X264_OPT("stats", stats); |
627 | if (x4->psy >= 0) |
628 | x4->params.analyse.b_psy = x4->psy; |
629 | if (x4->rc_lookahead >= 0) |
630 | x4->params.rc.i_lookahead = x4->rc_lookahead; |
631 | if (x4->weightp >= 0) |
632 | x4->params.analyse.i_weighted_pred = x4->weightp; |
633 | if (x4->weightb >= 0) |
634 | x4->params.analyse.b_weighted_bipred = x4->weightb; |
635 | if (x4->cplxblur >= 0) |
636 | x4->params.rc.f_complexity_blur = x4->cplxblur; |
637 | |
638 | if (x4->ssim >= 0) |
639 | x4->params.analyse.b_ssim = x4->ssim; |
640 | if (x4->intra_refresh >= 0) |
641 | x4->params.b_intra_refresh = x4->intra_refresh; |
642 | if (x4->bluray_compat >= 0) { |
643 | x4->params.b_bluray_compat = x4->bluray_compat; |
644 | x4->params.b_vfr_input = 0; |
645 | } |
646 | if (x4->avcintra_class >= 0) |
647 | #if X264_BUILD >= 142 |
648 | x4->params.i_avcintra_class = x4->avcintra_class; |
649 | #else |
650 | av_log(avctx, AV_LOG_ERROR, |
651 | "x264 too old for AVC Intra, at least version 142 needed\n"); |
652 | #endif |
653 | if (x4->b_bias != INT_MIN) |
654 | x4->params.i_bframe_bias = x4->b_bias; |
655 | if (x4->b_pyramid >= 0) |
656 | x4->params.i_bframe_pyramid = x4->b_pyramid; |
657 | if (x4->mixed_refs >= 0) |
658 | x4->params.analyse.b_mixed_references = x4->mixed_refs; |
659 | if (x4->dct8x8 >= 0) |
660 | x4->params.analyse.b_transform_8x8 = x4->dct8x8; |
661 | if (x4->fast_pskip >= 0) |
662 | x4->params.analyse.b_fast_pskip = x4->fast_pskip; |
663 | if (x4->aud >= 0) |
664 | x4->params.b_aud = x4->aud; |
665 | if (x4->mbtree >= 0) |
666 | x4->params.rc.b_mb_tree = x4->mbtree; |
667 | if (x4->direct_pred >= 0) |
668 | x4->params.analyse.i_direct_mv_pred = x4->direct_pred; |
669 | |
670 | if (x4->slice_max_size >= 0) |
671 | x4->params.i_slice_max_size = x4->slice_max_size; |
672 | |
673 | if (x4->fastfirstpass) |
674 | x264_param_apply_fastfirstpass(&x4->params); |
675 | |
676 | /* Allow specifying the x264 profile through AVCodecContext. */ |
677 | if (!x4->profile) |
678 | switch (avctx->profile) { |
679 | case FF_PROFILE_H264_BASELINE: |
680 | x4->profile = av_strdup("baseline"); |
681 | break; |
682 | case FF_PROFILE_H264_HIGH: |
683 | x4->profile = av_strdup("high"); |
684 | break; |
685 | case FF_PROFILE_H264_HIGH_10: |
686 | x4->profile = av_strdup("high10"); |
687 | break; |
688 | case FF_PROFILE_H264_HIGH_422: |
689 | x4->profile = av_strdup("high422"); |
690 | break; |
691 | case FF_PROFILE_H264_HIGH_444: |
692 | x4->profile = av_strdup("high444"); |
693 | break; |
694 | case FF_PROFILE_H264_MAIN: |
695 | x4->profile = av_strdup("main"); |
696 | break; |
697 | default: |
698 | break; |
699 | } |
700 | |
701 | if (x4->nal_hrd >= 0) |
702 | x4->params.i_nal_hrd = x4->nal_hrd; |
703 | |
704 | if (x4->motion_est >= 0) { |
705 | x4->params.analyse.i_me_method = x4->motion_est; |
706 | #if FF_API_MOTION_EST |
707 | FF_DISABLE_DEPRECATION_WARNINGS |
708 | } else { |
709 | if (avctx->me_method == ME_EPZS) |
710 | x4->params.analyse.i_me_method = X264_ME_DIA; |
711 | else if (avctx->me_method == ME_HEX) |
712 | x4->params.analyse.i_me_method = X264_ME_HEX; |
713 | else if (avctx->me_method == ME_UMH) |
714 | x4->params.analyse.i_me_method = X264_ME_UMH; |
715 | else if (avctx->me_method == ME_FULL) |
716 | x4->params.analyse.i_me_method = X264_ME_ESA; |
717 | else if (avctx->me_method == ME_TESA) |
718 | x4->params.analyse.i_me_method = X264_ME_TESA; |
719 | FF_ENABLE_DEPRECATION_WARNINGS |
720 | #endif |
721 | } |
722 | |
723 | if (x4->coder >= 0) |
724 | x4->params.b_cabac = x4->coder; |
725 | |
726 | if (x4->b_frame_strategy >= 0) |
727 | x4->params.i_bframe_adaptive = x4->b_frame_strategy; |
728 | |
729 | if (x4->profile) |
730 | if (x264_param_apply_profile(&x4->params, x4->profile) < 0) { |
731 | int i; |
732 | av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile); |
733 | av_log(avctx, AV_LOG_INFO, "Possible profiles:"); |
734 | for (i = 0; x264_profile_names[i]; i++) |
735 | av_log(avctx, AV_LOG_INFO, " %s", x264_profile_names[i]); |
736 | av_log(avctx, AV_LOG_INFO, "\n"); |
737 | return AVERROR(EINVAL); |
738 | } |
739 | |
740 | x4->params.i_width = avctx->width; |
741 | x4->params.i_height = avctx->height; |
742 | av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096); |
743 | x4->params.vui.i_sar_width = sw; |
744 | x4->params.vui.i_sar_height = sh; |
745 | x4->params.i_timebase_den = avctx->time_base.den; |
746 | x4->params.i_timebase_num = avctx->time_base.num; |
747 | x4->params.i_fps_num = avctx->time_base.den; |
748 | x4->params.i_fps_den = avctx->time_base.num * avctx->ticks_per_frame; |
749 | |
750 | x4->params.analyse.b_psnr = avctx->flags & AV_CODEC_FLAG_PSNR; |
751 | |
752 | x4->params.i_threads = avctx->thread_count; |
753 | if (avctx->thread_type) |
754 | x4->params.b_sliced_threads = avctx->thread_type == FF_THREAD_SLICE; |
755 | |
756 | x4->params.b_interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT; |
757 | |
758 | x4->params.b_open_gop = !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP); |
759 | |
760 | x4->params.i_slice_count = avctx->slices; |
761 | |
762 | x4->params.vui.b_fullrange = avctx->pix_fmt == AV_PIX_FMT_YUVJ420P || |
763 | avctx->pix_fmt == AV_PIX_FMT_YUVJ422P || |
764 | avctx->pix_fmt == AV_PIX_FMT_YUVJ444P || |
765 | avctx->color_range == AVCOL_RANGE_JPEG; |
766 | |
767 | if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED) |
768 | x4->params.vui.i_colmatrix = avctx->colorspace; |
769 | if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) |
770 | x4->params.vui.i_colorprim = avctx->color_primaries; |
771 | if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED) |
772 | x4->params.vui.i_transfer = avctx->color_trc; |
773 | |
774 | if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) |
775 | x4->params.b_repeat_headers = 0; |
776 | |
777 | if(x4->x264opts){ |
778 | const char *p= x4->x264opts; |
779 | while(p){ |
780 | char param[4096]={0}, val[4096]={0}; |
781 | if(sscanf(p, "%4095[^:=]=%4095[^:]", param, val) == 1){ |
782 | OPT_STR(param, "1"); |
783 | }else |
784 | OPT_STR(param, val); |
785 | p= strchr(p, ':'); |
786 | p+=!!p; |
787 | } |
788 | } |
789 | |
790 | if (x4->x264_params) { |
791 | AVDictionary *dict = NULL; |
792 | AVDictionaryEntry *en = NULL; |
793 | |
794 | if (!av_dict_parse_string(&dict, x4->x264_params, "=", ":", 0)) { |
795 | while ((en = av_dict_get(dict, "", en, AV_DICT_IGNORE_SUFFIX))) { |
796 | if (x264_param_parse(&x4->params, en->key, en->value) < 0) |
797 | av_log(avctx, AV_LOG_WARNING, |
798 | "Error parsing option '%s = %s'.\n", |
799 | en->key, en->value); |
800 | } |
801 | |
802 | av_dict_free(&dict); |
803 | } |
804 | } |
805 | |
806 | // update AVCodecContext with x264 parameters |
807 | avctx->has_b_frames = x4->params.i_bframe ? |
808 | x4->params.i_bframe_pyramid ? 2 : 1 : 0; |
809 | if (avctx->max_b_frames < 0) |
810 | avctx->max_b_frames = 0; |
811 | |
812 | avctx->bit_rate = x4->params.rc.i_bitrate*1000; |
813 | |
814 | x4->enc = x264_encoder_open(&x4->params); |
815 | if (!x4->enc) |
816 | return AVERROR_EXTERNAL; |
817 | |
818 | if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) { |
819 | x264_nal_t *nal; |
820 | uint8_t *p; |
821 | int nnal, s, i; |
822 | |
823 | s = x264_encoder_headers(x4->enc, &nal, &nnal); |
824 | avctx->extradata = p = av_mallocz(s + AV_INPUT_BUFFER_PADDING_SIZE); |
825 | if (!p) |
826 | return AVERROR(ENOMEM); |
827 | |
828 | for (i = 0; i < nnal; i++) { |
829 | /* Don't put the SEI in extradata. */ |
830 | if (nal[i].i_type == NAL_SEI) { |
831 | av_log(avctx, AV_LOG_INFO, "%s\n", nal[i].p_payload+25); |
832 | x4->sei_size = nal[i].i_payload; |
833 | x4->sei = av_malloc(x4->sei_size); |
834 | if (!x4->sei) |
835 | return AVERROR(ENOMEM); |
836 | memcpy(x4->sei, nal[i].p_payload, nal[i].i_payload); |
837 | continue; |
838 | } |
839 | memcpy(p, nal[i].p_payload, nal[i].i_payload); |
840 | p += nal[i].i_payload; |
841 | } |
842 | avctx->extradata_size = p - avctx->extradata; |
843 | } |
844 | |
845 | cpb_props = ff_add_cpb_side_data(avctx); |
846 | if (!cpb_props) |
847 | return AVERROR(ENOMEM); |
848 | cpb_props->buffer_size = x4->params.rc.i_vbv_buffer_size * 1000; |
849 | cpb_props->max_bitrate = x4->params.rc.i_vbv_max_bitrate * 1000; |
850 | cpb_props->avg_bitrate = x4->params.rc.i_bitrate * 1000; |
851 | |
852 | return 0; |
853 | } |
854 | |
855 | static const enum AVPixelFormat pix_fmts_8bit[] = { |
856 | AV_PIX_FMT_YUV420P, |
857 | AV_PIX_FMT_YUVJ420P, |
858 | AV_PIX_FMT_YUV422P, |
859 | AV_PIX_FMT_YUVJ422P, |
860 | AV_PIX_FMT_YUV444P, |
861 | AV_PIX_FMT_YUVJ444P, |
862 | AV_PIX_FMT_NV12, |
863 | AV_PIX_FMT_NV16, |
864 | #ifdef X264_CSP_NV21 |
865 | AV_PIX_FMT_NV21, |
866 | #endif |
867 | AV_PIX_FMT_NONE |
868 | }; |
869 | static const enum AVPixelFormat pix_fmts_9bit[] = { |
870 | AV_PIX_FMT_YUV420P9, |
871 | AV_PIX_FMT_YUV444P9, |
872 | AV_PIX_FMT_NONE |
873 | }; |
874 | static const enum AVPixelFormat pix_fmts_10bit[] = { |
875 | AV_PIX_FMT_YUV420P10, |
876 | AV_PIX_FMT_YUV422P10, |
877 | AV_PIX_FMT_YUV444P10, |
878 | AV_PIX_FMT_NV20, |
879 | AV_PIX_FMT_NONE |
880 | }; |
881 | #if CONFIG_LIBX264RGB_ENCODER |
882 | static const enum AVPixelFormat pix_fmts_8bit_rgb[] = { |
883 | AV_PIX_FMT_BGR0, |
884 | AV_PIX_FMT_BGR24, |
885 | AV_PIX_FMT_RGB24, |
886 | AV_PIX_FMT_NONE |
887 | }; |
888 | #endif |
889 | |
890 | static av_cold void X264_init_static(AVCodec *codec) |
891 | { |
892 | if (x264_bit_depth == 8) |
893 | codec->pix_fmts = pix_fmts_8bit; |
894 | else if (x264_bit_depth == 9) |
895 | codec->pix_fmts = pix_fmts_9bit; |
896 | else if (x264_bit_depth == 10) |
897 | codec->pix_fmts = pix_fmts_10bit; |
898 | } |
899 | |
900 | #define OFFSET(x) offsetof(X264Context, x) |
901 | #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM |
902 | static const AVOption options[] = { |
903 | { "preset", "Set the encoding preset (cf. x264 --fullhelp)", OFFSET(preset), AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE}, |
904 | { "tune", "Tune the encoding params (cf. x264 --fullhelp)", OFFSET(tune), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, |
905 | { "profile", "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, |
906 | { "fastfirstpass", "Use fast settings when encoding first pass", OFFSET(fastfirstpass), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE}, |
907 | {"level", "Specify level (as defined by Annex A)", OFFSET(level), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, |
908 | {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, |
909 | {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, |
910 | {"a53cc", "Use A53 Closed Captions (if available)", OFFSET(a53_cc), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VE}, |
911 | {"x264opts", "x264 options", OFFSET(x264opts), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE}, |
912 | { "crf", "Select the quality for constant quality mode", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE }, |
913 | { "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 }, |
914 | { "qp", "Constant quantization parameter rate control method",OFFSET(cqp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE }, |
915 | { "aq-mode", "AQ method", OFFSET(aq_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "aq_mode"}, |
916 | { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_NONE}, INT_MIN, INT_MAX, VE, "aq_mode" }, |
917 | { "variance", "Variance AQ (complexity mask)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_VARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" }, |
918 | { "autovariance", "Auto-variance AQ", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" }, |
919 | #if X264_BUILD >= 144 |
920 | { "autovariance-biased", "Auto-variance AQ with bias to dark scenes", 0, AV_OPT_TYPE_CONST, {.i64 = X264_AQ_AUTOVARIANCE_BIASED}, INT_MIN, INT_MAX, VE, "aq_mode" }, |
921 | #endif |
922 | { "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}, |
923 | { "psy", "Use psychovisual optimizations.", OFFSET(psy), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, |
924 | { "psy-rd", "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING, {0 }, 0, 0, VE}, |
925 | { "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 }, |
926 | { "weightb", "Weighted prediction for B-frames.", OFFSET(weightb), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, |
927 | { "weightp", "Weighted prediction analysis method.", OFFSET(weightp), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "weightp" }, |
928 | { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_NONE}, INT_MIN, INT_MAX, VE, "weightp" }, |
929 | { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" }, |
930 | { "smart", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_WEIGHTP_SMART}, INT_MIN, INT_MAX, VE, "weightp" }, |
931 | { "ssim", "Calculate and print SSIM stats.", OFFSET(ssim), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, |
932 | { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, |
933 | { "bluray-compat", "Bluray compatibility workarounds.", OFFSET(bluray_compat) ,AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE }, |
934 | { "b-bias", "Influences how often B-frames are used", OFFSET(b_bias), AV_OPT_TYPE_INT, { .i64 = INT_MIN}, INT_MIN, INT_MAX, VE }, |
935 | { "b-pyramid", "Keep some B-frames as references.", OFFSET(b_pyramid), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "b_pyramid" }, |
936 | { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NONE}, INT_MIN, INT_MAX, VE, "b_pyramid" }, |
937 | { "strict", "Strictly hierarchical pyramid", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" }, |
938 | { "normal", "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {.i64 = X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" }, |
939 | { "mixed-refs", "One reference per partition, as opposed to one reference per macroblock", OFFSET(mixed_refs), AV_OPT_TYPE_BOOL, { .i64 = -1}, -1, 1, VE }, |
940 | { "8x8dct", "High profile 8x8 transform.", OFFSET(dct8x8), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, |
941 | { "fast-pskip", NULL, OFFSET(fast_pskip), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, |
942 | { "aud", "Use access unit delimiters.", OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, |
943 | { "mbtree", "Use macroblock tree ratecontrol.", OFFSET(mbtree), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE}, |
944 | { "deblock", "Loop filter parameters, in <alpha:beta> form.", OFFSET(deblock), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, |
945 | { "cplxblur", "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, VE}, |
946 | { "partitions", "A comma-separated list of partitions to consider. " |
947 | "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE}, |
948 | { "direct-pred", "Direct MV prediction mode", OFFSET(direct_pred), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "direct-pred" }, |
949 | { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_NONE }, 0, 0, VE, "direct-pred" }, |
950 | { "spatial", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_SPATIAL }, 0, 0, VE, "direct-pred" }, |
951 | { "temporal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" }, |
952 | { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_DIRECT_PRED_AUTO }, 0, 0, VE, "direct-pred" }, |
953 | { "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 }, |
954 | { "stats", "Filename for 2 pass stats", OFFSET(stats), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE }, |
955 | { "nal-hrd", "Signal HRD information (requires vbv-bufsize; " |
956 | "cbr not allowed in .mp4)", OFFSET(nal_hrd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE, "nal-hrd" }, |
957 | { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_NONE}, INT_MIN, INT_MAX, VE, "nal-hrd" }, |
958 | { "vbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_VBR}, INT_MIN, INT_MAX, VE, "nal-hrd" }, |
959 | { "cbr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = X264_NAL_HRD_CBR}, INT_MIN, INT_MAX, VE, "nal-hrd" }, |
960 | { "avcintra-class","AVC-Intra class 50/100/200", OFFSET(avcintra_class),AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 200 , VE}, |
961 | { "motion-est", "Set motion estimation method", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, X264_ME_TESA, VE, "motion-est"}, |
962 | { "dia", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_DIA }, INT_MIN, INT_MAX, VE, "motion-est" }, |
963 | { "hex", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_HEX }, INT_MIN, INT_MAX, VE, "motion-est" }, |
964 | { "umh", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH }, INT_MIN, INT_MAX, VE, "motion-est" }, |
965 | { "esa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA }, INT_MIN, INT_MAX, VE, "motion-est" }, |
966 | { "tesa", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" }, |
967 | { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr), AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE }, |
968 | { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" }, |
969 | { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" }, |
970 | { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" }, |
971 | { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" }, |
972 | { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" }, |
973 | { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" }, |
974 | { "b_strategy", "Strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, VE }, |
975 | { "chromaoffset", "QP difference between chroma and luma", OFFSET(chroma_offset), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE }, |
976 | { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE }, |
977 | { "noise_reduction", "Noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX, VE }, |
978 | |
979 | { "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 }, |
980 | { NULL }, |
981 | }; |
982 | |
983 | static const AVCodecDefault x264_defaults[] = { |
984 | { "b", "0" }, |
985 | { "bf", "-1" }, |
986 | { "flags2", "0" }, |
987 | { "g", "-1" }, |
988 | { "i_qfactor", "-1" }, |
989 | { "b_qfactor", "-1" }, |
990 | { "qmin", "-1" }, |
991 | { "qmax", "-1" }, |
992 | { "qdiff", "-1" }, |
993 | { "qblur", "-1" }, |
994 | { "qcomp", "-1" }, |
995 | // { "rc_lookahead", "-1" }, |
996 | { "refs", "-1" }, |
997 | #if FF_API_PRIVATE_OPT |
998 | { "sc_threshold", "-1" }, |
999 | #endif |
1000 | { "trellis", "-1" }, |
1001 | #if FF_API_PRIVATE_OPT |
1002 | { "nr", "-1" }, |
1003 | #endif |
1004 | { "me_range", "-1" }, |
1005 | #if FF_API_MOTION_EST |
1006 | { "me_method", "-1" }, |
1007 | #endif |
1008 | { "subq", "-1" }, |
1009 | #if FF_API_PRIVATE_OPT |
1010 | { "b_strategy", "-1" }, |
1011 | #endif |
1012 | { "keyint_min", "-1" }, |
1013 | #if FF_API_CODER_TYPE |
1014 | { "coder", "-1" }, |
1015 | #endif |
1016 | { "cmp", "-1" }, |
1017 | { "threads", AV_STRINGIFY(X264_THREADS_AUTO) }, |
1018 | { "thread_type", "0" }, |
1019 | { "flags", "+cgop" }, |
1020 | { "rc_init_occupancy","-1" }, |
1021 | { NULL }, |
1022 | }; |
1023 | |
1024 | #if CONFIG_LIBX264_ENCODER |
1025 | static const AVClass x264_class = { |
1026 | .class_name = "libx264", |
1027 | .item_name = av_default_item_name, |
1028 | .option = options, |
1029 | .version = LIBAVUTIL_VERSION_INT, |
1030 | }; |
1031 | |
1032 | AVCodec ff_libx264_encoder = { |
1033 | .name = "libx264", |
1034 | .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), |
1035 | .type = AVMEDIA_TYPE_VIDEO, |
1036 | .id = AV_CODEC_ID_H264, |
1037 | .priv_data_size = sizeof(X264Context), |
1038 | .init = X264_init, |
1039 | .encode2 = X264_frame, |
1040 | .close = X264_close, |
1041 | .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS, |
1042 | .priv_class = &x264_class, |
1043 | .defaults = x264_defaults, |
1044 | .init_static_data = X264_init_static, |
1045 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
1046 | FF_CODEC_CAP_INIT_CLEANUP, |
1047 | }; |
1048 | #endif |
1049 | |
1050 | #if CONFIG_LIBX264RGB_ENCODER |
1051 | static const AVClass rgbclass = { |
1052 | .class_name = "libx264rgb", |
1053 | .item_name = av_default_item_name, |
1054 | .option = options, |
1055 | .version = LIBAVUTIL_VERSION_INT, |
1056 | }; |
1057 | |
1058 | AVCodec ff_libx264rgb_encoder = { |
1059 | .name = "libx264rgb", |
1060 | .long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"), |
1061 | .type = AVMEDIA_TYPE_VIDEO, |
1062 | .id = AV_CODEC_ID_H264, |
1063 | .priv_data_size = sizeof(X264Context), |
1064 | .init = X264_init, |
1065 | .encode2 = X264_frame, |
1066 | .close = X264_close, |
1067 | .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS, |
1068 | .priv_class = &rgbclass, |
1069 | .defaults = x264_defaults, |
1070 | .pix_fmts = pix_fmts_8bit_rgb, |
1071 | }; |
1072 | #endif |
1073 | |
1074 | #if CONFIG_LIBX262_ENCODER |
1075 | static const AVClass X262_class = { |
1076 | .class_name = "libx262", |
1077 | .item_name = av_default_item_name, |
1078 | .option = options, |
1079 | .version = LIBAVUTIL_VERSION_INT, |
1080 | }; |
1081 | |
1082 | AVCodec ff_libx262_encoder = { |
1083 | .name = "libx262", |
1084 | .long_name = NULL_IF_CONFIG_SMALL("libx262 MPEG2VIDEO"), |
1085 | .type = AVMEDIA_TYPE_VIDEO, |
1086 | .id = AV_CODEC_ID_MPEG2VIDEO, |
1087 | .priv_data_size = sizeof(X264Context), |
1088 | .init = X264_init, |
1089 | .encode2 = X264_frame, |
1090 | .close = X264_close, |
1091 | .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS, |
1092 | .priv_class = &X262_class, |
1093 | .defaults = x264_defaults, |
1094 | .pix_fmts = pix_fmts_8bit, |
1095 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
1096 | FF_CODEC_CAP_INIT_CLEANUP, |
1097 | }; |
1098 | #endif |
1099 |