FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/vaapi_encode_mjpeg.c
Date: 2022-11-28 23:49:43
Exec Total Coverage
Lines: 0 231 0.0%
Branches: 0 107 0.0%

Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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_jpeg.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/pixdesc.h"
27
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "cbs.h"
31 #include "cbs_jpeg.h"
32 #include "codec_internal.h"
33 #include "jpegtables.h"
34 #include "mjpeg.h"
35 #include "put_bits.h"
36 #include "vaapi_encode.h"
37
38
39 // Standard JPEG quantisation tables, in zigzag order.
40 static const unsigned char vaapi_encode_mjpeg_quant_luminance[64] = {
41 16, 11, 12, 14, 12, 10, 16, 14,
42 13, 14, 18, 17, 16, 19, 24, 40,
43 26, 24, 22, 22, 24, 49, 35, 37,
44 29, 40, 58, 51, 61, 60, 57, 51,
45 56, 55, 64, 72, 92, 78, 64, 68,
46 87, 69, 55, 56, 80, 109, 81, 87,
47 95, 98, 103, 104, 103, 62, 77, 113,
48 121, 112, 100, 120, 92, 101, 103, 99,
49 };
50 static const unsigned char vaapi_encode_mjpeg_quant_chrominance[64] = {
51 17, 18, 18, 24, 21, 24, 47, 26,
52 26, 47, 99, 66, 56, 66, 99, 99,
53 99, 99, 99, 99, 99, 99, 99, 99,
54 99, 99, 99, 99, 99, 99, 99, 99,
55 99, 99, 99, 99, 99, 99, 99, 99,
56 99, 99, 99, 99, 99, 99, 99, 99,
57 99, 99, 99, 99, 99, 99, 99, 99,
58 99, 99, 99, 99, 99, 99, 99, 99,
59 };
60
61 typedef struct VAAPIEncodeMJPEGContext {
62 VAAPIEncodeContext common;
63
64 // User options.
65 int jfif;
66 int huffman;
67
68 // Derived settings.
69 int quality;
70 uint8_t jfif_data[14];
71
72 // Writer structures.
73 JPEGRawFrameHeader frame_header;
74 JPEGRawScan scan;
75 JPEGRawApplicationData jfif_header;
76 JPEGRawQuantisationTableSpecification quant_tables;
77 JPEGRawHuffmanTableSpecification huffman_tables;
78
79 CodedBitstreamContext *cbc;
80 CodedBitstreamFragment current_fragment;
81 } VAAPIEncodeMJPEGContext;
82
83 static int vaapi_encode_mjpeg_write_image_header(AVCodecContext *avctx,
84 VAAPIEncodePicture *pic,
85 VAAPIEncodeSlice *slice,
86 char *data, size_t *data_len)
87 {
88 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
89 CodedBitstreamFragment *frag = &priv->current_fragment;
90 int err;
91
92 if (priv->jfif) {
93 err = ff_cbs_insert_unit_content(frag, -1,
94 JPEG_MARKER_APPN + 0,
95 &priv->jfif_header, NULL);
96 if (err < 0)
97 goto fail;
98 }
99
100 err = ff_cbs_insert_unit_content(frag, -1,
101 JPEG_MARKER_DQT,
102 &priv->quant_tables, NULL);
103 if (err < 0)
104 goto fail;
105
106 err = ff_cbs_insert_unit_content(frag, -1,
107 JPEG_MARKER_SOF0,
108 &priv->frame_header, NULL);
109 if (err < 0)
110 goto fail;
111
112 if (priv->huffman) {
113 err = ff_cbs_insert_unit_content(frag, -1,
114 JPEG_MARKER_DHT,
115 &priv->huffman_tables, NULL);
116 if (err < 0)
117 goto fail;
118 }
119
120 err = ff_cbs_insert_unit_content(frag, -1,
121 JPEG_MARKER_SOS,
122 &priv->scan, NULL);
123 if (err < 0)
124 goto fail;
125
126 err = ff_cbs_write_fragment_data(priv->cbc, frag);
127 if (err < 0) {
128 av_log(avctx, AV_LOG_ERROR, "Failed to write image header.\n");
129 goto fail;
130 }
131
132 if (*data_len < 8 * frag->data_size) {
133 av_log(avctx, AV_LOG_ERROR, "Image header too large: "
134 "%zu < %zu.\n", *data_len, 8 * frag->data_size);
135 err = AVERROR(ENOSPC);
136 goto fail;
137 }
138
139 // Remove the EOI at the end of the fragment.
140 memcpy(data, frag->data, frag->data_size - 2);
141 *data_len = 8 * (frag->data_size - 2);
142
143 err = 0;
144 fail:
145 ff_cbs_fragment_reset(frag);
146 return err;
147 }
148
149 static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx,
150 VAAPIEncodePicture *pic,
151 int index, int *type,
152 char *data, size_t *data_len)
153 {
154 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
155 int t, i, k;
156
157 if (index == 0) {
158 // Write quantisation tables.
159 JPEGRawFrameHeader *fh = &priv->frame_header;
160 JPEGRawQuantisationTableSpecification *dqt = &priv->quant_tables;
161 VAQMatrixBufferJPEG *quant;
162
163 if (*data_len < sizeof(*quant))
164 return AVERROR(ENOSPC);
165 *type = VAQMatrixBufferType;
166 *data_len = sizeof(*quant);
167
168 quant = (VAQMatrixBufferJPEG*)data;
169 memset(quant, 0, sizeof(*quant));
170
171 quant->load_lum_quantiser_matrix = 1;
172 for (i = 0; i < 64; i++)
173 quant->lum_quantiser_matrix[i] = dqt->table[fh->Tq[0]].Q[i];
174
175 if (fh->Nf > 1) {
176 quant->load_chroma_quantiser_matrix = 1;
177 for (i = 0; i < 64; i++)
178 quant->chroma_quantiser_matrix[i] =
179 dqt->table[fh->Tq[1]].Q[i];
180 }
181
182 } else if (index == 1) {
183 // Write huffman tables.
184 JPEGRawScanHeader *sh = &priv->scan.header;
185 JPEGRawHuffmanTableSpecification *dht = &priv->huffman_tables;
186 VAHuffmanTableBufferJPEGBaseline *huff;
187
188 if (*data_len < sizeof(*huff))
189 return AVERROR(ENOSPC);
190 *type = VAHuffmanTableBufferType;
191 *data_len = sizeof(*huff);
192
193 huff = (VAHuffmanTableBufferJPEGBaseline*)data;
194 memset(huff, 0, sizeof(*huff));
195
196 for (t = 0; t < 1 + (sh->Ns > 1); t++) {
197 const JPEGRawHuffmanTable *ht;
198
199 huff->load_huffman_table[t] = 1;
200
201 ht = &dht->table[2 * t];
202 for (i = k = 0; i < 16; i++)
203 k += (huff->huffman_table[t].num_dc_codes[i] = ht->L[i]);
204 av_assert0(k <= sizeof(huff->huffman_table[t].dc_values));
205 for (i = 0; i < k; i++)
206 huff->huffman_table[t].dc_values[i] = ht->V[i];
207
208 ht = &dht->table[2 * t + 1];
209 for (i = k = 0; i < 16; i++)
210 k += (huff->huffman_table[t].num_ac_codes[i] = ht->L[i]);
211 av_assert0(k <= sizeof(huff->huffman_table[t].ac_values));
212 for (i = 0; i < k; i++)
213 huff->huffman_table[t].ac_values[i] = ht->V[i];
214 }
215
216 } else {
217 return AVERROR_EOF;
218 }
219 return 0;
220 }
221
222 static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
223 VAAPIEncodePicture *pic)
224 {
225 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
226 JPEGRawFrameHeader *fh = &priv->frame_header;
227 JPEGRawScanHeader *sh = &priv->scan.header;
228 VAEncPictureParameterBufferJPEG *vpic = pic->codec_picture_params;
229 const AVPixFmtDescriptor *desc;
230 const uint8_t components_rgb[3] = { 'R', 'G', 'B' };
231 const uint8_t components_yuv[3] = { 1, 2, 3 };
232 const uint8_t *components;
233 int t, i, quant_scale, len;
234
235 av_assert0(pic->type == PICTURE_TYPE_IDR);
236
237 desc = av_pix_fmt_desc_get(priv->common.input_frames->sw_format);
238 av_assert0(desc);
239 if (desc->flags & AV_PIX_FMT_FLAG_RGB)
240 components = components_rgb;
241 else
242 components = components_yuv;
243
244 // Frame header.
245
246 fh->P = 8;
247 fh->Y = avctx->height;
248 fh->X = avctx->width;
249 fh->Nf = desc->nb_components;
250
251 for (i = 0; i < fh->Nf; i++) {
252 fh->C[i] = components[i];
253 fh->H[i] = 1 + (i == 0 ? desc->log2_chroma_w : 0);
254 fh->V[i] = 1 + (i == 0 ? desc->log2_chroma_h : 0);
255
256 fh->Tq[i] = !!i;
257 }
258
259 fh->Lf = 8 + 3 * fh->Nf;
260
261 // JFIF header.
262 if (priv->jfif) {
263 JPEGRawApplicationData *app = &priv->jfif_header;
264 AVRational sar = pic->input_image->sample_aspect_ratio;
265 int sar_w, sar_h;
266 PutByteContext pbc;
267
268 bytestream2_init_writer(&pbc, priv->jfif_data,
269 sizeof(priv->jfif_data));
270
271 bytestream2_put_buffer(&pbc, "JFIF", 5);
272 bytestream2_put_be16(&pbc, 0x0102);
273 bytestream2_put_byte(&pbc, 0);
274
275 av_reduce(&sar_w, &sar_h, sar.num, sar.den, 65535);
276 if (sar_w && sar_h) {
277 bytestream2_put_be16(&pbc, sar_w);
278 bytestream2_put_be16(&pbc, sar_h);
279 } else {
280 bytestream2_put_be16(&pbc, 1);
281 bytestream2_put_be16(&pbc, 1);
282 }
283
284 bytestream2_put_byte(&pbc, 0);
285 bytestream2_put_byte(&pbc, 0);
286
287 av_assert0(bytestream2_get_bytes_left_p(&pbc) == 0);
288
289 app->Lp = 2 + sizeof(priv->jfif_data);
290 app->Ap = priv->jfif_data;
291 app->Ap_ref = NULL;
292 }
293
294 // Quantisation tables.
295
296 if (priv->quality < 50)
297 quant_scale = 5000 / priv->quality;
298 else
299 quant_scale = 200 - 2 * priv->quality;
300
301 len = 2;
302
303 for (t = 0; t < 1 + (fh->Nf > 1); t++) {
304 JPEGRawQuantisationTable *quant = &priv->quant_tables.table[t];
305 const uint8_t *data = t == 0 ?
306 vaapi_encode_mjpeg_quant_luminance :
307 vaapi_encode_mjpeg_quant_chrominance;
308
309 quant->Pq = 0;
310 quant->Tq = t;
311 for (i = 0; i < 64; i++)
312 quant->Q[i] = av_clip(data[i] * quant_scale / 100, 1, 255);
313
314 len += 65;
315 }
316
317 priv->quant_tables.Lq = len;
318
319 // Huffman tables.
320
321 len = 2;
322
323 for (t = 0; t < 2 + 2 * (fh->Nf > 1); t++) {
324 JPEGRawHuffmanTable *huff = &priv->huffman_tables.table[t];
325 const uint8_t *lengths, *values;
326 int k;
327
328 switch (t) {
329 case 0:
330 lengths = ff_mjpeg_bits_dc_luminance + 1;
331 values = ff_mjpeg_val_dc;
332 break;
333 case 1:
334 lengths = ff_mjpeg_bits_ac_luminance + 1;
335 values = ff_mjpeg_val_ac_luminance;
336 break;
337 case 2:
338 lengths = ff_mjpeg_bits_dc_chrominance + 1;
339 values = ff_mjpeg_val_dc;
340 break;
341 case 3:
342 lengths = ff_mjpeg_bits_ac_chrominance + 1;
343 values = ff_mjpeg_val_ac_chrominance;
344 break;
345 }
346
347 huff->Tc = t % 2;
348 huff->Th = t / 2;
349
350 for (i = k = 0; i < 16; i++)
351 k += (huff->L[i] = lengths[i]);
352
353 for (i = 0; i < k; i++)
354 huff->V[i] = values[i];
355
356 len += 17 + k;
357 }
358
359 priv->huffman_tables.Lh = len;
360
361 // Scan header.
362
363 sh->Ns = fh->Nf;
364
365 for (i = 0; i < fh->Nf; i++) {
366 sh->Cs[i] = fh->C[i];
367 sh->Td[i] = i > 0;
368 sh->Ta[i] = i > 0;
369 }
370
371 sh->Ss = 0;
372 sh->Se = 63;
373 sh->Ah = 0;
374 sh->Al = 0;
375
376 sh->Ls = 6 + 2 * sh->Ns;
377
378
379 *vpic = (VAEncPictureParameterBufferJPEG) {
380 .reconstructed_picture = pic->recon_surface,
381 .coded_buf = pic->output_buffer,
382
383 .picture_width = fh->X,
384 .picture_height = fh->Y,
385
386 .pic_flags.bits = {
387 .profile = 0,
388 .progressive = 0,
389 .huffman = 1,
390 .interleaved = 0,
391 .differential = 0,
392 },
393
394 .sample_bit_depth = fh->P,
395 .num_scan = 1,
396 .num_components = fh->Nf,
397
398 // The driver modifies the provided quantisation tables according
399 // to this quality value; the middle value of 50 makes that the
400 // identity so that they are used unchanged.
401 .quality = 50,
402 };
403
404 for (i = 0; i < fh->Nf; i++) {
405 vpic->component_id[i] = fh->C[i];
406 vpic->quantiser_table_selector[i] = fh->Tq[i];
407 }
408
409 pic->nb_slices = 1;
410
411 return 0;
412 }
413
414 static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx,
415 VAAPIEncodePicture *pic,
416 VAAPIEncodeSlice *slice)
417 {
418 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
419 JPEGRawScanHeader *sh = &priv->scan.header;
420 VAEncSliceParameterBufferJPEG *vslice = slice->codec_slice_params;
421 int i;
422
423 *vslice = (VAEncSliceParameterBufferJPEG) {
424 .restart_interval = 0,
425 .num_components = sh->Ns,
426 };
427
428 for (i = 0; i < sh->Ns; i++) {
429 vslice->components[i].component_selector = sh->Cs[i];
430 vslice->components[i].dc_table_selector = sh->Td[i];
431 vslice->components[i].ac_table_selector = sh->Ta[i];
432 }
433
434 return 0;
435 }
436
437 static av_cold int vaapi_encode_mjpeg_get_encoder_caps(AVCodecContext *avctx)
438 {
439 VAAPIEncodeContext *ctx = avctx->priv_data;
440 const AVPixFmtDescriptor *desc;
441
442 desc = av_pix_fmt_desc_get(ctx->input_frames->sw_format);
443 av_assert0(desc);
444
445 ctx->surface_width = FFALIGN(avctx->width, 8 << desc->log2_chroma_w);
446 ctx->surface_height = FFALIGN(avctx->height, 8 << desc->log2_chroma_h);
447
448 return 0;
449 }
450
451 static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
452 {
453 VAAPIEncodeContext *ctx = avctx->priv_data;
454 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
455 int err;
456
457 priv->quality = ctx->rc_quality;
458 if (priv->quality < 1 || priv->quality > 100) {
459 av_log(avctx, AV_LOG_ERROR, "Invalid quality value %d "
460 "(must be 1-100).\n", priv->quality);
461 return AVERROR(EINVAL);
462 }
463
464 // Hack: the implementation calls the JPEG image header (which we
465 // will use in the same way as a slice header) generic "raw data".
466 // Therefore, if after the packed header capability check we have
467 // PACKED_HEADER_RAW_DATA available, rewrite it as
468 // PACKED_HEADER_SLICE so that the header-writing code can do the
469 // right thing.
470 if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_RAW_DATA) {
471 ctx->va_packed_headers &= ~VA_ENC_PACKED_HEADER_RAW_DATA;
472 ctx->va_packed_headers |= VA_ENC_PACKED_HEADER_SLICE;
473 }
474
475 err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_MJPEG, avctx);
476 if (err < 0)
477 return err;
478
479 return 0;
480 }
481
482 static const VAAPIEncodeProfile vaapi_encode_mjpeg_profiles[] = {
483 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
484 8, 1, 0, 0, VAProfileJPEGBaseline },
485 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
486 8, 3, 1, 1, VAProfileJPEGBaseline },
487 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
488 8, 3, 1, 0, VAProfileJPEGBaseline },
489 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
490 8, 3, 0, 0, VAProfileJPEGBaseline },
491 { FF_PROFILE_UNKNOWN }
492 };
493
494 static const VAAPIEncodeType vaapi_encode_type_mjpeg = {
495 .profiles = vaapi_encode_mjpeg_profiles,
496
497 .flags = FLAG_CONSTANT_QUALITY_ONLY |
498 FLAG_INTRA_ONLY,
499
500 .get_encoder_caps = &vaapi_encode_mjpeg_get_encoder_caps,
501 .configure = &vaapi_encode_mjpeg_configure,
502
503 .default_quality = 80,
504
505 .picture_params_size = sizeof(VAEncPictureParameterBufferJPEG),
506 .init_picture_params = &vaapi_encode_mjpeg_init_picture_params,
507
508 .slice_params_size = sizeof(VAEncSliceParameterBufferJPEG),
509 .init_slice_params = &vaapi_encode_mjpeg_init_slice_params,
510
511 .slice_header_type = VAEncPackedHeaderRawData,
512 .write_slice_header = &vaapi_encode_mjpeg_write_image_header,
513
514 .write_extra_buffer = &vaapi_encode_mjpeg_write_extra_buffer,
515 };
516
517 static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx)
518 {
519 VAAPIEncodeContext *ctx = avctx->priv_data;
520
521 ctx->codec = &vaapi_encode_type_mjpeg;
522
523 // The JPEG image header - see note above.
524 ctx->desired_packed_headers =
525 VA_ENC_PACKED_HEADER_RAW_DATA;
526
527 return ff_vaapi_encode_init(avctx);
528 }
529
530 static av_cold int vaapi_encode_mjpeg_close(AVCodecContext *avctx)
531 {
532 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
533
534 ff_cbs_fragment_free(&priv->current_fragment);
535 ff_cbs_close(&priv->cbc);
536
537 return ff_vaapi_encode_close(avctx);
538 }
539
540 #define OFFSET(x) offsetof(VAAPIEncodeMJPEGContext, x)
541 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
542 static const AVOption vaapi_encode_mjpeg_options[] = {
543 VAAPI_ENCODE_COMMON_OPTIONS,
544
545 { "jfif", "Include JFIF header",
546 OFFSET(jfif), AV_OPT_TYPE_BOOL,
547 { .i64 = 0 }, 0, 1, FLAGS },
548 { "huffman", "Include huffman tables",
549 OFFSET(huffman), AV_OPT_TYPE_BOOL,
550 { .i64 = 1 }, 0, 1, FLAGS },
551
552 { NULL },
553 };
554
555 static const FFCodecDefault vaapi_encode_mjpeg_defaults[] = {
556 { "b", "0" },
557 { NULL },
558 };
559
560 static const AVClass vaapi_encode_mjpeg_class = {
561 .class_name = "mjpeg_vaapi",
562 .item_name = av_default_item_name,
563 .option = vaapi_encode_mjpeg_options,
564 .version = LIBAVUTIL_VERSION_INT,
565 };
566
567 const FFCodec ff_mjpeg_vaapi_encoder = {
568 .p.name = "mjpeg_vaapi",
569 CODEC_LONG_NAME("MJPEG (VAAPI)"),
570 .p.type = AVMEDIA_TYPE_VIDEO,
571 .p.id = AV_CODEC_ID_MJPEG,
572 .priv_data_size = sizeof(VAAPIEncodeMJPEGContext),
573 .init = &vaapi_encode_mjpeg_init,
574 FF_CODEC_RECEIVE_PACKET_CB(&ff_vaapi_encode_receive_packet),
575 .close = &vaapi_encode_mjpeg_close,
576 .p.priv_class = &vaapi_encode_mjpeg_class,
577 .p.capabilities = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DR1,
578 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
579 FF_CODEC_CAP_INIT_CLEANUP,
580 .defaults = vaapi_encode_mjpeg_defaults,
581 .p.pix_fmts = (const enum AVPixelFormat[]) {
582 AV_PIX_FMT_VAAPI,
583 AV_PIX_FMT_NONE,
584 },
585 .hw_configs = ff_vaapi_encode_hw_configs,
586 .p.wrapper_name = "vaapi",
587 };
588