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