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