Mercurial > libavcodec.hg
annotate mjpegenc.c @ 6920:d02af7474bff libavcodec
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
fixes CID84 RUN2
CID85 RUN2
CID86 RUN2
CID87 RUN2
CID88 RUN2
CID89 RUN2
CID90 RUN2
CID91 RUN2
CID92 RUN2
CID93 RUN2
CID94 RUN2
CID95 RUN2
CID96 RUN2
CID97 RUN2
CID98 RUN2
CID99 RUN2
CID100 RUN2
CID101 RUN2
CID102 RUN2
CID103 RUN2
CID104 RUN2
CID105 RUN2
CID106 RUN2
author | michael |
---|---|
date | Wed, 28 May 2008 11:59:41 +0000 |
parents | e1302edb0f69 |
children | e943e1409077 |
rev | line source |
---|---|
5020 | 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 * | |
5214 | 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 * | |
5020 | 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 mjpegenc.c | |
30 * MJPEG encoder. | |
31 */ | |
32 | |
33 //#define DEBUG | |
34 #include <assert.h> | |
35 | |
36 #include "avcodec.h" | |
37 #include "dsputil.h" | |
38 #include "mpegvideo.h" | |
39 #include "mjpeg.h" | |
5028 | 40 #include "mjpegenc.h" |
5020 | 41 |
42 /* use two quantizer tables (one for luminance and one for chrominance) */ | |
43 /* not yet working */ | |
44 #undef TWOMATRIXES | |
45 | |
46 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
5214
diff
changeset
|
47 av_cold int ff_mjpeg_encode_init(MpegEncContext *s) |
5020 | 48 { |
49 MJpegContext *m; | |
50 | |
51 m = av_malloc(sizeof(MJpegContext)); | |
52 if (!m) | |
53 return -1; | |
54 | |
55 s->min_qcoeff=-1023; | |
56 s->max_qcoeff= 1023; | |
57 | |
58 /* build all the huffman tables */ | |
5021 | 59 ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance, |
60 m->huff_code_dc_luminance, | |
61 ff_mjpeg_bits_dc_luminance, | |
62 ff_mjpeg_val_dc_luminance); | |
63 ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance, | |
64 m->huff_code_dc_chrominance, | |
65 ff_mjpeg_bits_dc_chrominance, | |
66 ff_mjpeg_val_dc_chrominance); | |
67 ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance, | |
68 m->huff_code_ac_luminance, | |
69 ff_mjpeg_bits_ac_luminance, | |
70 ff_mjpeg_val_ac_luminance); | |
71 ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance, | |
72 m->huff_code_ac_chrominance, | |
73 ff_mjpeg_bits_ac_chrominance, | |
74 ff_mjpeg_val_ac_chrominance); | |
5020 | 75 |
76 s->mjpeg_ctx = m; | |
77 return 0; | |
78 } | |
79 | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
80 void ff_mjpeg_encode_close(MpegEncContext *s) |
5020 | 81 { |
82 av_free(s->mjpeg_ctx); | |
83 } | |
84 | |
85 /* table_class: 0 = DC coef, 1 = AC coefs */ | |
86 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id, | |
87 const uint8_t *bits_table, const uint8_t *value_table) | |
88 { | |
89 PutBitContext *p = &s->pb; | |
90 int n, i; | |
91 | |
92 put_bits(p, 4, table_class); | |
93 put_bits(p, 4, table_id); | |
94 | |
95 n = 0; | |
96 for(i=1;i<=16;i++) { | |
97 n += bits_table[i]; | |
98 put_bits(p, 8, bits_table[i]); | |
99 } | |
100 | |
101 for(i=0;i<n;i++) | |
102 put_bits(p, 8, value_table[i]); | |
103 | |
104 return n + 17; | |
105 } | |
106 | |
107 static void jpeg_table_header(MpegEncContext *s) | |
108 { | |
109 PutBitContext *p = &s->pb; | |
110 int i, j, size; | |
111 uint8_t *ptr; | |
112 | |
113 /* quant matrixes */ | |
114 put_marker(p, DQT); | |
115 #ifdef TWOMATRIXES | |
116 put_bits(p, 16, 2 + 2 * (1 + 64)); | |
117 #else | |
118 put_bits(p, 16, 2 + 1 * (1 + 64)); | |
119 #endif | |
120 put_bits(p, 4, 0); /* 8 bit precision */ | |
121 put_bits(p, 4, 0); /* table 0 */ | |
122 for(i=0;i<64;i++) { | |
123 j = s->intra_scantable.permutated[i]; | |
124 put_bits(p, 8, s->intra_matrix[j]); | |
125 } | |
126 #ifdef TWOMATRIXES | |
127 put_bits(p, 4, 0); /* 8 bit precision */ | |
128 put_bits(p, 4, 1); /* table 1 */ | |
129 for(i=0;i<64;i++) { | |
130 j = s->intra_scantable.permutated[i]; | |
131 put_bits(p, 8, s->chroma_intra_matrix[j]); | |
132 } | |
133 #endif | |
134 | |
135 /* huffman table */ | |
136 put_marker(p, DHT); | |
137 flush_put_bits(p); | |
138 ptr = pbBufPtr(p); | |
139 put_bits(p, 16, 0); /* patched later */ | |
140 size = 2; | |
5021 | 141 size += put_huffman_table(s, 0, 0, ff_mjpeg_bits_dc_luminance, |
142 ff_mjpeg_val_dc_luminance); | |
143 size += put_huffman_table(s, 0, 1, ff_mjpeg_bits_dc_chrominance, | |
144 ff_mjpeg_val_dc_chrominance); | |
5020 | 145 |
5021 | 146 size += put_huffman_table(s, 1, 0, ff_mjpeg_bits_ac_luminance, |
147 ff_mjpeg_val_ac_luminance); | |
148 size += put_huffman_table(s, 1, 1, ff_mjpeg_bits_ac_chrominance, | |
149 ff_mjpeg_val_ac_chrominance); | |
5089 | 150 AV_WB16(ptr, size); |
5020 | 151 } |
152 | |
153 static void jpeg_put_comments(MpegEncContext *s) | |
154 { | |
155 PutBitContext *p = &s->pb; | |
156 int size; | |
157 uint8_t *ptr; | |
158 | |
159 if (s->aspect_ratio_info /* && !lossless */) | |
160 { | |
161 /* JFIF header */ | |
162 put_marker(p, APP0); | |
163 put_bits(p, 16, 16); | |
164 ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */ | |
165 put_bits(p, 16, 0x0201); /* v 1.02 */ | |
166 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */ | |
167 put_bits(p, 16, s->avctx->sample_aspect_ratio.num); | |
168 put_bits(p, 16, s->avctx->sample_aspect_ratio.den); | |
169 put_bits(p, 8, 0); /* thumbnail width */ | |
170 put_bits(p, 8, 0); /* thumbnail height */ | |
171 } | |
172 | |
173 /* comment */ | |
174 if(!(s->flags & CODEC_FLAG_BITEXACT)){ | |
175 put_marker(p, COM); | |
176 flush_put_bits(p); | |
177 ptr = pbBufPtr(p); | |
178 put_bits(p, 16, 0); /* patched later */ | |
179 ff_put_string(p, LIBAVCODEC_IDENT, 1); | |
180 size = strlen(LIBAVCODEC_IDENT)+3; | |
5089 | 181 AV_WB16(ptr, size); |
5020 | 182 } |
183 | |
184 if( s->avctx->pix_fmt == PIX_FMT_YUV420P | |
185 ||s->avctx->pix_fmt == PIX_FMT_YUV422P | |
186 ||s->avctx->pix_fmt == PIX_FMT_YUV444P){ | |
187 put_marker(p, COM); | |
188 flush_put_bits(p); | |
189 ptr = pbBufPtr(p); | |
190 put_bits(p, 16, 0); /* patched later */ | |
191 ff_put_string(p, "CS=ITU601", 1); | |
192 size = strlen("CS=ITU601")+3; | |
5089 | 193 AV_WB16(ptr, size); |
5020 | 194 } |
195 } | |
196 | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
197 void ff_mjpeg_encode_picture_header(MpegEncContext *s) |
5020 | 198 { |
199 const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG; | |
200 | |
201 put_marker(&s->pb, SOI); | |
202 | |
203 jpeg_put_comments(s); | |
204 | |
205 jpeg_table_header(s); | |
206 | |
207 switch(s->avctx->codec_id){ | |
208 case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break; | |
209 case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break; | |
210 default: assert(0); | |
211 } | |
212 | |
213 put_bits(&s->pb, 16, 17); | |
214 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32) | |
215 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */ | |
216 else | |
217 put_bits(&s->pb, 8, 8); /* 8 bits/component */ | |
218 put_bits(&s->pb, 16, s->height); | |
219 put_bits(&s->pb, 16, s->width); | |
220 put_bits(&s->pb, 8, 3); /* 3 components */ | |
221 | |
222 /* Y component */ | |
223 put_bits(&s->pb, 8, 1); /* component number */ | |
224 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */ | |
225 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */ | |
226 put_bits(&s->pb, 8, 0); /* select matrix */ | |
227 | |
228 /* Cb component */ | |
229 put_bits(&s->pb, 8, 2); /* component number */ | |
230 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */ | |
231 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */ | |
232 #ifdef TWOMATRIXES | |
233 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */ | |
234 #else | |
235 put_bits(&s->pb, 8, 0); /* select matrix */ | |
236 #endif | |
237 | |
238 /* Cr component */ | |
239 put_bits(&s->pb, 8, 3); /* component number */ | |
240 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */ | |
241 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */ | |
242 #ifdef TWOMATRIXES | |
243 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */ | |
244 #else | |
245 put_bits(&s->pb, 8, 0); /* select matrix */ | |
246 #endif | |
247 | |
248 /* scan header */ | |
249 put_marker(&s->pb, SOS); | |
250 put_bits(&s->pb, 16, 12); /* length */ | |
251 put_bits(&s->pb, 8, 3); /* 3 components */ | |
252 | |
253 /* Y component */ | |
254 put_bits(&s->pb, 8, 1); /* index */ | |
255 put_bits(&s->pb, 4, 0); /* DC huffman table index */ | |
256 put_bits(&s->pb, 4, 0); /* AC huffman table index */ | |
257 | |
258 /* Cb component */ | |
259 put_bits(&s->pb, 8, 2); /* index */ | |
260 put_bits(&s->pb, 4, 1); /* DC huffman table index */ | |
261 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */ | |
262 | |
263 /* Cr component */ | |
264 put_bits(&s->pb, 8, 3); /* index */ | |
265 put_bits(&s->pb, 4, 1); /* DC huffman table index */ | |
266 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */ | |
267 | |
268 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */ | |
269 | |
270 switch(s->avctx->codec_id){ | |
271 case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */ | |
272 case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */ | |
273 default: assert(0); | |
274 } | |
275 | |
276 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */ | |
277 } | |
278 | |
279 static void escape_FF(MpegEncContext *s, int start) | |
280 { | |
281 int size= put_bits_count(&s->pb) - start*8; | |
282 int i, ff_count; | |
283 uint8_t *buf= s->pb.buf + start; | |
284 int align= (-(size_t)(buf))&3; | |
285 | |
286 assert((size&7) == 0); | |
287 size >>= 3; | |
288 | |
289 ff_count=0; | |
290 for(i=0; i<size && i<align; i++){ | |
291 if(buf[i]==0xFF) ff_count++; | |
292 } | |
293 for(; i<size-15; i+=16){ | |
294 int acc, v; | |
295 | |
296 v= *(uint32_t*)(&buf[i]); | |
297 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
298 v= *(uint32_t*)(&buf[i+4]); | |
299 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
300 v= *(uint32_t*)(&buf[i+8]); | |
301 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
302 v= *(uint32_t*)(&buf[i+12]); | |
303 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
304 | |
305 acc>>=4; | |
306 acc+= (acc>>16); | |
307 acc+= (acc>>8); | |
308 ff_count+= acc&0xFF; | |
309 } | |
310 for(; i<size; i++){ | |
311 if(buf[i]==0xFF) ff_count++; | |
312 } | |
313 | |
314 if(ff_count==0) return; | |
315 | |
316 /* skip put bits */ | |
317 for(i=0; i<ff_count-3; i+=4) | |
318 put_bits(&s->pb, 32, 0); | |
319 put_bits(&s->pb, (ff_count-i)*8, 0); | |
320 flush_put_bits(&s->pb); | |
321 | |
322 for(i=size-1; ff_count; i--){ | |
323 int v= buf[i]; | |
324 | |
325 if(v==0xFF){ | |
326 //printf("%d %d\n", i, ff_count); | |
327 buf[i+ff_count]= 0; | |
328 ff_count--; | |
329 } | |
330 | |
331 buf[i+ff_count]= v; | |
332 } | |
333 } | |
334 | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
335 void ff_mjpeg_encode_stuffing(PutBitContext * pbc) |
5020 | 336 { |
337 int length; | |
338 length= (-put_bits_count(pbc))&7; | |
339 if(length) put_bits(pbc, length, (1<<length)-1); | |
340 } | |
341 | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
342 void ff_mjpeg_encode_picture_trailer(MpegEncContext *s) |
5020 | 343 { |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
344 ff_mjpeg_encode_stuffing(&s->pb); |
5020 | 345 flush_put_bits(&s->pb); |
346 | |
347 assert((s->header_bits&7)==0); | |
348 | |
349 escape_FF(s, s->header_bits>>3); | |
350 | |
351 put_marker(&s->pb, EOI); | |
352 } | |
353 | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
354 void ff_mjpeg_encode_dc(MpegEncContext *s, int val, |
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
355 uint8_t *huff_size, uint16_t *huff_code) |
5020 | 356 { |
357 int mant, nbits; | |
358 | |
359 if (val == 0) { | |
360 put_bits(&s->pb, huff_size[0], huff_code[0]); | |
361 } else { | |
362 mant = val; | |
363 if (val < 0) { | |
364 val = -val; | |
365 mant--; | |
366 } | |
367 | |
368 nbits= av_log2_16bit(val) + 1; | |
369 | |
370 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]); | |
371 | |
372 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1)); | |
373 } | |
374 } | |
375 | |
376 static void encode_block(MpegEncContext *s, DCTELEM *block, int n) | |
377 { | |
378 int mant, nbits, code, i, j; | |
379 int component, dc, run, last_index, val; | |
380 MJpegContext *m = s->mjpeg_ctx; | |
381 uint8_t *huff_size_ac; | |
382 uint16_t *huff_code_ac; | |
383 | |
384 /* DC coef */ | |
385 component = (n <= 3 ? 0 : (n&1) + 1); | |
386 dc = block[0]; /* overflow is impossible */ | |
387 val = dc - s->last_dc[component]; | |
388 if (n < 4) { | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
389 ff_mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance); |
5020 | 390 huff_size_ac = m->huff_size_ac_luminance; |
391 huff_code_ac = m->huff_code_ac_luminance; | |
392 } else { | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
393 ff_mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); |
5020 | 394 huff_size_ac = m->huff_size_ac_chrominance; |
395 huff_code_ac = m->huff_code_ac_chrominance; | |
396 } | |
397 s->last_dc[component] = dc; | |
398 | |
399 /* AC coefs */ | |
400 | |
401 run = 0; | |
402 last_index = s->block_last_index[n]; | |
403 for(i=1;i<=last_index;i++) { | |
404 j = s->intra_scantable.permutated[i]; | |
405 val = block[j]; | |
406 if (val == 0) { | |
407 run++; | |
408 } else { | |
409 while (run >= 16) { | |
410 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]); | |
411 run -= 16; | |
412 } | |
413 mant = val; | |
414 if (val < 0) { | |
415 val = -val; | |
416 mant--; | |
417 } | |
418 | |
419 nbits= av_log2(val) + 1; | |
420 code = (run << 4) | nbits; | |
421 | |
422 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]); | |
423 | |
424 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1)); | |
425 run = 0; | |
426 } | |
427 } | |
428 | |
429 /* output EOB only if not already 64 values */ | |
430 if (last_index < 63 || run != 0) | |
431 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]); | |
432 } | |
433 | |
5029
dbaa06366c3c
add a proper prefix to all mjpeg encoder exported functions
aurel
parents:
5028
diff
changeset
|
434 void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64]) |
5020 | 435 { |
436 int i; | |
437 for(i=0;i<5;i++) { | |
438 encode_block(s, block[i], i); | |
439 } | |
440 if (s->chroma_format == CHROMA_420) { | |
441 encode_block(s, block[5], 5); | |
442 } else { | |
443 encode_block(s, block[6], 6); | |
444 encode_block(s, block[5], 5); | |
445 encode_block(s, block[7], 7); | |
446 } | |
447 } | |
5030
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
448 |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
449 AVCodec mjpeg_encoder = { |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
450 "mjpeg", |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
451 CODEC_TYPE_VIDEO, |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
452 CODEC_ID_MJPEG, |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
453 sizeof(MpegEncContext), |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
454 MPV_encode_init, |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
455 MPV_encode_picture, |
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
456 MPV_encode_end, |
6788 | 457 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE}, |
6710 | 458 .long_name= "MJPEG (Motion JPEG)", |
5030
9ce0052d533a
move the mjpeg_encoder struct from mpegvideo.c to mjpegenc.c
aurel
parents:
5029
diff
changeset
|
459 }; |