2 * This file is part of FFmpeg.
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.
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.
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
20 #include <va/va_enc_jpeg.h>
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"
29 #include "bytestream.h"
33 #include "jpegtables.h"
36 #include "vaapi_encode.h"
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,
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,
61 typedef struct VAAPIEncodeMJPEGContext {
62 VAAPIEncodeContext common;
70 uint8_t jfif_data[14];
73 JPEGRawFrameHeader frame_header;
75 JPEGRawApplicationData jfif_header;
76 JPEGRawQuantisationTableSpecification quant_tables;
77 JPEGRawHuffmanTableSpecification huffman_tables;
79 CodedBitstreamContext *cbc;
80 CodedBitstreamFragment current_fragment;
81 } VAAPIEncodeMJPEGContext;
83 static int vaapi_encode_mjpeg_write_image_header(AVCodecContext *avctx,
84 VAAPIEncodePicture *pic,
85 VAAPIEncodeSlice *slice,
86 char *data, size_t *data_len)
88 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
89 CodedBitstreamFragment *frag = &priv->current_fragment;
93 err = ff_cbs_insert_unit_content(priv->cbc, frag, -1,
95 &priv->jfif_header, NULL);
100 err = ff_cbs_insert_unit_content(priv->cbc, frag, -1,
102 &priv->quant_tables, NULL);
106 err = ff_cbs_insert_unit_content(priv->cbc, frag, -1,
108 &priv->frame_header, NULL);
113 err = ff_cbs_insert_unit_content(priv->cbc, frag, -1,
115 &priv->huffman_tables, NULL);
120 err = ff_cbs_insert_unit_content(priv->cbc, frag, -1,
126 err = ff_cbs_write_fragment_data(priv->cbc, frag);
128 av_log(avctx, AV_LOG_ERROR, "Failed to write image header.\n");
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);
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);
145 ff_cbs_fragment_reset(priv->cbc, frag);
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)
154 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
158 // Write quantisation tables.
159 JPEGRawFrameHeader *fh = &priv->frame_header;
160 JPEGRawQuantisationTableSpecification *dqt = &priv->quant_tables;
161 VAQMatrixBufferJPEG *quant;
163 if (*data_len < sizeof(*quant))
164 return AVERROR(ENOSPC);
165 *type = VAQMatrixBufferType;
166 *data_len = sizeof(*quant);
168 quant = (VAQMatrixBufferJPEG*)data;
169 memset(quant, 0, sizeof(*quant));
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];
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];
182 } else if (index == 1) {
183 // Write huffman tables.
184 JPEGRawScanHeader *sh = &priv->scan.header;
185 JPEGRawHuffmanTableSpecification *dht = &priv->huffman_tables;
186 VAHuffmanTableBufferJPEGBaseline *huff;
188 if (*data_len < sizeof(*huff))
189 return AVERROR(ENOSPC);
190 *type = VAHuffmanTableBufferType;
191 *data_len = sizeof(*huff);
193 huff = (VAHuffmanTableBufferJPEGBaseline*)data;
194 memset(huff, 0, sizeof(*huff));
196 for (t = 0; t < 1 + (sh->Ns > 1); t++) {
197 const JPEGRawHuffmanTable *ht;
199 huff->load_huffman_table[t] = 1;
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];
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];
222 static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
223 VAAPIEncodePicture *pic)
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;
235 av_assert0(pic->type == PICTURE_TYPE_IDR);
237 desc = av_pix_fmt_desc_get(priv->common.input_frames->sw_format);
239 if (desc->flags & AV_PIX_FMT_FLAG_RGB)
240 components = components_rgb;
242 components = components_yuv;
247 fh->Y = avctx->height;
248 fh->X = avctx->width;
249 fh->Nf = desc->nb_components;
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);
259 fh->Lf = 8 + 3 * fh->Nf;
263 JPEGRawApplicationData *app = &priv->jfif_header;
264 AVRational sar = pic->input_image->sample_aspect_ratio;
268 bytestream2_init_writer(&pbc, priv->jfif_data,
269 sizeof(priv->jfif_data));
271 bytestream2_put_buffer(&pbc, "JFIF", 5);
272 bytestream2_put_be16(&pbc, 0x0102);
273 bytestream2_put_byte(&pbc, 0);
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);
280 bytestream2_put_be16(&pbc, 1);
281 bytestream2_put_be16(&pbc, 1);
284 bytestream2_put_byte(&pbc, 0);
285 bytestream2_put_byte(&pbc, 0);
287 av_assert0(bytestream2_get_bytes_left_p(&pbc) == 0);
289 app->Lp = 2 + sizeof(priv->jfif_data);
290 app->Ap = priv->jfif_data;
294 // Quantisation tables.
296 if (priv->quality < 50)
297 quant_scale = 5000 / priv->quality;
299 quant_scale = 200 - 2 * priv->quality;
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;
311 for (i = 0; i < 64; i++)
312 quant->Q[i] = av_clip(data[i] * quant_scale / 100, 1, 255);
317 priv->quant_tables.Lq = len;
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;
330 lengths = avpriv_mjpeg_bits_dc_luminance + 1;
331 values = avpriv_mjpeg_val_dc;
334 lengths = avpriv_mjpeg_bits_ac_luminance + 1;
335 values = avpriv_mjpeg_val_ac_luminance;
338 lengths = avpriv_mjpeg_bits_dc_chrominance + 1;
339 values = avpriv_mjpeg_val_dc;
342 lengths = avpriv_mjpeg_bits_ac_chrominance + 1;
343 values = avpriv_mjpeg_val_ac_chrominance;
350 for (i = k = 0; i < 16; i++)
351 k += (huff->L[i] = lengths[i]);
353 for (i = 0; i < k; i++)
354 huff->V[i] = values[i];
359 priv->huffman_tables.Lh = len;
365 for (i = 0; i < fh->Nf; i++) {
366 sh->Cs[i] = fh->C[i];
376 sh->Ls = 6 + 2 * sh->Ns;
379 *vpic = (VAEncPictureParameterBufferJPEG) {
380 .reconstructed_picture = pic->recon_surface,
381 .coded_buf = pic->output_buffer,
383 .picture_width = fh->X,
384 .picture_height = fh->Y,
394 .sample_bit_depth = fh->P,
396 .num_components = fh->Nf,
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.
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];
414 static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx,
415 VAAPIEncodePicture *pic,
416 VAAPIEncodeSlice *slice)
418 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
419 JPEGRawScanHeader *sh = &priv->scan.header;
420 VAEncSliceParameterBufferJPEG *vslice = slice->codec_slice_params;
423 *vslice = (VAEncSliceParameterBufferJPEG) {
424 .restart_interval = 0,
425 .num_components = sh->Ns,
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];
437 static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
439 VAAPIEncodeContext *ctx = avctx->priv_data;
440 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
443 priv->quality = ctx->rc_quality;
444 if (priv->quality < 1 || priv->quality > 100) {
445 av_log(avctx, AV_LOG_ERROR, "Invalid quality value %d "
446 "(must be 1-100).\n", priv->quality);
447 return AVERROR(EINVAL);
450 // Hack: the implementation calls the JPEG image header (which we
451 // will use in the same way as a slice header) generic "raw data".
452 // Therefore, if after the packed header capability check we have
453 // PACKED_HEADER_RAW_DATA available, rewrite it as
454 // PACKED_HEADER_SLICE so that the header-writing code can do the
456 if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_RAW_DATA) {
457 ctx->va_packed_headers &= ~VA_ENC_PACKED_HEADER_RAW_DATA;
458 ctx->va_packed_headers |= VA_ENC_PACKED_HEADER_SLICE;
461 err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_MJPEG, avctx);
468 static const VAAPIEncodeProfile vaapi_encode_mjpeg_profiles[] = {
469 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
470 8, 1, 0, 0, VAProfileJPEGBaseline },
471 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
472 8, 3, 1, 1, VAProfileJPEGBaseline },
473 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
474 8, 3, 1, 0, VAProfileJPEGBaseline },
475 { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
476 8, 3, 0, 0, VAProfileJPEGBaseline },
477 { FF_PROFILE_UNKNOWN }
480 static const VAAPIEncodeType vaapi_encode_type_mjpeg = {
481 .profiles = vaapi_encode_mjpeg_profiles,
483 .flags = FLAG_CONSTANT_QUALITY_ONLY |
486 .configure = &vaapi_encode_mjpeg_configure,
488 .default_quality = 80,
490 .picture_params_size = sizeof(VAEncPictureParameterBufferJPEG),
491 .init_picture_params = &vaapi_encode_mjpeg_init_picture_params,
493 .slice_params_size = sizeof(VAEncSliceParameterBufferJPEG),
494 .init_slice_params = &vaapi_encode_mjpeg_init_slice_params,
496 .slice_header_type = VAEncPackedHeaderRawData,
497 .write_slice_header = &vaapi_encode_mjpeg_write_image_header,
499 .write_extra_buffer = &vaapi_encode_mjpeg_write_extra_buffer,
502 static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx)
504 VAAPIEncodeContext *ctx = avctx->priv_data;
506 ctx->codec = &vaapi_encode_type_mjpeg;
508 // The JPEG image header - see note above.
509 ctx->desired_packed_headers =
510 VA_ENC_PACKED_HEADER_RAW_DATA;
512 ctx->surface_width = FFALIGN(avctx->width, 8);
513 ctx->surface_height = FFALIGN(avctx->height, 8);
515 return ff_vaapi_encode_init(avctx);
518 static av_cold int vaapi_encode_mjpeg_close(AVCodecContext *avctx)
520 VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
522 ff_cbs_fragment_free(priv->cbc, &priv->current_fragment);
523 ff_cbs_close(&priv->cbc);
525 return ff_vaapi_encode_close(avctx);
528 #define OFFSET(x) offsetof(VAAPIEncodeMJPEGContext, x)
529 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
530 static const AVOption vaapi_encode_mjpeg_options[] = {
531 VAAPI_ENCODE_COMMON_OPTIONS,
533 { "jfif", "Include JFIF header",
534 OFFSET(jfif), AV_OPT_TYPE_BOOL,
535 { .i64 = 0 }, 0, 1, FLAGS },
536 { "huffman", "Include huffman tables",
537 OFFSET(huffman), AV_OPT_TYPE_BOOL,
538 { .i64 = 1 }, 0, 1, FLAGS },
543 static const AVCodecDefault vaapi_encode_mjpeg_defaults[] = {
548 static const AVClass vaapi_encode_mjpeg_class = {
549 .class_name = "mjpeg_vaapi",
550 .item_name = av_default_item_name,
551 .option = vaapi_encode_mjpeg_options,
552 .version = LIBAVUTIL_VERSION_INT,
555 AVCodec ff_mjpeg_vaapi_encoder = {
556 .name = "mjpeg_vaapi",
557 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (VAAPI)"),
558 .type = AVMEDIA_TYPE_VIDEO,
559 .id = AV_CODEC_ID_MJPEG,
560 .priv_data_size = sizeof(VAAPIEncodeMJPEGContext),
561 .init = &vaapi_encode_mjpeg_init,
562 .send_frame = &ff_vaapi_encode_send_frame,
563 .receive_packet = &ff_vaapi_encode_receive_packet,
564 .close = &vaapi_encode_mjpeg_close,
565 .priv_class = &vaapi_encode_mjpeg_class,
566 .capabilities = AV_CODEC_CAP_HARDWARE |
567 AV_CODEC_CAP_INTRA_ONLY,
568 .defaults = vaapi_encode_mjpeg_defaults,
569 .pix_fmts = (const enum AVPixelFormat[]) {
573 .hw_configs = ff_vaapi_encode_hw_configs,
574 .wrapper_name = "vaapi",