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/mem.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 /**
49  * Buffer of JPEG frame data.
50  *
51  * Optimal Huffman table generation requires the frame data to be loaded into
52  * a buffer so that the tables can be computed.
53  * There are at most mb_width*mb_height*12*64 of these per frame.
54  */
55 typedef struct MJpegHuffmanCode {
56  // 0=DC lum, 1=DC chrom, 2=AC lum, 3=AC chrom
57  uint8_t table_id; ///< The Huffman table id associated with the data.
58  uint8_t code; ///< The exponent.
59  uint16_t mant; ///< The mantissa.
61 
62 /* The following is the private context of MJPEG/AMV decoder.
63  * Note that when using slice threading only the main thread's
64  * MPVEncContext is followed by a MjpegContext; the other threads
65  * can access this shared context via MPVEncContext.mjpeg. */
66 typedef struct MJPEGEncContext {
70 
71 static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],
72  uint8_t *uni_ac_vlc_len)
73 {
74  for (int i = 0; i < 128; i++) {
75  int level = i - 64;
76  if (!level)
77  continue;
78  for (int run = 0; run < 64; run++) {
79  int len, code, nbits;
80  int alevel = FFABS(level);
81 
82  len = (run >> 4) * huff_size_ac[0xf0];
83 
84  nbits= av_log2_16bit(alevel) + 1;
85  code = ((15&run) << 4) | nbits;
86 
87  len += huff_size_ac[code] + nbits;
88 
89  uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
90  // We ignore EOB as its just a constant which does not change generally
91  }
92  }
93 }
94 
96 {
97  ff_mjpeg_encode_picture_header(s->c.avctx, &s->pb, s->c.cur_pic.ptr->f, s->mjpeg_ctx,
98  s->c.intra_scantable.permutated, 0,
99  s->c.intra_matrix, s->c.chroma_intra_matrix,
100  s->c.slice_context_count > 1);
101 
102  s->esc_pos = put_bytes_count(&s->pb, 0);
103  for (int i = 1; i < s->c.slice_context_count; i++)
104  s->c.enc_contexts[i]->esc_pos = 0;
105 }
106 
108 {
109  MJPEGEncContext *const m2 = (MJPEGEncContext*)m;
110  MPVEncContext *const s = &m->s;
111  av_assert2(s->mjpeg_ctx == &m2->mjpeg);
112  /* s->huffman == HUFFMAN_TABLE_OPTIMAL can only be true for MJPEG. */
113  if (!CONFIG_MJPEG_ENCODER || m2->mjpeg.huffman != HUFFMAN_TABLE_OPTIMAL)
115 
116  return 0;
117 }
118 
119 #if CONFIG_MJPEG_ENCODER
120 /**
121  * Encodes and outputs the entire frame in the JPEG format.
122  *
123  * @param main The MPVMainEncContext.
124  */
125 static void mjpeg_encode_picture_frame(MPVMainEncContext *const main)
126 {
127  MPVEncContext *const s = &main->s;
128  int nbits, code, table_id;
129  MJpegContext *m = s->mjpeg_ctx;
130  uint8_t *huff_size[4] = { m->huff_size_dc_luminance,
134  uint16_t *huff_code[4] = { m->huff_code_dc_luminance,
138  size_t total_bits = 0;
139  size_t bytes_needed;
140 
141  main->header_bits = get_bits_diff(s);
142  // Estimate the total size first
143  for (int i = 0; i < m->huff_ncode; i++) {
144  table_id = m->huff_buffer[i].table_id;
145  code = m->huff_buffer[i].code;
146  nbits = code & 0xf;
147 
148  total_bits += huff_size[table_id][code] + nbits;
149  }
150 
151  bytes_needed = (total_bits + 7) / 8;
152  ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
153 
154  for (int i = 0; i < m->huff_ncode; i++) {
155  table_id = m->huff_buffer[i].table_id;
156  code = m->huff_buffer[i].code;
157  nbits = code & 0xf;
158 
159  put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
160  if (nbits != 0) {
161  put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
162  }
163  }
164 
165  m->huff_ncode = 0;
166  s->i_tex_bits = get_bits_diff(s);
167 }
168 
169 /**
170  * Builds all 4 optimal Huffman tables.
171  *
172  * Uses the data stored in the JPEG buffer to compute the tables.
173  * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
174  *
175  * @param m MJpegContext containing the JPEG buffer.
176  */
177 static void mjpeg_build_optimal_huffman(MJpegContext *m)
178 {
179  MJpegEncHuffmanContext dc_luminance_ctx;
180  MJpegEncHuffmanContext dc_chrominance_ctx;
181  MJpegEncHuffmanContext ac_luminance_ctx;
182  MJpegEncHuffmanContext ac_chrominance_ctx;
183  MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx,
184  &dc_chrominance_ctx,
185  &ac_luminance_ctx,
186  &ac_chrominance_ctx };
187  for (int i = 0; i < 4; i++)
189 
190  for (int i = 0; i < m->huff_ncode; i++) {
191  int table_id = m->huff_buffer[i].table_id;
192  int code = m->huff_buffer[i].code;
193 
195  }
196 
197  ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
199  m->val_dc_luminance, 12);
200  ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
202  m->val_dc_chrominance, 12);
203  ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
205  m->val_ac_luminance, 256);
206  ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
208  m->val_ac_chrominance, 256);
209 
213  m->val_dc_luminance);
217  m->val_dc_chrominance);
221  m->val_ac_luminance);
225  m->val_ac_chrominance);
226 }
227 #endif
228 
229 /**
230  * Writes the complete JPEG frame when optimal huffman tables are enabled,
231  * otherwise writes the stuffing.
232  *
233  * Header + values + stuffing.
234  *
235  * @param s The MPVEncContext.
236  * @return int Error code, 0 if successful.
237  */
239 {
240  MJpegContext *const m = s->mjpeg_ctx;
241  PutBitContext *pbc = &s->pb;
242  int mb_y = s->c.mb_y - !s->c.mb_x;
243  int ret;
244 
245 #if CONFIG_MJPEG_ENCODER
246  if (m->huffman == HUFFMAN_TABLE_OPTIMAL) {
247  /* HUFFMAN_TABLE_OPTIMAL is incompatible with slice threading,
248  * therefore the following cast is allowed. */
250 
251  mjpeg_build_optimal_huffman(m);
252 
253  // Replace the VLCs with the optimal ones.
254  // The default ones may be used for trellis during quantization.
257  s->intra_ac_vlc_length =
258  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
259  s->intra_chroma_ac_vlc_length =
260  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
261 
263  mjpeg_encode_picture_frame(main);
264  }
265 #endif
266 
268  put_bits_count(&s->pb) / 4 + 1000);
269  if (ret < 0) {
270  av_log(s->c.avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
271  goto fail;
272  }
273 
274  ff_mjpeg_escape_FF(pbc, s->esc_pos);
275 
276  if (s->c.slice_context_count > 1 && mb_y < s->c.mb_height - 1)
277  put_marker(pbc, RST0 + (mb_y&7));
278  s->esc_pos = put_bytes_count(pbc, 0);
279 
280 fail:
281  for (int i = 0; i < 3; i++)
282  s->c.last_dc[i] = 128 << s->c.intra_dc_precision;
283 
284  return ret;
285 }
286 
287 static int alloc_huffman(MJPEGEncContext *const m2)
288 {
289  MJpegContext *const m = &m2->mjpeg;
290  MPVEncContext *const s = &m2->mpeg.s;
291  static const char blocks_per_mb[] = {
292  [CHROMA_420] = 6, [CHROMA_422] = 8, [CHROMA_444] = 12
293  };
294  size_t num_blocks;
295 
296  // Make sure we have enough space to hold this frame.
297  num_blocks = s->c.mb_num * blocks_per_mb[s->c.chroma_format];
298 
299  m->huff_buffer = av_malloc_array(num_blocks,
300  64 /* codes per MB */ * sizeof(MJpegHuffmanCode));
301  if (!m->huff_buffer)
302  return AVERROR(ENOMEM);
303  return 0;
304 }
305 
307 {
308  MJPEGEncContext *const mjpeg = avctx->priv_data;
309  av_freep(&mjpeg->mjpeg.huff_buffer);
310  ff_mpv_encode_end(avctx);
311  return 0;
312 }
313 
314 /**
315  * Add code and table_id to the JPEG buffer.
316  *
317  * @param s The MJpegContext which contains the JPEG buffer.
318  * @param table_id Which Huffman table the code belongs to.
319  * @param code The encoded exponent of the coefficients and the run-bits.
320  */
321 static inline void mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
322 {
323  MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
324  c->table_id = table_id;
325  c->code = code;
326 }
327 
328 /**
329  * Add the coefficient's data to the JPEG buffer.
330  *
331  * @param s The MJpegContext which contains the JPEG buffer.
332  * @param table_id Which Huffman table the code belongs to.
333  * @param val The coefficient.
334  * @param run The run-bits.
335  */
336 static void mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
337 {
338  int mant, code;
339 
340  if (val == 0) {
341  av_assert0(run == 0);
342  mjpeg_encode_code(s, table_id, 0);
343  } else {
344  mant = val;
345  if (val < 0) {
346  val = -val;
347  mant--;
348  }
349 
350  code = (run << 4) | (av_log2_16bit(val) + 1);
351 
352  s->huff_buffer[s->huff_ncode].mant = mant;
353  mjpeg_encode_code(s, table_id, code);
354  }
355 }
356 
357 /**
358  * Add the block's data into the JPEG buffer.
359  *
360  * @param s The MPVEncContext that contains the JPEG buffer.
361  * @param block The block.
362  * @param n The block's index or number.
363  */
364 static void record_block(MPVEncContext *const s, int16_t block[], int n)
365 {
366  int i, j, table_id;
367  int component, dc, last_index, val, run;
368  MJpegContext *m = s->mjpeg_ctx;
369 
370  /* DC coef */
371  component = (n <= 3 ? 0 : (n&1) + 1);
372  table_id = (n <= 3 ? 0 : 1);
373  dc = block[0]; /* overflow is impossible */
374  val = dc - s->c.last_dc[component];
375 
376  mjpeg_encode_coef(m, table_id, val, 0);
377 
378  s->c.last_dc[component] = dc;
379 
380  /* AC coefs */
381 
382  run = 0;
383  last_index = s->c.block_last_index[n];
384  table_id |= 2;
385 
386  for(i=1;i<=last_index;i++) {
387  j = s->c.intra_scantable.permutated[i];
388  val = block[j];
389 
390  if (val == 0) {
391  run++;
392  } else {
393  while (run >= 16) {
394  mjpeg_encode_code(m, table_id, 0xf0);
395  run -= 16;
396  }
397  mjpeg_encode_coef(m, table_id, val, run);
398  run = 0;
399  }
400  }
401 
402  /* output EOB only if not already 64 values */
403  if (last_index < 63 || run != 0)
404  mjpeg_encode_code(m, table_id, 0);
405 }
406 
407 static void encode_block(MPVEncContext *const s, int16_t block[], int n)
408 {
409  int mant, nbits, code, i, j;
410  int component, dc, run, last_index, val;
411  const MJpegContext *const m = s->mjpeg_ctx;
412  const uint16_t *huff_code_ac;
413  const uint8_t *huff_size_ac;
414 
415  /* DC coef */
416  component = (n <= 3 ? 0 : (n&1) + 1);
417  dc = block[0]; /* overflow is impossible */
418  val = dc - s->c.last_dc[component];
419  if (n < 4) {
421  huff_size_ac = m->huff_size_ac_luminance;
422  huff_code_ac = m->huff_code_ac_luminance;
423  } else {
425  huff_size_ac = m->huff_size_ac_chrominance;
426  huff_code_ac = m->huff_code_ac_chrominance;
427  }
428  s->c.last_dc[component] = dc;
429 
430  /* AC coefs */
431 
432  run = 0;
433  last_index = s->c.block_last_index[n];
434  for(i=1;i<=last_index;i++) {
435  j = s->c.intra_scantable.permutated[i];
436  val = block[j];
437  if (val == 0) {
438  run++;
439  } else {
440  while (run >= 16) {
441  put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
442  run -= 16;
443  }
444  mant = val;
445  if (val < 0) {
446  val = -val;
447  mant--;
448  }
449 
450  nbits= av_log2_16bit(val) + 1;
451  code = (run << 4) | nbits;
452 
453  put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
454 
455  put_sbits(&s->pb, nbits, mant);
456  run = 0;
457  }
458  }
459 
460  /* output EOB only if not already 64 values */
461  if (last_index < 63 || run != 0)
462  put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
463 }
464 
465 static void mjpeg_record_mb(MPVEncContext *const s, int16_t block[][64],
466  int unused_x, int unused_y)
467 {
468  if (s->c.chroma_format == CHROMA_444) {
469  record_block(s, block[0], 0);
470  record_block(s, block[2], 2);
471  record_block(s, block[4], 4);
472  record_block(s, block[8], 8);
473  record_block(s, block[5], 5);
474  record_block(s, block[9], 9);
475 
476  if (16*s->c.mb_x+8 < s->c.width) {
477  record_block(s, block[1], 1);
478  record_block(s, block[3], 3);
479  record_block(s, block[6], 6);
480  record_block(s, block[10], 10);
481  record_block(s, block[7], 7);
482  record_block(s, block[11], 11);
483  }
484  } else {
485  for (int i = 0; i < 5; i++)
486  record_block(s, block[i], i);
487  if (s->c.chroma_format == CHROMA_420) {
488  record_block(s, block[5], 5);
489  } else {
490  record_block(s, block[6], 6);
491  record_block(s, block[5], 5);
492  record_block(s, block[7], 7);
493  }
494  }
495 }
496 
497 static void mjpeg_encode_mb(MPVEncContext *const s, int16_t block[][64],
498  int unused_x, int unused_y)
499 {
500  if (s->c.chroma_format == CHROMA_444) {
501  encode_block(s, block[0], 0);
502  encode_block(s, block[2], 2);
503  encode_block(s, block[4], 4);
504  encode_block(s, block[8], 8);
505  encode_block(s, block[5], 5);
506  encode_block(s, block[9], 9);
507 
508  if (16 * s->c.mb_x + 8 < s->c.width) {
509  encode_block(s, block[1], 1);
510  encode_block(s, block[3], 3);
511  encode_block(s, block[6], 6);
512  encode_block(s, block[10], 10);
513  encode_block(s, block[7], 7);
514  encode_block(s, block[11], 11);
515  }
516  } else {
517  for (int i = 0; i < 5; i++)
518  encode_block(s, block[i], i);
519  if (s->c.chroma_format == CHROMA_420) {
520  encode_block(s, block[5], 5);
521  } else {
522  encode_block(s, block[6], 6);
523  encode_block(s, block[5], 5);
524  encode_block(s, block[7], 7);
525  }
526  }
527 
528  s->i_tex_bits += get_bits_diff(s);
529 }
530 
532 {
533  MJPEGEncContext *const m2 = avctx->priv_data;
534  MJpegContext *const m = &m2->mjpeg;
535  MPVEncContext *const s = &m2->mpeg.s;
536  int ret;
537 
538  s->mjpeg_ctx = m;
540  // May be overridden below
541  s->encode_mb = mjpeg_encode_mb;
542 
543  if (s->mpv_flags & FF_MPV_FLAG_QP_RD) {
544  // Used to produce garbage with MJPEG.
545  av_log(avctx, AV_LOG_ERROR,
546  "QP RD is no longer compatible with MJPEG or AMV\n");
547  return AVERROR(EINVAL);
548  }
549 
550  /* The following check is automatically true for AMV,
551  * but it doesn't hurt either. */
553  if (ret < 0)
554  return ret;
555 
556  if (avctx->width > 65500 || avctx->height > 65500) {
557  av_log(avctx, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
558  return AVERROR(EINVAL);
559  }
560 
561  // Build default Huffman tables.
562  // These may be overwritten later with more optimal Huffman tables, but
563  // they are needed at least right now for some processes like trellis.
580 
583 
584  s->min_qcoeff = -1023;
585  s->max_qcoeff = 1023;
586 
587  s->intra_ac_vlc_length =
588  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
589  s->intra_chroma_ac_vlc_length =
590  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
591 
592  ret = ff_mpv_encode_init(avctx);
593  if (ret < 0)
594  return ret;
595 
596  // Buffers start out empty.
597  m->huff_ncode = 0;
598 
599  if (s->c.slice_context_count > 1)
601 
602  if (m->huffman == HUFFMAN_TABLE_OPTIMAL) {
603  // If we are here, we have only one slice_context. So no loop necessary.
604  s->encode_mb = mjpeg_record_mb;
605  return alloc_huffman(m2);
606  }
607 
608  return 0;
609 }
610 
611 #if CONFIG_AMV_ENCODER
612 // maximum over s->mjpeg_vsample[i]
613 #define V_MAX 2
614 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
615  const AVFrame *pic_arg, int *got_packet)
616 {
617  MPVEncContext *const s = avctx->priv_data;
618  AVFrame *pic;
619  int i, ret;
620  int chroma_v_shift = 1; /* AMV is 420-only */
621 
622  if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
623  av_log(avctx, AV_LOG_ERROR,
624  "Heights which are not a multiple of 16 might fail with some decoders, "
625  "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
626  av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
627  "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
628  return AVERROR_EXPERIMENTAL;
629  }
630 
631  pic = av_frame_clone(pic_arg);
632  if (!pic)
633  return AVERROR(ENOMEM);
634  //picture should be flipped upside-down
635  for(i=0; i < 3; i++) {
636  int vsample = i ? 2 >> chroma_v_shift : 2;
637  pic->data[i] += pic->linesize[i] * (vsample * s->c.height / V_MAX - 1);
638  pic->linesize[i] *= -1;
639  }
640  ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
641  av_frame_free(&pic);
642  return ret;
643 }
644 #endif
645 
646 #define OFFSET(x) offsetof(MJPEGEncContext, mjpeg.x)
647 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
648 static const AVOption options[] = {
649 #define AMV_OPTIONS_OFFSET 4
650 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, .unit = "huffman" },
651  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "huffman" },
652  { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, .unit = "huffman" },
653 { "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 },
655 { NULL},
656 };
657 
658 #if CONFIG_MJPEG_ENCODER
659 static const AVClass mjpeg_class = {
660  .class_name = "mjpeg encoder",
661  .item_name = av_default_item_name,
662  .option = options,
663  .version = LIBAVUTIL_VERSION_INT,
664 };
665 
666 static int mjpeg_get_supported_config(const AVCodecContext *avctx,
667  const AVCodec *codec,
668  enum AVCodecConfig config,
669  unsigned flags, const void **out,
670  int *out_num)
671 {
673  static const enum AVColorRange mjpeg_ranges[] = {
675  };
676  int strict = avctx ? avctx->strict_std_compliance : 0;
677  int index = strict > FF_COMPLIANCE_UNOFFICIAL ? 1 : 0;
678  *out = &mjpeg_ranges[index];
679  *out_num = FF_ARRAY_ELEMS(mjpeg_ranges) - index - 1;
680  return 0;
681  }
682 
683  return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num);
684 }
685 
686 const FFCodec ff_mjpeg_encoder = {
687  .p.name = "mjpeg",
688  CODEC_LONG_NAME("MJPEG (Motion JPEG)"),
689  .p.type = AVMEDIA_TYPE_VIDEO,
690  .p.id = AV_CODEC_ID_MJPEG,
691  .priv_data_size = sizeof(MJPEGEncContext),
694  .close = mjpeg_encode_close,
695  .p.capabilities = AV_CODEC_CAP_DR1 |
701  .p.priv_class = &mjpeg_class,
703  .get_supported_config = mjpeg_get_supported_config,
704 };
705 #endif
706 
707 #if CONFIG_AMV_ENCODER
708 static const AVClass amv_class = {
709  .class_name = "amv encoder",
710  .item_name = av_default_item_name,
711  .option = options + AMV_OPTIONS_OFFSET,
712  .version = LIBAVUTIL_VERSION_INT,
713 };
714 
715 const FFCodec ff_amv_encoder = {
716  .p.name = "amv",
717  CODEC_LONG_NAME("AMV Video"),
718  .p.type = AVMEDIA_TYPE_VIDEO,
719  .p.id = AV_CODEC_ID_AMV,
721  .priv_data_size = sizeof(MJPEGEncContext),
723  FF_CODEC_ENCODE_CB(amv_encode_picture),
724  .close = mjpeg_encode_close,
725  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
727  .color_ranges = AVCOL_RANGE_JPEG,
728  .p.priv_class = &amv_class,
729 };
730 #endif
flags
const SwsFlags flags[]
Definition: swscale.c:61
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
AVCodec
AVCodec.
Definition: codec.h:172
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
ff_mjpeg_encode_dc
void ff_mjpeg_encode_dc(PutBitContext *pb, int val, const uint8_t huff_size[], const uint16_t huff_code[])
Definition: mjpegenc_common.c:467
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:205
MPVEncContext
Definition: mpegvideoenc.h:45
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:42
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
mjpeg_encode_coef
static void 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:336
MJPEGEncContext::mjpeg
MJpegContext mjpeg
Definition: mjpegenc.c:68
out
FILE * out
Definition: movenc.c:55
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.
Definition: mjpegenc.h:60
mpegvideoenc.h
MJpegHuffmanCode
Buffer of JPEG frame data.
Definition: mjpegenc.c:55
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:63
mjpeg_encode_init
static av_cold int mjpeg_encode_init(AVCodecContext *avctx)
Definition: mjpegenc.c:531
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:410
MJpegContext::bits_ac_chrominance
uint8_t bits_ac_chrominance[17]
AC chrominance Huffman bits.
Definition: mjpegenc.h:73
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:750
AV_CODEC_CONFIG_COLOR_RANGE
@ AV_CODEC_CONFIG_COLOR_RANGE
AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED.
Definition: avcodec.h:2529
AVOption
AVOption.
Definition: opt.h:429
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:68
MJpegContext::huffman
int huffman
Definition: mjpegenc.h:45
MJpegHuffmanCode::mant
uint16_t mant
The mantissa.
Definition: mjpegenc.c:59
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
FFCodec
Definition: codec_internal.h:127
MJpegContext::huff_code_dc_chrominance
uint16_t huff_code_dc_chrominance[12]
DC chrominance Huffman table codes.
Definition: mjpegenc.h:52
mpegvideo.h
MJpegHuffmanCode::table_id
uint8_t table_id
The Huffman table id associated with the data.
Definition: mjpegenc.c:57
ff_mjpeg_encode_huffman_init
void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s)
Definition: mjpegenc_huffman.c:145
record_block
static void record_block(MPVEncContext *const s, int16_t block[], int n)
Add the block's data into the JPEG buffer.
Definition: mjpegenc.c:364
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:51
mjpeg_record_mb
static void mjpeg_record_mb(MPVEncContext *const s, int16_t block[][64], int unused_x, int unused_y)
Definition: mjpegenc.c:465
tf_sess_config.config
config
Definition: tf_sess_config.py:33
MPVMainEncContext::encode_picture_header
int(* encode_picture_header)(struct MPVMainEncContext *m)
Definition: mpegvideoenc.h:221
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1926
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:309
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
MJpegContext::uni_chroma_ac_vlc_len
uint8_t uni_chroma_ac_vlc_len[64 *64 *2]
Storage for AC chrominance VLC.
Definition: mjpegenc.h:62
fail
#define fail()
Definition: checkasm.h:194
AMV_OPTIONS_OFFSET
#define AMV_OPTIONS_OFFSET
mjpeg_encode_picture_header
static void mjpeg_encode_picture_header(MPVEncContext *const s)
Definition: mjpegenc.c:95
val
static double val(void *priv, double ch)
Definition: aeval.c:77
ff_amv_encoder
const FFCodec ff_amv_encoder
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
ff_mjpeg_profiles
const AVProfile ff_mjpeg_profiles[]
Definition: profiles.c:185
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
main
int main
Definition: dovi_rpuenc.c:37
MJpegContext::bits_dc_luminance
uint8_t bits_dc_luminance[17]
DC luminance Huffman bits.
Definition: mjpegenc.h:65
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:86
s
#define s(width, name)
Definition: cbs_vp9.c:198
CHROMA_422
#define CHROMA_422
Definition: mpegvideo.h:310
MJpegContext::val_dc_luminance
uint8_t val_dc_luminance[12]
DC luminance Huffman values.
Definition: mjpegenc.h:66
HUFFMAN_TABLE_OPTIMAL
@ HUFFMAN_TABLE_OPTIMAL
Compute and use optimal Huffman tables.
Definition: mjpegenc.h:85
encode_block
static void encode_block(MPVEncContext *const s, int16_t block[], int n)
Definition: mjpegenc.c:407
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:144
MJpegEncHuffmanContext
Definition: mjpegenc_huffman.h:32
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ctx
AVFormatContext * ctx
Definition: movenc.c:49
RST0
@ RST0
Definition: mjpeg.h:61
MJpegContext::val_ac_chrominance
uint8_t val_ac_chrominance[256]
AC chrominance Huffman values.
Definition: mjpegenc.h:74
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:485
mjpeg_encode_code
static void mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
Add code and table_id to the JPEG buffer.
Definition: mjpegenc.c:321
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:73
PutBitContext
Definition: put_bits.h:50
NB_HUFFMAN_TABLE_OPTION
@ NB_HUFFMAN_TABLE_OPTION
Definition: mjpegenc.h:86
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
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:87
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:204
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:85
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:239
profiles.h
options
Definition: swscale.c:43
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:1104
ff_mpv_reallocate_putbitbuffer
int ff_mpv_reallocate_putbitbuffer(MPVEncContext *const s, size_t threshold, size_t size_increase)
Definition: mpegvideo_enc.c:2940
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
MPVMainEncContext
Definition: mpegvideoenc.h:172
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:716
index
int index
Definition: gxfenc.c:90
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:76
MJPEGEncContext
Definition: mjpegenc.c:66
HUFFMAN_TABLE_DEFAULT
@ HUFFMAN_TABLE_DEFAULT
Use the default Huffman tables.
Definition: mjpegenc.h:84
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
OFFSET
#define OFFSET(x)
Definition: mjpegenc.c:646
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:94
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:648
ff_mjpeg_bits_ac_luminance
const uint8_t ff_mjpeg_bits_ac_luminance[]
Definition: jpegtabs.h:40
MJpegContext::huff_buffer
struct MJpegHuffmanCode * huff_buffer
Buffer for Huffman code values.
Definition: mjpegenc.h:77
FF_MPV_FLAG_QP_RD
#define FF_MPV_FLAG_QP_RD
Definition: mpegvideoenc.h:283
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:99
VE
#define VE
Definition: mjpegenc.c:647
MJpegContext::huff_code_ac_luminance
uint16_t huff_code_ac_luminance[256]
AC luminance Huffman table codes.
Definition: mjpegenc.h:55
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
UNI_AC_ENC_INDEX
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideoenc.h:259
MJPEGEncContext::mpeg
MPVMainEncContext mpeg
Definition: mjpegenc.c:67
CHROMA_444
#define CHROMA_444
Definition: mpegvideo.h:311
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:440
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
MJpegContext::huff_code_ac_chrominance
uint16_t huff_code_ac_chrominance[256]
AC chrominance Huffman table codes.
Definition: mjpegenc.h:57
get_bits_diff
static int get_bits_diff(MPVEncContext *s)
Definition: mpegvideoenc.h:382
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
ff_default_get_supported_config
int ff_default_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out_configs, int *out_num_configs)
Definition: avcodec.c:752
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:309
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
ff_mjpeg_encode_check_pix_fmt
int ff_mjpeg_encode_check_pix_fmt(AVCodecContext *avctx)
Definition: mjpegenc_common.c:489
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
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:67
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
MJpegContext::huff_size_dc_luminance
uint8_t huff_size_dc_luminance[12]
DC luminance Huffman table size.
Definition: mjpegenc.h:49
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1357
Code::code
int code
LZW code.
Definition: lzwenc.c:46
alloc_huffman
static int alloc_huffman(MJPEGEncContext *const m2)
Definition: mjpegenc.c:287
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:159
AVCodecContext
main external API structure.
Definition: avcodec.h:431
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:71
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
ff_mjpeg_encode_stuffing
int ff_mjpeg_encode_stuffing(MPVEncContext *const s)
Writes the complete JPEG frame when optimal huffman tables are enabled, otherwise writes the stuffing...
Definition: mjpegenc.c:238
ff_mjpeg_escape_FF
void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
Definition: mjpegenc_common.c:384
mjpeg_encode_close
static av_cold int mjpeg_encode_close(AVCodecContext *avctx)
Definition: mjpegenc.c:306
MJpegContext
Holds JPEG frame data and Huffman table data.
Definition: mjpegenc.h:44
put_marker
static void put_marker(PutBitContext *p, enum JpegMarker code)
Definition: mjpegenc.h:89
MJpegContext::huff_size_ac_chrominance
uint8_t huff_size_ac_chrominance[256]
AC chrominance Huffman table size.
Definition: mjpegenc.h:56
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:78
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:77
ff_mjpeg_encode_picture_header
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, const AVFrame *frame, const struct MJpegContext *m, const uint8_t intra_matrix_permutation[64], int pred, const uint16_t luma_intra_matrix[64], const uint16_t chroma_intra_matrix[64], int use_slices)
Definition: mjpegenc_common.c:275
mem.h
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:544
ff_mjpeg_bits_dc_luminance
const FF_VISIBILITY_PUSH_HIDDEN uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
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:455
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:71
MJpegContext::val_ac_luminance
uint8_t val_ac_luminance[256]
AC luminance Huffman values.
Definition: mjpegenc.h:72
MJpegContext::huff_size_ac_luminance
uint8_t huff_size_ac_luminance[256]
AC luminance Huffman table size.
Definition: mjpegenc.h:54
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:715
mjpegenc.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
MPVMainEncContext::s
MPVEncContext s
The main slicecontext.
Definition: mpegvideoenc.h:173
AVCodecConfig
AVCodecConfig
Definition: avcodec.h:2523
mjpeg_encode_mb
static void mjpeg_encode_mb(MPVEncContext *const s, int16_t block[][64], int unused_x, int unused_y)
Definition: mjpegenc.c:497
MJpegHuffmanCode::code
uint8_t code
The exponent.
Definition: mjpegenc.c:58
mjpeg_amv_encode_picture_header
static int mjpeg_amv_encode_picture_header(MPVMainEncContext *const m)
Definition: mjpegenc.c:107
MJpegContext::huff_code_dc_luminance
uint16_t huff_code_dc_luminance[12]
DC luminance Huffman table codes.
Definition: mjpegenc.h:50