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
34
43
45 uint8_t *uni_ac_vlc_len)
46 {
47 for (
int i = 0;
i < 128;
i++) {
50 continue;
54
55 len = (
run >> 4) * huff_size_ac[0xf0];
56
59
60 len += huff_size_ac[
code] + nbits;
61
63 // We ignore EOB as its just a constant which does not change generally
64 }
65 }
66 }
67
68 #if CONFIG_MJPEG_ENCODER
69 /**
70 * Encodes and outputs the entire frame in the JPEG format.
71 *
72 * @param s The MpegEncContext.
73 */
75 {
76 int nbits,
code, table_id;
86 size_t total_bits = 0;
87 size_t bytes_needed;
88
90 // Estimate the total size first
95
96 total_bits += huff_size[table_id][
code] + nbits;
97 }
98
99 bytes_needed = (total_bits + 7) / 8;
101
106
108 if (nbits != 0) {
110 }
111 }
112
115 }
116
117 /**
118 * Builds all 4 optimal Huffman tables.
119 *
120 * Uses the data stored in the JPEG buffer to compute the tables.
121 * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
122 *
123 * @param m MJpegContext containing the JPEG buffer.
124 */
125 static void mjpeg_build_optimal_huffman(
MJpegContext *m)
126 {
132 &dc_chrominance_ctx,
133 &ac_luminance_ctx,
134 &ac_chrominance_ctx };
135 for (
int i = 0;
i < 4;
i++)
137
141
143 }
144
157
174 }
175 #endif
176
177 /**
178 * Writes the complete JPEG frame when optimal huffman tables are enabled,
179 * otherwise writes the stuffing.
180 *
181 * Header + values + stuffing.
182 *
183 * @param s The MpegEncContext.
184 * @return int Error code, 0 if successful.
185 */
187 {
189 int mb_y =
s->mb_y - !
s->mb_x;
191
192 #if CONFIG_MJPEG_ENCODER
195
196 mjpeg_build_optimal_huffman(m);
197
198 // Replace the VLCs with the optimal ones.
199 // The default ones may be used for trellis during quantization.
202 s->intra_ac_vlc_length =
204 s->intra_chroma_ac_vlc_length =
206
208 s->pred,
s->intra_matrix,
s->chroma_intra_matrix);
209 mjpeg_encode_picture_frame(
s);
210 }
211 #endif
212
218 }
219
221
222 if ((
s->avctx->active_thread_type &
FF_THREAD_SLICE) && mb_y < s->mb_height - 1)
225
227 for (
int i = 0;
i < 3;
i++)
228 s->last_dc[
i] = 128 <<
s->intra_dc_precision;
229
231 }
232
234 {
236 size_t num_mbs, num_blocks, num_codes;
237 int blocks_per_mb;
238
239 // We need to init this here as the mjpeg init is called before the common init,
240 s->mb_width = (
s->width + 15) / 16;
241 s->mb_height = (
s->height + 15) / 16;
242
243 switch (
s->chroma_format) {
248 };
249
250 // Make sure we have enough space to hold this frame.
251 num_mbs =
s->mb_width *
s->mb_height;
252 num_blocks = num_mbs * blocks_per_mb;
253 num_codes = num_blocks * 64;
254
258 return 0;
259 }
260
262 {
265
267
268 /* The following check is automatically true for AMV,
269 * but it doesn't hurt either. */
273
274 if (
s->width > 65500 ||
s->height > 65500) {
277 }
278
280 if (!m)
282
285
286 // Build default Huffman tables.
287 // These may be overwritten later with more optimal Huffman tables, but
288 // they are needed at least right now for some processes like trellis.
305
308 s->intra_ac_vlc_length =
310 s->intra_chroma_ac_vlc_length =
312
313 // Buffers start out empty.
316
319
320 return 0;
321 }
322
324 {
328 }
329 }
330
331 /**
332 * Add code and table_id to the JPEG buffer.
333 *
334 * @param s The MJpegContext which contains the JPEG buffer.
335 * @param table_id Which Huffman table the code belongs to.
336 * @param code The encoded exponent of the coefficients and the run-bits.
337 */
339 {
341 c->table_id = table_id;
343 }
344
345 /**
346 * Add the coefficient's data to the JPEG buffer.
347 *
348 * @param s The MJpegContext which contains the JPEG buffer.
349 * @param table_id Which Huffman table the code belongs to.
350 * @param val The coefficient.
351 * @param run The run-bits.
352 */
354 {
356
360 } else {
364 mant--;
365 }
366
368
369 s->huff_buffer[
s->huff_ncode].mant = mant;
371 }
372 }
373
374 /**
375 * Add the block's data into the JPEG buffer.
376 *
377 * @param s The MJpegEncContext that contains the JPEG buffer.
378 * @param block The block.
379 * @param n The block's index or number.
380 */
382 {
384 int component,
dc, last_index,
val,
run;
386
387 /* DC coef */
388 component = (n <= 3 ? 0 : (n&1) + 1);
389 table_id = (n <= 3 ? 0 : 1);
390 dc =
block[0];
/* overflow is impossible */
391 val =
dc -
s->last_dc[component];
392
394
395 s->last_dc[component] =
dc;
396
397 /* AC coefs */
398
400 last_index =
s->block_last_index[n];
401 table_id |= 2;
402
403 for(
i=1;
i<=last_index;
i++) {
404 j =
s->intra_scantable.permutated[
i];
406
409 } else {
413 }
416 }
417 }
418
419 /* output EOB only if not already 64 values */
420 if (last_index < 63 ||
run != 0)
422 }
423
425 {
426 int mant, nbits,
code,
i, j;
427 int component,
dc,
run, last_index,
val;
429 uint8_t *huff_size_ac;
430 uint16_t *huff_code_ac;
431
432 /* DC coef */
433 component = (n <= 3 ? 0 : (n&1) + 1);
434 dc =
block[0];
/* overflow is impossible */
435 val =
dc -
s->last_dc[component];
436 if (n < 4) {
440 } else {
444 }
445 s->last_dc[component] =
dc;
446
447 /* AC coefs */
448
450 last_index =
s->block_last_index[n];
451 for(
i=1;
i<=last_index;
i++) {
452 j =
s->intra_scantable.permutated[
i];
456 } else {
458 put_bits(&
s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
460 }
464 mant--;
465 }
466
469
471
474 }
475 }
476
477 /* output EOB only if not already 64 values */
478 if (last_index < 63 ||
run != 0)
479 put_bits(&
s->pb, huff_size_ac[0], huff_code_ac[0]);
480 }
481
483 {
493
494 if (16*
s->mb_x+8 <
s->width) {
501 }
502 } else {
505 }
508 } else {
512 }
513 }
514 } else {
522
523 if (16*
s->mb_x+8 <
s->width) {
530 }
531 } else {
534 }
537 } else {
541 }
542 }
543
545 }
546 }
547
548 #if CONFIG_AMV_ENCODER
549 // maximum over s->mjpeg_vsample[i]
550 #define V_MAX 2
552 const AVFrame *pic_arg,
int *got_packet)
553 {
557 int chroma_h_shift, chroma_v_shift;
558
560
563 "Heights which are not a multiple of 16 might fail with some decoders, "
564 "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->
height);
565 av_log(avctx,
AV_LOG_WARNING,
"If you have a device that plays AMV videos, please test if videos "
566 "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
568 }
569
571 if (!pic)
573 //picture should be flipped upside-down
574 for(
i=0;
i < 3;
i++) {
575 int vsample =
i ? 2 >> chroma_v_shift : 2;
578 }
582 }
583 #endif
584
585 #define OFFSET(x) offsetof(MpegEncContext, x)
586 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
596 {
"force_duplicated_matrix",
"Always write luma and chroma matrix for mjpeg, useful for rtp streaming.",
OFFSET(force_duplicated_matrix),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1,
VE },
597 #if FF_API_MPEGVIDEO_OPTS
601 #endif
603 };
604
605 #if CONFIG_MJPEG_ENCODER
606 static const AVClass mjpeg_class = {
611 };
612
628 },
629 .priv_class = &mjpeg_class,
631 };
632 #endif
633
634 #if CONFIG_AMV_ENCODER
635 static const AVClass amv_class = {
640 };
641
649 .encode2 = amv_encode_picture,
654 },
655 .priv_class = &amv_class,
656 };
657 #endif
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]