diff options
Diffstat (limited to 'libavcodec/mjpegdec.c')
| -rw-r--r-- | libavcodec/mjpegdec.c | 509 |
1 files changed, 351 insertions, 158 deletions
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c index f738040..23a818e 100644 --- a/libavcodec/mjpegdec.c +++ b/libavcodec/mjpegdec.c @@ -8,20 +8,20 @@ * aspecting, new decode_frame mechanism and apple mjpeg-b support * by Alex Beregszaszi * - * This file is part of Libav. + * This file is part of FFmpeg. * - * Libav is free software; you can redistribute it and/or + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * Libav is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with Libav; if not, write to the Free Software + * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -30,10 +30,8 @@ * MJPEG decoder. */ -// #define DEBUG -#include <assert.h> - #include "libavutil/imgutils.h" +#include "libavutil/avassert.h" #include "libavutil/opt.h" #include "avcodec.h" #include "dsputil.h" @@ -51,7 +49,7 @@ static int build_vlc(VLC *vlc, const uint8_t *bits_table, uint16_t huff_sym[256]; int i; - assert(nb_codes <= 256); + av_assert0(nb_codes <= 256); ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table); @@ -87,6 +85,7 @@ av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx) if (!s->picture_ptr) s->picture_ptr = &s->picture; + avcodec_get_frame_defaults(&s->picture); s->avctx = avctx; ff_dsputil_init(&s->dsp, avctx); @@ -101,18 +100,17 @@ av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx) build_basic_mjpeg_vlc(s); if (s->extern_huff) { - int ret; - av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); + av_log(avctx, AV_LOG_INFO, "using external huffman table\n"); init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8); - if ((ret = ff_mjpeg_decode_dht(s))) { + if (ff_mjpeg_decode_dht(s)) { av_log(avctx, AV_LOG_ERROR, - "mjpeg: error using external huffman table\n"); - return ret; + "error using external huffman table, switching back to internal\n"); + build_basic_mjpeg_vlc(s); } } if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */ s->interlace_polarity = 1; /* bottom field first */ - av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n"); + av_log(avctx, AV_LOG_DEBUG, "bottom field first\n"); } if (avctx->codec->id == AV_CODEC_ID_AMV) s->flipped = 1; @@ -213,6 +211,9 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) { int len, nb_components, i, width, height, pix_fmt_id; + s->cur_scan = 0; + s->upscale_h = s->upscale_v = 0; + /* XXX: verify len field validity */ len = get_bits(&s->gb, 16); s->bits = get_bits(&s->gb, 8); @@ -227,6 +228,11 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) return -1; } + if(s->lossless && s->avctx->lowres){ + av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n"); + return -1; + } + height = get_bits(&s->gb, 16); width = get_bits(&s->gb, 16); @@ -242,6 +248,12 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) if (nb_components <= 0 || nb_components > MAX_COMPONENTS) return -1; + if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) { + if (nb_components != s->nb_components) { + av_log(s->avctx, AV_LOG_ERROR, "nb_components changing in interlaced picture\n"); + return AVERROR_INVALIDDATA; + } + } if (s->ls && !(s->bits <= 8 || nb_components == 1)) { av_log_missing_feature(s->avctx, "only <= 8 bits/component or " @@ -261,6 +273,10 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) s->h_max = s->h_count[i]; if (s->v_count[i] > s->v_max) s->v_max = s->v_count[i]; + if (!s->h_count[i] || !s->v_count[i]) { + av_log(s->avctx, AV_LOG_ERROR, "h/v_count is 0\n"); + return -1; + } s->quant_index[i] = get_bits(&s->gb, 8); if (s->quant_index[i] >= 4) return AVERROR_INVALIDDATA; @@ -275,7 +291,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) return AVERROR_PATCHWELCOME; } - if (s->v_max == 1 && s->h_max == 1 && s->lossless == 1) + if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && nb_components==3) s->rgb = 1; /* if different size, realloc/alloc picture */ @@ -304,7 +320,12 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) s->first_picture = 0; } - if (!(s->interlaced && (s->bottom_field == !s->interlace_polarity))) { + if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) { + if (s->progressive) { + av_log_ask_for_sample(s->avctx, "progressively coded interlaced pictures not supported\n"); + return AVERROR_INVALIDDATA; + } + } else{ /* XXX: not complete test ! */ pix_fmt_id = (s->h_count[0] << 28) | (s->v_count[0] << 24) | (s->h_count[1] << 20) | (s->v_count[1] << 16) | @@ -321,28 +342,78 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s) switch (pix_fmt_id) { case 0x11111100: if (s->rgb) - s->avctx->pix_fmt = PIX_FMT_BGRA; - else + s->avctx->pix_fmt = PIX_FMT_BGR24; + else { + if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') { + s->avctx->pix_fmt = PIX_FMT_GBR24P; + } else { s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; - assert(s->nb_components == 3); + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + } + } + av_assert0(s->nb_components == 3); + break; + case 0x12121100: + case 0x22122100: + s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + s->upscale_v = 2; + s->upscale_h = (pix_fmt_id == 0x22122100); + s->chroma_height = s->height; + break; + case 0x21211100: + case 0x22211200: + s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + s->upscale_v = (pix_fmt_id == 0x22211200); + s->upscale_h = 2; + s->chroma_height = s->height; + break; + case 0x22221100: + s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + s->upscale_v = 2; + s->upscale_h = 2; + s->chroma_height = s->height / 2; break; case 0x11000000: - s->avctx->pix_fmt = PIX_FMT_GRAY8; + if(s->bits <= 8) + s->avctx->pix_fmt = PIX_FMT_GRAY8; + else + s->avctx->pix_fmt = PIX_FMT_GRAY16; break; case 0x12111100: + case 0x22211100: + case 0x22112100: s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV440P : PIX_FMT_YUVJ440P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + s->upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100); + s->chroma_height = s->height / 2; break; case 0x21111100: s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + break; + case 0x22121100: + case 0x22111200: + s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; + s->upscale_v = (pix_fmt_id == 0x22121100) + 1; break; case 0x22111100: s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; + s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; break; default: av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id); return AVERROR_PATCHWELCOME; } + if ((s->upscale_h || s->upscale_v) && s->avctx->lowres) { + av_log(s->avctx, AV_LOG_ERROR, "lowres not supported for weird subsampling\n"); + return AVERROR_PATCHWELCOME; + } if (s->ls) { + s->upscale_h = s->upscale_v = 0; if (s->nb_components > 1) s->avctx->pix_fmt = PIX_FMT_RGB24; else if (s->bits <= 8) @@ -637,25 +708,27 @@ static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, #undef REFINE_BIT #undef ZERO_RUN -static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, - int point_transform) +static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform) { int i, mb_x, mb_y; uint16_t (*buffer)[4]; int left[3], top[3], topleft[3]; const int linesize = s->linesize[0]; const int mask = (1 << s->bits) - 1; + int resync_mb_y = 0; + int resync_mb_x = 0; + + s->restart_count = s->restart_interval; av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0])); buffer = s->ljpeg_buffer; for (i = 0; i < 3; i++) - buffer[0][i] = 1 << (s->bits + point_transform - 1); + buffer[0][i] = 1 << (s->bits - 1); for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - const int modified_predictor = mb_y ? predictor : 1; - uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y); + uint8_t *ptr = s->picture.data[0] + (linesize * mb_y); if (s->interlaced && s->bottom_field) ptr += linesize >> 1; @@ -664,19 +737,32 @@ static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, top[i] = left[i] = topleft[i] = buffer[0][i]; for (mb_x = 0; mb_x < s->mb_width; mb_x++) { - if (s->restart_interval && !s->restart_count) + int modified_predictor = predictor; + + if (s->restart_interval && !s->restart_count){ s->restart_count = s->restart_interval; + resync_mb_x = mb_x; + resync_mb_y = mb_y; + for(i=0; i<3; i++) + top[i] = left[i]= topleft[i]= 1 << (s->bits - 1); + } + if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x) + modified_predictor = 1; - for (i = 0; i < 3; i++) { - int pred; + for (i=0;i<nb_components;i++) { + int pred, dc; topleft[i] = top[i]; top[i] = buffer[mb_x][i]; PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); + dc = mjpeg_decode_dc(s, s->dc_index[i]); + if(dc == 0xFFFF) + return -1; + left[i] = buffer[mb_x][i] = - mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform)); + mask & (pred + (dc << point_transform)); } if (s->restart_interval && !--s->restart_count) { @@ -687,21 +773,22 @@ static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, if (s->rct) { for (mb_x = 0; mb_x < s->mb_width; mb_x++) { - ptr[4 * mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2); - ptr[4 * mb_x + 0] = buffer[mb_x][1] + ptr[4 * mb_x + 1]; - ptr[4 * mb_x + 2] = buffer[mb_x][2] + ptr[4 * mb_x + 1]; + ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2); + ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1]; + ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1]; } } else if (s->pegasus_rct) { for (mb_x = 0; mb_x < s->mb_width; mb_x++) { - ptr[4 * mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2); - ptr[4 * mb_x + 0] = buffer[mb_x][1] + ptr[4 * mb_x + 1]; - ptr[4 * mb_x + 2] = buffer[mb_x][2] + ptr[4 * mb_x + 1]; + ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2); + ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1]; + ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1]; } } else { - for (mb_x = 0; mb_x < s->mb_width; mb_x++) { - ptr[4 * mb_x + 0] = buffer[mb_x][2]; - ptr[4 * mb_x + 1] = buffer[mb_x][1]; - ptr[4 * mb_x + 2] = buffer[mb_x][0]; + for(i=0; i<nb_components; i++) { + int c= s->comp_index[i]; + for(mb_x = 0; mb_x < s->mb_width; mb_x++) { + ptr[3*mb_x+2-c] = buffer[mb_x][i]; + } } } } @@ -712,48 +799,87 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform) { int i, mb_x, mb_y; - const int nb_components = 3; + const int nb_components=s->nb_components; + int bits= (s->bits+7)&~7; + int resync_mb_y = 0; + int resync_mb_x = 0; + + point_transform += bits - s->bits; + + av_assert0(nb_components==1 || nb_components==3); for (mb_y = 0; mb_y < s->mb_height; mb_y++) { for (mb_x = 0; mb_x < s->mb_width; mb_x++) { - if (s->restart_interval && !s->restart_count) + if (s->restart_interval && !s->restart_count){ s->restart_count = s->restart_interval; + resync_mb_x = mb_x; + resync_mb_y = mb_y; + } - if (mb_x == 0 || mb_y == 0 || s->interlaced) { + if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){ + int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x; + int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x; for (i = 0; i < nb_components; i++) { uint8_t *ptr; + uint16_t *ptr16; int n, h, v, x, y, c, j, linesize; - n = s->nb_blocks[i]; - c = s->comp_index[i]; - h = s->h_scount[i]; - v = s->v_scount[i]; - x = 0; - y = 0; - linesize = s->linesize[c]; - - for (j = 0; j < n; j++) { - int pred; - // FIXME optimize this crap - ptr = s->picture_ptr->data[c] + - (linesize * (v * mb_y + y)) + - (h * mb_x + x); - if (y == 0 && mb_y == 0) { - if (x == 0 && mb_x == 0) - pred = 128 << point_transform; - else - pred = ptr[-1]; - } else { - if (x == 0 && mb_x == 0) - pred = ptr[-linesize]; - else - PREDICT(pred, ptr[-linesize - 1], - ptr[-linesize], ptr[-1], predictor); - } + n = s->nb_blocks[i]; + c = s->comp_index[i]; + h = s->h_scount[i]; + v = s->v_scount[i]; + x = 0; + y = 0; + linesize= s->linesize[c]; + + if(bits>8) linesize /= 2; + + for(j=0; j<n; j++) { + int pred, dc; + + dc = mjpeg_decode_dc(s, s->dc_index[i]); + if(dc == 0xFFFF) + return -1; + if(bits<=8){ + ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap + if(y==0 && toprow){ + if(x==0 && leftcol){ + pred= 1 << (bits - 1); + }else{ + pred= ptr[-1]; + } + }else{ + if(x==0 && leftcol){ + pred= ptr[-linesize]; + }else{ + PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); + } + } if (s->interlaced && s->bottom_field) ptr += linesize >> 1; - *ptr = pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); + pred &= (-1)<<(8-s->bits); + *ptr= pred + (dc << point_transform); + }else{ + ptr16 = (uint16_t*)(s->picture.data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap + if(y==0 && toprow){ + if(x==0 && leftcol){ + pred= 1 << (bits - 1); + }else{ + pred= ptr16[-1]; + } + }else{ + if(x==0 && leftcol){ + pred= ptr16[-linesize]; + }else{ + PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor); + } + } + if (s->interlaced && s->bottom_field) + ptr16 += linesize >> 1; + pred &= (-1)<<(16-s->bits); + *ptr16= pred + (dc << point_transform); + } if (++x == h) { x = 0; y++; @@ -763,7 +889,8 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, } else { for (i = 0; i < nb_components; i++) { uint8_t *ptr; - int n, h, v, x, y, c, j, linesize; + uint16_t *ptr16; + int n, h, v, x, y, c, j, linesize, dc; n = s->nb_blocks[i]; c = s->comp_index[i]; h = s->h_scount[i]; @@ -772,16 +899,30 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, y = 0; linesize = s->linesize[c]; + if(bits>8) linesize /= 2; + for (j = 0; j < n; j++) { int pred; - // FIXME optimize this crap - ptr = s->picture_ptr->data[c] + + dc = mjpeg_decode_dc(s, s->dc_index[i]); + if(dc == 0xFFFF) + return -1; + if(bits<=8){ + ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + - (h * mb_x + x); - PREDICT(pred, ptr[-linesize - 1], - ptr[-linesize], ptr[-1], predictor); - *ptr = pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); + (h * mb_x + x); //FIXME optimize this crap + PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); + + pred &= (-1)<<(8-s->bits); + *ptr = pred + (dc << point_transform); + }else{ + ptr16 = (uint16_t*)(s->picture.data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap + PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor); + + pred &= (-1)<<(16-s->bits); + *ptr16= pred + (dc << point_transform); + } + if (++x == h) { x = 0; y++; @@ -798,6 +939,21 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, return 0; } +static av_always_inline void mjpeg_copy_block(uint8_t *dst, const uint8_t *src, + int linesize, int lowres) +{ + switch (lowres) { + case 0: copy_block8(dst, src, linesize, linesize, 8); + break; + case 1: copy_block4(dst, src, linesize, linesize, 4); + break; + case 2: copy_block2(dst, src, linesize, linesize, 2); + break; + case 3: *dst = *src; + break; + } +} + static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, const AVFrame *reference) @@ -811,9 +967,8 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, if (mb_bitmask) init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height); - if (s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) { - av_log(s->avctx, AV_LOG_ERROR, - "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n"); + if (s->flipped && s->avctx->lowres) { + av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with lowres\n"); s->flipped = 0; } @@ -823,7 +978,7 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, reference_data[c] = reference ? reference->data[c] : NULL; linesize[c] = s->linesize[c]; s->coefs_finished[c] |= 1; - if (s->flipped) { + if (s->flipped && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) { // picture should be flipped upside-down for this codec int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height - ((s->height / s->v_max) & 7)) - 1)); @@ -856,16 +1011,16 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, x = 0; y = 0; for (j = 0; j < n; j++) { - block_offset = ((linesize[c] * (v * mb_y + y) * 8) + - (h * mb_x + x) * 8); + block_offset = (((linesize[c] * (v * mb_y + y) * 8) + + (h * mb_x + x) * 8) >> s->avctx->lowres); if (s->interlaced && s->bottom_field) block_offset += linesize[c] >> 1; ptr = data[c] + block_offset; if (!s->progressive) { if (copy_mb) - copy_block8(ptr, reference_data[c] + block_offset, - linesize[c], linesize[c], 8); + mjpeg_copy_block(ptr, reference_data[c] + block_offset, + linesize[c], s->avctx->lowres); else { s->dsp.clear_block(s->block); if (decode_block(s, s->block, i, @@ -906,6 +1061,12 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, if (s->restart_interval) { s->restart_count--; + if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){ + align_get_bits(&s->gb); + for (i = 0; i < nb_components; i++) /* reset dc */ + s->last_dc[i] = 1024; + } + i = 8 + ((-get_bits_count(&s->gb)) & 7); /* skip RSTn */ if (show_bits(&s->gb, i) == (1 << i) - 1) { @@ -913,7 +1074,7 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, align_get_bits(&s->gb); while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF) skip_bits(&s->gb, 8); - if ((get_bits(&s->gb, 8) & 0xF8) == 0xD0) { + if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) { for (i = 0; i < nb_components; i++) /* reset dc */ s->last_dc[i] = 1024; } else @@ -926,44 +1087,30 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, } static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, - int se, int Ah, int Al, - const uint8_t *mb_bitmask, - const AVFrame *reference) + int se, int Ah, int Al) { int mb_x, mb_y; int EOBRUN = 0; int c = s->comp_index[0]; - uint8_t *data = s->picture_ptr->data[c]; - const uint8_t *reference_data = reference ? reference->data[c] : NULL; + uint8_t *data = s->picture.data[c]; int linesize = s->linesize[c]; int last_scan = 0; int16_t *quant_matrix = s->quant_matrixes[s->quant_index[c]]; - GetBitContext mb_bitmask_gb; - - if (mb_bitmask) - init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height); if (!Al) { s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss); last_scan = !~s->coefs_finished[c]; } - if (s->interlaced && s->bottom_field) { - int offset = linesize >> 1; - data += offset; - reference_data += offset; - } + if (s->interlaced && s->bottom_field) + data += linesize >> 1; for (mb_y = 0; mb_y < s->mb_height; mb_y++) { - int block_offset = mb_y * linesize * 8; - uint8_t *ptr = data + block_offset; + uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres); int block_idx = mb_y * s->block_stride[c]; DCTELEM (*block)[64] = &s->blocks[c][block_idx]; uint8_t *last_nnz = &s->last_nnz[c][block_idx]; for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) { - const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb); - - if (!copy_mb) { int ret; if (Ah) ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0], @@ -976,16 +1123,10 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, "error y=%d x=%d\n", mb_y, mb_x); return AVERROR_INVALIDDATA; } - } if (last_scan) { - if (copy_mb) { - copy_block8(ptr, reference_data + block_offset, - linesize, linesize, 8); - } else { s->dsp.idct_put(ptr, linesize, *block); - ptr += 8; - } + ptr += 8 >> s->avctx->lowres; } } } @@ -1000,6 +1141,13 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, const int block_size = s->lossless ? 1 : 8; int ilv, prev_shift; + if (!s->got_picture) { + av_log(s->avctx, AV_LOG_WARNING, + "Can not process SOS before SOF, skipping\n"); + return -1; + } + + av_assert0(s->picture_ptr->data[0]); /* XXX: verify len field validity */ len = get_bits(&s->gb, 16); nb_components = get_bits(&s->gb, 8); @@ -1029,6 +1177,11 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, && nb_components == 3 && s->nb_components == 3 && i) index = 3 - i; + if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == PIX_FMT_GBR24P) + index = (i+2)%3; + if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == PIX_FMT_GBR24P) + index = (index+2)%3; + s->comp_index[i] = index; s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; @@ -1041,15 +1194,17 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || s->dc_index[i] >= 4 || s->ac_index[i] >= 4) goto out_of_range; - if (!s->vlcs[0][s->dc_index[i]].table || - !s->vlcs[1][s->ac_index[i]].table) + if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table)) goto out_of_range; } predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */ ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */ - prev_shift = get_bits(&s->gb, 4); /* Ah */ - point_transform = get_bits(&s->gb, 4); /* Al */ + if(s->avctx->codec_tag != AV_RL32("CJPG")){ + prev_shift = get_bits(&s->gb, 4); /* Ah */ + point_transform = get_bits(&s->gb, 4); /* Al */ + }else + prev_shift = point_transform = 0; if (nb_components > 1) { /* interleaved stream */ @@ -1066,10 +1221,10 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, } if (s->avctx->debug & FF_DEBUG_PICT_INFO) - av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", + av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n", s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "", - predictor, point_transform, ilv, s->bits, - s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : "")); + predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod, + s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components); /* mjpeg-b can have padding bytes between sos and image data, skip them */ @@ -1081,6 +1236,7 @@ next_field: s->last_dc[i] = 1024; if (s->lossless) { + av_assert0(s->picture_ptr == &s->picture); if (CONFIG_JPEGLS_DECODER && s->ls) { // for () { // reset_ls_coding_parameters(s, 0); @@ -1090,22 +1246,19 @@ next_field: return ret; } else { if (s->rgb) { - if ((ret = ljpeg_decode_rgb_scan(s, predictor, - point_transform)) < 0) + if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0) return ret; } else { - if ((ret = ljpeg_decode_yuv_scan(s, predictor, - point_transform)) < 0) + if ((ret = ljpeg_decode_yuv_scan(s, predictor, point_transform)) < 0) return ret; } } } else { if (s->progressive && predictor) { + av_assert0(s->picture_ptr == &s->picture); if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, - point_transform, - mb_bitmask, - reference)) < 0) + point_transform)) < 0) return ret; } else { if ((ret = mjpeg_decode_scan(s, nb_components, @@ -1121,7 +1274,7 @@ next_field: GetBitContext bak = s->gb; align_get_bits(&bak); if (show_bits(&bak, 16) == 0xFFD1) { - av_dlog(s->avctx, "AVRn interlaced picture marker found\n"); + av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n"); s->gb = bak; skip_bits(&s->gb, 16); s->bottom_field ^= 1; @@ -1177,14 +1330,11 @@ static int mjpeg_decode_app(MJpegDecodeContext *s) 4bytes field_size 4bytes field_size_less_padding */ - s->buggy_avid = 1; -// if (s->first_picture) -// printf("mjpeg: workarounding buggy AVID\n"); - i = get_bits(&s->gb, 8); - if (i == 2) - s->bottom_field = 1; - else if (i == 1) - s->bottom_field = 0; + s->buggy_avid = 1; +// if (s->first_picture) +// printf("mjpeg: workarounding buggy AVID\n"); + i = get_bits(&s->gb, 8); len--; + av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i); #if 0 skip_bits(&s->gb, 8); skip_bits(&s->gb, 32); @@ -1309,7 +1459,7 @@ static int mjpeg_decode_com(MJpegDecodeContext *s) cbuf[i] = 0; if (s->avctx->debug & FF_DEBUG_PICT_INFO) - av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf); + av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf); /* buggy avid, it puts EOI only at every 10th frame */ if (!strcmp(cbuf, "AVID")) { @@ -1318,7 +1468,7 @@ static int mjpeg_decode_com(MJpegDecodeContext *s) // printf("mjpeg: workarounding buggy AVID\n"); } else if (!strcmp(cbuf, "CS=ITU601")) s->cs_itu601 = 1; - else if ((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) || + else if ((len > 31 && !strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32)) || (len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20))) s->flipped = 1; @@ -1336,9 +1486,7 @@ static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end) const uint8_t *buf_ptr; unsigned int v, v2; int val; -#ifdef DEBUG int skipped = 0; -#endif buf_ptr = *pbuf_ptr; while (buf_ptr < buf_end) { @@ -1348,9 +1496,7 @@ static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end) val = *buf_ptr++; goto found; } -#ifdef DEBUG skipped++; -#endif } val = -1; found: @@ -1453,6 +1599,7 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *unescaped_buf_ptr; int unescaped_buf_size; int start_code; + int i, index; int ret = 0; AVFrame *picture = data; @@ -1542,21 +1689,19 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, return ret; break; case EOI: - s->cur_scan = 0; - if ((s->buggy_avid && !s->interlaced) || s->restart_interval) - break; eoi_parser: + s->cur_scan = 0; if (!s->got_picture) { av_log(avctx, AV_LOG_WARNING, "Found EOI before any SOF, ignoring\n"); break; - } + } if (s->interlaced) { s->bottom_field ^= 1; /* if not bottom field, do not output image yet */ if (s->bottom_field == !s->interlace_polarity) - goto not_the_end; - } + break; + } *picture = *s->picture_ptr; *data_size = sizeof(AVFrame); @@ -1576,18 +1721,9 @@ eoi_parser: goto the_end; case SOS: - if (!s->got_picture) { - av_log(avctx, AV_LOG_WARNING, - "Can not process SOS before SOF, skipping\n"); - break; - } if ((ret = ff_mjpeg_decode_sos(s, NULL, NULL)) < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) return ret; - /* buggy avid puts EOI every 10-20th frame */ - /* if restart period is over process EOI */ - if ((s->buggy_avid && !s->interlaced) || s->restart_interval) - goto eoi_parser; break; case DRI: mjpeg_decode_dri(s); @@ -1610,7 +1746,6 @@ eoi_parser: // break; } -not_the_end: /* eof process start code */ buf_ptr += (get_bits_count(&s->gb) + 7) / 8; av_log(avctx, AV_LOG_DEBUG, @@ -1625,7 +1760,60 @@ not_the_end: av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n"); return AVERROR_INVALIDDATA; the_end: - av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n", + if (s->upscale_h) { + uint8_t *line = s->picture_ptr->data[s->upscale_h]; + av_assert0(avctx->pix_fmt == PIX_FMT_YUVJ444P || + avctx->pix_fmt == PIX_FMT_YUV444P || + avctx->pix_fmt == PIX_FMT_YUVJ440P || + avctx->pix_fmt == PIX_FMT_YUV440P); + for (i = 0; i < s->chroma_height; i++) { + for (index = s->width - 1; index; index--) + line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1; + line += s->linesize[s->upscale_h]; + } + } + if (s->upscale_v) { + uint8_t *dst = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(s->height - 1) * s->linesize[s->upscale_v]]; + av_assert0(avctx->pix_fmt == PIX_FMT_YUVJ444P || + avctx->pix_fmt == PIX_FMT_YUV444P || + avctx->pix_fmt == PIX_FMT_YUVJ422P || + avctx->pix_fmt == PIX_FMT_YUV422P); + for (i = s->height - 1; i; i--) { + uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[i / 2 * s->linesize[s->upscale_v]]; + uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[s->upscale_v])[(i + 1) / 2 * s->linesize[s->upscale_v]]; + if (src1 == src2) { + memcpy(dst, src1, s->width); + } else { + for (index = 0; index < s->width; index++) + dst[index] = (src1[index] + src2[index]) >> 1; + } + dst -= s->linesize[s->upscale_v]; + } + } + if (s->flipped && (s->avctx->flags & CODEC_FLAG_EMU_EDGE)) { + int hshift, vshift, j; + avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift); + for (index=0; index<4; index++) { + uint8_t *dst = s->picture_ptr->data[index]; + int w = s->width; + int h = s->height; + if(index && index<3){ + w = -((-w) >> hshift); + h = -((-h) >> vshift); + } + if(dst){ + uint8_t *dst2 = dst + s->linesize[index]*(h-1); + for (i=0; i<h/2; i++) { + for (j=0; j<w; j++) + FFSWAP(int, dst[j], dst2[j]); + dst += s->linesize[index]; + dst2 -= s->linesize[index]; + } + } + } + } + + av_log(avctx, AV_LOG_DEBUG, "decode frame unused %td bytes\n", buf_end - buf_ptr); // return buf_end - buf_ptr; return buf_ptr - buf; @@ -1655,6 +1843,7 @@ av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx) return 0; } +#if CONFIG_MJPEG_DECODER #define OFFSET(x) offsetof(MJpegDecodeContext, x) #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM static const AVOption options[] = { @@ -1679,10 +1868,12 @@ AVCodec ff_mjpeg_decoder = { .close = ff_mjpeg_decode_end, .decode = ff_mjpeg_decode_frame, .capabilities = CODEC_CAP_DR1, + .max_lowres = 3, .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), .priv_class = &mjpegdec_class, }; - +#endif +#if CONFIG_THP_DECODER AVCodec ff_thp_decoder = { .name = "thp", .type = AVMEDIA_TYPE_VIDEO, @@ -1692,5 +1883,7 @@ AVCodec ff_thp_decoder = { .close = ff_mjpeg_decode_end, .decode = ff_mjpeg_decode_frame, .capabilities = CODEC_CAP_DR1, + .max_lowres = 3, .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"), }; +#endif |
