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 "mpegvideo.h"
39 #include "mjpeg.h"
40 #include "mjpegenc.h"
41 #include "profiles.h"
42 
44 {
45  MJpegContext *m = s->mjpeg_ctx;
46  size_t num_mbs, num_blocks, num_codes;
47  int blocks_per_mb;
48 
49  // We need to init this here as the mjpeg init is called before the common init,
50  s->mb_width = (s->width + 15) / 16;
51  s->mb_height = (s->height + 15) / 16;
52 
53  switch (s->chroma_format) {
54  case CHROMA_420: blocks_per_mb = 6; break;
55  case CHROMA_422: blocks_per_mb = 8; break;
56  case CHROMA_444: blocks_per_mb = 12; break;
57  default: av_assert0(0);
58  };
59 
60  // Make sure we have enough space to hold this frame.
61  num_mbs = s->mb_width * s->mb_height;
62  num_blocks = num_mbs * blocks_per_mb;
63  num_codes = num_blocks * 64;
64 
65  m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
66  if (!m->huff_buffer)
67  return AVERROR(ENOMEM);
68  return 0;
69 }
70 
72 {
73  MJpegContext *m;
74 
76 
77  if (s->width > 65500 || s->height > 65500) {
78  av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
79  return AVERROR(EINVAL);
80  }
81 
82  m = av_mallocz(sizeof(MJpegContext));
83  if (!m)
84  return AVERROR(ENOMEM);
85 
86  s->min_qcoeff=-1023;
87  s->max_qcoeff= 1023;
88 
89  // Build default Huffman tables.
90  // These may be overwritten later with more optimal Huffman tables, but
91  // they are needed at least right now for some processes like trellis.
108 
115 
116  // Buffers start out empty.
117  m->huff_ncode = 0;
118  s->mjpeg_ctx = m;
119 
121  return alloc_huffman(s);
122 
123  return 0;
124 }
125 
127 {
129  av_freep(&s->mjpeg_ctx);
130 }
131 
132 /**
133  * Add code and table_id to the JPEG buffer.
134  *
135  * @param s The MJpegContext which contains the JPEG buffer.
136  * @param table_id Which Huffman table the code belongs to.
137  * @param code The encoded exponent of the coefficients and the run-bits.
138  */
139 static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
140 {
142  c->table_id = table_id;
143  c->code = code;
144 }
145 
146 /**
147  * Add the coefficient's data to the JPEG buffer.
148  *
149  * @param s The MJpegContext which contains the JPEG buffer.
150  * @param table_id Which Huffman table the code belongs to.
151  * @param val The coefficient.
152  * @param run The run-bits.
153  */
154 static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
155 {
156  int mant, code;
157 
158  if (val == 0) {
159  av_assert0(run == 0);
160  ff_mjpeg_encode_code(s, table_id, 0);
161  } else {
162  mant = val;
163  if (val < 0) {
164  val = -val;
165  mant--;
166  }
167 
168  code = (run << 4) | (av_log2_16bit(val) + 1);
169 
170  s->huff_buffer[s->huff_ncode].mant = mant;
171  ff_mjpeg_encode_code(s, table_id, code);
172  }
173 }
174 
175 /**
176  * Add the block's data into the JPEG buffer.
177  *
178  * @param s The MJpegEncContext that contains the JPEG buffer.
179  * @param block The block.
180  * @param n The block's index or number.
181  */
182 static void record_block(MpegEncContext *s, int16_t *block, int n)
183 {
184  int i, j, table_id;
185  int component, dc, last_index, val, run;
186  MJpegContext *m = s->mjpeg_ctx;
187 
188  /* DC coef */
189  component = (n <= 3 ? 0 : (n&1) + 1);
190  table_id = (n <= 3 ? 0 : 1);
191  dc = block[0]; /* overflow is impossible */
192  val = dc - s->last_dc[component];
193 
194  ff_mjpeg_encode_coef(m, table_id, val, 0);
195 
196  s->last_dc[component] = dc;
197 
198  /* AC coefs */
199 
200  run = 0;
201  last_index = s->block_last_index[n];
202  table_id |= 2;
203 
204  for(i=1;i<=last_index;i++) {
205  j = s->intra_scantable.permutated[i];
206  val = block[j];
207 
208  if (val == 0) {
209  run++;
210  } else {
211  while (run >= 16) {
212  ff_mjpeg_encode_code(m, table_id, 0xf0);
213  run -= 16;
214  }
215  ff_mjpeg_encode_coef(m, table_id, val, run);
216  run = 0;
217  }
218  }
219 
220  /* output EOB only if not already 64 values */
221  if (last_index < 63 || run != 0)
222  ff_mjpeg_encode_code(m, table_id, 0);
223 }
224 
225 static void encode_block(MpegEncContext *s, int16_t *block, int n)
226 {
227  int mant, nbits, code, i, j;
228  int component, dc, run, last_index, val;
229  MJpegContext *m = s->mjpeg_ctx;
230  uint8_t *huff_size_ac;
231  uint16_t *huff_code_ac;
232 
233  /* DC coef */
234  component = (n <= 3 ? 0 : (n&1) + 1);
235  dc = block[0]; /* overflow is impossible */
236  val = dc - s->last_dc[component];
237  if (n < 4) {
239  huff_size_ac = m->huff_size_ac_luminance;
240  huff_code_ac = m->huff_code_ac_luminance;
241  } else {
243  huff_size_ac = m->huff_size_ac_chrominance;
244  huff_code_ac = m->huff_code_ac_chrominance;
245  }
246  s->last_dc[component] = dc;
247 
248  /* AC coefs */
249 
250  run = 0;
251  last_index = s->block_last_index[n];
252  for(i=1;i<=last_index;i++) {
253  j = s->intra_scantable.permutated[i];
254  val = block[j];
255  if (val == 0) {
256  run++;
257  } else {
258  while (run >= 16) {
259  put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
260  run -= 16;
261  }
262  mant = val;
263  if (val < 0) {
264  val = -val;
265  mant--;
266  }
267 
268  nbits= av_log2_16bit(val) + 1;
269  code = (run << 4) | nbits;
270 
271  put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
272 
273  put_sbits(&s->pb, nbits, mant);
274  run = 0;
275  }
276  }
277 
278  /* output EOB only if not already 64 values */
279  if (last_index < 63 || run != 0)
280  put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
281 }
282 
283 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
284 {
285  int i;
286  if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
287  if (s->chroma_format == CHROMA_444) {
288  record_block(s, block[0], 0);
289  record_block(s, block[2], 2);
290  record_block(s, block[4], 4);
291  record_block(s, block[8], 8);
292  record_block(s, block[5], 5);
293  record_block(s, block[9], 9);
294 
295  if (16*s->mb_x+8 < s->width) {
296  record_block(s, block[1], 1);
297  record_block(s, block[3], 3);
298  record_block(s, block[6], 6);
299  record_block(s, block[10], 10);
300  record_block(s, block[7], 7);
301  record_block(s, block[11], 11);
302  }
303  } else {
304  for(i=0;i<5;i++) {
305  record_block(s, block[i], i);
306  }
307  if (s->chroma_format == CHROMA_420) {
308  record_block(s, block[5], 5);
309  } else {
310  record_block(s, block[6], 6);
311  record_block(s, block[5], 5);
312  record_block(s, block[7], 7);
313  }
314  }
315  } else {
316  if (s->chroma_format == CHROMA_444) {
317  encode_block(s, block[0], 0);
318  encode_block(s, block[2], 2);
319  encode_block(s, block[4], 4);
320  encode_block(s, block[8], 8);
321  encode_block(s, block[5], 5);
322  encode_block(s, block[9], 9);
323 
324  if (16*s->mb_x+8 < s->width) {
325  encode_block(s, block[1], 1);
326  encode_block(s, block[3], 3);
327  encode_block(s, block[6], 6);
328  encode_block(s, block[10], 10);
329  encode_block(s, block[7], 7);
330  encode_block(s, block[11], 11);
331  }
332  } else {
333  for(i=0;i<5;i++) {
334  encode_block(s, block[i], i);
335  }
336  if (s->chroma_format == CHROMA_420) {
337  encode_block(s, block[5], 5);
338  } else {
339  encode_block(s, block[6], 6);
340  encode_block(s, block[5], 5);
341  encode_block(s, block[7], 7);
342  }
343  }
344 
345  s->i_tex_bits += get_bits_diff(s);
346  }
347 }
348 
349 #if CONFIG_AMV_ENCODER
350 // maximum over s->mjpeg_vsample[i]
351 #define V_MAX 2
352 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
353  const AVFrame *pic_arg, int *got_packet)
354 {
355  MpegEncContext *s = avctx->priv_data;
356  AVFrame *pic;
357  int i, ret;
358  int chroma_h_shift, chroma_v_shift;
359 
360  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
361 
362  if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
363  av_log(avctx, AV_LOG_ERROR,
364  "Heights which are not a multiple of 16 might fail with some decoders, "
365  "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
366  av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
367  "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
368  return AVERROR_EXPERIMENTAL;
369  }
370 
371  pic = av_frame_clone(pic_arg);
372  if (!pic)
373  return AVERROR(ENOMEM);
374  //picture should be flipped upside-down
375  for(i=0; i < 3; i++) {
376  int vsample = i ? 2 >> chroma_v_shift : 2;
377  pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
378  pic->linesize[i] *= -1;
379  }
380  ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
381  av_frame_free(&pic);
382  return ret;
383 }
384 #endif
385 
386 #define OFFSET(x) offsetof(MpegEncContext, x)
387 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
388 static const AVOption options[] = {
390 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
391  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
392  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
393  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
394 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
395  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
396  { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
397 { NULL},
398 };
399 
400 #if CONFIG_MJPEG_ENCODER
401 static const AVClass mjpeg_class = {
402  .class_name = "mjpeg encoder",
403  .item_name = av_default_item_name,
404  .option = options,
405  .version = LIBAVUTIL_VERSION_INT,
406 };
407 
409  .name = "mjpeg",
410  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
411  .type = AVMEDIA_TYPE_VIDEO,
412  .id = AV_CODEC_ID_MJPEG,
413  .priv_data_size = sizeof(MpegEncContext),
415  .encode2 = ff_mpv_encode_picture,
416  .close = ff_mpv_encode_end,
418  .pix_fmts = (const enum AVPixelFormat[]) {
420  },
421  .priv_class = &mjpeg_class,
423 };
424 #endif
425 
426 #if CONFIG_AMV_ENCODER
427 static const AVClass amv_class = {
428  .class_name = "amv encoder",
429  .item_name = av_default_item_name,
430  .option = options,
431  .version = LIBAVUTIL_VERSION_INT,
432 };
433 
435  .name = "amv",
436  .long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
437  .type = AVMEDIA_TYPE_VIDEO,
438  .id = AV_CODEC_ID_AMV,
439  .priv_data_size = sizeof(MpegEncContext),
441  .encode2 = amv_encode_picture,
442  .close = ff_mpv_encode_end,
443  .pix_fmts = (const enum AVPixelFormat[]) {
445  },
446  .priv_class = &amv_class,
447 };
448 #endif
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
Holds JPEG frame data and Huffman table data.
Definition: mjpegenc.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
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:154
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
MJPEG encoder.
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:616
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1780
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:236
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:71
uint8_t permutated[64]
Definition: idctdsp.h:33
uint8_t run
Definition: svq3.c:206
static AVPacket pkt
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: avcodec.h:3494
av_cold void ff_init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
MJPEG encoder and decoder.
uint16_t huff_code_dc_chrominance[12]
DC chrominance Huffman table codes.
Definition: mjpegenc.h:64
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1072
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
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: jpegtables.c:127
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:82
static void encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mjpegenc.c:225
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 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:483
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
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:485
#define av_log(a,...)
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2637
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:755
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
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:202
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:2550
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static void record_block(MpegEncContext *s, int16_t *block, int n)
Add the block&#39;s data into the JPEG buffer.
Definition: mjpegenc.c:182
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: avcodec.h:3501
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1042
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
#define CHROMA_422
Definition: mpegvideo.h:484
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 uni_ac_vlc_len[64 *64 *2]
Storage for AC luminance VLC (in MpegEncContext)
Definition: mjpegenc.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
int n
Definition: avisynth_c.h:760
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
#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:424
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1046
#define OFFSET(x)
Definition: mjpegenc.c:386
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:139
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.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static int alloc_huffman(MpegEncContext *s)
Definition: mjpegenc.c:43
uint8_t * intra_chroma_ac_vlc_last_length
Definition: mpegvideo.h:314
main external API structure.
Definition: avcodec.h:1570
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:387
const uint8_t avpriv_mjpeg_val_dc[12]
Definition: jpegtables.c:67
Describe the class of an AVClass context structure.
Definition: log.h:67
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
Definition: mjpegenc.c:126
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
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 * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
MpegEncContext.
Definition: mpegvideo.h:81
uint16_t huff_code_dc_luminance[12]
DC luminance Huffman table codes.
Definition: mjpegenc.h:62
PutBitContext pb
bit output
Definition: mpegvideo.h:151
const AVProfile ff_mjpeg_profiles[]
Definition: profiles.c:164
uint8_t huff_size_dc_luminance[12]
DC luminance Huffman table size.
Definition: mjpegenc.h:61
uint8_t code
The exponent.
Definition: mjpegenc.h:52
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:1597
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:283
AVCodec ff_amv_encoder
#define av_freep(p)
#define av_malloc_array(a, b)
MJpegHuffmanCode * huff_buffer
Buffer for Huffman code values.
Definition: mjpegenc.h:89
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1459
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2633
static const AVOption options[]
Definition: mjpegenc.c:388