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 
75  av_assert0(s->slice_context_count == 1);
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 
111  s->intra_ac_vlc_length =
112  s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
113  s->intra_chroma_ac_vlc_length =
114  s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
115 
116  // Buffers start out empty.
117  m->huff_ncode = 0;
118  s->mjpeg_ctx = m;
119 
120  if(s->huffman == HUFFMAN_TABLE_OPTIMAL)
121  return alloc_huffman(s);
122 
123  return 0;
124 }
125 
127 {
128  av_freep(&s->mjpeg_ctx->huff_buffer);
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 {
141  MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
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
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:594
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:154
AVCodec
AVCodec.
Definition: codec.h:190
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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
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:139
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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: jpegtables.c:127
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:240
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
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
avpriv_mjpeg_val_ac_luminance
const uint8_t avpriv_mjpeg_val_ac_luminance[]
Definition: jpegtables.c:75
pixdesc.h
AVOption
AVOption.
Definition: opt.h:246
ff_mjpeg_encode_init
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
Definition: mjpegenc.c:71
MJpegContext::huff_code_dc_chrominance
uint16_t huff_code_dc_chrominance[12]
DC chrominance Huffman table codes.
Definition: mjpegenc.h:64
mpegvideo.h
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:1593
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
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
encode_block
static void encode_block(MpegEncContext *s, int16_t *block, int n)
Definition: mjpegenc.c:225
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:2577
ff_mjpeg_encode_mb
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mjpegenc.c:283
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:163
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
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:484
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:288
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:182
HUFFMAN_TABLE_OPTIMAL
@ HUFFMAN_TABLE_OPTIMAL
Compute and use optimal Huffman tables.
Definition: mjpegenc.h:97
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:1824
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:541
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
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
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:209
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:386
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:188
options
static const AVOption options[]
Definition: mjpegenc.c:388
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
VE
#define VE
Definition: mjpegenc.c:387
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:485
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
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:483
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
alloc_huffman
static int alloc_huffman(MpegEncContext *s)
Definition: mjpegenc.c:43
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:1072
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:197
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
avcodec.h
get_bits_diff
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:755
ret
ret
Definition: filter_design.txt:187
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:1589
ff_mjpeg_encode_close
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
Definition: mjpegenc.c:126
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:526
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
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
ff_init_uni_ac_vlc
av_cold void ff_init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
Definition: mjpegenc_common.c:39
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
ff_mjpeg_encoder
AVCodec ff_mjpeg_encoder
MJpegContext
Holds JPEG frame data and Huffman table data.
Definition: mjpegenc.h:59
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:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
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:331
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
avpriv_mjpeg_bits_ac_chrominance
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
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:616
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
MJpegContext::huff_code_dc_luminance
uint16_t huff_code_dc_luminance[12]
DC luminance Huffman table codes.
Definition: mjpegenc.h:62