634178521f2f9166ecb9c088e7edb0b4f160542e
[libav.git] / libavcodec / vaapi_encode_mpeg2.c
1 /*
2 * This file is part of Libav.
3 *
4 * Libav is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * Libav is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with Libav; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <va/va.h>
20 #include <va/va_enc_mpeg2.h>
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/common.h"
24 #include "libavutil/internal.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/pixfmt.h"
27
28 #include "avcodec.h"
29 #include "internal.h"
30 #include "mpegvideo.h"
31 #include "put_bits.h"
32 #include "vaapi_encode.h"
33
34 typedef struct VAAPIEncodeMPEG2Context {
35 int mb_width;
36 int mb_height;
37
38 int quant_i;
39 int quant_p;
40 int quant_b;
41
42 int64_t last_i_frame;
43
44 unsigned int bit_rate;
45 unsigned int vbv_buffer_size;
46 } VAAPIEncodeMPEG2Context;
47
48
49 #define vseq_var(name) vseq->name, name
50 #define vseqext_field(name) vseq->sequence_extension.bits.name, name
51 #define vgop_field(name) vseq->gop_header.bits.name, name
52 #define vpic_var(name) vpic->name, name
53 #define vpcext_field(name) vpic->picture_coding_extension.bits.name, name
54 #define vcomp_field(name) vpic->composite_display.bits.name, name
55
56 #define u2(width, value, name) put_bits(&pbc, width, value)
57 #define u(width, ...) u2(width, __VA_ARGS__)
58
59 static int vaapi_encode_mpeg2_write_sequence_header(AVCodecContext *avctx,
60 char *data, size_t *data_len)
61 {
62 VAAPIEncodeContext *ctx = avctx->priv_data;
63 VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
64 VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
65 PutBitContext pbc;
66
67 init_put_bits(&pbc, data, 8 * *data_len);
68
69 u(32, SEQ_START_CODE, sequence_header_code);
70
71 u(12, vseq->picture_width, horizontal_size_value);
72 u(12, vseq->picture_height, vertical_size_value);
73 u(4, vseq_var(aspect_ratio_information));
74 u(4, 8, frame_rate_code);
75 u(18, priv->bit_rate & 0x3fff, bit_rate_value);
76 u(1, 1, marker_bit);
77 u(10, priv->vbv_buffer_size & 0x3ff, vbv_buffer_size_value);
78 u(1, 0, constrained_parameters_flag);
79 u(1, 0, load_intra_quantiser_matrix);
80 // intra_quantiser_matrix[64]
81 u(1, 0, load_non_intra_quantiser_matrix);
82 // non_intra_quantiser_matrix[64]
83
84 while (put_bits_count(&pbc) % 8)
85 u(1, 0, zero_bit);
86
87 u(32, EXT_START_CODE, extension_start_code);
88 u(4, 1, extension_start_code_identifier);
89 u(8, vseqext_field(profile_and_level_indication));
90 u(1, vseqext_field(progressive_sequence));
91 u(2, vseqext_field(chroma_format));
92 u(2, 0, horizontal_size_extension);
93 u(2, 0, vertical_size_extension);
94 u(12, priv->bit_rate >> 18, bit_rate_extension);
95 u(1, 1, marker_bit);
96 u(8, priv->vbv_buffer_size >> 10, vbv_buffer_size_extension);
97 u(1, vseqext_field(low_delay));
98 u(2, vseqext_field(frame_rate_extension_n));
99 u(2, vseqext_field(frame_rate_extension_d));
100
101 while (put_bits_count(&pbc) % 8)
102 u(1, 0, zero_bit);
103
104 u(32, GOP_START_CODE, group_start_code);
105 u(25, vgop_field(time_code));
106 u(1, vgop_field(closed_gop));
107 u(1, vgop_field(broken_link));
108
109 while (put_bits_count(&pbc) % 8)
110 u(1, 0, zero_bit);
111
112 *data_len = put_bits_count(&pbc);
113 flush_put_bits(&pbc);
114
115 return 0;
116 }
117
118 static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx,
119 VAAPIEncodePicture *pic,
120 char *data, size_t *data_len)
121 {
122 VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
123 int picture_coding_type;
124 PutBitContext pbc;
125
126 init_put_bits(&pbc, data, 8 * *data_len);
127
128 u(32, PICTURE_START_CODE, picture_start_code);
129 u(10, vpic_var(temporal_reference));
130
131 switch (vpic->picture_type) {
132 case VAEncPictureTypeIntra:
133 picture_coding_type = AV_PICTURE_TYPE_I;
134 break;
135 case VAEncPictureTypePredictive:
136 picture_coding_type = AV_PICTURE_TYPE_P;
137 break;
138 case VAEncPictureTypeBidirectional:
139 picture_coding_type = AV_PICTURE_TYPE_B;
140 break;
141 default:
142 av_assert0(0 && "invalid picture_coding_type");
143 }
144 u(3, picture_coding_type, picture_coding_type);
145 u(16, 0xffff, vbv_delay);
146 if (picture_coding_type == 2 || picture_coding_type == 3) {
147 u(1, 0, full_pel_forward_vector);
148 u(3, 7, forward_f_code);
149 }
150 if (picture_coding_type == 3) {
151 u(1, 0, full_pel_backward_vector);
152 u(3, 7, backward_f_code);
153 }
154 u(1, 0, extra_bit_picture);
155
156 while (put_bits_count(&pbc) % 8)
157 u(1, 0, zero_bit);
158
159 u(32, EXT_START_CODE, extension_start_code);
160 u(4, 8, extension_start_code_identifier);
161 u(4, vpic_var(f_code[0][0]));
162 u(4, vpic_var(f_code[0][1]));
163 u(4, vpic_var(f_code[1][0]));
164 u(4, vpic_var(f_code[1][1]));
165 u(2, vpcext_field(intra_dc_precision));
166 u(2, vpcext_field(picture_structure));
167 u(1, vpcext_field(top_field_first));
168 u(1, vpcext_field(frame_pred_frame_dct));
169 u(1, vpcext_field(concealment_motion_vectors));
170 u(1, vpcext_field(q_scale_type));
171 u(1, vpcext_field(intra_vlc_format));
172 u(1, vpcext_field(alternate_scan));
173 u(1, vpcext_field(repeat_first_field));
174 u(1, 1, chroma_420_type);
175 u(1, vpcext_field(progressive_frame));
176 u(1, vpcext_field(composite_display_flag));
177 if (vpic->picture_coding_extension.bits.composite_display_flag) {
178 u(1, vcomp_field(v_axis));
179 u(3, vcomp_field(field_sequence));
180 u(1, vcomp_field(sub_carrier));
181 u(7, vcomp_field(burst_amplitude));
182 u(8, vcomp_field(sub_carrier_phase));
183 }
184
185 while (put_bits_count(&pbc) % 8)
186 u(1, 0, zero_bit);
187
188 *data_len = put_bits_count(&pbc);
189 flush_put_bits(&pbc);
190
191 return 0;
192 }
193
194 static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
195 {
196 VAAPIEncodeContext *ctx = avctx->priv_data;
197 VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
198 VAEncPictureParameterBufferMPEG2 *vpic = ctx->codec_picture_params;
199 VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
200
201 vseq->intra_period = avctx->gop_size;
202 vseq->ip_period = ctx->b_per_p + 1;
203
204 vseq->picture_width = avctx->width;
205 vseq->picture_height = avctx->height;
206
207 vseq->bits_per_second = avctx->bit_rate;
208 if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
209 vseq->frame_rate = (float)avctx->framerate.num / avctx->framerate.den;
210 else
211 vseq->frame_rate = (float)avctx->time_base.num / avctx->time_base.den;
212
213 vseq->aspect_ratio_information = 1;
214 vseq->vbv_buffer_size = avctx->rc_buffer_size / (16 * 1024);
215
216 vseq->sequence_extension.bits.profile_and_level_indication =
217 avctx->profile << 4 | avctx->level;
218 vseq->sequence_extension.bits.progressive_sequence = 1;
219 vseq->sequence_extension.bits.chroma_format = 1;
220 vseq->sequence_extension.bits.low_delay = 0;
221 vseq->sequence_extension.bits.frame_rate_extension_n = 0;
222 vseq->sequence_extension.bits.frame_rate_extension_d = 0;
223
224 vseq->new_gop_header = 0;
225 vseq->gop_header.bits.time_code = 0;
226 vseq->gop_header.bits.closed_gop = 1;
227 vseq->gop_header.bits.broken_link = 0;
228
229 vpic->forward_reference_picture = VA_INVALID_ID;
230 vpic->backward_reference_picture = VA_INVALID_ID;
231 vpic->reconstructed_picture = VA_INVALID_ID;
232
233 vpic->coded_buf = VA_INVALID_ID;
234
235 vpic->temporal_reference = 0;
236 vpic->f_code[0][0] = 15;
237 vpic->f_code[0][1] = 15;
238 vpic->f_code[1][0] = 15;
239 vpic->f_code[1][1] = 15;
240
241 vpic->picture_coding_extension.bits.intra_dc_precision = 0;
242 vpic->picture_coding_extension.bits.picture_structure = 3;
243 vpic->picture_coding_extension.bits.top_field_first = 0;
244 vpic->picture_coding_extension.bits.frame_pred_frame_dct = 1;
245 vpic->picture_coding_extension.bits.concealment_motion_vectors = 0;
246 vpic->picture_coding_extension.bits.q_scale_type = 0;
247 vpic->picture_coding_extension.bits.intra_vlc_format = 0;
248 vpic->picture_coding_extension.bits.alternate_scan = 0;
249 vpic->picture_coding_extension.bits.repeat_first_field = 0;
250 vpic->picture_coding_extension.bits.progressive_frame = 1;
251 vpic->picture_coding_extension.bits.composite_display_flag = 0;
252
253 priv->bit_rate = (avctx->bit_rate + 399) / 400;
254 priv->vbv_buffer_size = avctx->rc_buffer_size / (16 * 1024);
255
256 return 0;
257 }
258
259 static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx,
260 VAAPIEncodePicture *pic)
261 {
262 VAAPIEncodeContext *ctx = avctx->priv_data;
263 VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
264 VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
265 int fch, fcv;
266
267 switch (avctx->level) {
268 case 4: // High.
269 case 6: // High 1440.
270 fch = 9;
271 fcv = 5;
272 break;
273 case 8: // Main.
274 fch = 8;
275 fcv = 5;
276 break;
277 case 10: // Low.
278 default:
279 fch = 7;
280 fcv = 4;
281 break;
282 }
283
284 switch (pic->type) {
285 case PICTURE_TYPE_IDR:
286 case PICTURE_TYPE_I:
287 vpic->picture_type = VAEncPictureTypeIntra;
288 priv->last_i_frame = pic->display_order;
289 break;
290 case PICTURE_TYPE_P:
291 vpic->picture_type = VAEncPictureTypePredictive;
292 vpic->forward_reference_picture = pic->refs[0]->recon_surface;
293 vpic->f_code[0][0] = fch;
294 vpic->f_code[0][1] = fcv;
295 break;
296 case PICTURE_TYPE_B:
297 vpic->picture_type = VAEncPictureTypeBidirectional;
298 vpic->forward_reference_picture = pic->refs[0]->recon_surface;
299 vpic->backward_reference_picture = pic->refs[1]->recon_surface;
300 vpic->f_code[0][0] = fch;
301 vpic->f_code[0][1] = fcv;
302 vpic->f_code[1][0] = fch;
303 vpic->f_code[1][1] = fcv;
304 break;
305 default:
306 av_assert0(0 && "invalid picture type");
307 }
308
309 vpic->reconstructed_picture = pic->recon_surface;
310 vpic->coded_buf = pic->output_buffer;
311
312 vpic->temporal_reference = pic->display_order - priv->last_i_frame;
313
314 pic->nb_slices = priv->mb_height;
315
316 return 0;
317 }
318
319 static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx,
320 VAAPIEncodePicture *pic,
321 VAAPIEncodeSlice *slice)
322 {
323 VAAPIEncodeContext *ctx = avctx->priv_data;
324 VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params;
325 VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
326 int qp;
327
328 vslice->macroblock_address = priv->mb_width * slice->index;
329 vslice->num_macroblocks = priv->mb_width;
330
331 switch (pic->type) {
332 case PICTURE_TYPE_IDR:
333 case PICTURE_TYPE_I:
334 qp = priv->quant_i;
335 break;
336 case PICTURE_TYPE_P:
337 qp = priv->quant_p;
338 break;
339 case PICTURE_TYPE_B:
340 qp = priv->quant_b;
341 break;
342 default:
343 av_assert0(0 && "invalid picture type");
344 }
345
346 vslice->quantiser_scale_code = qp;
347 vslice->is_intra_slice = (pic->type == PICTURE_TYPE_IDR ||
348 pic->type == PICTURE_TYPE_I);
349
350 return 0;
351 }
352
353 static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
354 {
355 VAAPIEncodeContext *ctx = avctx->priv_data;
356 VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
357
358 priv->mb_width = FFALIGN(avctx->width, 16) / 16;
359 priv->mb_height = FFALIGN(avctx->height, 16) / 16;
360
361 if (ctx->va_rc_mode == VA_RC_CQP) {
362 priv->quant_p = av_clip(avctx->global_quality, 1, 31);
363 if (avctx->i_quant_factor > 0.0)
364 priv->quant_i = av_clip((avctx->global_quality *
365 avctx->i_quant_factor +
366 avctx->i_quant_offset) + 0.5,
367 1, 31);
368 else
369 priv->quant_i = priv->quant_p;
370 if (avctx->b_quant_factor > 0.0)
371 priv->quant_b = av_clip((avctx->global_quality *
372 avctx->b_quant_factor +
373 avctx->b_quant_offset) + 0.5,
374 1, 31);
375 else
376 priv->quant_b = priv->quant_p;
377
378 av_log(avctx, AV_LOG_DEBUG, "Using fixed quantiser "
379 "%d / %d / %d for I- / P- / B-frames.\n",
380 priv->quant_i, priv->quant_p, priv->quant_b);
381
382 } else {
383 av_assert0(0 && "Invalid RC mode.");
384 }
385
386 return 0;
387 }
388
389 static const VAAPIEncodeType vaapi_encode_type_mpeg2 = {
390 .priv_data_size = sizeof(VAAPIEncodeMPEG2Context),
391
392 .configure = &vaapi_encode_mpeg2_configure,
393
394 .sequence_params_size = sizeof(VAEncSequenceParameterBufferMPEG2),
395 .init_sequence_params = &vaapi_encode_mpeg2_init_sequence_params,
396
397 .picture_params_size = sizeof(VAEncPictureParameterBufferMPEG2),
398 .init_picture_params = &vaapi_encode_mpeg2_init_picture_params,
399
400 .slice_params_size = sizeof(VAEncSliceParameterBufferMPEG2),
401 .init_slice_params = &vaapi_encode_mpeg2_init_slice_params,
402
403 .sequence_header_type = VAEncPackedHeaderSequence,
404 .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
405
406 .picture_header_type = VAEncPackedHeaderPicture,
407 .write_picture_header = &vaapi_encode_mpeg2_write_picture_header,
408 };
409
410 static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
411 {
412 VAAPIEncodeContext *ctx = avctx->priv_data;
413
414 ctx->codec = &vaapi_encode_type_mpeg2;
415
416 switch (avctx->profile) {
417 case FF_PROFILE_MPEG2_SIMPLE:
418 ctx->va_profile = VAProfileMPEG2Simple;
419 break;
420 case FF_PROFILE_MPEG2_MAIN:
421 ctx->va_profile = VAProfileMPEG2Main;
422 break;
423 default:
424 av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 profile %d.\n",
425 avctx->profile);
426 return AVERROR(EINVAL);
427 }
428
429 ctx->va_entrypoint = VAEntrypointEncSlice;
430 ctx->va_rt_format = VA_RT_FORMAT_YUV420;
431 ctx->va_rc_mode = VA_RC_CQP;
432
433 ctx->va_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
434 VA_ENC_PACKED_HEADER_PICTURE;
435
436 ctx->surface_width = FFALIGN(avctx->width, 16);
437 ctx->surface_height = FFALIGN(avctx->height, 16);
438
439 return ff_vaapi_encode_init(avctx);
440 }
441
442 static const AVCodecDefault vaapi_encode_mpeg2_defaults[] = {
443 { "profile", "4" },
444 { "level", "4" },
445 { "bf", "1" },
446 { "g", "120" },
447 { "i_qfactor", "1.0" },
448 { "i_qoffset", "0.0" },
449 { "b_qfactor", "1.2" },
450 { "b_qoffset", "0.0" },
451 { "global_quality", "10" },
452 { NULL },
453 };
454
455 AVCodec ff_mpeg2_vaapi_encoder = {
456 .name = "mpeg2_vaapi",
457 .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
458 .type = AVMEDIA_TYPE_VIDEO,
459 .id = AV_CODEC_ID_MPEG2VIDEO,
460 .priv_data_size = sizeof(VAAPIEncodeContext),
461 .init = &vaapi_encode_mpeg2_init,
462 .encode2 = &ff_vaapi_encode2,
463 .close = &ff_vaapi_encode_close,
464 .capabilities = AV_CODEC_CAP_DELAY,
465 .defaults = vaapi_encode_mpeg2_defaults,
466 .pix_fmts = (const enum AVPixelFormat[]) {
467 AV_PIX_FMT_VAAPI,
468 AV_PIX_FMT_NONE,
469 },
470 };