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 /**
69  * Encodes and outputs the entire frame in the JPEG format.
70  *
71  * @param s The MpegEncContext.
72  */
74 {
75  int nbits, code, table_id;
76  MJpegContext *m = s->mjpeg_ctx;
77  uint8_t *huff_size[4] = { m->huff_size_dc_luminance,
81  uint16_t *huff_code[4] = { m->huff_code_dc_luminance,
85  size_t total_bits = 0;
86  size_t bytes_needed;
87 
88  s->header_bits = get_bits_diff(s);
89  // Estimate the total size first
90  for (int i = 0; i < m->huff_ncode; i++) {
91  table_id = m->huff_buffer[i].table_id;
92  code = m->huff_buffer[i].code;
93  nbits = code & 0xf;
94 
95  total_bits += huff_size[table_id][code] + nbits;
96  }
97 
98  bytes_needed = (total_bits + 7) / 8;
99  ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
100 
101  for (int i = 0; i < m->huff_ncode; i++) {
102  table_id = m->huff_buffer[i].table_id;
103  code = m->huff_buffer[i].code;
104  nbits = code & 0xf;
105 
106  put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
107  if (nbits != 0) {
108  put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
109  }
110  }
111 
112  m->huff_ncode = 0;
113  s->i_tex_bits = get_bits_diff(s);
114 }
115 
116 /**
117  * Builds all 4 optimal Huffman tables.
118  *
119  * Uses the data stored in the JPEG buffer to compute the tables.
120  * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
121  *
122  * @param m MJpegContext containing the JPEG buffer.
123  */
125 {
126  MJpegEncHuffmanContext dc_luminance_ctx;
127  MJpegEncHuffmanContext dc_chrominance_ctx;
128  MJpegEncHuffmanContext ac_luminance_ctx;
129  MJpegEncHuffmanContext ac_chrominance_ctx;
130  MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx,
131  &dc_chrominance_ctx,
132  &ac_luminance_ctx,
133  &ac_chrominance_ctx };
134  for (int i = 0; i < 4; i++)
136 
137  for (int i = 0; i < m->huff_ncode; i++) {
138  int table_id = m->huff_buffer[i].table_id;
139  int code = m->huff_buffer[i].code;
140 
142  }
143 
144  ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
146  m->val_dc_luminance, 12);
147  ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
149  m->val_dc_chrominance, 12);
150  ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
152  m->val_ac_luminance, 256);
153  ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
155  m->val_ac_chrominance, 256);
156 
160  m->val_dc_luminance);
164  m->val_dc_chrominance);
168  m->val_ac_luminance);
172  m->val_ac_chrominance);
173 }
174 
175 /**
176  * Writes the complete JPEG frame when optimal huffman tables are enabled,
177  * otherwise writes the stuffing.
178  *
179  * Header + values + stuffing.
180  *
181  * @param s The MpegEncContext.
182  * @return int Error code, 0 if successful.
183  */
185 {
186  PutBitContext *pbc = &s->pb;
187  int mb_y = s->mb_y - !s->mb_x;
188  int ret;
189  MJpegContext *m;
190 
191  m = s->mjpeg_ctx;
192 
193  if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
195 
196  // Replace the VLCs with the optimal ones.
197  // The default ones may be used for trellis during quantization.
200  s->intra_ac_vlc_length =
201  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
202  s->intra_chroma_ac_vlc_length =
203  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
204 
205  ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
206  s->pred, s->intra_matrix, s->chroma_intra_matrix);
208  }
209 
211  put_bits_count(&s->pb) / 4 + 1000);
212  if (ret < 0) {
213  av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
214  goto fail;
215  }
216 
217  ff_mjpeg_escape_FF(pbc, s->esc_pos);
218 
219  if ((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height - 1)
220  put_marker(pbc, RST0 + (mb_y&7));
221  s->esc_pos = put_bits_count(pbc) >> 3;
222 
223 fail:
224  for (int i = 0; i < 3; i++)
225  s->last_dc[i] = 128 << s->intra_dc_precision;
226 
227  return ret;
228 }
229 
231 {
232  MJpegContext *m = s->mjpeg_ctx;
233  size_t num_mbs, num_blocks, num_codes;
234  int blocks_per_mb;
235 
236  // We need to init this here as the mjpeg init is called before the common init,
237  s->mb_width = (s->width + 15) / 16;
238  s->mb_height = (s->height + 15) / 16;
239 
240  switch (s->chroma_format) {
241  case CHROMA_420: blocks_per_mb = 6; break;
242  case CHROMA_422: blocks_per_mb = 8; break;
243  case CHROMA_444: blocks_per_mb = 12; break;
244  default: av_assert0(0);
245  };
246 
247  // Make sure we have enough space to hold this frame.
248  num_mbs = s->mb_width * s->mb_height;
249  num_blocks = num_mbs * blocks_per_mb;
250  num_codes = num_blocks * 64;
251 
252  m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
253  if (!m->huff_buffer)
254  return AVERROR(ENOMEM);
255  return 0;
256 }
257 
259 {
260  MJpegContext *m;
261 
262  av_assert0(s->slice_context_count == 1);
263 
264  if (s->width > 65500 || s->height > 65500) {
265  av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
266  return AVERROR(EINVAL);
267  }
268 
269  m = av_mallocz(sizeof(MJpegContext));
270  if (!m)
271  return AVERROR(ENOMEM);
272 
273  s->min_qcoeff=-1023;
274  s->max_qcoeff= 1023;
275 
276  // Build default Huffman tables.
277  // These may be overwritten later with more optimal Huffman tables, but
278  // they are needed at least right now for some processes like trellis.
295 
298  s->intra_ac_vlc_length =
299  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
300  s->intra_chroma_ac_vlc_length =
301  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
302 
303  // Buffers start out empty.
304  m->huff_ncode = 0;
305  s->mjpeg_ctx = m;
306 
307  if(s->huffman == HUFFMAN_TABLE_OPTIMAL)
308  return alloc_huffman(s);
309 
310  return 0;
311 }
312 
314 {
315  if (s->mjpeg_ctx) {
316  av_freep(&s->mjpeg_ctx->huff_buffer);
317  av_freep(&s->mjpeg_ctx);
318  }
319 }
320 
321 /**
322  * Add code and table_id to the JPEG buffer.
323  *
324  * @param s The MJpegContext which contains the JPEG buffer.
325  * @param table_id Which Huffman table the code belongs to.
326  * @param code The encoded exponent of the coefficients and the run-bits.
327  */
328 static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
329 {
330  MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
331  c->table_id = table_id;
332  c->code = code;
333 }
334 
335 /**
336  * Add the coefficient's data to the JPEG buffer.
337  *
338  * @param s The MJpegContext which contains the JPEG buffer.
339  * @param table_id Which Huffman table the code belongs to.
340  * @param val The coefficient.
341  * @param run The run-bits.
342  */
343 static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
344 {
345  int mant, code;
346 
347  if (val == 0) {
348  av_assert0(run == 0);
349  ff_mjpeg_encode_code(s, table_id, 0);
350  } else {
351  mant = val;
352  if (val < 0) {
353  val = -val;
354  mant--;
355  }
356 
357  code = (run << 4) | (av_log2_16bit(val) + 1);
358 
359  s->huff_buffer[s->huff_ncode].mant = mant;
360  ff_mjpeg_encode_code(s, table_id, code);
361  }
362 }
363 
364 /**
365  * Add the block's data into the JPEG buffer.
366  *
367  * @param s The MJpegEncContext that contains the JPEG buffer.
368  * @param block The block.
369  * @param n The block's index or number.
370  */
371 static void record_block(MpegEncContext *s, int16_t *block, int n)
372 {
373  int i, j, table_id;
374  int component, dc, last_index, val, run;
375  MJpegContext *m = s->mjpeg_ctx;
376 
377  /* DC coef */
378  component = (n <= 3 ? 0 : (n&1) + 1);
379  table_id = (n <= 3 ? 0 : 1);
380  dc = block[0]; /* overflow is impossible */
381  val = dc - s->last_dc[component];
382 
383  ff_mjpeg_encode_coef(m, table_id, val, 0);
384 
385  s->last_dc[component] = dc;
386 
387  /* AC coefs */
388 
389  run = 0;
390  last_index = s->block_last_index[n];
391  table_id |= 2;
392 
393  for(i=1;i<=last_index;i++) {
394  j = s->intra_scantable.permutated[i];
395  val = block[j];
396 
397  if (val == 0) {
398  run++;
399  } else {
400  while (run >= 16) {
401  ff_mjpeg_encode_code(m, table_id, 0xf0);
402  run -= 16;
403  }
404  ff_mjpeg_encode_coef(m, table_id, val, run);
405  run = 0;
406  }
407  }
408 
409  /* output EOB only if not already 64 values */
410  if (last_index < 63 || run != 0)
411  ff_mjpeg_encode_code(m, table_id, 0);
412 }
413 
414 static void encode_block(MpegEncContext *s, int16_t *block, int n)
415 {
416  int mant, nbits, code, i, j;
417  int component, dc, run, last_index, val;
418  MJpegContext *m = s->mjpeg_ctx;
419  uint8_t *huff_size_ac;
420  uint16_t *huff_code_ac;
421 
422  /* DC coef */
423  component = (n <= 3 ? 0 : (n&1) + 1);
424  dc = block[0]; /* overflow is impossible */
425  val = dc - s->last_dc[component];
426  if (n < 4) {
428  huff_size_ac = m->huff_size_ac_luminance;
429  huff_code_ac = m->huff_code_ac_luminance;
430  } else {
432  huff_size_ac = m->huff_size_ac_chrominance;
433  huff_code_ac = m->huff_code_ac_chrominance;
434  }
435  s->last_dc[component] = dc;
436 
437  /* AC coefs */
438 
439  run = 0;
440  last_index = s->block_last_index[n];
441  for(i=1;i<=last_index;i++) {
442  j = s->intra_scantable.permutated[i];
443  val = block[j];
444  if (val == 0) {
445  run++;
446  } else {
447  while (run >= 16) {
448  put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
449  run -= 16;
450  }
451  mant = val;
452  if (val < 0) {
453  val = -val;
454  mant--;
455  }
456 
457  nbits= av_log2_16bit(val) + 1;
458  code = (run << 4) | nbits;
459 
460  put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
461 
462  put_sbits(&s->pb, nbits, mant);
463  run = 0;
464  }
465  }
466 
467  /* output EOB only if not already 64 values */
468  if (last_index < 63 || run != 0)
469  put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
470 }
471 
472 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
473 {
474  int i;
475  if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
476  if (s->chroma_format == CHROMA_444) {
477  record_block(s, block[0], 0);
478  record_block(s, block[2], 2);
479  record_block(s, block[4], 4);
480  record_block(s, block[8], 8);
481  record_block(s, block[5], 5);
482  record_block(s, block[9], 9);
483 
484  if (16*s->mb_x+8 < s->width) {
485  record_block(s, block[1], 1);
486  record_block(s, block[3], 3);
487  record_block(s, block[6], 6);
488  record_block(s, block[10], 10);
489  record_block(s, block[7], 7);
490  record_block(s, block[11], 11);
491  }
492  } else {
493  for(i=0;i<5;i++) {
494  record_block(s, block[i], i);
495  }
496  if (s->chroma_format == CHROMA_420) {
497  record_block(s, block[5], 5);
498  } else {
499  record_block(s, block[6], 6);
500  record_block(s, block[5], 5);
501  record_block(s, block[7], 7);
502  }
503  }
504  } else {
505  if (s->chroma_format == CHROMA_444) {
506  encode_block(s, block[0], 0);
507  encode_block(s, block[2], 2);
508  encode_block(s, block[4], 4);
509  encode_block(s, block[8], 8);
510  encode_block(s, block[5], 5);
511  encode_block(s, block[9], 9);
512 
513  if (16*s->mb_x+8 < s->width) {
514  encode_block(s, block[1], 1);
515  encode_block(s, block[3], 3);
516  encode_block(s, block[6], 6);
517  encode_block(s, block[10], 10);
518  encode_block(s, block[7], 7);
519  encode_block(s, block[11], 11);
520  }
521  } else {
522  for(i=0;i<5;i++) {
523  encode_block(s, block[i], i);
524  }
525  if (s->chroma_format == CHROMA_420) {
526  encode_block(s, block[5], 5);
527  } else {
528  encode_block(s, block[6], 6);
529  encode_block(s, block[5], 5);
530  encode_block(s, block[7], 7);
531  }
532  }
533 
534  s->i_tex_bits += get_bits_diff(s);
535  }
536 }
537 
538 #if CONFIG_AMV_ENCODER
539 // maximum over s->mjpeg_vsample[i]
540 #define V_MAX 2
541 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
542  const AVFrame *pic_arg, int *got_packet)
543 {
544  MpegEncContext *s = avctx->priv_data;
545  AVFrame *pic;
546  int i, ret;
547  int chroma_h_shift, chroma_v_shift;
548 
549  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
550 
551  if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
552  av_log(avctx, AV_LOG_ERROR,
553  "Heights which are not a multiple of 16 might fail with some decoders, "
554  "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
555  av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
556  "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
557  return AVERROR_EXPERIMENTAL;
558  }
559 
560  pic = av_frame_clone(pic_arg);
561  if (!pic)
562  return AVERROR(ENOMEM);
563  //picture should be flipped upside-down
564  for(i=0; i < 3; i++) {
565  int vsample = i ? 2 >> chroma_v_shift : 2;
566  pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
567  pic->linesize[i] *= -1;
568  }
569  ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
570  av_frame_free(&pic);
571  return ret;
572 }
573 #endif
574 
575 #define OFFSET(x) offsetof(MpegEncContext, x)
576 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
577 static const AVOption options[] = {
579 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
580  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
581  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
582  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
583 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
584  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
585  { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
586 { NULL},
587 };
588 
589 #if CONFIG_MJPEG_ENCODER
590 static const AVClass mjpeg_class = {
591  .class_name = "mjpeg encoder",
592  .item_name = av_default_item_name,
593  .option = options,
594  .version = LIBAVUTIL_VERSION_INT,
595 };
596 
598  .name = "mjpeg",
599  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
600  .type = AVMEDIA_TYPE_VIDEO,
601  .id = AV_CODEC_ID_MJPEG,
602  .priv_data_size = sizeof(MpegEncContext),
604  .encode2 = ff_mpv_encode_picture,
605  .close = ff_mpv_encode_end,
608  .pix_fmts = (const enum AVPixelFormat[]) {
610  },
611  .priv_class = &mjpeg_class,
613 };
614 #endif
615 
616 #if CONFIG_AMV_ENCODER
617 static const AVClass amv_class = {
618  .class_name = "amv encoder",
619  .item_name = av_default_item_name,
620  .option = options,
621  .version = LIBAVUTIL_VERSION_INT,
622 };
623 
625  .name = "amv",
626  .long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
627  .type = AVMEDIA_TYPE_VIDEO,
628  .id = AV_CODEC_ID_AMV,
629  .priv_data_size = sizeof(MpegEncContext),
631  .encode2 = amv_encode_picture,
632  .close = ff_mpv_encode_end,
634  .pix_fmts = (const enum AVPixelFormat[]) {
636  },
637  .priv_class = &amv_class,
638 };
639 #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:421
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:343
AVCodec
AVCodec.
Definition: codec.h:197
mjpeg_build_optimal_huffman
static void mjpeg_build_optimal_huffman(MJpegContext *m)
Builds all 4 optimal Huffman tables.
Definition: mjpegenc.c:124
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
FF_CODEC_CAP_INIT_THREADSAFE
#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
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:72
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:328
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
mjpegenc_common.h
MJpegContext::uni_ac_vlc_len
uint8_t uni_ac_vlc_len[64 *64 *2]
Storage for AC luminance VLC (in MpegEncContext)
Definition: mjpegenc.h:72
avpriv_mjpeg_bits_ac_luminance
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
Definition: jpegtables.c:73
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:253
ff_mjpeg_encode_picture_header
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])
Definition: mjpegenc_common.c:220
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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:161
UNI_AC_ENC_INDEX
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:318
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
MJpegContext::bits_ac_chrominance
uint8_t bits_ac_chrominance[17]
AC chrominance Huffman bits.
Definition: mjpegenc.h:85
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
avpriv_mjpeg_val_ac_luminance
const uint8_t avpriv_mjpeg_val_ac_luminance[]
Definition: jpegtables.c:75
pixdesc.h
AVOption
AVOption.
Definition: opt.h:248
MJpegContext::val_dc_chrominance
uint8_t val_dc_chrominance[12]
DC chrominance Huffman values.
Definition: mjpegenc.h:80
MJpegHuffmanCode::mant
uint16_t mant
The mantissa.
Definition: mjpegenc.h:53
ff_mjpeg_encode_init
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:258
MJpegContext::huff_code_dc_chrominance
uint16_t huff_code_dc_chrominance[12]
DC chrominance Huffman table codes.
Definition: mjpegenc.h:64
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:148
MJpegContext::huff_size_dc_chrominance
uint8_t huff_size_dc_chrominance[12]
DC chrominance Huffman table size.
Definition: mjpegenc.h:63
avpriv_mjpeg_bits_dc_luminance
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
Definition: jpegtables.c:65
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1605
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
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:74
fail
#define fail()
Definition: checkasm.h:133
mjpeg_encode_picture_frame
static void mjpeg_encode_picture_frame(MpegEncContext *s)
Encodes and outputs the entire frame in the JPEG format.
Definition: mjpegenc.c:73
encode_block
static void encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mjpegenc.c:414
val
static double val(void *priv, double ch)
Definition: aeval.c:76
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:2601
ff_mjpeg_encode_mb
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mjpegenc.c:472
avpriv_mjpeg_bits_dc_chrominance
const uint8_t avpriv_mjpeg_bits_dc_chrominance[17]
Definition: jpegtables.c:70
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:194
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:77
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:257
CHROMA_422
#define CHROMA_422
Definition: mpegvideo.h:489
MJpegContext::val_dc_luminance
uint8_t val_dc_luminance[12]
DC luminance Huffman values.
Definition: mjpegenc.h:78
avpriv_mjpeg_val_dc
const uint8_t avpriv_mjpeg_val_dc[12]
Definition: jpegtables.c:67
ff_mpv_encode_init
int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:296
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:371
HUFFMAN_TABLE_OPTIMAL
@ HUFFMAN_TABLE_OPTIMAL
Compute and use optimal Huffman tables.
Definition: mjpegenc.h:97
MJpegEncHuffmanContext
Definition: mjpegenc_huffman.h:32
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: mpegvideo_enc.c:1859
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
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:86
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
PutBitContext
Definition: put_bits.h:44
NB_HUFFMAN_TABLE_OPTION
@ NB_HUFFMAN_TABLE_OPTION
Definition: mjpegenc.h:98
ff_amv_encoder
AVCodec ff_amv_encoder
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:72
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:235
profiles.h
avpriv_mjpeg_val_ac_chrominance
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
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:88
HUFFMAN_TABLE_DEFAULT
@ HUFFMAN_TABLE_DEFAULT
Use the default Huffman tables.
Definition: mjpegenc.h:96
OFFSET
#define OFFSET(x)
Definition: mjpegenc.c:575
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
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:577
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1785
mjpegenc_huffman.h
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
VE
#define VE
Definition: mjpegenc.c:576
MJpegContext::huff_code_ac_luminance
uint16_t huff_code_ac_luminance[256]
AC luminance Huffman table codes.
Definition: mjpegenc.h:67
CHROMA_444
#define CHROMA_444
Definition: mpegvideo.h:490
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:394
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
MJpegContext::huff_code_ac_chrominance
uint16_t huff_code_ac_chrominance[256]
AC chrominance Huffman table codes.
Definition: mjpegenc.h:69
i
int i
Definition: input.c:407
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:488
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:76
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: internal.h:49
ff_mpv_reallocate_putbitbuffer
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
Definition: mpegvideo_enc.c:2917
alloc_huffman
static int alloc_huffman(MpegEncContext *s)
Definition: mjpegenc.c:230
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
ff_mpv_encode_end
int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:1096
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
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
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
len
int len
Definition: vorbis_enc_data.h:452
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
avcodec.h
get_bits_diff
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:765
ret
ret
Definition: filter_design.txt:187
MJpegContext::bits_dc_chrominance
uint8_t bits_dc_chrominance[17]
DC chrominance Huffman bits.
Definition: mjpegenc.h:79
pred
static const float pred[4]
Definition: siprdata.h:259
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:72
MJpegContext::huff_size_dc_luminance
uint8_t huff_size_dc_luminance[12]
DC luminance Huffman table size.
Definition: mjpegenc.h:61
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
ff_mjpeg_encode_close
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
Definition: mjpegenc.c:313
Code::code
int code
LZW code.
Definition: lzwenc.c:45
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:156
AVCodecContext
main external API structure.
Definition: avcodec.h:536
MJpegContext::huff_buffer
MJpegHuffmanCode * huff_buffer
Buffer for Huffman code values.
Definition: mjpegenc.h:89
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:44
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:334
ff_mjpeg_encoder
AVCodec ff_mjpeg_encoder
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:101
MJpegContext::huff_size_ac_chrominance
uint8_t huff_size_ac_chrominance[256]
AC chrominance Huffman table size.
Definition: mjpegenc.h:68
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
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:28
MJpegContext::bits_ac_luminance
uint8_t bits_ac_luminance[17]
AC luminance Huffman bits.
Definition: mjpegenc.h:83
avpriv_mjpeg_bits_ac_chrominance
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
MJpegContext::val_ac_luminance
uint8_t val_ac_luminance[256]
AC luminance Huffman values.
Definition: mjpegenc.h:84
MJpegContext::huff_size_ac_luminance
uint8_t huff_size_ac_luminance[256]
AC luminance Huffman table size.
Definition: mjpegenc.h:66
mjpegenc.h
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:629
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
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:184
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:62