FFmpeg
mjpegenc.c
Go to the documentation of this file.
1 /*
2  * MJPEG encoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2003 Alex Beregszaszi
5  * Copyright (c) 2003-2004 Michael Niedermayer
6  *
7  * Support for external huffman table, various fixes (AVID workaround),
8  * aspecting, new decode_frame mechanism and apple mjpeg-b support
9  * by Alex Beregszaszi
10  *
11  * This file is part of FFmpeg.
12  *
13  * FFmpeg is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU Lesser General Public
15  * License as published by the Free Software Foundation; either
16  * version 2.1 of the License, or (at your option) any later version.
17  *
18  * FFmpeg is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21  * Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public
24  * License along with FFmpeg; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26  */
27 
28 /**
29  * @file
30  * MJPEG encoder.
31  */
32 
33 #include "config_components.h"
34 
35 #include "libavutil/pixdesc.h"
36 
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "jpegtables.h"
40 #include "mjpegenc_common.h"
41 #include "mjpegenc_huffman.h"
42 #include "mpegvideo.h"
43 #include "mjpeg.h"
44 #include "mjpegenc.h"
45 #include "mpegvideoenc.h"
46 #include "profiles.h"
47 
48 /* The following is the private context of MJPEG/AMV decoder.
49  * Note that when using slice threading only the main thread's
50  * MpegEncContext is followed by a MjpegContext; the other threads
51  * can access this shared context via MpegEncContext.mjpeg. */
52 typedef struct MJPEGEncContext {
56 
57 static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],
58  uint8_t *uni_ac_vlc_len)
59 {
60  for (int i = 0; i < 128; i++) {
61  int level = i - 64;
62  if (!level)
63  continue;
64  for (int run = 0; run < 64; run++) {
65  int len, code, nbits;
66  int alevel = FFABS(level);
67 
68  len = (run >> 4) * huff_size_ac[0xf0];
69 
70  nbits= av_log2_16bit(alevel) + 1;
71  code = ((15&run) << 4) | nbits;
72 
73  len += huff_size_ac[code] + nbits;
74 
75  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
76  // We ignore EOB as its just a constant which does not change generally
77  }
78  }
79 }
80 
82 {
83  ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->picture->f, s->mjpeg_ctx,
84  &s->intra_scantable, 0,
85  s->intra_matrix, s->chroma_intra_matrix,
86  s->slice_context_count > 1);
87 
88  s->esc_pos = put_bytes_count(&s->pb, 0);
89  for (int i = 1; i < s->slice_context_count; i++)
90  s->thread_context[i]->esc_pos = 0;
91 }
92 
94 {
95  MJPEGEncContext *const m = (MJPEGEncContext*)s;
96  av_assert2(s->mjpeg_ctx == &m->mjpeg);
97  /* s->huffman == HUFFMAN_TABLE_OPTIMAL can only be true for MJPEG. */
98  if (!CONFIG_MJPEG_ENCODER || m->mjpeg.huffman != HUFFMAN_TABLE_OPTIMAL)
100 }
101 
102 #if CONFIG_MJPEG_ENCODER
103 /**
104  * Encodes and outputs the entire frame in the JPEG format.
105  *
106  * @param s The MpegEncContext.
107  */
108 static void mjpeg_encode_picture_frame(MpegEncContext *s)
109 {
110  int nbits, code, table_id;
111  MJpegContext *m = s->mjpeg_ctx;
112  uint8_t *huff_size[4] = { m->huff_size_dc_luminance,
116  uint16_t *huff_code[4] = { m->huff_code_dc_luminance,
120  size_t total_bits = 0;
121  size_t bytes_needed;
122 
123  s->header_bits = get_bits_diff(s);
124  // Estimate the total size first
125  for (int i = 0; i < m->huff_ncode; i++) {
126  table_id = m->huff_buffer[i].table_id;
127  code = m->huff_buffer[i].code;
128  nbits = code & 0xf;
129 
130  total_bits += huff_size[table_id][code] + nbits;
131  }
132 
133  bytes_needed = (total_bits + 7) / 8;
134  ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
135 
136  for (int i = 0; i < m->huff_ncode; i++) {
137  table_id = m->huff_buffer[i].table_id;
138  code = m->huff_buffer[i].code;
139  nbits = code & 0xf;
140 
141  put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
142  if (nbits != 0) {
143  put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
144  }
145  }
146 
147  m->huff_ncode = 0;
148  s->i_tex_bits = get_bits_diff(s);
149 }
150 
151 /**
152  * Builds all 4 optimal Huffman tables.
153  *
154  * Uses the data stored in the JPEG buffer to compute the tables.
155  * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
156  *
157  * @param m MJpegContext containing the JPEG buffer.
158  */
159 static void mjpeg_build_optimal_huffman(MJpegContext *m)
160 {
161  MJpegEncHuffmanContext dc_luminance_ctx;
162  MJpegEncHuffmanContext dc_chrominance_ctx;
163  MJpegEncHuffmanContext ac_luminance_ctx;
164  MJpegEncHuffmanContext ac_chrominance_ctx;
165  MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx,
166  &dc_chrominance_ctx,
167  &ac_luminance_ctx,
168  &ac_chrominance_ctx };
169  for (int i = 0; i < 4; i++)
171 
172  for (int i = 0; i < m->huff_ncode; i++) {
173  int table_id = m->huff_buffer[i].table_id;
174  int code = m->huff_buffer[i].code;
175 
177  }
178 
179  ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
181  m->val_dc_luminance, 12);
182  ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
184  m->val_dc_chrominance, 12);
185  ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
187  m->val_ac_luminance, 256);
188  ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
190  m->val_ac_chrominance, 256);
191 
195  m->val_dc_luminance);
199  m->val_dc_chrominance);
203  m->val_ac_luminance);
207  m->val_ac_chrominance);
208 }
209 #endif
210 
211 /**
212  * Writes the complete JPEG frame when optimal huffman tables are enabled,
213  * otherwise writes the stuffing.
214  *
215  * Header + values + stuffing.
216  *
217  * @param s The MpegEncContext.
218  * @return int Error code, 0 if successful.
219  */
221 {
222  MJpegContext *const m = s->mjpeg_ctx;
223  PutBitContext *pbc = &s->pb;
224  int mb_y = s->mb_y - !s->mb_x;
225  int ret;
226 
227 #if CONFIG_MJPEG_ENCODER
228  if (m->huffman == HUFFMAN_TABLE_OPTIMAL) {
229 
230  mjpeg_build_optimal_huffman(m);
231 
232  // Replace the VLCs with the optimal ones.
233  // The default ones may be used for trellis during quantization.
236  s->intra_ac_vlc_length =
237  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
238  s->intra_chroma_ac_vlc_length =
239  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
240 
242  mjpeg_encode_picture_frame(s);
243  }
244 #endif
245 
247  put_bits_count(&s->pb) / 4 + 1000);
248  if (ret < 0) {
249  av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
250  goto fail;
251  }
252 
253  ff_mjpeg_escape_FF(pbc, s->esc_pos);
254 
255  if (s->slice_context_count > 1 && mb_y < s->mb_height - 1)
256  put_marker(pbc, RST0 + (mb_y&7));
257  s->esc_pos = put_bytes_count(pbc, 0);
258 
259 fail:
260  for (int i = 0; i < 3; i++)
261  s->last_dc[i] = 128 << s->intra_dc_precision;
262 
263  return ret;
264 }
265 
267 {
268  MJpegContext *m = s->mjpeg_ctx;
269  size_t num_mbs, num_blocks, num_codes;
270  int blocks_per_mb;
271 
272  // We need to init this here as the mjpeg init is called before the common init,
273  s->mb_width = (s->width + 15) / 16;
274  s->mb_height = (s->height + 15) / 16;
275 
276  switch (s->chroma_format) {
277  case CHROMA_420: blocks_per_mb = 6; break;
278  case CHROMA_422: blocks_per_mb = 8; break;
279  case CHROMA_444: blocks_per_mb = 12; break;
280  default: av_assert0(0);
281  };
282 
283  // Make sure we have enough space to hold this frame.
284  num_mbs = s->mb_width * s->mb_height;
285  num_blocks = num_mbs * blocks_per_mb;
286  num_codes = num_blocks * 64;
287 
288  m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
289  if (!m->huff_buffer)
290  return AVERROR(ENOMEM);
291  return 0;
292 }
293 
295 {
296  MJpegContext *const m = &((MJPEGEncContext*)s)->mjpeg;
297  int ret, use_slices;
298 
299  s->mjpeg_ctx = m;
300  use_slices = s->avctx->slices > 0 ? s->avctx->slices > 1 :
301  (s->avctx->active_thread_type & FF_THREAD_SLICE) &&
302  s->avctx->thread_count > 1;
303 
304  if (s->codec_id == AV_CODEC_ID_AMV || use_slices)
306 
307  if (s->mpv_flags & FF_MPV_FLAG_QP_RD) {
308  // Used to produce garbage with MJPEG.
309  av_log(s->avctx, AV_LOG_ERROR,
310  "QP RD is no longer compatible with MJPEG or AMV\n");
311  return AVERROR(EINVAL);
312  }
313 
314  /* The following check is automatically true for AMV,
315  * but it doesn't hurt either. */
317  if (ret < 0)
318  return ret;
319 
320  if (s->width > 65500 || s->height > 65500) {
321  av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
322  return AVERROR(EINVAL);
323  }
324 
325  s->min_qcoeff=-1023;
326  s->max_qcoeff= 1023;
327 
328  // Build default Huffman tables.
329  // These may be overwritten later with more optimal Huffman tables, but
330  // they are needed at least right now for some processes like trellis.
347 
350  s->intra_ac_vlc_length =
351  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
352  s->intra_chroma_ac_vlc_length =
353  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
354 
355  // Buffers start out empty.
356  m->huff_ncode = 0;
357 
358  if (m->huffman == HUFFMAN_TABLE_OPTIMAL)
359  return alloc_huffman(s);
360 
361  return 0;
362 }
363 
365 {
366  MJPEGEncContext *const mjpeg = avctx->priv_data;
367  av_freep(&mjpeg->mjpeg.huff_buffer);
368  ff_mpv_encode_end(avctx);
369  return 0;
370 }
371 
372 /**
373  * Add code and table_id to the JPEG buffer.
374  *
375  * @param s The MJpegContext which contains the JPEG buffer.
376  * @param table_id Which Huffman table the code belongs to.
377  * @param code The encoded exponent of the coefficients and the run-bits.
378  */
379 static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
380 {
381  MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
382  c->table_id = table_id;
383  c->code = code;
384 }
385 
386 /**
387  * Add the coefficient's data to the JPEG buffer.
388  *
389  * @param s The MJpegContext which contains the JPEG buffer.
390  * @param table_id Which Huffman table the code belongs to.
391  * @param val The coefficient.
392  * @param run The run-bits.
393  */
394 static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
395 {
396  int mant, code;
397 
398  if (val == 0) {
399  av_assert0(run == 0);
400  ff_mjpeg_encode_code(s, table_id, 0);
401  } else {
402  mant = val;
403  if (val < 0) {
404  val = -val;
405  mant--;
406  }
407 
408  code = (run << 4) | (av_log2_16bit(val) + 1);
409 
410  s->huff_buffer[s->huff_ncode].mant = mant;
411  ff_mjpeg_encode_code(s, table_id, code);
412  }
413 }
414 
415 /**
416  * Add the block's data into the JPEG buffer.
417  *
418  * @param s The MpegEncContext that contains the JPEG buffer.
419  * @param block The block.
420  * @param n The block's index or number.
421  */
422 static void record_block(MpegEncContext *s, int16_t *block, int n)
423 {
424  int i, j, table_id;
425  int component, dc, last_index, val, run;
426  MJpegContext *m = s->mjpeg_ctx;
427 
428  /* DC coef */
429  component = (n <= 3 ? 0 : (n&1) + 1);
430  table_id = (n <= 3 ? 0 : 1);
431  dc = block[0]; /* overflow is impossible */
432  val = dc - s->last_dc[component];
433 
434  ff_mjpeg_encode_coef(m, table_id, val, 0);
435 
436  s->last_dc[component] = dc;
437 
438  /* AC coefs */
439 
440  run = 0;
441  last_index = s->block_last_index[n];
442  table_id |= 2;
443 
444  for(i=1;i<=last_index;i++) {
445  j = s->intra_scantable.permutated[i];
446  val = block[j];
447 
448  if (val == 0) {
449  run++;
450  } else {
451  while (run >= 16) {
452  ff_mjpeg_encode_code(m, table_id, 0xf0);
453  run -= 16;
454  }
455  ff_mjpeg_encode_coef(m, table_id, val, run);
456  run = 0;
457  }
458  }
459 
460  /* output EOB only if not already 64 values */
461  if (last_index < 63 || run != 0)
462  ff_mjpeg_encode_code(m, table_id, 0);
463 }
464 
465 static void encode_block(MpegEncContext *s, int16_t *block, int n)
466 {
467  int mant, nbits, code, i, j;
468  int component, dc, run, last_index, val;
469  MJpegContext *m = s->mjpeg_ctx;
470  uint8_t *huff_size_ac;
471  uint16_t *huff_code_ac;
472 
473  /* DC coef */
474  component = (n <= 3 ? 0 : (n&1) + 1);
475  dc = block[0]; /* overflow is impossible */
476  val = dc - s->last_dc[component];
477  if (n < 4) {
479  huff_size_ac = m->huff_size_ac_luminance;
480  huff_code_ac = m->huff_code_ac_luminance;
481  } else {
483  huff_size_ac = m->huff_size_ac_chrominance;
484  huff_code_ac = m->huff_code_ac_chrominance;
485  }
486  s->last_dc[component] = dc;
487 
488  /* AC coefs */
489 
490  run = 0;
491  last_index = s->block_last_index[n];
492  for(i=1;i<=last_index;i++) {
493  j = s->intra_scantable.permutated[i];
494  val = block[j];
495  if (val == 0) {
496  run++;
497  } else {
498  while (run >= 16) {
499  put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
500  run -= 16;
501  }
502  mant = val;
503  if (val < 0) {
504  val = -val;
505  mant--;
506  }
507 
508  nbits= av_log2_16bit(val) + 1;
509  code = (run << 4) | nbits;
510 
511  put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
512 
513  put_sbits(&s->pb, nbits, mant);
514  run = 0;
515  }
516  }
517 
518  /* output EOB only if not already 64 values */
519  if (last_index < 63 || run != 0)
520  put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
521 }
522 
523 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
524 {
525  int i;
526  if (s->mjpeg_ctx->huffman == HUFFMAN_TABLE_OPTIMAL) {
527  if (s->chroma_format == CHROMA_444) {
528  record_block(s, block[0], 0);
529  record_block(s, block[2], 2);
530  record_block(s, block[4], 4);
531  record_block(s, block[8], 8);
532  record_block(s, block[5], 5);
533  record_block(s, block[9], 9);
534 
535  if (16*s->mb_x+8 < s->width) {
536  record_block(s, block[1], 1);
537  record_block(s, block[3], 3);
538  record_block(s, block[6], 6);
539  record_block(s, block[10], 10);
540  record_block(s, block[7], 7);
541  record_block(s, block[11], 11);
542  }
543  } else {
544  for(i=0;i<5;i++) {
545  record_block(s, block[i], i);
546  }
547  if (s->chroma_format == CHROMA_420) {
548  record_block(s, block[5], 5);
549  } else {
550  record_block(s, block[6], 6);
551  record_block(s, block[5], 5);
552  record_block(s, block[7], 7);
553  }
554  }
555  } else {
556  if (s->chroma_format == CHROMA_444) {
557  encode_block(s, block[0], 0);
558  encode_block(s, block[2], 2);
559  encode_block(s, block[4], 4);
560  encode_block(s, block[8], 8);
561  encode_block(s, block[5], 5);
562  encode_block(s, block[9], 9);
563 
564  if (16*s->mb_x+8 < s->width) {
565  encode_block(s, block[1], 1);
566  encode_block(s, block[3], 3);
567  encode_block(s, block[6], 6);
568  encode_block(s, block[10], 10);
569  encode_block(s, block[7], 7);
570  encode_block(s, block[11], 11);
571  }
572  } else {
573  for(i=0;i<5;i++) {
574  encode_block(s, block[i], i);
575  }
576  if (s->chroma_format == CHROMA_420) {
577  encode_block(s, block[5], 5);
578  } else {
579  encode_block(s, block[6], 6);
580  encode_block(s, block[5], 5);
581  encode_block(s, block[7], 7);
582  }
583  }
584 
585  s->i_tex_bits += get_bits_diff(s);
586  }
587 }
588 
589 #if CONFIG_AMV_ENCODER
590 // maximum over s->mjpeg_vsample[i]
591 #define V_MAX 2
592 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
593  const AVFrame *pic_arg, int *got_packet)
594 {
595  MpegEncContext *s = avctx->priv_data;
596  AVFrame *pic;
597  int i, ret;
598  int chroma_h_shift, chroma_v_shift;
599 
600  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
601 
602  if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
603  av_log(avctx, AV_LOG_ERROR,
604  "Heights which are not a multiple of 16 might fail with some decoders, "
605  "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
606  av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
607  "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
608  return AVERROR_EXPERIMENTAL;
609  }
610 
611  pic = av_frame_clone(pic_arg);
612  if (!pic)
613  return AVERROR(ENOMEM);
614  //picture should be flipped upside-down
615  for(i=0; i < 3; i++) {
616  int vsample = i ? 2 >> chroma_v_shift : 2;
617  pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
618  pic->linesize[i] *= -1;
619  }
620  ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
621  av_frame_free(&pic);
622  return ret;
623 }
624 #endif
625 
626 #define OFFSET(x) offsetof(MJPEGEncContext, mjpeg.x)
627 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
628 static const AVOption options[] = {
630 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
631  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
632  { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
633 { "force_duplicated_matrix", "Always write luma and chroma matrix for mjpeg, useful for rtp streaming.", OFFSET(force_duplicated_matrix), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, VE },
634 { NULL},
635 };
636 
637 #if CONFIG_MJPEG_ENCODER
638 static const AVClass mjpeg_class = {
639  .class_name = "mjpeg encoder",
640  .item_name = av_default_item_name,
641  .option = options,
642  .version = LIBAVUTIL_VERSION_INT,
643 };
644 
645 const FFCodec ff_mjpeg_encoder = {
646  .p.name = "mjpeg",
647  .p.long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
648  .p.type = AVMEDIA_TYPE_VIDEO,
649  .p.id = AV_CODEC_ID_MJPEG,
650  .priv_data_size = sizeof(MJPEGEncContext),
653  .close = mjpeg_encode_close,
656  .p.pix_fmts = (const enum AVPixelFormat[]) {
660  },
661  .p.priv_class = &mjpeg_class,
663 };
664 #endif
665 
666 #if CONFIG_AMV_ENCODER
667 static const AVClass amv_class = {
668  .class_name = "amv encoder",
669  .item_name = av_default_item_name,
670  .option = options,
671  .version = LIBAVUTIL_VERSION_INT,
672 };
673 
674 const FFCodec ff_amv_encoder = {
675  .p.name = "amv",
676  .p.long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
677  .p.type = AVMEDIA_TYPE_VIDEO,
678  .p.id = AV_CODEC_ID_AMV,
679  .priv_data_size = sizeof(MJPEGEncContext),
681  FF_CODEC_ENCODE_CB(amv_encode_picture),
682  .close = mjpeg_encode_close,
683  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
684  .p.pix_fmts = (const enum AVPixelFormat[]) {
686  },
687  .p.priv_class = &amv_class,
688 };
689 #endif
ff_mjpeg_encode_dc
void ff_mjpeg_encode_dc(PutBitContext *pb, int val, uint8_t *huff_size, uint16_t *huff_code)
Definition: mjpegenc_common.c:470
ff_mjpeg_encode_coef
static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
Add the coefficient's data to the JPEG buffer.
Definition: mjpegenc.c:394
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
jpegtables.h
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:74
mjpeg.h
level
uint8_t level
Definition: svq3.c:206
ff_mjpeg_encode_code
static void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
Add code and table_id to the JPEG buffer.
Definition: mjpegenc.c:379
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:41
get_bits_diff
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideoenc.h:139
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
MJPEGEncContext::mjpeg
MJpegContext mjpeg
Definition: mjpegenc.c:54
mjpegenc_common.h
ff_mjpeg_encoder
const FFCodec ff_mjpeg_encoder
MJpegContext::uni_ac_vlc_len
uint8_t uni_ac_vlc_len[64 *64 *2]
Storage for AC luminance VLC (in MpegEncContext)
Definition: mjpegenc.h:75
mpegvideoenc.h
MJpegHuffmanCode
Buffer of JPEG frame data.
Definition: mjpegenc.h:49
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
ff_mjpeg_encode_huffman_close
void ff_mjpeg_encode_huffman_close(MJpegEncHuffmanContext *s, uint8_t bits[17], uint8_t val[], int max_nval)
Produces a Huffman encoding with a given input.
Definition: mjpegenc_huffman.c:158
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
MJpegContext::bits_ac_chrominance
uint8_t bits_ac_chrominance[17]
AC chrominance Huffman bits.
Definition: mjpegenc.h:88
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
pixdesc.h
ff_mjpeg_encode_picture_header
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, const AVFrame *frame, struct MJpegContext *m, ScanTable *intra_scantable, int pred, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64], int use_slices)
Definition: mjpegenc_common.c:278
AVOption
AVOption.
Definition: opt.h:251
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:100
MJpegContext::val_dc_chrominance
uint8_t val_dc_chrominance[12]
DC chrominance Huffman values.
Definition: mjpegenc.h:83
MJpegContext::huffman
int huffman
Definition: mjpegenc.h:60
MJpegHuffmanCode::mant
uint16_t mant
The mantissa.
Definition: mjpegenc.h:53
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
ff_mjpeg_encode_init
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:294
FFCodec
Definition: codec_internal.h:118
MJpegContext::huff_code_dc_chrominance
uint16_t huff_code_dc_chrominance[12]
DC chrominance Huffman table codes.
Definition: mjpegenc.h:67
mpegvideo.h
MJpegHuffmanCode::table_id
uint8_t table_id
The Huffman table id associated with the data.
Definition: mjpegenc.h:51
ff_mjpeg_encode_huffman_init
void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s)
Definition: mjpegenc_huffman.c:145
ff_mjpeg_bits_ac_chrominance
const uint8_t ff_mjpeg_bits_ac_chrominance[]
Definition: jpegtabs.h:66
MJpegContext::huff_size_dc_chrominance
uint8_t huff_size_dc_chrominance[12]
DC chrominance Huffman table size.
Definition: mjpegenc.h:66
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1313
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
init
static int init
Definition: av_tx.c:47
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1671
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:65
MJPEGEncContext::mpeg
MpegEncContext mpeg
Definition: mjpegenc.c:53
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
MJpegContext::uni_chroma_ac_vlc_len
uint8_t uni_chroma_ac_vlc_len[64 *64 *2]
Storage for AC chrominance VLC (in MpegEncContext)
Definition: mjpegenc.h:77
fail
#define fail()
Definition: checkasm.h:131
encode_block
static void encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mjpegenc.c:465
mjpeg_encode_picture_header
static void mjpeg_encode_picture_header(MpegEncContext *s)
Definition: mjpegenc.c:81
val
static double val(void *priv, double ch)
Definition: aeval.c:77
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2731
ff_amv_encoder
const FFCodec ff_amv_encoder
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
ff_mpv_reallocate_putbitbuffer
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
Definition: mpegvideo_enc.c:2729
ff_mjpeg_encode_mb
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mjpegenc.c:523
ff_mjpeg_profiles
const AVProfile ff_mjpeg_profiles[]
Definition: profiles.c:169
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
MJpegContext::bits_dc_luminance
uint8_t bits_dc_luminance[17]
DC luminance Huffman bits.
Definition: mjpegenc.h:80
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
s
#define s(width, name)
Definition: cbs_vp9.c:256
CHROMA_422
#define CHROMA_422
Definition: mpegvideo.h:458
MJpegContext::val_dc_luminance
uint8_t val_dc_luminance[12]
DC luminance Huffman values.
Definition: mjpegenc.h:81
record_block
static void record_block(MpegEncContext *s, int16_t *block, int n)
Add the block's data into the JPEG buffer.
Definition: mjpegenc.c:422
HUFFMAN_TABLE_OPTIMAL
@ HUFFMAN_TABLE_OPTIMAL
Compute and use optimal Huffman tables.
Definition: mjpegenc.h:100
MJpegEncHuffmanContext
Definition: mjpegenc_huffman.h:32
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ctx
AVFormatContext * ctx
Definition: movenc.c:48
RST0
@ RST0
Definition: mjpeg.h:61
MJpegContext::val_ac_chrominance
uint8_t val_ac_chrominance[256]
AC chrominance Huffman values.
Definition: mjpegenc.h:89
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:474
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
PutBitContext
Definition: put_bits.h:50
NB_HUFFMAN_TABLE_OPTION
@ NB_HUFFMAN_TABLE_OPTION
Definition: mjpegenc.h:101
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:205
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
profiles.h
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:932
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
ff_mjpeg_amv_encode_picture_header
void ff_mjpeg_amv_encode_picture_header(MpegEncContext *s)
Definition: mjpegenc.c:93
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MJpegContext::huff_ncode
size_t huff_ncode
Number of current entries in the buffer.
Definition: mjpegenc.h:91
MJPEGEncContext
Definition: mjpegenc.c:52
HUFFMAN_TABLE_DEFAULT
@ HUFFMAN_TABLE_DEFAULT
Use the default Huffman tables.
Definition: mjpegenc.h:99
OFFSET
#define OFFSET(x)
Definition: mjpegenc.c:626
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
codec_internal.h
ff_mjpeg_encode_huffman_increment
static void ff_mjpeg_encode_huffman_increment(MJpegEncHuffmanContext *s, uint8_t val)
Definition: mjpegenc_huffman.h:38
options
static const AVOption options[]
Definition: mjpegenc.c:628
ff_mjpeg_bits_ac_luminance
const uint8_t ff_mjpeg_bits_ac_luminance[]
Definition: jpegtabs.h:40
FF_MPV_FLAG_QP_RD
#define FF_MPV_FLAG_QP_RD
Definition: mpegvideoenc.h:41
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1484
mjpegenc_huffman.h
ff_mjpeg_bits_dc_luminance
const uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
VE
#define VE
Definition: mjpegenc.c:627
MJpegContext::huff_code_ac_luminance
uint16_t huff_code_ac_luminance[256]
AC luminance Huffman table codes.
Definition: mjpegenc.h:70
UNI_AC_ENC_INDEX
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideoenc.h:36
CHROMA_444
#define CHROMA_444
Definition: mpegvideo.h:459
ff_mjpeg_build_huffman_codes
void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, const uint8_t *bits_table, const uint8_t *val_table)
Definition: mjpegenc_common.c:443
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
MJpegContext::huff_code_ac_chrominance
uint16_t huff_code_ac_chrominance[256]
AC chrominance Huffman table codes.
Definition: mjpegenc.h:72
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:457
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
alloc_huffman
static int alloc_huffman(MpegEncContext *s)
Definition: mjpegenc.c:266
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_mjpeg_encode_check_pix_fmt
int ff_mjpeg_encode_check_pix_fmt(AVCodecContext *avctx)
Definition: mjpegenc_common.c:492
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
FF_CODEC_CAP_ICC_PROFILES
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
Definition: codec_internal.h:81
avcodec.h
ret
ret
Definition: filter_design.txt:187
MJpegContext::bits_dc_chrominance
uint8_t bits_dc_chrominance[17]
DC chrominance Huffman bits.
Definition: mjpegenc.h:82
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:71
MJpegContext::huff_size_dc_luminance
uint8_t huff_size_dc_luminance[12]
DC luminance Huffman table size.
Definition: mjpegenc.h:64
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1309
Code::code
int code
LZW code.
Definition: lzwenc.c:46
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:157
AVCodecContext
main external API structure.
Definition: avcodec.h:398
MJpegContext::huff_buffer
MJpegHuffmanCode * huff_buffer
Buffer for Huffman code values.
Definition: mjpegenc.h:92
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
init_uni_ac_vlc
static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
Definition: mjpegenc.c:57
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
ff_mjpeg_escape_FF
void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
Definition: mjpegenc_common.c:386
mjpeg_encode_close
static av_cold int mjpeg_encode_close(AVCodecContext *avctx)
Definition: mjpegenc.c:364
MJpegContext
Holds JPEG frame data and Huffman table data.
Definition: mjpegenc.h:59
put_marker
static void put_marker(PutBitContext *p, enum JpegMarker code)
Definition: mjpegenc.h:104
MJpegContext::huff_size_ac_chrominance
uint8_t huff_size_ac_chrominance[256]
AC chrominance Huffman table size.
Definition: mjpegenc.h:71
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
ff_mjpeg_bits_dc_chrominance
const uint8_t ff_mjpeg_bits_dc_chrominance[]
Definition: jpegtabs.h:37
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:311
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MJpegContext::bits_ac_luminance
uint8_t bits_ac_luminance[17]
AC luminance Huffman bits.
Definition: mjpegenc.h:86
MJpegContext::val_ac_luminance
uint8_t val_ac_luminance[256]
AC luminance Huffman values.
Definition: mjpegenc.h:87
MJpegContext::huff_size_ac_luminance
uint8_t huff_size_ac_luminance[256]
AC luminance Huffman table size.
Definition: mjpegenc.h:69
mjpegenc.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:62
ff_mjpeg_encode_stuffing
int ff_mjpeg_encode_stuffing(MpegEncContext *s)
Writes the complete JPEG frame when optimal huffman tables are enabled, otherwise writes the stuffing...
Definition: mjpegenc.c:220
MJpegHuffmanCode::code
uint8_t code
The exponent.
Definition: mjpegenc.h:52
MJpegContext::huff_code_dc_luminance
uint16_t huff_code_dc_luminance[12]
DC luminance Huffman table codes.
Definition: mjpegenc.h:65