X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2F4xm.c;h=6e22fda65680302872e9fc8f1111bda36fa38d40;hb=2bb6eba21d1843d67127be031aab7576dbe4c200;hp=e78bc3a9e5fd9f3c34afc87713ad1a3ae5955071;hpb=115329f16062074e11ccf3b89ead6176606c9696;p=ffmpeg diff --git a/libavcodec/4xm.c b/libavcodec/4xm.c index e78bc3a9e5f..6e22fda6568 100644 --- a/libavcodec/4xm.c +++ b/libavcodec/4xm.c @@ -2,19 +2,21 @@ * 4XM codec * Copyright (c) 2003 Michael Niedermayer * - * This library is free software; you can redistribute it and/or + * This file is part of FFmpeg. + * + * 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 of the License, or (at your option) any later version. + * version 2.1 of the License, or (at your option) any later version. * - * This library 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 this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** @@ -22,9 +24,11 @@ * 4XM codec. */ +#include "libavutil/intreadwrite.h" #include "avcodec.h" #include "dsputil.h" -#include "mpegvideo.h" +#include "bitstream.h" +#include "bytestream.h" //#undef NDEBUG //#include @@ -34,7 +38,8 @@ #define CFRAME_BUFFER_COUNT 100 -static const uint8_t block_type_tab[4][8][2]={ +static const uint8_t block_type_tab[2][4][8][2]={ + { { //{8,4,2}x{8,4,2} { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0} },{ //{8,4}x1 @@ -44,6 +49,17 @@ static const uint8_t block_type_tab[4][8][2]={ },{ //1x2, 2x1 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4} } + },{ + { //{8,4,2}x{8,4,2} + { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0} + },{//{8,4}x1 + { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0} + },{//1x{8,4} + { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0} + },{//1x2, 2x1 + { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3} + } + } }; static const uint8_t size2index[4][4]={ @@ -100,12 +116,12 @@ static const uint8_t dequant_table[64]={ 20, 35, 34, 32, 31, 22, 15, 8, }; -static VLC block_type_vlc[4]; +static VLC block_type_vlc[2][4]; typedef struct CFrameBuffer{ - int allocated_size; - int size; + unsigned int allocated_size; + unsigned int size; int id; uint8_t *data; }CFrameBuffer; @@ -116,14 +132,15 @@ typedef struct FourXContext{ AVFrame current_picture, last_picture; GetBitContext pre_gb; ///< ac/dc prefix GetBitContext gb; - uint8_t *bytestream; - uint16_t *wordstream; + const uint8_t *bytestream; + const uint16_t *wordstream; int mv[256]; VLC pre_vlc; int last_dc; - DCTELEM __align8 block[6][64]; + DECLARE_ALIGNED_8(DCTELEM, block[6][64]); uint8_t *bitstream_buffer; - int bitstream_buffer_size; + unsigned int bitstream_buffer_size; + int version; CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]; } FourXContext; @@ -219,13 +236,13 @@ static void idct(DCTELEM block[64]){ } } -static void init_vlcs(FourXContext *f){ +static av_cold void init_vlcs(FourXContext *f){ int i; - for(i=0; i<4; i++){ - init_vlc(&block_type_vlc[i], BLOCK_TYPE_VLC_BITS, 7, - &block_type_tab[i][0][1], 2, 1, - &block_type_tab[i][0][0], 2, 1, 1); + for(i=0; i<8; i++){ + init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7, + &block_type_tab[0][i][0][1], 2, 1, + &block_type_tab[0][i][0][0], 2, 1, 1); } } @@ -233,7 +250,10 @@ static void init_mv(FourXContext *f){ int i; for(i=0; i<256; i++){ - f->mv[i] = mv[i][0] + mv[i][1]*f->current_picture.linesize[0]/2; + if(f->version>1) + f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2; + else + f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2; } } @@ -281,12 +301,18 @@ static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stri static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){ const int index= size2index[log2h][log2w]; const int h= 1<gb, block_type_vlc[index].table, BLOCK_TYPE_VLC_BITS, 1); + int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1); + uint16_t *start= (uint16_t*)f->last_picture.data[0]; + uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<=0 && code<=6); if(code == 0){ src += f->mv[ *f->bytestream++ ]; + if(start > src || src > end){ + av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n"); + return; + } mcdc(dst, src, log2w, h, stride, 1, 0); }else if(code == 1){ log2h--; @@ -296,8 +322,14 @@ static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int lo log2w--; decode_p_block(f, dst , src , log2w, log2h, stride); decode_p_block(f, dst + (1<version<2){ + mcdc(dst, src, log2w, h, stride, 1, 0); }else if(code == 4){ src += f->mv[ *f->bytestream++ ]; + if(start > src || src > end){ + av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n"); + return; + } mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++)); }else if(code == 5){ mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++)); @@ -312,22 +344,28 @@ static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int lo } } -static int get32(void *p){ - return le2me_32(*(uint32_t*)p); -} - -static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){ +static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){ int x, y; const int width= f->avctx->width; const int height= f->avctx->height; uint16_t *src= (uint16_t*)f->last_picture.data[0]; uint16_t *dst= (uint16_t*)f->current_picture.data[0]; const int stride= f->current_picture.linesize[0]>>1; - const unsigned int bitstream_size= get32(buf+8); - const unsigned int bytestream_size= get32(buf+16); - const unsigned int wordstream_size= get32(buf+12); + unsigned int bitstream_size, bytestream_size, wordstream_size, extra; - if(bitstream_size+ bytestream_size+ wordstream_size + 20 != length + if(f->version>1){ + extra=20; + bitstream_size= AV_RL32(buf+8); + wordstream_size= AV_RL32(buf+12); + bytestream_size= AV_RL32(buf+16); + }else{ + extra=0; + bitstream_size = AV_RL16(buf-4); + wordstream_size= AV_RL16(buf-2); + bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0); + } + + if(bitstream_size+ bytestream_size+ wordstream_size + extra != length || bitstream_size > (1<<26) || bytestream_size > (1<<26) || wordstream_size > (1<<26) @@ -338,11 +376,11 @@ static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){ } f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE); - f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + 20), bitstream_size/4); + f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4); init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size); - f->wordstream= (uint16_t*)(buf + 20 + bitstream_size); - f->bytestream= buf + 20 + bitstream_size + wordstream_size; + f->wordstream= (const uint16_t*)(buf + extra + bitstream_size); + f->bytestream= buf + extra + bitstream_size + wordstream_size; init_mv(f); @@ -354,11 +392,13 @@ static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){ dst += 8*stride; } - if(bitstream_size != (get_bits_count(&f->gb)+31)/32*4) + if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4 + || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size + || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size) av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n", bitstream_size - (get_bits_count(&f->gb)+31)/32*4, - bytestream_size - (f->bytestream - (buf + 20 + bitstream_size + wordstream_size)), - wordstream_size - (((uint8_t*)f->wordstream) - (buf + 20 + bitstream_size)) + -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size), + -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size) ); return 0; @@ -366,7 +406,7 @@ static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){ /** * decode block and dequantize. - * Note this is allmost identical to mjpeg + * Note this is almost identical to MJPEG. */ static int decode_i_block(FourXContext *f, DCTELEM *block){ int code, i, j, level, val; @@ -469,14 +509,14 @@ static int decode_i_mb(FourXContext *f){ return 0; } -static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){ +static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){ int frequency[512]; uint8_t flag[512]; int up[512]; uint8_t len_tab[257]; int bits_tab[257]; int start, end; - uint8_t *ptr= buf; + const uint8_t *ptr= buf; int j; memset(frequency, 0, sizeof(frequency)); @@ -489,7 +529,6 @@ static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){ for(i=start; i<=end; i++){ frequency[i]= *ptr++; -// printf("%d %d %d\n", start, end, frequency[i]); } start= *ptr++; if(start==0) break; @@ -500,9 +539,6 @@ static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){ while((ptr - buf)&3) ptr++; // 4byte align -// for(j=0; j<16; j++) -// printf("%2X", ptr[j]); - for(j=257; j<512; j++){ int min_freq[2]= {256*256, 256*256}; int smallest[2]= {0, 0}; @@ -550,16 +586,59 @@ static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){ return ptr; } -static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){ +static int mix(int c0, int c1){ + int blue = 2*(c0&0x001F) + (c1&0x001F); + int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5; + int red = 2*(c0>>10) + (c1>>10); + return red/3*1024 + green/3*32 + blue/3; +} + +static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){ + int x, y, x2, y2; + const int width= f->avctx->width; + const int height= f->avctx->height; + uint16_t *dst= (uint16_t*)f->current_picture.data[0]; + const int stride= f->current_picture.linesize[0]>>1; + + for(y=0; y>2) + 8*(y2>>2); + dst[y2*stride+x2]= color[(bits>>index)&3]; + } + } + dst+=16; + } + dst += 16*stride - width; + } + + return 0; +} + +static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){ int x, y; const int width= f->avctx->width; const int height= f->avctx->height; uint16_t *dst= (uint16_t*)f->current_picture.data[0]; const int stride= f->current_picture.linesize[0]>>1; - const unsigned int bitstream_size= get32(buf); - const int token_count __attribute__((unused)) = get32(buf + bitstream_size + 8); - unsigned int prestream_size= 4*get32(buf + bitstream_size + 4); - uint8_t *prestream= buf + bitstream_size + 12; + const unsigned int bitstream_size= AV_RL32(buf); + const int token_count av_unused = AV_RL32(buf + bitstream_size + 8); + unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4); + const uint8_t *prestream= buf + bitstream_size + 12; if(prestream_size + bitstream_size + 12 != length || bitstream_size > (1<<26) @@ -575,7 +654,7 @@ static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){ prestream_size= length + buf - prestream; f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE); - f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4); + f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4); init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size); f->last_dc= 0*128*8*8; @@ -598,23 +677,23 @@ static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, - uint8_t *buf, int buf_size) + const uint8_t *buf, int buf_size) { FourXContext * const f = avctx->priv_data; AVFrame *picture = data; AVFrame *p, temp; int i, frame_4cc, frame_size; - frame_4cc= get32(buf); - if(buf_size != get32(buf+4)+8){ - av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4)); + frame_4cc= AV_RL32(buf); + if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){ + av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4)); } - if(frame_4cc == ff_get_fourcc("cfrm")){ + if(frame_4cc == AV_RL32("cfrm")){ int free_index=-1; const int data_size= buf_size - 20; - const int id= get32(buf+12); - const int whole_size= get32(buf+16); + const int id= AV_RL32(buf+12); + const int whole_size= AV_RL32(buf+16); CFrameBuffer *cfrm; for(i=0; icfrm[i]; cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE); + if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL + av_log(f->avctx, AV_LOG_ERROR, "realloc falure"); + return -1; + } memcpy(cfrm->data + cfrm->size, buf+20, data_size); cfrm->size += data_size; @@ -647,7 +730,7 @@ static int decode_frame(AVCodecContext *avctx, } cfrm->size= cfrm->id= 0; - frame_4cc= ff_get_fourcc("pfrm"); + frame_4cc= AV_RL32("pfrm"); }else return buf_size; }else{ @@ -673,27 +756,25 @@ static int decode_frame(AVCodecContext *avctx, return -1; } - if(frame_4cc == ff_get_fourcc("ifrm")){ - p->pict_type= I_TYPE; + if(frame_4cc == AV_RL32("ifr2")){ + p->pict_type= FF_I_TYPE; + if(decode_i2_frame(f, buf-4, frame_size) < 0) + return -1; + }else if(frame_4cc == AV_RL32("ifrm")){ + p->pict_type= FF_I_TYPE; if(decode_i_frame(f, buf, frame_size) < 0) return -1; - }else if(frame_4cc == ff_get_fourcc("pfrm")){ - p->pict_type= P_TYPE; + }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){ + p->pict_type= FF_P_TYPE; if(decode_p_frame(f, buf, frame_size) < 0) return -1; - }else if(frame_4cc == ff_get_fourcc("snd_")){ + }else if(frame_4cc == AV_RL32("snd_")){ av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size); }else{ av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size); } -#if 0 -for(i=0; i<20; i++){ - printf("%2X %c ", buf[i], clip(buf[i],16,126)); -} -#endif - - p->key_frame= p->pict_type == I_TYPE; + p->key_frame= p->pict_type == FF_I_TYPE; *picture= *p; *data_size = sizeof(AVPicture); @@ -712,19 +793,26 @@ static void common_init(AVCodecContext *avctx){ f->avctx= avctx; } -static int decode_init(AVCodecContext *avctx){ +static av_cold int decode_init(AVCodecContext *avctx){ FourXContext * const f = avctx->priv_data; + if(avctx->extradata_size != 4 || !avctx->extradata) { + av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n"); + return 1; + } + + f->version= AV_RL32(avctx->extradata)>>16; common_init(avctx); init_vlcs(f); - avctx->pix_fmt= PIX_FMT_RGB565; + if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565; + else avctx->pix_fmt= PIX_FMT_RGB555; return 0; } -static int decode_end(AVCodecContext *avctx){ +static av_cold int decode_end(AVCodecContext *avctx){ FourXContext * const f = avctx->priv_data; int i; @@ -749,5 +837,6 @@ AVCodec fourxm_decoder = { decode_end, decode_frame, /*CODEC_CAP_DR1,*/ + .long_name = NULL_IF_CONFIG_SMALL("4X Movie"), };