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