Libav 0.7.1
|
00001 /* 00002 * MJPEG decoder 00003 * Copyright (c) 2000, 2001 Fabrice Bellard 00004 * Copyright (c) 2003 Alex Beregszaszi 00005 * Copyright (c) 2003-2004 Michael Niedermayer 00006 * 00007 * Support for external huffman table, various fixes (AVID workaround), 00008 * aspecting, new decode_frame mechanism and apple mjpeg-b support 00009 * by Alex Beregszaszi 00010 * 00011 * This file is part of Libav. 00012 * 00013 * Libav is free software; you can redistribute it and/or 00014 * modify it under the terms of the GNU Lesser General Public 00015 * License as published by the Free Software Foundation; either 00016 * version 2.1 of the License, or (at your option) any later version. 00017 * 00018 * Libav is distributed in the hope that it will be useful, 00019 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00020 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00021 * Lesser General Public License for more details. 00022 * 00023 * You should have received a copy of the GNU Lesser General Public 00024 * License along with Libav; if not, write to the Free Software 00025 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00026 */ 00027 00033 //#define DEBUG 00034 #include <assert.h> 00035 00036 #include "libavutil/imgutils.h" 00037 #include "avcodec.h" 00038 #include "dsputil.h" 00039 #include "mjpeg.h" 00040 #include "mjpegdec.h" 00041 #include "jpeglsdec.h" 00042 00043 00044 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 00045 int nb_codes, int use_static, int is_ac) 00046 { 00047 uint8_t huff_size[256]; 00048 uint16_t huff_code[256]; 00049 uint16_t huff_sym[256]; 00050 int i; 00051 00052 assert(nb_codes <= 256); 00053 00054 memset(huff_size, 0, sizeof(huff_size)); 00055 ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table); 00056 00057 for(i=0; i<256; i++) 00058 huff_sym[i]= i + 16*is_ac; 00059 00060 if(is_ac) huff_sym[0]= 16*256; 00061 00062 return init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, huff_sym, 2, 2, use_static); 00063 } 00064 00065 static void build_basic_mjpeg_vlc(MJpegDecodeContext * s) { 00066 build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance, 00067 ff_mjpeg_val_dc, 12, 0, 0); 00068 build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance, 00069 ff_mjpeg_val_dc, 12, 0, 0); 00070 build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance, 00071 ff_mjpeg_val_ac_luminance, 251, 0, 1); 00072 build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance, 00073 ff_mjpeg_val_ac_chrominance, 251, 0, 1); 00074 build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance, 00075 ff_mjpeg_val_ac_luminance, 251, 0, 0); 00076 build_vlc(&s->vlcs[2][1], ff_mjpeg_bits_ac_chrominance, 00077 ff_mjpeg_val_ac_chrominance, 251, 0, 0); 00078 } 00079 00080 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx) 00081 { 00082 MJpegDecodeContext *s = avctx->priv_data; 00083 00084 if (!s->picture_ptr) 00085 s->picture_ptr = &s->picture; 00086 00087 s->avctx = avctx; 00088 dsputil_init(&s->dsp, avctx); 00089 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct); 00090 s->buffer_size = 0; 00091 s->buffer = NULL; 00092 s->start_code = -1; 00093 s->first_picture = 1; 00094 s->org_height = avctx->coded_height; 00095 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; 00096 00097 build_basic_mjpeg_vlc(s); 00098 00099 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF) 00100 { 00101 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); 00102 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8); 00103 if (ff_mjpeg_decode_dht(s)) { 00104 av_log(avctx, AV_LOG_ERROR, "mjpeg: error using external huffman table, switching back to internal\n"); 00105 build_basic_mjpeg_vlc(s); 00106 } 00107 } 00108 if (avctx->extradata_size > 9 && 00109 AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) { 00110 if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */ 00111 s->interlace_polarity = 1; /* bottom field first */ 00112 av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n"); 00113 } 00114 } 00115 if (avctx->codec->id == CODEC_ID_AMV) 00116 s->flipped = 1; 00117 00118 return 0; 00119 } 00120 00121 00122 /* quantize tables */ 00123 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s) 00124 { 00125 int len, index, i, j; 00126 00127 len = get_bits(&s->gb, 16) - 2; 00128 00129 while (len >= 65) { 00130 /* only 8 bit precision handled */ 00131 if (get_bits(&s->gb, 4) != 0) 00132 { 00133 av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n"); 00134 return -1; 00135 } 00136 index = get_bits(&s->gb, 4); 00137 if (index >= 4) 00138 return -1; 00139 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index); 00140 /* read quant table */ 00141 for(i=0;i<64;i++) { 00142 j = s->scantable.permutated[i]; 00143 s->quant_matrixes[index][j] = get_bits(&s->gb, 8); 00144 } 00145 00146 //XXX FIXME finetune, and perhaps add dc too 00147 s->qscale[index]= FFMAX( 00148 s->quant_matrixes[index][s->scantable.permutated[1]], 00149 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1; 00150 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]); 00151 len -= 65; 00152 } 00153 00154 return 0; 00155 } 00156 00157 /* decode huffman tables and build VLC decoders */ 00158 int ff_mjpeg_decode_dht(MJpegDecodeContext *s) 00159 { 00160 int len, index, i, class, n, v, code_max; 00161 uint8_t bits_table[17]; 00162 uint8_t val_table[256]; 00163 00164 len = get_bits(&s->gb, 16) - 2; 00165 00166 while (len > 0) { 00167 if (len < 17) 00168 return -1; 00169 class = get_bits(&s->gb, 4); 00170 if (class >= 2) 00171 return -1; 00172 index = get_bits(&s->gb, 4); 00173 if (index >= 4) 00174 return -1; 00175 n = 0; 00176 for(i=1;i<=16;i++) { 00177 bits_table[i] = get_bits(&s->gb, 8); 00178 n += bits_table[i]; 00179 } 00180 len -= 17; 00181 if (len < n || n > 256) 00182 return -1; 00183 00184 code_max = 0; 00185 for(i=0;i<n;i++) { 00186 v = get_bits(&s->gb, 8); 00187 if (v > code_max) 00188 code_max = v; 00189 val_table[i] = v; 00190 } 00191 len -= n; 00192 00193 /* build VLC and flush previous vlc if present */ 00194 free_vlc(&s->vlcs[class][index]); 00195 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n", 00196 class, index, code_max + 1); 00197 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){ 00198 return -1; 00199 } 00200 00201 if(class>0){ 00202 free_vlc(&s->vlcs[2][index]); 00203 if(build_vlc(&s->vlcs[2][index], bits_table, val_table, code_max + 1, 0, 0) < 0){ 00204 return -1; 00205 } 00206 } 00207 } 00208 return 0; 00209 } 00210 00211 int ff_mjpeg_decode_sof(MJpegDecodeContext *s) 00212 { 00213 int len, nb_components, i, width, height, pix_fmt_id; 00214 00215 /* XXX: verify len field validity */ 00216 len = get_bits(&s->gb, 16); 00217 s->bits= get_bits(&s->gb, 8); 00218 00219 if(s->pegasus_rct) s->bits=9; 00220 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly 00221 00222 if (s->bits != 8 && !s->lossless){ 00223 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n"); 00224 return -1; 00225 } 00226 00227 height = get_bits(&s->gb, 16); 00228 width = get_bits(&s->gb, 16); 00229 00230 //HACK for odd_height.mov 00231 if(s->interlaced && s->width == width && s->height == height + 1) 00232 height= s->height; 00233 00234 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height); 00235 if(av_image_check_size(width, height, 0, s->avctx)) 00236 return -1; 00237 00238 nb_components = get_bits(&s->gb, 8); 00239 if (nb_components <= 0 || 00240 nb_components > MAX_COMPONENTS) 00241 return -1; 00242 if (s->ls && !(s->bits <= 8 || nb_components == 1)){ 00243 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n"); 00244 return -1; 00245 } 00246 s->nb_components = nb_components; 00247 s->h_max = 1; 00248 s->v_max = 1; 00249 for(i=0;i<nb_components;i++) { 00250 /* component id */ 00251 s->component_id[i] = get_bits(&s->gb, 8) - 1; 00252 s->h_count[i] = get_bits(&s->gb, 4); 00253 s->v_count[i] = get_bits(&s->gb, 4); 00254 /* compute hmax and vmax (only used in interleaved case) */ 00255 if (s->h_count[i] > s->h_max) 00256 s->h_max = s->h_count[i]; 00257 if (s->v_count[i] > s->v_max) 00258 s->v_max = s->v_count[i]; 00259 s->quant_index[i] = get_bits(&s->gb, 8); 00260 if (s->quant_index[i] >= 4) 00261 return -1; 00262 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i], 00263 s->v_count[i], s->component_id[i], s->quant_index[i]); 00264 } 00265 00266 if(s->ls && (s->h_max > 1 || s->v_max > 1)) { 00267 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n"); 00268 return -1; 00269 } 00270 00271 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1; 00272 00273 /* if different size, realloc/alloc picture */ 00274 /* XXX: also check h_count and v_count */ 00275 if (width != s->width || height != s->height) { 00276 av_freep(&s->qscale_table); 00277 00278 s->width = width; 00279 s->height = height; 00280 s->interlaced = 0; 00281 00282 /* test interlaced mode */ 00283 if (s->first_picture && 00284 s->org_height != 0 && 00285 s->height < ((s->org_height * 3) / 4)) { 00286 s->interlaced = 1; 00287 s->bottom_field = s->interlace_polarity; 00288 s->picture_ptr->interlaced_frame = 1; 00289 s->picture_ptr->top_field_first = !s->interlace_polarity; 00290 height *= 2; 00291 } 00292 00293 avcodec_set_dimensions(s->avctx, width, height); 00294 00295 s->qscale_table= av_mallocz((s->width+15)/16); 00296 00297 s->first_picture = 0; 00298 } 00299 00300 if(s->interlaced && (s->bottom_field == !s->interlace_polarity)) 00301 return 0; 00302 00303 /* XXX: not complete test ! */ 00304 pix_fmt_id = (s->h_count[0] << 28) | (s->v_count[0] << 24) | 00305 (s->h_count[1] << 20) | (s->v_count[1] << 16) | 00306 (s->h_count[2] << 12) | (s->v_count[2] << 8) | 00307 (s->h_count[3] << 4) | s->v_count[3]; 00308 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id); 00309 //NOTE we do not allocate pictures large enough for the possible padding of h/v_count being 4 00310 if(!(pix_fmt_id & 0xD0D0D0D0)) 00311 pix_fmt_id-= (pix_fmt_id & 0xF0F0F0F0)>>1; 00312 if(!(pix_fmt_id & 0x0D0D0D0D)) 00313 pix_fmt_id-= (pix_fmt_id & 0x0F0F0F0F)>>1; 00314 00315 switch(pix_fmt_id){ 00316 case 0x11111100: 00317 if(s->rgb){ 00318 s->avctx->pix_fmt = PIX_FMT_BGRA; 00319 }else 00320 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; 00321 assert(s->nb_components==3); 00322 break; 00323 case 0x11000000: 00324 s->avctx->pix_fmt = PIX_FMT_GRAY8; 00325 break; 00326 case 0x12111100: 00327 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV440P : PIX_FMT_YUVJ440P; 00328 break; 00329 case 0x21111100: 00330 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; 00331 break; 00332 case 0x22111100: 00333 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; 00334 break; 00335 default: 00336 av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id); 00337 return -1; 00338 } 00339 if(s->ls){ 00340 if(s->nb_components > 1) 00341 s->avctx->pix_fmt = PIX_FMT_RGB24; 00342 else if(s->bits <= 8) 00343 s->avctx->pix_fmt = PIX_FMT_GRAY8; 00344 else 00345 s->avctx->pix_fmt = PIX_FMT_GRAY16; 00346 } 00347 00348 if(s->picture_ptr->data[0]) 00349 s->avctx->release_buffer(s->avctx, s->picture_ptr); 00350 00351 if(s->avctx->get_buffer(s->avctx, s->picture_ptr) < 0){ 00352 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 00353 return -1; 00354 } 00355 s->picture_ptr->pict_type= AV_PICTURE_TYPE_I; 00356 s->picture_ptr->key_frame= 1; 00357 s->got_picture = 1; 00358 00359 for(i=0; i<3; i++){ 00360 s->linesize[i]= s->picture_ptr->linesize[i] << s->interlaced; 00361 } 00362 00363 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height); 00364 00365 if (len != (8+(3*nb_components))) 00366 { 00367 av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len); 00368 } 00369 00370 /* totally blank picture as progressive JPEG will only add details to it */ 00371 if(s->progressive){ 00372 int bw = (width + s->h_max*8-1) / (s->h_max*8); 00373 int bh = (height + s->v_max*8-1) / (s->v_max*8); 00374 for(i=0; i<s->nb_components; i++) { 00375 int size = bw * bh * s->h_count[i] * s->v_count[i]; 00376 av_freep(&s->blocks[i]); 00377 av_freep(&s->last_nnz[i]); 00378 s->blocks[i] = av_malloc(size * sizeof(**s->blocks)); 00379 s->last_nnz[i] = av_mallocz(size * sizeof(**s->last_nnz)); 00380 s->block_stride[i] = bw * s->h_count[i]; 00381 } 00382 memset(s->coefs_finished, 0, sizeof(s->coefs_finished)); 00383 } 00384 return 0; 00385 } 00386 00387 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) 00388 { 00389 int code; 00390 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); 00391 if (code < 0) 00392 { 00393 av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, 00394 &s->vlcs[0][dc_index]); 00395 return 0xffff; 00396 } 00397 00398 if(code) 00399 return get_xbits(&s->gb, code); 00400 else 00401 return 0; 00402 } 00403 00404 /* decode block and dequantize */ 00405 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 00406 int component, int dc_index, int ac_index, int16_t *quant_matrix) 00407 { 00408 int code, i, j, level, val; 00409 00410 /* DC coef */ 00411 val = mjpeg_decode_dc(s, dc_index); 00412 if (val == 0xffff) { 00413 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); 00414 return -1; 00415 } 00416 val = val * quant_matrix[0] + s->last_dc[component]; 00417 s->last_dc[component] = val; 00418 block[0] = val; 00419 /* AC coefs */ 00420 i = 0; 00421 {OPEN_READER(re, &s->gb); 00422 do { 00423 UPDATE_CACHE(re, &s->gb); 00424 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2); 00425 00426 i += ((unsigned)code) >> 4; 00427 code &= 0xf; 00428 if(code){ 00429 if(code > MIN_CACHE_BITS - 16){ 00430 UPDATE_CACHE(re, &s->gb); 00431 } 00432 { 00433 int cache=GET_CACHE(re,&s->gb); 00434 int sign=(~cache)>>31; 00435 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; 00436 } 00437 00438 LAST_SKIP_BITS(re, &s->gb, code); 00439 00440 if (i > 63) { 00441 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); 00442 return -1; 00443 } 00444 j = s->scantable.permutated[i]; 00445 block[j] = level * quant_matrix[j]; 00446 } 00447 }while(i<63); 00448 CLOSE_READER(re, &s->gb);} 00449 00450 return 0; 00451 } 00452 00453 static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block, int component, 00454 int dc_index, int16_t *quant_matrix, int Al) 00455 { 00456 int val; 00457 s->dsp.clear_block(block); 00458 val = mjpeg_decode_dc(s, dc_index); 00459 if (val == 0xffff) { 00460 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); 00461 return -1; 00462 } 00463 val = (val * quant_matrix[0] << Al) + s->last_dc[component]; 00464 s->last_dc[component] = val; 00465 block[0] = val; 00466 return 0; 00467 } 00468 00469 /* decode block and dequantize - progressive JPEG version */ 00470 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, 00471 int ac_index, int16_t *quant_matrix, 00472 int ss, int se, int Al, int *EOBRUN) 00473 { 00474 int code, i, j, level, val, run; 00475 00476 if(*EOBRUN){ 00477 (*EOBRUN)--; 00478 return 0; 00479 } 00480 {OPEN_READER(re, &s->gb); 00481 for(i=ss;;i++) { 00482 UPDATE_CACHE(re, &s->gb); 00483 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2); 00484 00485 run = ((unsigned) code) >> 4; 00486 code &= 0xF; 00487 if(code) { 00488 i += run; 00489 if(code > MIN_CACHE_BITS - 16){ 00490 UPDATE_CACHE(re, &s->gb); 00491 } 00492 { 00493 int cache=GET_CACHE(re,&s->gb); 00494 int sign=(~cache)>>31; 00495 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; 00496 } 00497 00498 LAST_SKIP_BITS(re, &s->gb, code); 00499 00500 if (i >= se) { 00501 if(i == se){ 00502 j = s->scantable.permutated[se]; 00503 block[j] = level * quant_matrix[j] << Al; 00504 break; 00505 } 00506 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); 00507 return -1; 00508 } 00509 j = s->scantable.permutated[i]; 00510 block[j] = level * quant_matrix[j] << Al; 00511 }else{ 00512 if(run == 0xF){// ZRL - skip 15 coefficients 00513 i += 15; 00514 if (i >= se) { 00515 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i); 00516 return -1; 00517 } 00518 }else{ 00519 val = (1 << run); 00520 if(run){ 00521 UPDATE_CACHE(re, &s->gb); 00522 val += NEG_USR32(GET_CACHE(re, &s->gb), run); 00523 LAST_SKIP_BITS(re, &s->gb, run); 00524 } 00525 *EOBRUN = val - 1; 00526 break; 00527 } 00528 } 00529 } 00530 CLOSE_READER(re, &s->gb);} 00531 if(i > *last_nnz) 00532 *last_nnz = i; 00533 return 0; 00534 } 00535 00536 #define REFINE_BIT(j) {\ 00537 UPDATE_CACHE(re, &s->gb);\ 00538 sign = block[j]>>15;\ 00539 block[j] += SHOW_UBITS(re, &s->gb, 1) * ((quant_matrix[j]^sign)-sign) << Al;\ 00540 LAST_SKIP_BITS(re, &s->gb, 1);\ 00541 } 00542 00543 #define ZERO_RUN \ 00544 for(;;i++) {\ 00545 if(i > last) {\ 00546 i += run;\ 00547 if(i > se) {\ 00548 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);\ 00549 return -1;\ 00550 }\ 00551 break;\ 00552 }\ 00553 j = s->scantable.permutated[i];\ 00554 if(block[j])\ 00555 REFINE_BIT(j)\ 00556 else if(run-- == 0)\ 00557 break;\ 00558 } 00559 00560 /* decode block and dequantize - progressive JPEG refinement pass */ 00561 static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, 00562 int ac_index, int16_t *quant_matrix, 00563 int ss, int se, int Al, int *EOBRUN) 00564 { 00565 int code, i=ss, j, sign, val, run; 00566 int last = FFMIN(se, *last_nnz); 00567 00568 OPEN_READER(re, &s->gb); 00569 if(*EOBRUN) 00570 (*EOBRUN)--; 00571 else { 00572 for(;;i++) { 00573 UPDATE_CACHE(re, &s->gb); 00574 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2); 00575 00576 if(code & 0xF) { 00577 run = ((unsigned) code) >> 4; 00578 UPDATE_CACHE(re, &s->gb); 00579 val = SHOW_UBITS(re, &s->gb, 1); 00580 LAST_SKIP_BITS(re, &s->gb, 1); 00581 ZERO_RUN; 00582 j = s->scantable.permutated[i]; 00583 val--; 00584 block[j] = ((quant_matrix[j]^val)-val) << Al; 00585 if(i == se) { 00586 if(i > *last_nnz) 00587 *last_nnz = i; 00588 CLOSE_READER(re, &s->gb); 00589 return 0; 00590 } 00591 }else{ 00592 run = ((unsigned) code) >> 4; 00593 if(run == 0xF){ 00594 ZERO_RUN; 00595 }else{ 00596 val = run; 00597 run = (1 << run); 00598 if(val) { 00599 UPDATE_CACHE(re, &s->gb); 00600 run += SHOW_UBITS(re, &s->gb, val); 00601 LAST_SKIP_BITS(re, &s->gb, val); 00602 } 00603 *EOBRUN = run - 1; 00604 break; 00605 } 00606 } 00607 } 00608 00609 if(i > *last_nnz) 00610 *last_nnz = i; 00611 } 00612 00613 for(;i<=last;i++) { 00614 j = s->scantable.permutated[i]; 00615 if(block[j]) 00616 REFINE_BIT(j) 00617 } 00618 CLOSE_READER(re, &s->gb); 00619 00620 return 0; 00621 } 00622 #undef REFINE_BIT 00623 #undef ZERO_RUN 00624 00625 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ 00626 int i, mb_x, mb_y; 00627 uint16_t (*buffer)[4]; 00628 int left[3], top[3], topleft[3]; 00629 const int linesize= s->linesize[0]; 00630 const int mask= (1<<s->bits)-1; 00631 00632 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0])); 00633 buffer= s->ljpeg_buffer; 00634 00635 for(i=0; i<3; i++){ 00636 buffer[0][i]= 1 << (s->bits + point_transform - 1); 00637 } 00638 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { 00639 const int modified_predictor= mb_y ? predictor : 1; 00640 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y); 00641 00642 if (s->interlaced && s->bottom_field) 00643 ptr += linesize >> 1; 00644 00645 for(i=0; i<3; i++){ 00646 top[i]= left[i]= topleft[i]= buffer[0][i]; 00647 } 00648 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 00649 if (s->restart_interval && !s->restart_count) 00650 s->restart_count = s->restart_interval; 00651 00652 for(i=0;i<3;i++) { 00653 int pred; 00654 00655 topleft[i]= top[i]; 00656 top[i]= buffer[mb_x][i]; 00657 00658 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); 00659 00660 left[i]= 00661 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform)); 00662 } 00663 00664 if (s->restart_interval && !--s->restart_count) { 00665 align_get_bits(&s->gb); 00666 skip_bits(&s->gb, 16); /* skip RSTn */ 00667 } 00668 } 00669 00670 if(s->rct){ 00671 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 00672 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2); 00673 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; 00674 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; 00675 } 00676 }else if(s->pegasus_rct){ 00677 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 00678 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2); 00679 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; 00680 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; 00681 } 00682 }else{ 00683 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 00684 ptr[4*mb_x+0] = buffer[mb_x][2]; 00685 ptr[4*mb_x+1] = buffer[mb_x][1]; 00686 ptr[4*mb_x+2] = buffer[mb_x][0]; 00687 } 00688 } 00689 } 00690 return 0; 00691 } 00692 00693 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ 00694 int i, mb_x, mb_y; 00695 const int nb_components=3; 00696 00697 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { 00698 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 00699 if (s->restart_interval && !s->restart_count) 00700 s->restart_count = s->restart_interval; 00701 00702 if(mb_x==0 || mb_y==0 || s->interlaced){ 00703 for(i=0;i<nb_components;i++) { 00704 uint8_t *ptr; 00705 int n, h, v, x, y, c, j, linesize; 00706 n = s->nb_blocks[i]; 00707 c = s->comp_index[i]; 00708 h = s->h_scount[i]; 00709 v = s->v_scount[i]; 00710 x = 0; 00711 y = 0; 00712 linesize= s->linesize[c]; 00713 00714 for(j=0; j<n; j++) { 00715 int pred; 00716 00717 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap 00718 if(y==0 && mb_y==0){ 00719 if(x==0 && mb_x==0){ 00720 pred= 128 << point_transform; 00721 }else{ 00722 pred= ptr[-1]; 00723 } 00724 }else{ 00725 if(x==0 && mb_x==0){ 00726 pred= ptr[-linesize]; 00727 }else{ 00728 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); 00729 } 00730 } 00731 00732 if (s->interlaced && s->bottom_field) 00733 ptr += linesize >> 1; 00734 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); 00735 00736 if (++x == h) { 00737 x = 0; 00738 y++; 00739 } 00740 } 00741 } 00742 }else{ 00743 for(i=0;i<nb_components;i++) { 00744 uint8_t *ptr; 00745 int n, h, v, x, y, c, j, linesize; 00746 n = s->nb_blocks[i]; 00747 c = s->comp_index[i]; 00748 h = s->h_scount[i]; 00749 v = s->v_scount[i]; 00750 x = 0; 00751 y = 0; 00752 linesize= s->linesize[c]; 00753 00754 for(j=0; j<n; j++) { 00755 int pred; 00756 00757 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap 00758 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); 00759 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); 00760 if (++x == h) { 00761 x = 0; 00762 y++; 00763 } 00764 } 00765 } 00766 } 00767 if (s->restart_interval && !--s->restart_count) { 00768 align_get_bits(&s->gb); 00769 skip_bits(&s->gb, 16); /* skip RSTn */ 00770 } 00771 } 00772 } 00773 return 0; 00774 } 00775 00776 static av_always_inline void mjpeg_copy_block(uint8_t *dst, const uint8_t *src, 00777 int linesize, int lowres) 00778 { 00779 switch (lowres) { 00780 case 0: copy_block8(dst, src, linesize, linesize, 8); 00781 break; 00782 case 1: copy_block4(dst, src, linesize, linesize, 4); 00783 break; 00784 case 2: copy_block2(dst, src, linesize, linesize, 2); 00785 break; 00786 case 3: *dst = *src; 00787 break; 00788 } 00789 } 00790 00791 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, 00792 const uint8_t *mb_bitmask, const AVFrame *reference){ 00793 int i, mb_x, mb_y; 00794 uint8_t* data[MAX_COMPONENTS]; 00795 const uint8_t *reference_data[MAX_COMPONENTS]; 00796 int linesize[MAX_COMPONENTS]; 00797 GetBitContext mb_bitmask_gb; 00798 00799 if (mb_bitmask) { 00800 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width*s->mb_height); 00801 } 00802 00803 if(s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) { 00804 av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n"); 00805 s->flipped = 0; 00806 } 00807 for(i=0; i < nb_components; i++) { 00808 int c = s->comp_index[i]; 00809 data[c] = s->picture_ptr->data[c]; 00810 reference_data[c] = reference ? reference->data[c] : NULL; 00811 linesize[c]=s->linesize[c]; 00812 s->coefs_finished[c] |= 1; 00813 if(s->flipped) { 00814 //picture should be flipped upside-down for this codec 00815 int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 )); 00816 data[c] += offset; 00817 reference_data[c] += offset; 00818 linesize[c] *= -1; 00819 } 00820 } 00821 00822 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { 00823 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 00824 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb); 00825 00826 if (s->restart_interval && !s->restart_count) 00827 s->restart_count = s->restart_interval; 00828 00829 if(get_bits_count(&s->gb)>s->gb.size_in_bits){ 00830 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", get_bits_count(&s->gb) - s->gb.size_in_bits); 00831 return -1; 00832 } 00833 for(i=0;i<nb_components;i++) { 00834 uint8_t *ptr; 00835 int n, h, v, x, y, c, j; 00836 int block_offset; 00837 n = s->nb_blocks[i]; 00838 c = s->comp_index[i]; 00839 h = s->h_scount[i]; 00840 v = s->v_scount[i]; 00841 x = 0; 00842 y = 0; 00843 for(j=0;j<n;j++) { 00844 block_offset = (((linesize[c] * (v * mb_y + y) * 8) + 00845 (h * mb_x + x) * 8) >> s->avctx->lowres); 00846 00847 if(s->interlaced && s->bottom_field) 00848 block_offset += linesize[c] >> 1; 00849 ptr = data[c] + block_offset; 00850 if(!s->progressive) { 00851 if (copy_mb) { 00852 mjpeg_copy_block(ptr, reference_data[c] + block_offset, linesize[c], s->avctx->lowres); 00853 } else { 00854 s->dsp.clear_block(s->block); 00855 if(decode_block(s, s->block, i, 00856 s->dc_index[i], s->ac_index[i], 00857 s->quant_matrixes[ s->quant_index[c] ]) < 0) { 00858 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); 00859 return -1; 00860 } 00861 s->dsp.idct_put(ptr, linesize[c], s->block); 00862 } 00863 } else { 00864 int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x); 00865 DCTELEM *block = s->blocks[c][block_idx]; 00866 if(Ah) 00867 block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al; 00868 else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) { 00869 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); 00870 return -1; 00871 } 00872 } 00873 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x); 00874 //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); 00875 if (++x == h) { 00876 x = 0; 00877 y++; 00878 } 00879 } 00880 } 00881 00882 if (s->restart_interval && show_bits(&s->gb, 8) == 0xFF){ /* skip RSTn */ 00883 --s->restart_count; 00884 align_get_bits(&s->gb); 00885 while(show_bits(&s->gb, 8) == 0xFF) 00886 skip_bits(&s->gb, 8); 00887 skip_bits(&s->gb, 8); 00888 for (i=0; i<nb_components; i++) /* reset dc */ 00889 s->last_dc[i] = 1024; 00890 } 00891 } 00892 } 00893 return 0; 00894 } 00895 00896 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al, 00897 const uint8_t *mb_bitmask, const AVFrame *reference){ 00898 int mb_x, mb_y; 00899 int EOBRUN = 0; 00900 int c = s->comp_index[0]; 00901 uint8_t* data = s->picture_ptr->data[c]; 00902 const uint8_t *reference_data = reference ? reference->data[c] : NULL; 00903 int linesize = s->linesize[c]; 00904 int last_scan = 0; 00905 int16_t *quant_matrix = s->quant_matrixes[ s->quant_index[c] ]; 00906 GetBitContext mb_bitmask_gb; 00907 00908 if (mb_bitmask) { 00909 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width*s->mb_height); 00910 } 00911 00912 if(!Al) { 00913 s->coefs_finished[c] |= (1LL<<(se+1))-(1LL<<ss); 00914 last_scan = !~s->coefs_finished[c]; 00915 } 00916 00917 if(s->interlaced && s->bottom_field) { 00918 int offset = linesize >> 1; 00919 data += offset; 00920 reference_data += offset; 00921 } 00922 00923 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { 00924 int block_offset = (mb_y*linesize*8 >> s->avctx->lowres); 00925 uint8_t *ptr = data + block_offset; 00926 int block_idx = mb_y * s->block_stride[c]; 00927 DCTELEM (*block)[64] = &s->blocks[c][block_idx]; 00928 uint8_t *last_nnz = &s->last_nnz[c][block_idx]; 00929 for(mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) { 00930 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb); 00931 00932 if (!copy_mb) { 00933 int ret; 00934 if(Ah) 00935 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0], 00936 quant_matrix, ss, se, Al, &EOBRUN); 00937 else 00938 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0], 00939 quant_matrix, ss, se, Al, &EOBRUN); 00940 if(ret < 0) { 00941 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x); 00942 return -1; 00943 } 00944 } 00945 00946 if(last_scan) { 00947 if (copy_mb) { 00948 mjpeg_copy_block(ptr, reference_data + block_offset, linesize, s->avctx->lowres); 00949 } else { 00950 s->dsp.idct_put(ptr, linesize, *block); 00951 ptr += 8 >> s->avctx->lowres; 00952 } 00953 } 00954 } 00955 } 00956 return 0; 00957 } 00958 00959 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, 00960 const uint8_t *mb_bitmask, const AVFrame *reference) 00961 { 00962 int len, nb_components, i, h, v, predictor, point_transform; 00963 int index, id; 00964 const int block_size= s->lossless ? 1 : 8; 00965 int ilv, prev_shift; 00966 00967 /* XXX: verify len field validity */ 00968 len = get_bits(&s->gb, 16); 00969 nb_components = get_bits(&s->gb, 8); 00970 if (nb_components == 0 || nb_components > MAX_COMPONENTS){ 00971 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: nb_components (%d) unsupported\n", nb_components); 00972 return -1; 00973 } 00974 if (len != 6+2*nb_components) 00975 { 00976 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len); 00977 return -1; 00978 } 00979 for(i=0;i<nb_components;i++) { 00980 id = get_bits(&s->gb, 8) - 1; 00981 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id); 00982 /* find component index */ 00983 for(index=0;index<s->nb_components;index++) 00984 if (id == s->component_id[index]) 00985 break; 00986 if (index == s->nb_components) 00987 { 00988 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index); 00989 return -1; 00990 } 00991 /* Metasoft MJPEG codec has Cb and Cr swapped */ 00992 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J') 00993 && nb_components == 3 && s->nb_components == 3 && i) 00994 index = 3 - i; 00995 00996 s->comp_index[i] = index; 00997 00998 s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; 00999 s->h_scount[i] = s->h_count[index]; 01000 s->v_scount[i] = s->v_count[index]; 01001 01002 s->dc_index[i] = get_bits(&s->gb, 4); 01003 s->ac_index[i] = get_bits(&s->gb, 4); 01004 01005 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || 01006 s->dc_index[i] >= 4 || s->ac_index[i] >= 4) 01007 goto out_of_range; 01008 if (!s->vlcs[0][s->dc_index[i]].table || !s->vlcs[1][s->ac_index[i]].table) 01009 goto out_of_range; 01010 } 01011 01012 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */ 01013 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */ 01014 prev_shift = get_bits(&s->gb, 4); /* Ah */ 01015 point_transform= get_bits(&s->gb, 4); /* Al */ 01016 01017 for(i=0;i<nb_components;i++) 01018 s->last_dc[i] = 1024; 01019 01020 if (nb_components > 1) { 01021 /* interleaved stream */ 01022 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); 01023 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); 01024 } else if(!s->ls) { /* skip this for JPEG-LS */ 01025 h = s->h_max / s->h_scount[0]; 01026 v = s->v_max / s->v_scount[0]; 01027 s->mb_width = (s->width + h * block_size - 1) / (h * block_size); 01028 s->mb_height = (s->height + v * block_size - 1) / (v * block_size); 01029 s->nb_blocks[0] = 1; 01030 s->h_scount[0] = 1; 01031 s->v_scount[0] = 1; 01032 } 01033 01034 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 01035 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "", 01036 predictor, point_transform, ilv, s->bits, 01037 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : "")); 01038 01039 01040 /* mjpeg-b can have padding bytes between sos and image data, skip them */ 01041 for (i = s->mjpb_skiptosod; i > 0; i--) 01042 skip_bits(&s->gb, 8); 01043 01044 if(s->lossless){ 01045 if(CONFIG_JPEGLS_DECODER && s->ls){ 01046 // for(){ 01047 // reset_ls_coding_parameters(s, 0); 01048 01049 if(ff_jpegls_decode_picture(s, predictor, point_transform, ilv) < 0) 01050 return -1; 01051 }else{ 01052 if(s->rgb){ 01053 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) 01054 return -1; 01055 }else{ 01056 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) 01057 return -1; 01058 } 01059 } 01060 }else{ 01061 if(s->progressive && predictor) { 01062 if(mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, point_transform, 01063 mb_bitmask, reference) < 0) 01064 return -1; 01065 } else { 01066 if(mjpeg_decode_scan(s, nb_components, prev_shift, point_transform, 01067 mb_bitmask, reference) < 0) 01068 return -1; 01069 } 01070 } 01071 emms_c(); 01072 return 0; 01073 out_of_range: 01074 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); 01075 return -1; 01076 } 01077 01078 static int mjpeg_decode_dri(MJpegDecodeContext *s) 01079 { 01080 if (get_bits(&s->gb, 16) != 4) 01081 return -1; 01082 s->restart_interval = get_bits(&s->gb, 16); 01083 s->restart_count = 0; 01084 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval); 01085 01086 return 0; 01087 } 01088 01089 static int mjpeg_decode_app(MJpegDecodeContext *s) 01090 { 01091 int len, id, i; 01092 01093 len = get_bits(&s->gb, 16); 01094 if (len < 5) 01095 return -1; 01096 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits) 01097 return -1; 01098 01099 id = get_bits_long(&s->gb, 32); 01100 id = av_be2ne32(id); 01101 len -= 6; 01102 01103 if(s->avctx->debug & FF_DEBUG_STARTCODE){ 01104 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 01105 } 01106 01107 /* buggy AVID, it puts EOI only at every 10th frame */ 01108 /* also this fourcc is used by non-avid files too, it holds some 01109 informations, but it's always present in AVID creates files */ 01110 if (id == AV_RL32("AVI1")) 01111 { 01112 /* structure: 01113 4bytes AVI1 01114 1bytes polarity 01115 1bytes always zero 01116 4bytes field_size 01117 4bytes field_size_less_padding 01118 */ 01119 s->buggy_avid = 1; 01120 // if (s->first_picture) 01121 // printf("mjpeg: workarounding buggy AVID\n"); 01122 i = get_bits(&s->gb, 8); 01123 if (i==2) s->bottom_field= 1; 01124 else if(i==1) s->bottom_field= 0; 01125 #if 0 01126 skip_bits(&s->gb, 8); 01127 skip_bits(&s->gb, 32); 01128 skip_bits(&s->gb, 32); 01129 len -= 10; 01130 #endif 01131 // if (s->interlace_polarity) 01132 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity); 01133 goto out; 01134 } 01135 01136 // len -= 2; 01137 01138 if (id == AV_RL32("JFIF")) 01139 { 01140 int t_w, t_h, v1, v2; 01141 skip_bits(&s->gb, 8); /* the trailing zero-byte */ 01142 v1= get_bits(&s->gb, 8); 01143 v2= get_bits(&s->gb, 8); 01144 skip_bits(&s->gb, 8); 01145 01146 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16); 01147 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16); 01148 01149 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 01150 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n", 01151 v1, v2, 01152 s->avctx->sample_aspect_ratio.num, 01153 s->avctx->sample_aspect_ratio.den 01154 ); 01155 01156 t_w = get_bits(&s->gb, 8); 01157 t_h = get_bits(&s->gb, 8); 01158 if (t_w && t_h) 01159 { 01160 /* skip thumbnail */ 01161 if (len-10-(t_w*t_h*3) > 0) 01162 len -= t_w*t_h*3; 01163 } 01164 len -= 10; 01165 goto out; 01166 } 01167 01168 if (id == AV_RL32("Adob") && (get_bits(&s->gb, 8) == 'e')) 01169 { 01170 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 01171 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n"); 01172 skip_bits(&s->gb, 16); /* version */ 01173 skip_bits(&s->gb, 16); /* flags0 */ 01174 skip_bits(&s->gb, 16); /* flags1 */ 01175 skip_bits(&s->gb, 8); /* transform */ 01176 len -= 7; 01177 goto out; 01178 } 01179 01180 if (id == AV_RL32("LJIF")){ 01181 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 01182 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n"); 01183 skip_bits(&s->gb, 16); /* version ? */ 01184 skip_bits(&s->gb, 16); /* unknwon always 0? */ 01185 skip_bits(&s->gb, 16); /* unknwon always 0? */ 01186 skip_bits(&s->gb, 16); /* unknwon always 0? */ 01187 switch( get_bits(&s->gb, 8)){ 01188 case 1: 01189 s->rgb= 1; 01190 s->pegasus_rct=0; 01191 break; 01192 case 2: 01193 s->rgb= 1; 01194 s->pegasus_rct=1; 01195 break; 01196 default: 01197 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n"); 01198 } 01199 len -= 9; 01200 goto out; 01201 } 01202 01203 /* Apple MJPEG-A */ 01204 if ((s->start_code == APP1) && (len > (0x28 - 8))) 01205 { 01206 id = get_bits_long(&s->gb, 32); 01207 id = av_be2ne32(id); 01208 len -= 4; 01209 if (id == AV_RL32("mjpg")) /* Apple MJPEG-A */ 01210 { 01211 #if 0 01212 skip_bits(&s->gb, 32); /* field size */ 01213 skip_bits(&s->gb, 32); /* pad field size */ 01214 skip_bits(&s->gb, 32); /* next off */ 01215 skip_bits(&s->gb, 32); /* quant off */ 01216 skip_bits(&s->gb, 32); /* huff off */ 01217 skip_bits(&s->gb, 32); /* image off */ 01218 skip_bits(&s->gb, 32); /* scan off */ 01219 skip_bits(&s->gb, 32); /* data off */ 01220 #endif 01221 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 01222 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n"); 01223 } 01224 } 01225 01226 out: 01227 /* slow but needed for extreme adobe jpegs */ 01228 if (len < 0) 01229 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n"); 01230 while(--len > 0) 01231 skip_bits(&s->gb, 8); 01232 01233 return 0; 01234 } 01235 01236 static int mjpeg_decode_com(MJpegDecodeContext *s) 01237 { 01238 int len = get_bits(&s->gb, 16); 01239 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) { 01240 char *cbuf = av_malloc(len - 1); 01241 if (cbuf) { 01242 int i; 01243 for (i = 0; i < len - 2; i++) 01244 cbuf[i] = get_bits(&s->gb, 8); 01245 if (i > 0 && cbuf[i-1] == '\n') 01246 cbuf[i-1] = 0; 01247 else 01248 cbuf[i] = 0; 01249 01250 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 01251 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf); 01252 01253 /* buggy avid, it puts EOI only at every 10th frame */ 01254 if (!strcmp(cbuf, "AVID")) 01255 { 01256 s->buggy_avid = 1; 01257 // if (s->first_picture) 01258 // printf("mjpeg: workarounding buggy AVID\n"); 01259 } 01260 else if(!strcmp(cbuf, "CS=ITU601")){ 01261 s->cs_itu601= 1; 01262 } 01263 else if((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) || 01264 (len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20))){ 01265 s->flipped = 1; 01266 } 01267 01268 av_free(cbuf); 01269 } 01270 } 01271 01272 return 0; 01273 } 01274 01275 #if 0 01276 static int valid_marker_list[] = 01277 { 01278 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */ 01279 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01280 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01281 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01282 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01283 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01284 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01285 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01286 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01287 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01288 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01289 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01290 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 01291 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01292 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01293 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 01294 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 01295 } 01296 #endif 01297 01298 /* return the 8 bit start code value and update the search 01299 state. Return -1 if no start code found */ 01300 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end) 01301 { 01302 const uint8_t *buf_ptr; 01303 unsigned int v, v2; 01304 int val; 01305 #ifdef DEBUG 01306 int skipped=0; 01307 #endif 01308 01309 buf_ptr = *pbuf_ptr; 01310 while (buf_ptr < buf_end) { 01311 v = *buf_ptr++; 01312 v2 = *buf_ptr; 01313 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { 01314 val = *buf_ptr++; 01315 goto found; 01316 } 01317 #ifdef DEBUG 01318 skipped++; 01319 #endif 01320 } 01321 val = -1; 01322 found: 01323 av_dlog(NULL, "find_marker skipped %d bytes\n", skipped); 01324 *pbuf_ptr = buf_ptr; 01325 return val; 01326 } 01327 01328 int ff_mjpeg_find_marker(MJpegDecodeContext *s, 01329 const uint8_t **buf_ptr, const uint8_t *buf_end, 01330 const uint8_t **unescaped_buf_ptr, int *unescaped_buf_size) 01331 { 01332 int start_code; 01333 start_code = find_marker(buf_ptr, buf_end); 01334 01335 if ((buf_end - *buf_ptr) > s->buffer_size) 01336 { 01337 av_free(s->buffer); 01338 s->buffer_size = buf_end - *buf_ptr; 01339 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); 01340 av_log(s->avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n", 01341 s->buffer_size); 01342 } 01343 01344 /* unescape buffer of SOS, use special treatment for JPEG-LS */ 01345 if (start_code == SOS && !s->ls) 01346 { 01347 const uint8_t *src = *buf_ptr; 01348 uint8_t *dst = s->buffer; 01349 01350 while (src<buf_end) 01351 { 01352 uint8_t x = *(src++); 01353 01354 *(dst++) = x; 01355 if (s->avctx->codec_id != CODEC_ID_THP) 01356 { 01357 if (x == 0xff) { 01358 while (src < buf_end && x == 0xff) 01359 x = *(src++); 01360 01361 if (x >= 0xd0 && x <= 0xd7) 01362 *(dst++) = x; 01363 else if (x) 01364 break; 01365 } 01366 } 01367 } 01368 *unescaped_buf_ptr = s->buffer; 01369 *unescaped_buf_size = dst - s->buffer; 01370 01371 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n", 01372 (buf_end - *buf_ptr) - (dst - s->buffer)); 01373 } 01374 else if(start_code == SOS && s->ls){ 01375 const uint8_t *src = *buf_ptr; 01376 uint8_t *dst = s->buffer; 01377 int bit_count = 0; 01378 int t = 0, b = 0; 01379 PutBitContext pb; 01380 01381 s->cur_scan++; 01382 01383 /* find marker */ 01384 while (src + t < buf_end){ 01385 uint8_t x = src[t++]; 01386 if (x == 0xff){ 01387 while((src + t < buf_end) && x == 0xff) 01388 x = src[t++]; 01389 if (x & 0x80) { 01390 t -= 2; 01391 break; 01392 } 01393 } 01394 } 01395 bit_count = t * 8; 01396 01397 init_put_bits(&pb, dst, t); 01398 01399 /* unescape bitstream */ 01400 while(b < t){ 01401 uint8_t x = src[b++]; 01402 put_bits(&pb, 8, x); 01403 if(x == 0xFF){ 01404 x = src[b++]; 01405 put_bits(&pb, 7, x); 01406 bit_count--; 01407 } 01408 } 01409 flush_put_bits(&pb); 01410 01411 *unescaped_buf_ptr = dst; 01412 *unescaped_buf_size = (bit_count + 7) >> 3; 01413 } 01414 else 01415 { 01416 *unescaped_buf_ptr = *buf_ptr; 01417 *unescaped_buf_size = buf_end - *buf_ptr; 01418 } 01419 01420 return start_code; 01421 } 01422 01423 int ff_mjpeg_decode_frame(AVCodecContext *avctx, 01424 void *data, int *data_size, 01425 AVPacket *avpkt) 01426 { 01427 const uint8_t *buf = avpkt->data; 01428 int buf_size = avpkt->size; 01429 MJpegDecodeContext *s = avctx->priv_data; 01430 const uint8_t *buf_end, *buf_ptr; 01431 const uint8_t *unescaped_buf_ptr; 01432 int unescaped_buf_size; 01433 int start_code; 01434 AVFrame *picture = data; 01435 01436 s->got_picture = 0; // picture from previous image can not be reused 01437 buf_ptr = buf; 01438 buf_end = buf + buf_size; 01439 while (buf_ptr < buf_end) { 01440 /* find start next marker */ 01441 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end, 01442 &unescaped_buf_ptr, &unescaped_buf_size); 01443 { 01444 /* EOF */ 01445 if (start_code < 0) { 01446 goto the_end; 01447 } else { 01448 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n", start_code, buf_end - buf_ptr); 01449 01450 init_get_bits(&s->gb, unescaped_buf_ptr, unescaped_buf_size*8); 01451 01452 s->start_code = start_code; 01453 if(s->avctx->debug & FF_DEBUG_STARTCODE){ 01454 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); 01455 } 01456 01457 /* process markers */ 01458 if (start_code >= 0xd0 && start_code <= 0xd7) { 01459 av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f); 01460 /* APP fields */ 01461 } else if (start_code >= APP0 && start_code <= APP15) { 01462 mjpeg_decode_app(s); 01463 /* Comment */ 01464 } else if (start_code == COM){ 01465 mjpeg_decode_com(s); 01466 } 01467 01468 switch(start_code) { 01469 case SOI: 01470 s->restart_interval = 0; 01471 01472 s->restart_count = 0; 01473 /* nothing to do on SOI */ 01474 break; 01475 case DQT: 01476 ff_mjpeg_decode_dqt(s); 01477 break; 01478 case DHT: 01479 if(ff_mjpeg_decode_dht(s) < 0){ 01480 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n"); 01481 return -1; 01482 } 01483 break; 01484 case SOF0: 01485 case SOF1: 01486 s->lossless=0; 01487 s->ls=0; 01488 s->progressive=0; 01489 if (ff_mjpeg_decode_sof(s) < 0) 01490 return -1; 01491 break; 01492 case SOF2: 01493 s->lossless=0; 01494 s->ls=0; 01495 s->progressive=1; 01496 if (ff_mjpeg_decode_sof(s) < 0) 01497 return -1; 01498 break; 01499 case SOF3: 01500 s->lossless=1; 01501 s->ls=0; 01502 s->progressive=0; 01503 if (ff_mjpeg_decode_sof(s) < 0) 01504 return -1; 01505 break; 01506 case SOF48: 01507 s->lossless=1; 01508 s->ls=1; 01509 s->progressive=0; 01510 if (ff_mjpeg_decode_sof(s) < 0) 01511 return -1; 01512 break; 01513 case LSE: 01514 if (!CONFIG_JPEGLS_DECODER || ff_jpegls_decode_lse(s) < 0) 01515 return -1; 01516 break; 01517 case EOI: 01518 s->cur_scan = 0; 01519 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 01520 break; 01521 eoi_parser: 01522 if (!s->got_picture) { 01523 av_log(avctx, AV_LOG_WARNING, "Found EOI before any SOF, ignoring\n"); 01524 break; 01525 } 01526 { 01527 if (s->interlaced) { 01528 s->bottom_field ^= 1; 01529 /* if not bottom field, do not output image yet */ 01530 if (s->bottom_field == !s->interlace_polarity) 01531 goto not_the_end; 01532 } 01533 *picture = *s->picture_ptr; 01534 *data_size = sizeof(AVFrame); 01535 01536 if(!s->lossless){ 01537 picture->quality= FFMAX3(s->qscale[0], s->qscale[1], s->qscale[2]); 01538 picture->qstride= 0; 01539 picture->qscale_table= s->qscale_table; 01540 memset(picture->qscale_table, picture->quality, (s->width+15)/16); 01541 if(avctx->debug & FF_DEBUG_QP) 01542 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality); 01543 picture->quality*= FF_QP2LAMBDA; 01544 } 01545 01546 goto the_end; 01547 } 01548 break; 01549 case SOS: 01550 if (!s->got_picture) { 01551 av_log(avctx, AV_LOG_WARNING, "Can not process SOS before SOF, skipping\n"); 01552 break; 01553 } 01554 ff_mjpeg_decode_sos(s, NULL, NULL); 01555 /* buggy avid puts EOI every 10-20th frame */ 01556 /* if restart period is over process EOI */ 01557 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 01558 goto eoi_parser; 01559 break; 01560 case DRI: 01561 mjpeg_decode_dri(s); 01562 break; 01563 case SOF5: 01564 case SOF6: 01565 case SOF7: 01566 case SOF9: 01567 case SOF10: 01568 case SOF11: 01569 case SOF13: 01570 case SOF14: 01571 case SOF15: 01572 case JPG: 01573 av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code); 01574 break; 01575 // default: 01576 // printf("mjpeg: unsupported marker (%x)\n", start_code); 01577 // break; 01578 } 01579 01580 not_the_end: 01581 /* eof process start code */ 01582 buf_ptr += (get_bits_count(&s->gb)+7)/8; 01583 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n", 01584 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb)); 01585 } 01586 } 01587 } 01588 if (s->got_picture) { 01589 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n"); 01590 goto eoi_parser; 01591 } 01592 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n"); 01593 return -1; 01594 the_end: 01595 av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n", buf_end - buf_ptr); 01596 // return buf_end - buf_ptr; 01597 return buf_ptr - buf; 01598 } 01599 01600 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx) 01601 { 01602 MJpegDecodeContext *s = avctx->priv_data; 01603 int i, j; 01604 01605 if (s->picture_ptr && s->picture_ptr->data[0]) 01606 avctx->release_buffer(avctx, s->picture_ptr); 01607 01608 av_free(s->buffer); 01609 av_free(s->qscale_table); 01610 av_freep(&s->ljpeg_buffer); 01611 s->ljpeg_buffer_size=0; 01612 01613 for(i=0;i<3;i++) { 01614 for(j=0;j<4;j++) 01615 free_vlc(&s->vlcs[i][j]); 01616 } 01617 for(i=0; i<MAX_COMPONENTS; i++) { 01618 av_freep(&s->blocks[i]); 01619 av_freep(&s->last_nnz[i]); 01620 } 01621 return 0; 01622 } 01623 01624 AVCodec ff_mjpeg_decoder = { 01625 "mjpeg", 01626 AVMEDIA_TYPE_VIDEO, 01627 CODEC_ID_MJPEG, 01628 sizeof(MJpegDecodeContext), 01629 ff_mjpeg_decode_init, 01630 NULL, 01631 ff_mjpeg_decode_end, 01632 ff_mjpeg_decode_frame, 01633 CODEC_CAP_DR1, 01634 NULL, 01635 .max_lowres = 3, 01636 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), 01637 }; 01638 01639 AVCodec ff_thp_decoder = { 01640 "thp", 01641 AVMEDIA_TYPE_VIDEO, 01642 CODEC_ID_THP, 01643 sizeof(MJpegDecodeContext), 01644 ff_mjpeg_decode_init, 01645 NULL, 01646 ff_mjpeg_decode_end, 01647 ff_mjpeg_decode_frame, 01648 CODEC_CAP_DR1, 01649 NULL, 01650 .max_lowres = 3, 01651 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"), 01652 };