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