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 "libavutil/pixdesc.h"
34 
35 #include "avcodec.h"
36 #include "jpegtables.h"
37 #include "mjpegenc_common.h"
38 #include "mjpegenc_huffman.h"
39 #include "mpegvideo.h"
40 #include "mjpeg.h"
41 #include "mjpegenc.h"
42 #include "profiles.h"
43 
44 static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],
45  uint8_t *uni_ac_vlc_len)
46 {
47  for (int i = 0; i < 128; i++) {
48  int level = i - 64;
49  if (!level)
50  continue;
51  for (int run = 0; run < 64; run++) {
52  int len, code, nbits;
53  int alevel = FFABS(level);
54 
55  len = (run >> 4) * huff_size_ac[0xf0];
56 
57  nbits= av_log2_16bit(alevel) + 1;
58  code = ((15&run) << 4) | nbits;
59 
60  len += huff_size_ac[code] + nbits;
61 
62  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
63  // We ignore EOB as its just a constant which does not change generally
64  }
65  }
66 }
67 
68 #if CONFIG_MJPEG_ENCODER
69 /**
70  * Encodes and outputs the entire frame in the JPEG format.
71  *
72  * @param s The MpegEncContext.
73  */
74 static void mjpeg_encode_picture_frame(MpegEncContext *s)
75 {
76  int nbits, code, table_id;
77  MJpegContext *m = s->mjpeg_ctx;
78  uint8_t *huff_size[4] = { m->huff_size_dc_luminance,
82  uint16_t *huff_code[4] = { m->huff_code_dc_luminance,
86  size_t total_bits = 0;
87  size_t bytes_needed;
88 
89  s->header_bits = get_bits_diff(s);
90  // Estimate the total size first
91  for (int i = 0; i < m->huff_ncode; i++) {
92  table_id = m->huff_buffer[i].table_id;
93  code = m->huff_buffer[i].code;
94  nbits = code & 0xf;
95 
96  total_bits += huff_size[table_id][code] + nbits;
97  }
98 
99  bytes_needed = (total_bits + 7) / 8;
100  ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
101 
102  for (int i = 0; i < m->huff_ncode; i++) {
103  table_id = m->huff_buffer[i].table_id;
104  code = m->huff_buffer[i].code;
105  nbits = code & 0xf;
106 
107  put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
108  if (nbits != 0) {
109  put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
110  }
111  }
112 
113  m->huff_ncode = 0;
114  s->i_tex_bits = get_bits_diff(s);
115 }
116 
117 /**
118  * Builds all 4 optimal Huffman tables.
119  *
120  * Uses the data stored in the JPEG buffer to compute the tables.
121  * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
122  *
123  * @param m MJpegContext containing the JPEG buffer.
124  */
125 static void mjpeg_build_optimal_huffman(MJpegContext *m)
126 {
127  MJpegEncHuffmanContext dc_luminance_ctx;
128  MJpegEncHuffmanContext dc_chrominance_ctx;
129  MJpegEncHuffmanContext ac_luminance_ctx;
130  MJpegEncHuffmanContext ac_chrominance_ctx;
131  MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx,
132  &dc_chrominance_ctx,
133  &ac_luminance_ctx,
134  &ac_chrominance_ctx };
135  for (int i = 0; i < 4; i++)
137 
138  for (int i = 0; i < m->huff_ncode; i++) {
139  int table_id = m->huff_buffer[i].table_id;
140  int code = m->huff_buffer[i].code;
141 
142  ff_mjpeg_encode_huffman_increment(ctx[table_id], code);
143  }
144 
145  ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
147  m->val_dc_luminance, 12);
148  ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
150  m->val_dc_chrominance, 12);
151  ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
153  m->val_ac_luminance, 256);
154  ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
156  m->val_ac_chrominance, 256);
157 
161  m->val_dc_luminance);
165  m->val_dc_chrominance);
169  m->val_ac_luminance);
173  m->val_ac_chrominance);
174 }
175 #endif
176 
177 /**
178  * Writes the complete JPEG frame when optimal huffman tables are enabled,
179  * otherwise writes the stuffing.
180  *
181  * Header + values + stuffing.
182  *
183  * @param s The MpegEncContext.
184  * @return int Error code, 0 if successful.
185  */
187 {
188  PutBitContext *pbc = &s->pb;
189  int mb_y = s->mb_y - !s->mb_x;
190  int ret;
191 
192 #if CONFIG_MJPEG_ENCODER
193  if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
194  MJpegContext *m = s->mjpeg_ctx;
195 
196  mjpeg_build_optimal_huffman(m);
197 
198  // Replace the VLCs with the optimal ones.
199  // The default ones may be used for trellis during quantization.
206 
209  mjpeg_encode_picture_frame(s);
210  }
211 #endif
212 
213  ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
214  put_bits_count(&s->pb) / 4 + 1000);
215  if (ret < 0) {
216  av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
217  goto fail;
218  }
219 
220  ff_mjpeg_escape_FF(pbc, s->esc_pos);
221 
222  if ((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height - 1)
223  put_marker(pbc, RST0 + (mb_y&7));
224  s->esc_pos = put_bytes_count(pbc, 0);
225 
226 fail:
227  for (int i = 0; i < 3; i++)
228  s->last_dc[i] = 128 << s->intra_dc_precision;
229 
230  return ret;
231 }
232 
234 {
235  MJpegContext *m = s->mjpeg_ctx;
236  size_t num_mbs, num_blocks, num_codes;
237  int blocks_per_mb;
238 
239  // We need to init this here as the mjpeg init is called before the common init,
240  s->mb_width = (s->width + 15) / 16;
241  s->mb_height = (s->height + 15) / 16;
242 
243  switch (s->chroma_format) {
244  case CHROMA_420: blocks_per_mb = 6; break;
245  case CHROMA_422: blocks_per_mb = 8; break;
246  case CHROMA_444: blocks_per_mb = 12; break;
247  default: av_assert0(0);
248  };
249 
250  // Make sure we have enough space to hold this frame.
251  num_mbs = s->mb_width * s->mb_height;
252  num_blocks = num_mbs * blocks_per_mb;
253  num_codes = num_blocks * 64;
254 
255  m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
256  if (!m->huff_buffer)
257  return AVERROR(ENOMEM);
258  return 0;
259 }
260 
262 {
263  MJpegContext *m;
264  int ret;
265 
267 
268  /* The following check is automatically true for AMV,
269  * but it doesn't hurt either. */
271  if (ret < 0)
272  return ret;
273 
274  if (s->width > 65500 || s->height > 65500) {
275  av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
276  return AVERROR(EINVAL);
277  }
278 
279  m = av_mallocz(sizeof(MJpegContext));
280  if (!m)
281  return AVERROR(ENOMEM);
282 
283  s->min_qcoeff=-1023;
284  s->max_qcoeff= 1023;
285 
286  // Build default Huffman tables.
287  // These may be overwritten later with more optimal Huffman tables, but
288  // they are needed at least right now for some processes like trellis.
305 
312 
313  // Buffers start out empty.
314  m->huff_ncode = 0;
315  s->mjpeg_ctx = m;
316 
318  return alloc_huffman(s);
319 
320  return 0;
321 }
322 
324 {
325  if (s->mjpeg_ctx) {
327  av_freep(&s->mjpeg_ctx);
328  }
329 }
330 
331 /**
332  * Add code and table_id to the JPEG buffer.
333  *
334  * @param s The MJpegContext which contains the JPEG buffer.
335  * @param table_id Which Huffman table the code belongs to.
336  * @param code The encoded exponent of the coefficients and the run-bits.
337  */
338 static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
339 {
341  c->table_id = table_id;
342  c->code = code;
343 }
344 
345 /**
346  * Add the coefficient's data to the JPEG buffer.
347  *
348  * @param s The MJpegContext which contains the JPEG buffer.
349  * @param table_id Which Huffman table the code belongs to.
350  * @param val The coefficient.
351  * @param run The run-bits.
352  */
353 static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
354 {
355  int mant, code;
356 
357  if (val == 0) {
358  av_assert0(run == 0);
359  ff_mjpeg_encode_code(s, table_id, 0);
360  } else {
361  mant = val;
362  if (val < 0) {
363  val = -val;
364  mant--;
365  }
366 
367  code = (run << 4) | (av_log2_16bit(val) + 1);
368 
369  s->huff_buffer[s->huff_ncode].mant = mant;
370  ff_mjpeg_encode_code(s, table_id, code);
371  }
372 }
373 
374 /**
375  * Add the block's data into the JPEG buffer.
376  *
377  * @param s The MJpegEncContext that contains the JPEG buffer.
378  * @param block The block.
379  * @param n The block's index or number.
380  */
381 static void record_block(MpegEncContext *s, int16_t *block, int n)
382 {
383  int i, j, table_id;
384  int component, dc, last_index, val, run;
385  MJpegContext *m = s->mjpeg_ctx;
386 
387  /* DC coef */
388  component = (n <= 3 ? 0 : (n&1) + 1);
389  table_id = (n <= 3 ? 0 : 1);
390  dc = block[0]; /* overflow is impossible */
391  val = dc - s->last_dc[component];
392 
393  ff_mjpeg_encode_coef(m, table_id, val, 0);
394 
395  s->last_dc[component] = dc;
396 
397  /* AC coefs */
398 
399  run = 0;
400  last_index = s->block_last_index[n];
401  table_id |= 2;
402 
403  for(i=1;i<=last_index;i++) {
404  j = s->intra_scantable.permutated[i];
405  val = block[j];
406 
407  if (val == 0) {
408  run++;
409  } else {
410  while (run >= 16) {
411  ff_mjpeg_encode_code(m, table_id, 0xf0);
412  run -= 16;
413  }
414  ff_mjpeg_encode_coef(m, table_id, val, run);
415  run = 0;
416  }
417  }
418 
419  /* output EOB only if not already 64 values */
420  if (last_index < 63 || run != 0)
421  ff_mjpeg_encode_code(m, table_id, 0);
422 }
423 
424 static void encode_block(MpegEncContext *s, int16_t *block, int n)
425 {
426  int mant, nbits, code, i, j;
427  int component, dc, run, last_index, val;
428  MJpegContext *m = s->mjpeg_ctx;
429  uint8_t *huff_size_ac;
430  uint16_t *huff_code_ac;
431 
432  /* DC coef */
433  component = (n <= 3 ? 0 : (n&1) + 1);
434  dc = block[0]; /* overflow is impossible */
435  val = dc - s->last_dc[component];
436  if (n < 4) {
438  huff_size_ac = m->huff_size_ac_luminance;
439  huff_code_ac = m->huff_code_ac_luminance;
440  } else {
442  huff_size_ac = m->huff_size_ac_chrominance;
443  huff_code_ac = m->huff_code_ac_chrominance;
444  }
445  s->last_dc[component] = dc;
446 
447  /* AC coefs */
448 
449  run = 0;
450  last_index = s->block_last_index[n];
451  for(i=1;i<=last_index;i++) {
452  j = s->intra_scantable.permutated[i];
453  val = block[j];
454  if (val == 0) {
455  run++;
456  } else {
457  while (run >= 16) {
458  put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
459  run -= 16;
460  }
461  mant = val;
462  if (val < 0) {
463  val = -val;
464  mant--;
465  }
466 
467  nbits= av_log2_16bit(val) + 1;
468  code = (run << 4) | nbits;
469 
470  put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
471 
472  put_sbits(&s->pb, nbits, mant);
473  run = 0;
474  }
475  }
476 
477  /* output EOB only if not already 64 values */
478  if (last_index < 63 || run != 0)
479  put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
480 }
481 
482 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
483 {
484  int i;
485  if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
486  if (s->chroma_format == CHROMA_444) {
487  record_block(s, block[0], 0);
488  record_block(s, block[2], 2);
489  record_block(s, block[4], 4);
490  record_block(s, block[8], 8);
491  record_block(s, block[5], 5);
492  record_block(s, block[9], 9);
493 
494  if (16*s->mb_x+8 < s->width) {
495  record_block(s, block[1], 1);
496  record_block(s, block[3], 3);
497  record_block(s, block[6], 6);
498  record_block(s, block[10], 10);
499  record_block(s, block[7], 7);
500  record_block(s, block[11], 11);
501  }
502  } else {
503  for(i=0;i<5;i++) {
504  record_block(s, block[i], i);
505  }
506  if (s->chroma_format == CHROMA_420) {
507  record_block(s, block[5], 5);
508  } else {
509  record_block(s, block[6], 6);
510  record_block(s, block[5], 5);
511  record_block(s, block[7], 7);
512  }
513  }
514  } else {
515  if (s->chroma_format == CHROMA_444) {
516  encode_block(s, block[0], 0);
517  encode_block(s, block[2], 2);
518  encode_block(s, block[4], 4);
519  encode_block(s, block[8], 8);
520  encode_block(s, block[5], 5);
521  encode_block(s, block[9], 9);
522 
523  if (16*s->mb_x+8 < s->width) {
524  encode_block(s, block[1], 1);
525  encode_block(s, block[3], 3);
526  encode_block(s, block[6], 6);
527  encode_block(s, block[10], 10);
528  encode_block(s, block[7], 7);
529  encode_block(s, block[11], 11);
530  }
531  } else {
532  for(i=0;i<5;i++) {
533  encode_block(s, block[i], i);
534  }
535  if (s->chroma_format == CHROMA_420) {
536  encode_block(s, block[5], 5);
537  } else {
538  encode_block(s, block[6], 6);
539  encode_block(s, block[5], 5);
540  encode_block(s, block[7], 7);
541  }
542  }
543 
544  s->i_tex_bits += get_bits_diff(s);
545  }
546 }
547 
548 #if CONFIG_AMV_ENCODER
549 // maximum over s->mjpeg_vsample[i]
550 #define V_MAX 2
551 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
552  const AVFrame *pic_arg, int *got_packet)
553 {
554  MpegEncContext *s = avctx->priv_data;
555  AVFrame *pic;
556  int i, ret;
557  int chroma_h_shift, chroma_v_shift;
558 
559  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
560 
561  if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
562  av_log(avctx, AV_LOG_ERROR,
563  "Heights which are not a multiple of 16 might fail with some decoders, "
564  "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
565  av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
566  "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
567  return AVERROR_EXPERIMENTAL;
568  }
569 
570  pic = av_frame_clone(pic_arg);
571  if (!pic)
572  return AVERROR(ENOMEM);
573  //picture should be flipped upside-down
574  for(i=0; i < 3; i++) {
575  int vsample = i ? 2 >> chroma_v_shift : 2;
576  pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
577  pic->linesize[i] *= -1;
578  }
579  ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
580  av_frame_free(&pic);
581  return ret;
582 }
583 #endif
584 
585 #define OFFSET(x) offsetof(MpegEncContext, x)
586 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
587 static const AVOption options[] = {
589 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
590  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
591  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
592  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
593 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
594  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
595  { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
596 { "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 },
597 #if FF_API_MPEGVIDEO_OPTS
601 #endif
602 { NULL},
603 };
604 
605 #if CONFIG_MJPEG_ENCODER
606 static const AVClass mjpeg_class = {
607  .class_name = "mjpeg encoder",
608  .item_name = av_default_item_name,
609  .option = options,
610  .version = LIBAVUTIL_VERSION_INT,
611 };
612 
614  .name = "mjpeg",
615  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
616  .type = AVMEDIA_TYPE_VIDEO,
617  .id = AV_CODEC_ID_MJPEG,
618  .priv_data_size = sizeof(MpegEncContext),
620  .encode2 = ff_mpv_encode_picture,
621  .close = ff_mpv_encode_end,
624  .pix_fmts = (const enum AVPixelFormat[]) {
628  },
629  .priv_class = &mjpeg_class,
631 };
632 #endif
633 
634 #if CONFIG_AMV_ENCODER
635 static const AVClass amv_class = {
636  .class_name = "amv encoder",
637  .item_name = av_default_item_name,
638  .option = options,
639  .version = LIBAVUTIL_VERSION_INT,
640 };
641 
643  .name = "amv",
644  .long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
645  .type = AVMEDIA_TYPE_VIDEO,
646  .id = AV_CODEC_ID_AMV,
647  .priv_data_size = sizeof(MpegEncContext),
649  .encode2 = amv_encode_picture,
650  .close = ff_mpv_encode_end,
652  .pix_fmts = (const enum AVPixelFormat[]) {
654  },
655  .priv_class = &amv_class,
656 };
657 #endif
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
#define NULL
Definition: coverity.c:32
Holds JPEG frame data and Huffman table data.
Definition: mjpegenc.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
AVOption.
Definition: opt.h:248
static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
Add the coefficient&#39;s data to the JPEG buffer.
Definition: mjpegenc.c:353
#define FF_MPV_DEPRECATED_A53_CC_OPT
Definition: mpegvideo.h:685
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:290
#define FF_MPV_DEPRECATED_MPEG_QUANT_OPT
Definition: mpegvideo.h:683
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
uint16_t chroma_intra_matrix[64]
Definition: mpegvideo.h:301
MJPEG encoder.
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:629
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:308
mpegvideo header.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:261
uint8_t permutated[64]
Definition: idctdsp.h:33
uint8_t run
Definition: svq3.c:203
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:104
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
AVPacket * pkt
Definition: movenc.c:59
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:318
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: codec.h:197
MJPEG encoder and decoder.
uint16_t huff_code_dc_chrominance[12]
DC chrominance Huffman table codes.
Definition: mjpegenc.h:64
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:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
The exact code depends on how similar the blocks are and how related they are to the block
uint16_t huff_code_ac_luminance[256]
AC luminance Huffman table codes.
Definition: mjpegenc.h:67
uint8_t
#define av_cold
Definition: attributes.h:88
uint8_t val_ac_luminance[256]
AC luminance Huffman values.
Definition: mjpegenc.h:84
static void encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mjpegenc.c:424
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
uint8_t val_dc_chrominance[12]
DC chrominance Huffman values.
Definition: mjpegenc.h:80
uint8_t uni_chroma_ac_vlc_len[64 *64 *2]
Storage for AC chrominance VLC (in MpegEncContext)
Definition: mjpegenc.h:74
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
Definition: jpegtables.c:65
#define CHROMA_420
Definition: mpegvideo.h:488
int intra_dc_precision
Definition: mpegvideo.h:469
void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, const uint8_t *bits_table, const uint8_t *val_table)
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
uint8_t huff_size_dc_chrominance[12]
DC chrominance Huffman table size.
Definition: mjpegenc.h:63
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.
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
Use the default Huffman tables.
Definition: mjpegenc.h:96
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
#define CHROMA_444
Definition: mpegvideo.h:490
#define av_log(a,...)
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1605
uint8_t table_id
The Huffman table id associated with the data.
Definition: mjpegenc.h:51
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:777
uint16_t huff_code_ac_chrominance[256]
AC chrominance Huffman table codes.
Definition: mjpegenc.h:69
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:156
uint8_t huff_size_ac_luminance[256]
AC luminance Huffman table size.
Definition: mjpegenc.h:66
uint16_t mant
The mantissa.
Definition: mjpegenc.h:53
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
#define FF_MPV_DEPRECATED_BFRAME_OPTS
Definition: mpegvideo.h:689
const uint8_t avpriv_mjpeg_bits_dc_chrominance[17]
Definition: jpegtables.c:70
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
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:2601
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
static void record_block(MpegEncContext *s, int16_t *block, int n)
Add the block&#39;s data into the JPEG buffer.
Definition: mjpegenc.c:381
uint8_t * intra_chroma_ac_vlc_length
Definition: mpegvideo.h:313
uint8_t huff_size_ac_chrominance[256]
AC chrominance Huffman table size.
Definition: mjpegenc.h:68
const char * name
Name of the codec implementation.
Definition: codec.h:204
uint8_t bits_dc_luminance[17]
DC luminance Huffman bits.
Definition: mjpegenc.h:77
#define fail()
Definition: checkasm.h:133
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:84
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
static void put_marker(PutBitContext *p, enum JpegMarker code)
Definition: mjpegenc.h:101
#define CHROMA_422
Definition: mpegvideo.h:489
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
uint8_t val_ac_chrominance[256]
AC chrominance Huffman values.
Definition: mjpegenc.h:86
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t uni_ac_vlc_len[64 *64 *2]
Storage for AC luminance VLC (in MpegEncContext)
Definition: mjpegenc.h:72
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1785
void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
Definition: error.h:72
Compute and use optimal Huffman tables.
Definition: mjpegenc.h:97
static const float pred[4]
Definition: siprdata.h:259
struct MJpegContext * mjpeg_ctx
Definition: mpegvideo.h:426
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
#define OFFSET(x)
Definition: mjpegenc.c:585
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:338
Buffer of JPEG frame data.
Definition: mjpegenc.h:49
void ff_mjpeg_encode_dc(PutBitContext *pb, int val, uint8_t *huff_size, uint16_t *huff_code)
Libavcodec external API header.
static void ff_mjpeg_encode_huffman_increment(MJpegEncHuffmanContext *s, uint8_t val)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
static int alloc_huffman(MpegEncContext *s)
Definition: mjpegenc.c:233
uint8_t * intra_chroma_ac_vlc_last_length
Definition: mpegvideo.h:314
main external API structure.
Definition: avcodec.h:536
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
ScanTable intra_scantable
Definition: mpegvideo.h:91
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
int ff_mpv_encode_init(AVCodecContext *avctx)
#define VE
Definition: mjpegenc.c:586
const uint8_t avpriv_mjpeg_val_dc[12]
Definition: jpegtables.c:67
Describe the class of an AVClass context structure.
Definition: log.h:67
uint8_t bits_ac_chrominance[17]
AC chrominance Huffman bits.
Definition: mjpegenc.h:85
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
Definition: mjpegenc.c:323
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, ScanTable *intra_scantable, int pred, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64])
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
Huffman table generation for MJPEG encoder.
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
uint8_t val_dc_luminance[12]
DC luminance Huffman values.
Definition: mjpegenc.h:78
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
uint8_t level
Definition: svq3.c:204
MpegEncContext.
Definition: mpegvideo.h:81
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
uint16_t huff_code_dc_luminance[12]
DC luminance Huffman table codes.
Definition: mjpegenc.h:62
PutBitContext pb
bit output
Definition: mpegvideo.h:151
uint8_t bits_dc_chrominance[17]
DC chrominance Huffman bits.
Definition: mjpegenc.h:79
const AVProfile ff_mjpeg_profiles[]
Definition: profiles.c:169
uint8_t huff_size_dc_luminance[12]
DC luminance Huffman table size.
Definition: mjpegenc.h:61
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
uint8_t bits_ac_luminance[17]
AC luminance Huffman bits.
Definition: mjpegenc.h:83
uint8_t code
The exponent.
Definition: mjpegenc.h:52
static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
Definition: mjpegenc.c:44
size_t huff_ncode
Number of current entries in the buffer.
Definition: mjpegenc.h:88
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
int ff_mpv_encode_end(AVCodecContext *avctx)
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
Definition: jpegtables.c:73
void * priv_data
Definition: avcodec.h:563
int len
const uint8_t avpriv_mjpeg_val_ac_luminance[]
Definition: jpegtables.c:75
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mjpegenc.c:482
AVCodec ff_amv_encoder
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:300
#define av_freep(p)
#define av_malloc_array(a, b)
MJpegHuffmanCode * huff_buffer
Buffer for Huffman code values.
Definition: mjpegenc.h:89
void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s)
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
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
AVCodec ff_mjpeg_encoder
Definition: mjpeg.h:61
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int ff_mjpeg_encode_check_pix_fmt(AVCodecContext *avctx)
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
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:186
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
int i
Definition: input.c:407
static const AVOption options[]
Definition: mjpegenc.c:587