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