3 * Copyright (c) 2000, 2001 Fabrice Bellard.
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
7 * Support for external huffman table, various fixes (AVID workaround),
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support
11 * This file is part of FFmpeg.
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.
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.
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
40 #include "jpeglsdec.h"
43 static int build_vlc(VLC
*vlc
, const uint8_t *bits_table
, const uint8_t *val_table
,
44 int nb_codes
, int use_static
, int is_ac
)
46 uint8_t huff_size
[256+16];
47 uint16_t huff_code
[256+16];
49 assert(nb_codes
<= 256);
51 memset(huff_size
, 0, sizeof(huff_size
));
52 ff_mjpeg_build_huffman_codes(huff_size
, huff_code
, bits_table
, val_table
);
55 memmove(huff_size
+16, huff_size
, sizeof(uint8_t)*nb_codes
);
56 memmove(huff_code
+16, huff_code
, sizeof(uint16_t)*nb_codes
);
57 memset(huff_size
, 0, sizeof(uint8_t)*16);
58 memset(huff_code
, 0, sizeof(uint16_t)*16);
62 return init_vlc(vlc
, 9, nb_codes
, huff_size
, 1, 1, huff_code
, 2, 2, use_static
);
65 static void build_basic_mjpeg_vlc(MJpegDecodeContext
* s
) {
66 build_vlc(&s
->vlcs
[0][0], ff_mjpeg_bits_dc_luminance
,
67 ff_mjpeg_val_dc
, 12, 0, 0);
68 build_vlc(&s
->vlcs
[0][1], ff_mjpeg_bits_dc_chrominance
,
69 ff_mjpeg_val_dc
, 12, 0, 0);
70 build_vlc(&s
->vlcs
[1][0], ff_mjpeg_bits_ac_luminance
,
71 ff_mjpeg_val_ac_luminance
, 251, 0, 1);
72 build_vlc(&s
->vlcs
[1][1], ff_mjpeg_bits_ac_chrominance
,
73 ff_mjpeg_val_ac_chrominance
, 251, 0, 1);
76 av_cold
int ff_mjpeg_decode_init(AVCodecContext
*avctx
)
78 MJpegDecodeContext
*s
= avctx
->priv_data
;
81 dsputil_init(&s
->dsp
, avctx
);
82 ff_init_scantable(s
->dsp
.idct_permutation
, &s
->scantable
, ff_zigzag_direct
);
87 s
->org_height
= avctx
->coded_height
;
89 build_basic_mjpeg_vlc(s
);
91 if (avctx
->flags
& CODEC_FLAG_EXTERN_HUFF
)
93 av_log(avctx
, AV_LOG_INFO
, "mjpeg: using external huffman table\n");
94 init_get_bits(&s
->gb
, avctx
->extradata
, avctx
->extradata_size
*8);
95 if (ff_mjpeg_decode_dht(s
)) {
96 av_log(avctx
, AV_LOG_ERROR
, "mjpeg: error using external huffman table, switching back to internal\n");
97 build_basic_mjpeg_vlc(s
);
100 if (avctx
->extradata_size
> 9 &&
101 AV_RL32(avctx
->extradata
+ 4) == MKTAG('f','i','e','l')) {
102 if (avctx
->extradata
[9] == 6) { /* quicktime icefloe 019 */
103 s
->interlace_polarity
= 1; /* bottom field first */
104 av_log(avctx
, AV_LOG_DEBUG
, "mjpeg bottom field first\n");
112 /* quantize tables */
113 int ff_mjpeg_decode_dqt(MJpegDecodeContext
*s
)
115 int len
, index
, i
, j
;
117 len
= get_bits(&s
->gb
, 16) - 2;
120 /* only 8 bit precision handled */
121 if (get_bits(&s
->gb
, 4) != 0)
123 av_log(s
->avctx
, AV_LOG_ERROR
, "dqt: 16bit precision\n");
126 index
= get_bits(&s
->gb
, 4);
129 av_log(s
->avctx
, AV_LOG_DEBUG
, "index=%d\n", index
);
130 /* read quant table */
132 j
= s
->scantable
.permutated
[i
];
133 s
->quant_matrixes
[index
][j
] = get_bits(&s
->gb
, 8);
136 //XXX FIXME finetune, and perhaps add dc too
137 s
->qscale
[index
]= FFMAX(
138 s
->quant_matrixes
[index
][s
->scantable
.permutated
[1]],
139 s
->quant_matrixes
[index
][s
->scantable
.permutated
[8]]) >> 1;
140 av_log(s
->avctx
, AV_LOG_DEBUG
, "qscale[%d]: %d\n", index
, s
->qscale
[index
]);
147 /* decode huffman tables and build VLC decoders */
148 int ff_mjpeg_decode_dht(MJpegDecodeContext
*s
)
150 int len
, index
, i
, class, n
, v
, code_max
;
151 uint8_t bits_table
[17];
152 uint8_t val_table
[256];
154 len
= get_bits(&s
->gb
, 16) - 2;
159 class = get_bits(&s
->gb
, 4);
162 index
= get_bits(&s
->gb
, 4);
167 bits_table
[i
] = get_bits(&s
->gb
, 8);
171 if (len
< n
|| n
> 256)
176 v
= get_bits(&s
->gb
, 8);
183 /* build VLC and flush previous vlc if present */
184 free_vlc(&s
->vlcs
[class][index
]);
185 av_log(s
->avctx
, AV_LOG_DEBUG
, "class=%d index=%d nb_codes=%d\n",
186 class, index
, code_max
+ 1);
187 if(build_vlc(&s
->vlcs
[class][index
], bits_table
, val_table
, code_max
+ 1, 0, class > 0) < 0){
194 int ff_mjpeg_decode_sof(MJpegDecodeContext
*s
)
196 int len
, nb_components
, i
, width
, height
, pix_fmt_id
;
198 /* XXX: verify len field validity */
199 len
= get_bits(&s
->gb
, 16);
200 s
->bits
= get_bits(&s
->gb
, 8);
202 if(s
->pegasus_rct
) s
->bits
=9;
203 if(s
->bits
==9 && !s
->pegasus_rct
) s
->rct
=1; //FIXME ugly
205 if (s
->bits
!= 8 && !s
->lossless
){
206 av_log(s
->avctx
, AV_LOG_ERROR
, "only 8 bits/component accepted\n");
210 height
= get_bits(&s
->gb
, 16);
211 width
= get_bits(&s
->gb
, 16);
213 //HACK for odd_height.mov
214 if(s
->interlaced
&& s
->width
== width
&& s
->height
== height
+ 1)
217 av_log(s
->avctx
, AV_LOG_DEBUG
, "sof0: picture: %dx%d\n", width
, height
);
218 if(avcodec_check_dimensions(s
->avctx
, width
, height
))
221 nb_components
= get_bits(&s
->gb
, 8);
222 if (nb_components
<= 0 ||
223 nb_components
> MAX_COMPONENTS
)
225 if (s
->ls
&& !(s
->bits
<= 8 || nb_components
== 1)){
226 av_log(s
->avctx
, AV_LOG_ERROR
, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
229 s
->nb_components
= nb_components
;
232 for(i
=0;i
<nb_components
;i
++) {
234 s
->component_id
[i
] = get_bits(&s
->gb
, 8) - 1;
235 s
->h_count
[i
] = get_bits(&s
->gb
, 4);
236 s
->v_count
[i
] = get_bits(&s
->gb
, 4);
237 /* compute hmax and vmax (only used in interleaved case) */
238 if (s
->h_count
[i
] > s
->h_max
)
239 s
->h_max
= s
->h_count
[i
];
240 if (s
->v_count
[i
] > s
->v_max
)
241 s
->v_max
= s
->v_count
[i
];
242 s
->quant_index
[i
] = get_bits(&s
->gb
, 8);
243 if (s
->quant_index
[i
] >= 4)
245 av_log(s
->avctx
, AV_LOG_DEBUG
, "component %d %d:%d id: %d quant:%d\n", i
, s
->h_count
[i
],
246 s
->v_count
[i
], s
->component_id
[i
], s
->quant_index
[i
]);
249 if(s
->ls
&& (s
->h_max
> 1 || s
->v_max
> 1)) {
250 av_log(s
->avctx
, AV_LOG_ERROR
, "Subsampling in JPEG-LS is not supported.\n");
254 if(s
->v_max
==1 && s
->h_max
==1 && s
->lossless
==1) s
->rgb
=1;
256 /* if different size, realloc/alloc picture */
257 /* XXX: also check h_count and v_count */
258 if (width
!= s
->width
|| height
!= s
->height
) {
259 av_freep(&s
->qscale_table
);
265 /* test interlaced mode */
266 if (s
->first_picture
&&
267 s
->org_height
!= 0 &&
268 s
->height
< ((s
->org_height
* 3) / 4)) {
270 s
->bottom_field
= s
->interlace_polarity
;
271 s
->picture
.interlaced_frame
= 1;
272 s
->picture
.top_field_first
= !s
->interlace_polarity
;
276 avcodec_set_dimensions(s
->avctx
, width
, height
);
278 s
->qscale_table
= av_mallocz((s
->width
+15)/16);
280 s
->first_picture
= 0;
283 if(s
->interlaced
&& (s
->bottom_field
== !s
->interlace_polarity
))
286 /* XXX: not complete test ! */
287 pix_fmt_id
= (s
->h_count
[0] << 28) | (s
->v_count
[0] << 24) |
288 (s
->h_count
[1] << 20) | (s
->v_count
[1] << 16) |
289 (s
->h_count
[2] << 12) | (s
->v_count
[2] << 8) |
290 (s
->h_count
[3] << 4) | s
->v_count
[3];
291 av_log(s
->avctx
, AV_LOG_DEBUG
, "pix fmt id %x\n", pix_fmt_id
);
292 if(!(pix_fmt_id
& 0x10101010))
293 pix_fmt_id
-= (pix_fmt_id
& 0xF0F0F0F0)>>1;
294 if(!(pix_fmt_id
& 0x01010101))
295 pix_fmt_id
-= (pix_fmt_id
& 0x0F0F0F0F)>>1;
300 s
->avctx
->pix_fmt
= PIX_FMT_RGB32
;
302 s
->avctx
->pix_fmt
= s
->cs_itu601
? PIX_FMT_YUV444P
: PIX_FMT_YUVJ444P
;
303 assert(s
->nb_components
==3);
306 s
->avctx
->pix_fmt
= PIX_FMT_GRAY8
;
309 s
->avctx
->pix_fmt
= s
->cs_itu601
? PIX_FMT_YUV440P
: PIX_FMT_YUVJ440P
;
312 s
->avctx
->pix_fmt
= s
->cs_itu601
? PIX_FMT_YUV422P
: PIX_FMT_YUVJ422P
;
315 s
->avctx
->pix_fmt
= s
->cs_itu601
? PIX_FMT_YUV420P
: PIX_FMT_YUVJ420P
;
318 av_log(s
->avctx
, AV_LOG_ERROR
, "Unhandled pixel format 0x%x\n", pix_fmt_id
);
322 if(s
->nb_components
> 1)
323 s
->avctx
->pix_fmt
= PIX_FMT_RGB24
;
324 else if(s
->bits
<= 8)
325 s
->avctx
->pix_fmt
= PIX_FMT_GRAY8
;
327 s
->avctx
->pix_fmt
= PIX_FMT_GRAY16
;
330 if(s
->picture
.data
[0])
331 s
->avctx
->release_buffer(s
->avctx
, &s
->picture
);
333 s
->picture
.reference
= 0;
334 if(s
->avctx
->get_buffer(s
->avctx
, &s
->picture
) < 0){
335 av_log(s
->avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
338 s
->picture
.pict_type
= FF_I_TYPE
;
339 s
->picture
.key_frame
= 1;
342 s
->linesize
[i
]= s
->picture
.linesize
[i
] << s
->interlaced
;
345 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
347 if (len
!= (8+(3*nb_components
)))
349 av_log(s
->avctx
, AV_LOG_DEBUG
, "decode_sof0: error, len(%d) mismatch\n", len
);
352 /* totally blank picture as progressive JPEG will only add details to it */
354 memset(s
->picture
.data
[0], 0, s
->picture
.linesize
[0] * s
->height
);
355 memset(s
->picture
.data
[1], 0, s
->picture
.linesize
[1] * s
->height
>> (s
->v_max
- s
->v_count
[1]));
356 memset(s
->picture
.data
[2], 0, s
->picture
.linesize
[2] * s
->height
>> (s
->v_max
- s
->v_count
[2]));
361 static inline int mjpeg_decode_dc(MJpegDecodeContext
*s
, int dc_index
)
364 code
= get_vlc2(&s
->gb
, s
->vlcs
[0][dc_index
].table
, 9, 2);
367 av_log(s
->avctx
, AV_LOG_WARNING
, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index
,
368 &s
->vlcs
[0][dc_index
]);
373 return get_xbits(&s
->gb
, code
);
378 /* decode block and dequantize */
379 static int decode_block(MJpegDecodeContext
*s
, DCTELEM
*block
,
380 int component
, int dc_index
, int ac_index
, int16_t *quant_matrix
)
382 int code
, i
, j
, level
, val
;
385 val
= mjpeg_decode_dc(s
, dc_index
);
387 av_log(s
->avctx
, AV_LOG_ERROR
, "error dc\n");
390 val
= val
* quant_matrix
[0] + s
->last_dc
[component
];
391 s
->last_dc
[component
] = val
;
395 {OPEN_READER(re
, &s
->gb
)
397 UPDATE_CACHE(re
, &s
->gb
);
398 GET_VLC(code
, re
, &s
->gb
, s
->vlcs
[1][ac_index
].table
, 9, 2)
403 i
+= ((unsigned)code
) >> 4;
406 if(code
> MIN_CACHE_BITS
- 16){
407 UPDATE_CACHE(re
, &s
->gb
)
410 int cache
=GET_CACHE(re
,&s
->gb
);
411 int sign
=(~cache
)>>31;
412 level
= (NEG_USR32(sign
^ cache
,code
) ^ sign
) - sign
;
415 LAST_SKIP_BITS(re
, &s
->gb
, code
)
419 j
= s
->scantable
.permutated
[63];
420 block
[j
] = level
* quant_matrix
[j
];
423 av_log(s
->avctx
, AV_LOG_ERROR
, "error count: %d\n", i
);
426 j
= s
->scantable
.permutated
[i
];
427 block
[j
] = level
* quant_matrix
[j
];
430 CLOSE_READER(re
, &s
->gb
)}
435 /* decode block and dequantize - progressive JPEG version */
436 static int decode_block_progressive(MJpegDecodeContext
*s
, DCTELEM
*block
,
437 int component
, int dc_index
, int ac_index
, int16_t *quant_matrix
,
438 int ss
, int se
, int Ah
, int Al
, int *EOBRUN
)
440 int code
, i
, j
, level
, val
, run
;
444 val
= mjpeg_decode_dc(s
, dc_index
);
446 av_log(s
->avctx
, AV_LOG_ERROR
, "error dc\n");
449 val
= (val
* quant_matrix
[0] << Al
) + s
->last_dc
[component
];
452 s
->last_dc
[component
] = val
;
460 {OPEN_READER(re
, &s
->gb
)
462 UPDATE_CACHE(re
, &s
->gb
);
463 GET_VLC(code
, re
, &s
->gb
, s
->vlcs
[1][ac_index
].table
, 9, 2)
464 /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
467 i
+= ((unsigned) code
) >> 4;
469 if(code
> MIN_CACHE_BITS
- 16){
470 UPDATE_CACHE(re
, &s
->gb
)
473 int cache
=GET_CACHE(re
,&s
->gb
);
474 int sign
=(~cache
)>>31;
475 level
= (NEG_USR32(sign
^ cache
,code
) ^ sign
) - sign
;
478 LAST_SKIP_BITS(re
, &s
->gb
, code
)
482 j
= s
->scantable
.permutated
[se
];
483 block
[j
] = level
* quant_matrix
[j
] << Al
;
486 av_log(s
->avctx
, AV_LOG_ERROR
, "error count: %d\n", i
);
489 j
= s
->scantable
.permutated
[i
];
490 block
[j
] = level
* quant_matrix
[j
] << Al
;
492 run
= ((unsigned) code
) >> 4;
493 if(run
== 0xF){// ZRL - skip 15 coefficients
498 UPDATE_CACHE(re
, &s
->gb
);
499 run
+= (GET_CACHE(re
, &s
->gb
) >> (32 - val
)) & (run
- 1);
501 LAST_SKIP_BITS(re
, &s
->gb
, val
);
507 CLOSE_READER(re
, &s
->gb
)}
512 static int ljpeg_decode_rgb_scan(MJpegDecodeContext
*s
, int predictor
, int point_transform
){
514 uint16_t buffer
[32768][4];
515 int left
[3], top
[3], topleft
[3];
516 const int linesize
= s
->linesize
[0];
517 const int mask
= (1<<s
->bits
)-1;
519 if((unsigned)s
->mb_width
> 32768) //dynamic alloc
523 buffer
[0][i
]= 1 << (s
->bits
+ point_transform
- 1);
525 for(mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
526 const int modified_predictor
= mb_y
? predictor
: 1;
527 uint8_t *ptr
= s
->picture
.data
[0] + (linesize
* mb_y
);
529 if (s
->interlaced
&& s
->bottom_field
)
530 ptr
+= linesize
>> 1;
533 top
[i
]= left
[i
]= topleft
[i
]= buffer
[0][i
];
535 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
536 if (s
->restart_interval
&& !s
->restart_count
)
537 s
->restart_count
= s
->restart_interval
;
543 top
[i
]= buffer
[mb_x
][i
];
545 PREDICT(pred
, topleft
[i
], top
[i
], left
[i
], modified_predictor
);
548 buffer
[mb_x
][i
]= mask
& (pred
+ (mjpeg_decode_dc(s
, s
->dc_index
[i
]) << point_transform
));
551 if (s
->restart_interval
&& !--s
->restart_count
) {
552 align_get_bits(&s
->gb
);
553 skip_bits(&s
->gb
, 16); /* skip RSTn */
558 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
559 ptr
[4*mb_x
+1] = buffer
[mb_x
][0] - ((buffer
[mb_x
][1] + buffer
[mb_x
][2] - 0x200)>>2);
560 ptr
[4*mb_x
+0] = buffer
[mb_x
][1] + ptr
[4*mb_x
+1];
561 ptr
[4*mb_x
+2] = buffer
[mb_x
][2] + ptr
[4*mb_x
+1];
563 }else if(s
->pegasus_rct
){
564 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
565 ptr
[4*mb_x
+1] = buffer
[mb_x
][0] - ((buffer
[mb_x
][1] + buffer
[mb_x
][2])>>2);
566 ptr
[4*mb_x
+0] = buffer
[mb_x
][1] + ptr
[4*mb_x
+1];
567 ptr
[4*mb_x
+2] = buffer
[mb_x
][2] + ptr
[4*mb_x
+1];
570 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
571 ptr
[4*mb_x
+0] = buffer
[mb_x
][0];
572 ptr
[4*mb_x
+1] = buffer
[mb_x
][1];
573 ptr
[4*mb_x
+2] = buffer
[mb_x
][2];
580 static int ljpeg_decode_yuv_scan(MJpegDecodeContext
*s
, int predictor
, int point_transform
){
582 const int nb_components
=3;
584 for(mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
585 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
586 if (s
->restart_interval
&& !s
->restart_count
)
587 s
->restart_count
= s
->restart_interval
;
589 if(mb_x
==0 || mb_y
==0 || s
->interlaced
){
590 for(i
=0;i
<nb_components
;i
++) {
592 int n
, h
, v
, x
, y
, c
, j
, linesize
;
594 c
= s
->comp_index
[i
];
599 linesize
= s
->linesize
[c
];
604 ptr
= s
->picture
.data
[c
] + (linesize
* (v
* mb_y
+ y
)) + (h
* mb_x
+ x
); //FIXME optimize this crap
607 pred
= 128 << point_transform
;
613 pred
= ptr
[-linesize
];
615 PREDICT(pred
, ptr
[-linesize
-1], ptr
[-linesize
], ptr
[-1], predictor
);
619 if (s
->interlaced
&& s
->bottom_field
)
620 ptr
+= linesize
>> 1;
621 *ptr
= pred
+ (mjpeg_decode_dc(s
, s
->dc_index
[i
]) << point_transform
);
630 for(i
=0;i
<nb_components
;i
++) {
632 int n
, h
, v
, x
, y
, c
, j
, linesize
;
634 c
= s
->comp_index
[i
];
639 linesize
= s
->linesize
[c
];
644 ptr
= s
->picture
.data
[c
] + (linesize
* (v
* mb_y
+ y
)) + (h
* mb_x
+ x
); //FIXME optimize this crap
645 PREDICT(pred
, ptr
[-linesize
-1], ptr
[-linesize
], ptr
[-1], predictor
);
646 *ptr
= pred
+ (mjpeg_decode_dc(s
, s
->dc_index
[i
]) << point_transform
);
654 if (s
->restart_interval
&& !--s
->restart_count
) {
655 align_get_bits(&s
->gb
);
656 skip_bits(&s
->gb
, 16); /* skip RSTn */
663 static int mjpeg_decode_scan(MJpegDecodeContext
*s
, int nb_components
, int ss
, int se
, int Ah
, int Al
){
666 uint8_t* data
[MAX_COMPONENTS
];
667 int linesize
[MAX_COMPONENTS
];
669 if(Ah
) return 0; /* TODO decode refinement planes too */
671 for(i
=0; i
< nb_components
; i
++) {
672 int c
= s
->comp_index
[i
];
673 data
[c
] = s
->picture
.data
[c
];
674 linesize
[c
]=s
->linesize
[c
];
675 if(s
->avctx
->codec
->id
==CODEC_ID_AMV
) {
676 //picture should be flipped upside-down for this codec
677 assert(!(s
->avctx
->flags
& CODEC_FLAG_EMU_EDGE
));
678 data
[c
] += (linesize
[c
] * (s
->v_scount
[i
] * (8 * s
->mb_height
-((s
->height
/s
->v_max
)&7)) - 1 ));
683 for(mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
684 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
685 if (s
->restart_interval
&& !s
->restart_count
)
686 s
->restart_count
= s
->restart_interval
;
688 for(i
=0;i
<nb_components
;i
++) {
690 int n
, h
, v
, x
, y
, c
, j
;
692 c
= s
->comp_index
[i
];
698 memset(s
->block
, 0, sizeof(s
->block
));
699 if (!s
->progressive
&& decode_block(s
, s
->block
, i
,
700 s
->dc_index
[i
], s
->ac_index
[i
],
701 s
->quant_matrixes
[ s
->quant_index
[c
] ]) < 0) {
702 av_log(s
->avctx
, AV_LOG_ERROR
, "error y=%d x=%d\n", mb_y
, mb_x
);
705 if (s
->progressive
&& decode_block_progressive(s
, s
->block
, i
,
706 s
->dc_index
[i
], s
->ac_index
[i
],
707 s
->quant_matrixes
[ s
->quant_index
[c
] ], ss
, se
, Ah
, Al
, &EOBRUN
) < 0) {
708 av_log(s
->avctx
, AV_LOG_ERROR
, "error y=%d x=%d\n", mb_y
, mb_x
);
711 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
713 (((linesize
[c
] * (v
* mb_y
+ y
) * 8) +
714 (h
* mb_x
+ x
) * 8) >> s
->avctx
->lowres
);
715 if (s
->interlaced
&& s
->bottom_field
)
716 ptr
+= linesize
[c
] >> 1;
717 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
719 s
->dsp
.idct_put(ptr
, linesize
[c
], s
->block
);
721 s
->dsp
.idct_add(ptr
, linesize
[c
], s
->block
);
728 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
729 if (s
->restart_interval
&& (s
->restart_interval
< 1350) &&
730 !--s
->restart_count
) {
731 align_get_bits(&s
->gb
);
732 skip_bits(&s
->gb
, 16); /* skip RSTn */
733 for (i
=0; i
<nb_components
; i
++) /* reset dc */
734 s
->last_dc
[i
] = 1024;
741 int ff_mjpeg_decode_sos(MJpegDecodeContext
*s
)
743 int len
, nb_components
, i
, h
, v
, predictor
, point_transform
;
744 int vmax
, hmax
, index
, id
;
745 const int block_size
= s
->lossless
? 1 : 8;
748 /* XXX: verify len field validity */
749 len
= get_bits(&s
->gb
, 16);
750 nb_components
= get_bits(&s
->gb
, 8);
751 if (len
!= 6+2*nb_components
)
753 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_sos: invalid len (%d)\n", len
);
758 for(i
=0;i
<nb_components
;i
++) {
759 id
= get_bits(&s
->gb
, 8) - 1;
760 av_log(s
->avctx
, AV_LOG_DEBUG
, "component: %d\n", id
);
761 /* find component index */
762 for(index
=0;index
<s
->nb_components
;index
++)
763 if (id
== s
->component_id
[index
])
765 if (index
== s
->nb_components
)
767 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_sos: index(%d) out of components\n", index
);
771 s
->comp_index
[i
] = index
;
773 s
->nb_blocks
[i
] = s
->h_count
[index
] * s
->v_count
[index
];
774 s
->h_scount
[i
] = s
->h_count
[index
];
775 s
->v_scount
[i
] = s
->v_count
[index
];
777 s
->dc_index
[i
] = get_bits(&s
->gb
, 4);
778 s
->ac_index
[i
] = get_bits(&s
->gb
, 4);
780 if (s
->dc_index
[i
] < 0 || s
->ac_index
[i
] < 0 ||
781 s
->dc_index
[i
] >= 4 || s
->ac_index
[i
] >= 4)
784 switch(s
->start_code
)
787 if (dc_index
[i
] > 1 || ac_index
[i
] > 1)
792 if (dc_index
[i
] > 3 || ac_index
[i
] > 3)
796 if (dc_index
[i
] > 3 || ac_index
[i
] != 0)
803 predictor
= get_bits(&s
->gb
, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
804 ilv
= get_bits(&s
->gb
, 8); /* JPEG Se / JPEG-LS ILV */
805 prev_shift
= get_bits(&s
->gb
, 4); /* Ah */
806 point_transform
= get_bits(&s
->gb
, 4); /* Al */
808 for(i
=0;i
<nb_components
;i
++)
809 s
->last_dc
[i
] = 1024;
811 if (nb_components
> 1) {
812 /* interleaved stream */
813 s
->mb_width
= (s
->width
+ s
->h_max
* block_size
- 1) / (s
->h_max
* block_size
);
814 s
->mb_height
= (s
->height
+ s
->v_max
* block_size
- 1) / (s
->v_max
* block_size
);
815 } else if(!s
->ls
) { /* skip this for JPEG-LS */
816 h
= s
->h_max
/ s
->h_scount
[0];
817 v
= s
->v_max
/ s
->v_scount
[0];
818 s
->mb_width
= (s
->width
+ h
* block_size
- 1) / (h
* block_size
);
819 s
->mb_height
= (s
->height
+ v
* block_size
- 1) / (v
* block_size
);
825 if(s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
826 av_log(s
->avctx
, AV_LOG_DEBUG
, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s
->lossless
? "lossless" : "sequencial DCT", s
->rgb
? "RGB" : "",
827 predictor
, point_transform
, ilv
, s
->bits
,
828 s
->pegasus_rct
? "PRCT" : (s
->rct
? "RCT" : ""));
831 /* mjpeg-b can have padding bytes between sos and image data, skip them */
832 for (i
= s
->mjpb_skiptosod
; i
> 0; i
--)
833 skip_bits(&s
->gb
, 8);
836 if(ENABLE_JPEGLS_DECODER
&& s
->ls
){
838 // reset_ls_coding_parameters(s, 0);
840 if(ff_jpegls_decode_picture(s
, predictor
, point_transform
, ilv
) < 0)
844 if(ljpeg_decode_rgb_scan(s
, predictor
, point_transform
) < 0)
847 if(ljpeg_decode_yuv_scan(s
, predictor
, point_transform
) < 0)
852 if(mjpeg_decode_scan(s
, nb_components
, predictor
, ilv
, prev_shift
, point_transform
) < 0)
858 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_sos: ac/dc index out of range\n");
862 static int mjpeg_decode_dri(MJpegDecodeContext
*s
)
864 if (get_bits(&s
->gb
, 16) != 4)
866 s
->restart_interval
= get_bits(&s
->gb
, 16);
867 s
->restart_count
= 0;
868 av_log(s
->avctx
, AV_LOG_DEBUG
, "restart interval: %d\n", s
->restart_interval
);
873 static int mjpeg_decode_app(MJpegDecodeContext
*s
)
877 len
= get_bits(&s
->gb
, 16);
880 if(8*len
+ get_bits_count(&s
->gb
) > s
->gb
.size_in_bits
)
883 id
= (get_bits(&s
->gb
, 16) << 16) | get_bits(&s
->gb
, 16);
887 if(s
->avctx
->debug
& FF_DEBUG_STARTCODE
){
888 av_log(s
->avctx
, AV_LOG_DEBUG
, "APPx %8X\n", id
);
891 /* buggy AVID, it puts EOI only at every 10th frame */
892 /* also this fourcc is used by non-avid files too, it holds some
893 informations, but it's always present in AVID creates files */
894 if (id
== ff_get_fourcc("AVI1"))
901 4bytes field_size_less_padding
904 // if (s->first_picture)
905 // printf("mjpeg: workarounding buggy AVID\n");
906 i
= get_bits(&s
->gb
, 8);
907 if (i
==2) s
->bottom_field
= 1;
908 else if(i
==1) s
->bottom_field
= 0;
910 skip_bits(&s
->gb
, 8);
911 skip_bits(&s
->gb
, 32);
912 skip_bits(&s
->gb
, 32);
915 // if (s->interlace_polarity)
916 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
922 if (id
== ff_get_fourcc("JFIF"))
924 int t_w
, t_h
, v1
, v2
;
925 skip_bits(&s
->gb
, 8); /* the trailing zero-byte */
926 v1
= get_bits(&s
->gb
, 8);
927 v2
= get_bits(&s
->gb
, 8);
928 skip_bits(&s
->gb
, 8);
930 s
->avctx
->sample_aspect_ratio
.num
= get_bits(&s
->gb
, 16);
931 s
->avctx
->sample_aspect_ratio
.den
= get_bits(&s
->gb
, 16);
933 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
934 av_log(s
->avctx
, AV_LOG_INFO
, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
936 s
->avctx
->sample_aspect_ratio
.num
,
937 s
->avctx
->sample_aspect_ratio
.den
940 t_w
= get_bits(&s
->gb
, 8);
941 t_h
= get_bits(&s
->gb
, 8);
945 if (len
-10-(t_w
*t_h
*3) > 0)
952 if (id
== ff_get_fourcc("Adob") && (get_bits(&s
->gb
, 8) == 'e'))
954 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
955 av_log(s
->avctx
, AV_LOG_INFO
, "mjpeg: Adobe header found\n");
956 skip_bits(&s
->gb
, 16); /* version */
957 skip_bits(&s
->gb
, 16); /* flags0 */
958 skip_bits(&s
->gb
, 16); /* flags1 */
959 skip_bits(&s
->gb
, 8); /* transform */
964 if (id
== ff_get_fourcc("LJIF")){
965 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
966 av_log(s
->avctx
, AV_LOG_INFO
, "Pegasus lossless jpeg header found\n");
967 skip_bits(&s
->gb
, 16); /* version ? */
968 skip_bits(&s
->gb
, 16); /* unknwon always 0? */
969 skip_bits(&s
->gb
, 16); /* unknwon always 0? */
970 skip_bits(&s
->gb
, 16); /* unknwon always 0? */
971 switch( get_bits(&s
->gb
, 8)){
981 av_log(s
->avctx
, AV_LOG_ERROR
, "unknown colorspace\n");
988 if ((s
->start_code
== APP1
) && (len
> (0x28 - 8)))
990 id
= (get_bits(&s
->gb
, 16) << 16) | get_bits(&s
->gb
, 16);
993 if (id
== ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
996 skip_bits(&s
->gb
, 32); /* field size */
997 skip_bits(&s
->gb
, 32); /* pad field size */
998 skip_bits(&s
->gb
, 32); /* next off */
999 skip_bits(&s
->gb
, 32); /* quant off */
1000 skip_bits(&s
->gb
, 32); /* huff off */
1001 skip_bits(&s
->gb
, 32); /* image off */
1002 skip_bits(&s
->gb
, 32); /* scan off */
1003 skip_bits(&s
->gb
, 32); /* data off */
1005 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1006 av_log(s
->avctx
, AV_LOG_INFO
, "mjpeg: Apple MJPEG-A header found\n");
1011 /* slow but needed for extreme adobe jpegs */
1013 av_log(s
->avctx
, AV_LOG_ERROR
, "mjpeg: error, decode_app parser read over the end\n");
1015 skip_bits(&s
->gb
, 8);
1020 static int mjpeg_decode_com(MJpegDecodeContext
*s
)
1022 int len
= get_bits(&s
->gb
, 16);
1023 if (len
>= 2 && 8*len
- 16 + get_bits_count(&s
->gb
) <= s
->gb
.size_in_bits
) {
1024 char *cbuf
= av_malloc(len
- 1);
1027 for (i
= 0; i
< len
- 2; i
++)
1028 cbuf
[i
] = get_bits(&s
->gb
, 8);
1029 if (i
> 0 && cbuf
[i
-1] == '\n')
1034 if(s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1035 av_log(s
->avctx
, AV_LOG_INFO
, "mjpeg comment: '%s'\n", cbuf
);
1037 /* buggy avid, it puts EOI only at every 10th frame */
1038 if (!strcmp(cbuf
, "AVID"))
1041 // if (s->first_picture)
1042 // printf("mjpeg: workarounding buggy AVID\n");
1044 else if(!strcmp(cbuf
, "CS=ITU601")){
1056 static int valid_marker_list
[] =
1058 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1059 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1060 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1061 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1062 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1063 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1064 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1065 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1066 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1067 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1068 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1069 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1070 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1071 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1072 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1073 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1074 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1078 /* return the 8 bit start code value and update the search
1079 state. Return -1 if no start code found */
1080 static int find_marker(const uint8_t **pbuf_ptr
, const uint8_t *buf_end
)
1082 const uint8_t *buf_ptr
;
1089 buf_ptr
= *pbuf_ptr
;
1090 while (buf_ptr
< buf_end
) {
1093 if ((v
== 0xff) && (v2
>= 0xc0) && (v2
<= 0xfe) && buf_ptr
< buf_end
) {
1104 av_log(NULL
, AV_LOG_VERBOSE
, "find_marker skipped %d bytes\n", skipped
);
1106 *pbuf_ptr
= buf_ptr
;
1110 int ff_mjpeg_decode_frame(AVCodecContext
*avctx
,
1111 void *data
, int *data_size
,
1112 const uint8_t *buf
, int buf_size
)
1114 MJpegDecodeContext
*s
= avctx
->priv_data
;
1115 const uint8_t *buf_end
, *buf_ptr
;
1117 AVFrame
*picture
= data
;
1120 buf_end
= buf
+ buf_size
;
1121 while (buf_ptr
< buf_end
) {
1122 /* find start next marker */
1123 start_code
= find_marker(&buf_ptr
, buf_end
);
1126 if (start_code
< 0) {
1129 av_log(avctx
, AV_LOG_DEBUG
, "marker=%x avail_size_in_buf=%td\n", start_code
, buf_end
- buf_ptr
);
1131 if ((buf_end
- buf_ptr
) > s
->buffer_size
)
1134 s
->buffer_size
= buf_end
-buf_ptr
;
1135 s
->buffer
= av_malloc(s
->buffer_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
1136 av_log(avctx
, AV_LOG_DEBUG
, "buffer too small, expanding to %d bytes\n",
1140 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1141 if (start_code
== SOS
&& !s
->ls
)
1143 const uint8_t *src
= buf_ptr
;
1144 uint8_t *dst
= s
->buffer
;
1148 uint8_t x
= *(src
++);
1151 if (avctx
->codec_id
!= CODEC_ID_THP
)
1154 while (src
< buf_end
&& x
== 0xff)
1157 if (x
>= 0xd0 && x
<= 0xd7)
1164 init_get_bits(&s
->gb
, s
->buffer
, (dst
- s
->buffer
)*8);
1166 av_log(avctx
, AV_LOG_DEBUG
, "escaping removed %td bytes\n",
1167 (buf_end
- buf_ptr
) - (dst
- s
->buffer
));
1169 else if(start_code
== SOS
&& s
->ls
){
1170 const uint8_t *src
= buf_ptr
;
1171 uint8_t *dst
= s
->buffer
;
1179 while (src
+ t
< buf_end
){
1180 uint8_t x
= src
[t
++];
1182 while((src
+ t
< buf_end
) && x
== 0xff)
1192 init_put_bits(&pb
, dst
, t
);
1194 /* unescape bitstream */
1196 uint8_t x
= src
[b
++];
1197 put_bits(&pb
, 8, x
);
1200 put_bits(&pb
, 7, x
);
1204 flush_put_bits(&pb
);
1206 init_get_bits(&s
->gb
, dst
, bit_count
);
1209 init_get_bits(&s
->gb
, buf_ptr
, (buf_end
- buf_ptr
)*8);
1211 s
->start_code
= start_code
;
1212 if(s
->avctx
->debug
& FF_DEBUG_STARTCODE
){
1213 av_log(avctx
, AV_LOG_DEBUG
, "startcode: %X\n", start_code
);
1216 /* process markers */
1217 if (start_code
>= 0xd0 && start_code
<= 0xd7) {
1218 av_log(avctx
, AV_LOG_DEBUG
, "restart marker: %d\n", start_code
&0x0f);
1220 } else if (start_code
>= APP0
&& start_code
<= APP15
) {
1221 mjpeg_decode_app(s
);
1223 } else if (start_code
== COM
){
1224 mjpeg_decode_com(s
);
1227 switch(start_code
) {
1229 s
->restart_interval
= 0;
1231 s
->restart_count
= 0;
1232 /* nothing to do on SOI */
1235 ff_mjpeg_decode_dqt(s
);
1238 if(ff_mjpeg_decode_dht(s
) < 0){
1239 av_log(avctx
, AV_LOG_ERROR
, "huffman table decode error\n");
1247 if (ff_mjpeg_decode_sof(s
) < 0)
1254 if (ff_mjpeg_decode_sof(s
) < 0)
1261 if (ff_mjpeg_decode_sof(s
) < 0)
1268 if (ff_mjpeg_decode_sof(s
) < 0)
1272 if (!ENABLE_JPEGLS_DECODER
|| ff_jpegls_decode_lse(s
) < 0)
1277 if ((s
->buggy_avid
&& !s
->interlaced
) || s
->restart_interval
)
1281 if (s
->interlaced
) {
1282 s
->bottom_field
^= 1;
1283 /* if not bottom field, do not output image yet */
1284 if (s
->bottom_field
== !s
->interlace_polarity
)
1287 *picture
= s
->picture
;
1288 *data_size
= sizeof(AVFrame
);
1291 picture
->quality
= FFMAX3(s
->qscale
[0], s
->qscale
[1], s
->qscale
[2]);
1292 picture
->qstride
= 0;
1293 picture
->qscale_table
= s
->qscale_table
;
1294 memset(picture
->qscale_table
, picture
->quality
, (s
->width
+15)/16);
1295 if(avctx
->debug
& FF_DEBUG_QP
)
1296 av_log(avctx
, AV_LOG_DEBUG
, "QP: %d\n", picture
->quality
);
1297 picture
->quality
*= FF_QP2LAMBDA
;
1304 ff_mjpeg_decode_sos(s
);
1305 /* buggy avid puts EOI every 10-20th frame */
1306 /* if restart period is over process EOI */
1307 if ((s
->buggy_avid
&& !s
->interlaced
) || s
->restart_interval
)
1311 mjpeg_decode_dri(s
);
1324 av_log(avctx
, AV_LOG_ERROR
, "mjpeg: unsupported coding type (%x)\n", start_code
);
1327 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1332 /* eof process start code */
1333 buf_ptr
+= (get_bits_count(&s
->gb
)+7)/8;
1334 av_log(avctx
, AV_LOG_DEBUG
, "marker parser used %d bytes (%d bits)\n",
1335 (get_bits_count(&s
->gb
)+7)/8, get_bits_count(&s
->gb
));
1340 av_log(avctx
, AV_LOG_DEBUG
, "mjpeg decode frame unused %td bytes\n", buf_end
- buf_ptr
);
1341 // return buf_end - buf_ptr;
1342 return buf_ptr
- buf
;
1345 av_cold
int ff_mjpeg_decode_end(AVCodecContext
*avctx
)
1347 MJpegDecodeContext
*s
= avctx
->priv_data
;
1351 av_free(s
->qscale_table
);
1355 free_vlc(&s
->vlcs
[i
][j
]);
1360 AVCodec mjpeg_decoder
= {
1364 sizeof(MJpegDecodeContext
),
1365 ff_mjpeg_decode_init
,
1367 ff_mjpeg_decode_end
,
1368 ff_mjpeg_decode_frame
,
1371 .long_name
= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
1374 AVCodec thp_decoder
= {
1378 sizeof(MJpegDecodeContext
),
1379 ff_mjpeg_decode_init
,
1381 ff_mjpeg_decode_end
,
1382 ff_mjpeg_decode_frame
,
1385 .long_name
= NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),