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