FFmpeg
vaapi_encode_mjpeg.c
Go to the documentation of this file.
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 {
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.
78 
82 
84  VAAPIEncodePicture *pic,
85  VAAPIEncodeSlice *slice,
86  char *data, size_t *data_len)
87 {
88  VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
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,
102  &priv->quant_tables, NULL);
103  if (err < 0)
104  goto fail;
105 
106  err = ff_cbs_insert_unit_content(frag, -1,
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,
115  &priv->huffman_tables, NULL);
116  if (err < 0)
117  goto fail;
118  }
119 
120  err = ff_cbs_insert_unit_content(frag, -1,
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 
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;
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;
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 
224 {
225  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
226  VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
227  VAAPIEncodePicture *vaapi_pic = pic->priv;
228  JPEGRawFrameHeader *fh = &priv->frame_header;
229  JPEGRawScanHeader *sh = &priv->scan.header;
230  VAEncPictureParameterBufferJPEG *vpic = vaapi_pic->codec_picture_params;
231  const AVPixFmtDescriptor *desc;
232  const uint8_t components_rgb[3] = { 'R', 'G', 'B' };
233  const uint8_t components_yuv[3] = { 1, 2, 3 };
234  const uint8_t *components;
235  int t, i, quant_scale, len;
236 
238 
240  av_assert0(desc);
241  if (desc->flags & AV_PIX_FMT_FLAG_RGB)
242  components = components_rgb;
243  else
244  components = components_yuv;
245 
246  // Frame header.
247 
248  fh->P = 8;
249  fh->Y = avctx->height;
250  fh->X = avctx->width;
251  fh->Nf = desc->nb_components;
252 
253  for (i = 0; i < fh->Nf; i++) {
254  fh->C[i] = components[i];
255  fh->H[i] = 1 + (i == 0 ? desc->log2_chroma_w : 0);
256  fh->V[i] = 1 + (i == 0 ? desc->log2_chroma_h : 0);
257 
258  fh->Tq[i] = !!i;
259  }
260 
261  fh->Lf = 8 + 3 * fh->Nf;
262 
263  // JFIF header.
264  if (priv->jfif) {
265  JPEGRawApplicationData *app = &priv->jfif_header;
267  int sar_w, sar_h;
268  PutByteContext pbc;
269 
271  sizeof(priv->jfif_data));
272 
273  bytestream2_put_buffer(&pbc, "JFIF", 5);
274  bytestream2_put_be16(&pbc, 0x0102);
275  bytestream2_put_byte(&pbc, 0);
276 
277  av_reduce(&sar_w, &sar_h, sar.num, sar.den, 65535);
278  if (sar_w && sar_h) {
279  bytestream2_put_be16(&pbc, sar_w);
280  bytestream2_put_be16(&pbc, sar_h);
281  } else {
282  bytestream2_put_be16(&pbc, 1);
283  bytestream2_put_be16(&pbc, 1);
284  }
285 
286  bytestream2_put_byte(&pbc, 0);
287  bytestream2_put_byte(&pbc, 0);
288 
290 
291  app->Lp = 2 + sizeof(priv->jfif_data);
292  app->Ap = priv->jfif_data;
293  app->Ap_ref = NULL;
294  }
295 
296  // Quantisation tables.
297 
298  if (priv->quality < 50)
299  quant_scale = 5000 / priv->quality;
300  else
301  quant_scale = 200 - 2 * priv->quality;
302 
303  len = 2;
304 
305  for (t = 0; t < 1 + (fh->Nf > 1); t++) {
307  const uint8_t *data = t == 0 ?
310 
311  quant->Pq = 0;
312  quant->Tq = t;
313  for (i = 0; i < 64; i++)
314  quant->Q[i] = av_clip(data[i] * quant_scale / 100, 1, 255);
315 
316  len += 65;
317  }
318 
319  priv->quant_tables.Lq = len;
320 
321  // Huffman tables.
322 
323  len = 2;
324 
325  for (t = 0; t < 2 + 2 * (fh->Nf > 1); t++) {
326  JPEGRawHuffmanTable *huff = &priv->huffman_tables.table[t];
327  const uint8_t *lengths, *values;
328  int k;
329 
330  switch (t) {
331  case 0:
332  lengths = ff_mjpeg_bits_dc_luminance + 1;
334  break;
335  case 1:
336  lengths = ff_mjpeg_bits_ac_luminance + 1;
338  break;
339  case 2:
340  lengths = ff_mjpeg_bits_dc_chrominance + 1;
342  break;
343  case 3:
344  lengths = ff_mjpeg_bits_ac_chrominance + 1;
346  break;
347  }
348 
349  huff->Tc = t % 2;
350  huff->Th = t / 2;
351 
352  for (i = k = 0; i < 16; i++)
353  k += (huff->L[i] = lengths[i]);
354 
355  for (i = 0; i < k; i++)
356  huff->V[i] = values[i];
357 
358  len += 17 + k;
359  }
360 
361  priv->huffman_tables.Lh = len;
362 
363  // Scan header.
364 
365  sh->Ns = fh->Nf;
366 
367  for (i = 0; i < fh->Nf; i++) {
368  sh->Cs[i] = fh->C[i];
369  sh->Td[i] = i > 0;
370  sh->Ta[i] = i > 0;
371  }
372 
373  sh->Ss = 0;
374  sh->Se = 63;
375  sh->Ah = 0;
376  sh->Al = 0;
377 
378  sh->Ls = 6 + 2 * sh->Ns;
379 
380 
381  *vpic = (VAEncPictureParameterBufferJPEG) {
382  .reconstructed_picture = vaapi_pic->recon_surface,
383  .coded_buf = vaapi_pic->output_buffer,
384 
385  .picture_width = fh->X,
386  .picture_height = fh->Y,
387 
388  .pic_flags.bits = {
389  .profile = 0,
390  .progressive = 0,
391  .huffman = 1,
392  .interleaved = 0,
393  .differential = 0,
394  },
395 
396  .sample_bit_depth = fh->P,
397  .num_scan = 1,
398  .num_components = fh->Nf,
399 
400  // The driver modifies the provided quantisation tables according
401  // to this quality value; the middle value of 50 makes that the
402  // identity so that they are used unchanged.
403  .quality = 50,
404  };
405 
406  for (i = 0; i < fh->Nf; i++) {
407  vpic->component_id[i] = fh->C[i];
408  vpic->quantiser_table_selector[i] = fh->Tq[i];
409  }
410 
411  vaapi_pic->nb_slices = 1;
412 
413  return 0;
414 }
415 
418  VAAPIEncodeSlice *slice)
419 {
420  VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
421  JPEGRawScanHeader *sh = &priv->scan.header;
422  VAEncSliceParameterBufferJPEG *vslice = slice->codec_slice_params;
423  int i;
424 
425  *vslice = (VAEncSliceParameterBufferJPEG) {
426  .restart_interval = 0,
427  .num_components = sh->Ns,
428  };
429 
430  for (i = 0; i < sh->Ns; i++) {
431  vslice->components[i].component_selector = sh->Cs[i];
432  vslice->components[i].dc_table_selector = sh->Td[i];
433  vslice->components[i].ac_table_selector = sh->Ta[i];
434  }
435 
436  return 0;
437 }
438 
440 {
441  FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
442  const AVPixFmtDescriptor *desc;
443 
445  av_assert0(desc);
446 
447  base_ctx->surface_width = FFALIGN(avctx->width, 8 << desc->log2_chroma_w);
448  base_ctx->surface_height = FFALIGN(avctx->height, 8 << desc->log2_chroma_h);
449 
450  return 0;
451 }
452 
454 {
455  VAAPIEncodeContext *ctx = avctx->priv_data;
456  VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
457  int err;
458 
459  priv->quality = ctx->rc_quality;
460  if (priv->quality < 1 || priv->quality > 100) {
461  av_log(avctx, AV_LOG_ERROR, "Invalid quality value %d "
462  "(must be 1-100).\n", priv->quality);
463  return AVERROR(EINVAL);
464  }
465 
466  // Hack: the implementation calls the JPEG image header (which we
467  // will use in the same way as a slice header) generic "raw data".
468  // Therefore, if after the packed header capability check we have
469  // PACKED_HEADER_RAW_DATA available, rewrite it as
470  // PACKED_HEADER_SLICE so that the header-writing code can do the
471  // right thing.
472  if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_RAW_DATA) {
473  ctx->va_packed_headers &= ~VA_ENC_PACKED_HEADER_RAW_DATA;
474  ctx->va_packed_headers |= VA_ENC_PACKED_HEADER_SLICE;
475  }
476 
477  err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_MJPEG, avctx);
478  if (err < 0)
479  return err;
480 
481  return 0;
482 }
483 
486  8, 1, 0, 0, VAProfileJPEGBaseline },
488  8, 3, 1, 1, VAProfileJPEGBaseline },
490  8, 3, 1, 0, VAProfileJPEGBaseline },
492  8, 3, 0, 0, VAProfileJPEGBaseline },
494 };
495 
498 
501 
502  .get_encoder_caps = &vaapi_encode_mjpeg_get_encoder_caps,
503  .configure = &vaapi_encode_mjpeg_configure,
504 
505  .default_quality = 80,
506 
507  .picture_params_size = sizeof(VAEncPictureParameterBufferJPEG),
508  .init_picture_params = &vaapi_encode_mjpeg_init_picture_params,
509 
510  .slice_params_size = sizeof(VAEncSliceParameterBufferJPEG),
511  .init_slice_params = &vaapi_encode_mjpeg_init_slice_params,
512 
513  .slice_header_type = VAEncPackedHeaderRawData,
514  .write_slice_header = &vaapi_encode_mjpeg_write_image_header,
515 
516  .write_extra_buffer = &vaapi_encode_mjpeg_write_extra_buffer,
517 };
518 
520 {
521  VAAPIEncodeContext *ctx = avctx->priv_data;
522 
523  ctx->codec = &vaapi_encode_type_mjpeg;
524 
525  // The JPEG image header - see note above.
526  ctx->desired_packed_headers =
527  VA_ENC_PACKED_HEADER_RAW_DATA;
528 
529  return ff_vaapi_encode_init(avctx);
530 }
531 
533 {
534  VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
535 
537  ff_cbs_close(&priv->cbc);
538 
539  return ff_vaapi_encode_close(avctx);
540 }
541 
542 #define OFFSET(x) offsetof(VAAPIEncodeMJPEGContext, x)
543 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
547 
548  { "jfif", "Include JFIF header",
549  OFFSET(jfif), AV_OPT_TYPE_BOOL,
550  { .i64 = 0 }, 0, 1, FLAGS },
551  { "huffman", "Include huffman tables",
552  OFFSET(huffman), AV_OPT_TYPE_BOOL,
553  { .i64 = 1 }, 0, 1, FLAGS },
554 
555  { NULL },
556 };
557 
559  { "b", "0" },
560  { NULL },
561 };
562 
564  .class_name = "mjpeg_vaapi",
565  .item_name = av_default_item_name,
566  .option = vaapi_encode_mjpeg_options,
567  .version = LIBAVUTIL_VERSION_INT,
568 };
569 
571  .p.name = "mjpeg_vaapi",
572  CODEC_LONG_NAME("MJPEG (VAAPI)"),
573  .p.type = AVMEDIA_TYPE_VIDEO,
574  .p.id = AV_CODEC_ID_MJPEG,
575  .priv_data_size = sizeof(VAAPIEncodeMJPEGContext),
578  .close = &vaapi_encode_mjpeg_close,
579  .p.priv_class = &vaapi_encode_mjpeg_class,
580  .p.capabilities = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DR1 |
582  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
584  .defaults = vaapi_encode_mjpeg_defaults,
585  .p.pix_fmts = (const enum AVPixelFormat[]) {
588  },
589  .color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
590  .hw_configs = ff_vaapi_encode_hw_configs,
591  .p.wrapper_name = "vaapi",
592 };
VAAPIEncodeSlice::codec_slice_params
void * codec_slice_params
Definition: vaapi_encode.h:62
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
jpegtables.h
mjpeg.h
JPEGRawApplicationData::Lp
uint16_t Lp
Definition: cbs_jpeg.h:111
av_clip
#define av_clip
Definition: common.h:100
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
cbs_jpeg.h
VAAPIEncodeMJPEGContext::common
VAAPIEncodeContext common
Definition: vaapi_encode_mjpeg.c:62
vaapi_encode_mjpeg_quant_luminance
static const unsigned char vaapi_encode_mjpeg_quant_luminance[64]
Definition: vaapi_encode_mjpeg.c:40
FFHWBaseEncodePicture::priv
void * priv
Definition: hw_base_encode.h:63
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_CODEC_CAP_HARDWARE
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
Definition: codec.h:145
JPEGRawHuffmanTableSpecification::table
JPEGRawHuffmanTable table[8]
Definition: cbs_jpeg.h:107
vaapi_encode_mjpeg_init_picture_params
static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
Definition: vaapi_encode_mjpeg.c:222
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
VAAPIEncodeMJPEGContext::cbc
CodedBitstreamContext * cbc
Definition: vaapi_encode_mjpeg.c:79
vaapi_encode_mjpeg_options
static const AVOption vaapi_encode_mjpeg_options[]
Definition: vaapi_encode_mjpeg.c:544
JPEGRawFrameHeader::Y
uint16_t Y
Definition: cbs_jpeg.h:56
pixdesc.h
JPEGRawHuffmanTable::L
uint8_t L[16]
Definition: cbs_jpeg.h:101
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:172
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
VAAPIEncodeSlice
Definition: vaapi_encode.h:56
AVOption
AVOption.
Definition: opt.h:429
data
const char data[16]
Definition: mxf.c:149
vaapi_encode_mjpeg_defaults
static const FFCodecDefault vaapi_encode_mjpeg_defaults[]
Definition: vaapi_encode_mjpeg.c:558
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:35
FFCodec
Definition: codec_internal.h:127
base
uint8_t base
Definition: vp3data.h:128
ff_vaapi_encode_close
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
Definition: vaapi_encode.c:2275
cbs.h
vaapi_encode_mjpeg_get_encoder_caps
static av_cold int vaapi_encode_mjpeg_get_encoder_caps(AVCodecContext *avctx)
Definition: vaapi_encode_mjpeg.c:439
ff_mjpeg_bits_ac_chrominance
const uint8_t ff_mjpeg_bits_ac_chrominance[]
Definition: jpegtabs.h:66
JPEGRawScanHeader::Ah
uint8_t Ah
Definition: cbs_jpeg.h:76
JPEG_MARKER_APPN
@ JPEG_MARKER_APPN
Definition: cbs_jpeg.h:40
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
FFHWBaseEncodeContext
Definition: hw_base_encode.h:122
JPEG_MARKER_DQT
@ JPEG_MARKER_DQT
Definition: cbs_jpeg.h:38
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
JPEGRawQuantisationTable
Definition: cbs_jpeg.h:87
FFHWBaseEncodePicture::type
int type
Definition: hw_base_encode.h:78
vaapi_encode.h
fail
#define fail()
Definition: checkasm.h:200
VAAPIEncodePicture
Definition: vaapi_encode.h:65
OFFSET
#define OFFSET(x)
Definition: vaapi_encode_mjpeg.c:542
JPEGRawQuantisationTableSpecification::Lq
uint16_t Lq
Definition: cbs_jpeg.h:94
FFHWBaseEncodePicture::input_image
AVFrame * input_image
Definition: hw_base_encode.h:83
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
vaapi_encode_mjpeg_close
static av_cold int vaapi_encode_mjpeg_close(AVCodecContext *avctx)
Definition: vaapi_encode_mjpeg.c:532
JPEGRawQuantisationTableSpecification
Definition: cbs_jpeg.h:93
JPEGRawApplicationData::Ap_ref
AVBufferRef * Ap_ref
Definition: cbs_jpeg.h:113
JPEGRawFrameHeader::Tq
uint8_t Tq[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:63
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
VAAPIEncodeMJPEGContext::huffman_tables
JPEGRawHuffmanTableSpecification huffman_tables
Definition: vaapi_encode_mjpeg.c:77
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
bytestream2_get_bytes_left_p
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:163
av_cold
#define av_cold
Definition: attributes.h:90
JPEGRawScanHeader::Al
uint8_t Al
Definition: cbs_jpeg.h:77
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
VAAPIEncodeMJPEGContext::current_fragment
CodedBitstreamFragment current_fragment
Definition: vaapi_encode_mjpeg.c:80
AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
Definition: defs.h:173
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
vaapi_encode_mjpeg_write_extra_buffer
static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx, FFHWBaseEncodePicture *base, int index, int *type, char *data, size_t *data_len)
Definition: vaapi_encode_mjpeg.c:149
JPEGRawHuffmanTable::Th
uint8_t Th
Definition: cbs_jpeg.h:100
VAAPIEncodePicture::codec_picture_params
void * codec_picture_params
Definition: vaapi_encode.h:83
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:135
bytestream2_put_buffer
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
Definition: bytestream.h:286
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FF_HW_PICTURE_TYPE_IDR
@ FF_HW_PICTURE_TYPE_IDR
Definition: hw_base_encode.h:39
ff_vaapi_encode_receive_packet
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: vaapi_encode.c:2086
JPEGRawQuantisationTableSpecification::table
JPEGRawQuantisationTable table[4]
Definition: cbs_jpeg.h:95
JPEG_MARKER_SOF0
@ JPEG_MARKER_SOF0
Definition: cbs_jpeg.h:29
VAAPIEncodeType
Definition: vaapi_encode.h:265
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
VAAPIEncodeContext
Definition: vaapi_encode.h:145
if
if(ret)
Definition: filter_design.txt:179
VAAPIEncodeMJPEGContext::frame_header
JPEGRawFrameHeader frame_header
Definition: vaapi_encode_mjpeg.c:73
JPEGRawScanHeader::Ns
uint8_t Ns
Definition: cbs_jpeg.h:68
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
VAAPIEncodeType::profiles
const VAAPIEncodeProfile * profiles
Definition: vaapi_encode.h:268
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
VAAPIEncodeMJPEGContext
Definition: vaapi_encode_mjpeg.c:61
JPEGRawFrameHeader::H
uint8_t H[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:61
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:326
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
JPEGRawHuffmanTable::Tc
uint8_t Tc
Definition: cbs_jpeg.h:99
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
JPEGRawFrameHeader::P
uint8_t P
Definition: cbs_jpeg.h:55
index
int index
Definition: gxfenc.c:90
PutByteContext
Definition: bytestream.h:37
JPEGRawHuffmanTableSpecification
Definition: cbs_jpeg.h:105
vaapi_encode_mjpeg_write_image_header
static int vaapi_encode_mjpeg_write_image_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)
Definition: vaapi_encode_mjpeg.c:83
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
VAAPIEncodeMJPEGContext::quant_tables
JPEGRawQuantisationTableSpecification quant_tables
Definition: vaapi_encode_mjpeg.c:76
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
vaapi_encode_mjpeg_class
static const AVClass vaapi_encode_mjpeg_class
Definition: vaapi_encode_mjpeg.c:563
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
vaapi_encode_mjpeg_profiles
static const VAAPIEncodeProfile vaapi_encode_mjpeg_profiles[]
Definition: vaapi_encode_mjpeg.c:484
JPEGRawFrameHeader::X
uint16_t X
Definition: cbs_jpeg.h:57
codec_internal.h
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
JPEGRawScanHeader::Ss
uint8_t Ss
Definition: cbs_jpeg.h:74
ff_mjpeg_bits_ac_luminance
const uint8_t ff_mjpeg_bits_ac_luminance[]
Definition: jpegtabs.h:40
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:128
vaapi_encode_mjpeg_quant_chrominance
static const unsigned char vaapi_encode_mjpeg_quant_chrominance[64]
Definition: vaapi_encode_mjpeg.c:50
VAAPI_ENCODE_COMMON_OPTIONS
#define VAAPI_ENCODE_COMMON_OPTIONS
Definition: vaapi_encode.h:350
VAAPIEncodePicture::recon_surface
VASurfaceID recon_surface
Definition: vaapi_encode.h:74
VAAPIEncodePicture::output_buffer
VABufferID output_buffer
Definition: vaapi_encode.h:81
JPEGRawScanHeader::Cs
uint8_t Cs[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:70
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
JPEGRawScanHeader::Ls
uint16_t Ls
Definition: cbs_jpeg.h:67
JPEGRawScanHeader::Td
uint8_t Td[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:71
VAAPIEncodeMJPEGContext::jfif
int jfif
Definition: vaapi_encode_mjpeg.c:65
ff_mjpeg_vaapi_encoder
const FFCodec ff_mjpeg_vaapi_encoder
Definition: vaapi_encode_mjpeg.c:570
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
JPEGRawScan::header
JPEGRawScanHeader header
Definition: cbs_jpeg.h:81
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
VAAPIEncodeMJPEGContext::huffman
int huffman
Definition: vaapi_encode_mjpeg.c:66
internal.h
common.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
VAAPIEncodeMJPEGContext::quality
int quality
Definition: vaapi_encode_mjpeg.c:69
ff_cbs_write_fragment_data
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:409
VAAPIEncodeMJPEGContext::jfif_data
uint8_t jfif_data[14]
Definition: vaapi_encode_mjpeg.c:70
JPEGRawFrameHeader::Nf
uint16_t Nf
Definition: cbs_jpeg.h:58
avcodec.h
JPEGRawApplicationData
Definition: cbs_jpeg.h:110
ff_vaapi_encode_hw_configs
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
Definition: vaapi_encode.c:36
FF_HW_FLAG_INTRA_ONLY
@ FF_HW_FLAG_INTRA_ONLY
Definition: hw_base_encode.h:51
ff_vaapi_encode_init
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
Definition: vaapi_encode.c:2091
JPEGRawScan
Definition: cbs_jpeg.h:80
FFHWBaseEncodePicture
Definition: hw_base_encode.h:61
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
dht
static int FUNC() dht(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawHuffmanTableSpecification *current)
Definition: cbs_jpeg_syntax_template.c:102
vaapi_encode_mjpeg_init_slice_params
static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx, FFHWBaseEncodePicture *base, VAAPIEncodeSlice *slice)
Definition: vaapi_encode_mjpeg.c:416
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:496
JPEGRawFrameHeader::C
uint8_t C[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:60
FFHWBaseEncodeContext::surface_height
int surface_height
Definition: hw_base_encode.h:141
AVCodecContext
main external API structure.
Definition: avcodec.h:451
JPEGRawHuffmanTable::V
uint8_t V[256]
Definition: cbs_jpeg.h:102
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
FF_HW_FLAG_CONSTANT_QUALITY_ONLY
@ FF_HW_FLAG_CONSTANT_QUALITY_ONLY
Definition: hw_base_encode.h:49
JPEG_MARKER_SOS
@ JPEG_MARKER_SOS
Definition: cbs_jpeg.h:37
FLAGS
#define FLAGS
Definition: vaapi_encode_mjpeg.c:543
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:263
FFHWBaseEncodeContext::input_frames
AVHWFramesContext * input_frames
Definition: hw_base_encode.h:153
JPEGRawFrameHeader::V
uint8_t V[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:62
dqt
static int FUNC() dqt(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawQuantisationTableSpecification *current)
Definition: cbs_jpeg_syntax_template.c:62
FFHWBaseEncodeContext::surface_width
int surface_width
Definition: hw_base_encode.h:140
ff_mjpeg_bits_dc_chrominance
const uint8_t ff_mjpeg_bits_dc_chrominance[]
Definition: jpegtabs.h:37
JPEGRawHuffmanTableSpecification::Lh
uint16_t Lh
Definition: cbs_jpeg.h:106
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
JPEG_MARKER_DHT
@ JPEG_MARKER_DHT
Definition: cbs_jpeg.h:34
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ff_cbs_init
av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:90
JPEGRawFrameHeader
Definition: cbs_jpeg.h:53
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
ff_mjpeg_bits_dc_luminance
const FF_VISIBILITY_PUSH_HIDDEN uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
JPEGRawFrameHeader::Lf
uint16_t Lf
Definition: cbs_jpeg.h:54
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
bytestream.h
JPEGRawHuffmanTable
Definition: cbs_jpeg.h:98
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
vaapi_encode_mjpeg_configure
static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
Definition: vaapi_encode_mjpeg.c:453
HW_BASE_ENCODE_COMMON_OPTIONS
#define HW_BASE_ENCODE_COMMON_OPTIONS
Definition: hw_base_encode.h:239
JPEGRawApplicationData::Ap
uint8_t * Ap
Definition: cbs_jpeg.h:112
JPEGRawScanHeader::Ta
uint8_t Ta[JPEG_MAX_COMPONENTS]
Definition: cbs_jpeg.h:72
put_bits.h
JPEGRawScanHeader::Se
uint8_t Se
Definition: cbs_jpeg.h:75
JPEGRawScanHeader
Definition: cbs_jpeg.h:66
VAAPIEncodeMJPEGContext::jfif_header
JPEGRawApplicationData jfif_header
Definition: vaapi_encode_mjpeg.c:75
vaapi_encode_mjpeg_init
static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx)
Definition: vaapi_encode_mjpeg.c:519
VAAPIEncodeProfile
Definition: vaapi_encode.h:100
vaapi_encode_type_mjpeg
static const VAAPIEncodeType vaapi_encode_type_mjpeg
Definition: vaapi_encode_mjpeg.c:496
VAAPIEncodePicture::nb_slices
int nb_slices
Definition: vaapi_encode.h:85
VAAPIEncodeMJPEGContext::scan
JPEGRawScan scan
Definition: vaapi_encode_mjpeg.c:74