00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00030 #include "avcodec.h"
00031 #include "dsputil.h"
00032 #include "mpegvideo.h"
00033
00034
00035
00036
00037 typedef struct MDECContext{
00038 AVCodecContext *avctx;
00039 DSPContext dsp;
00040 AVFrame picture;
00041 PutBitContext pb;
00042 GetBitContext gb;
00043 ScanTable scantable;
00044 int version;
00045 int qscale;
00046 int last_dc[3];
00047 int mb_width;
00048 int mb_height;
00049 int mb_x, mb_y;
00050 DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
00051 DECLARE_ALIGNED_8(uint16_t, intra_matrix[64]);
00052 DECLARE_ALIGNED_8(int, q_intra_matrix[64]);
00053 uint8_t *bitstream_buffer;
00054 unsigned int bitstream_buffer_size;
00055 int block_last_index[6];
00056 } MDECContext;
00057
00058
00059 static inline int mdec_decode_block_intra(MDECContext *a, DCTELEM *block, int n)
00060 {
00061 int level, diff, i, j, run;
00062 int component;
00063 RLTable *rl = &ff_rl_mpeg1;
00064 uint8_t * const scantable= a->scantable.permutated;
00065 const uint16_t *quant_matrix= ff_mpeg1_default_intra_matrix;
00066 const int qscale= a->qscale;
00067
00068
00069 if(a->version==2){
00070 block[0]= 2*get_sbits(&a->gb, 10) + 1024;
00071 }else{
00072 component = (n <= 3 ? 0 : n - 4 + 1);
00073 diff = decode_dc(&a->gb, component);
00074 if (diff >= 0xffff)
00075 return -1;
00076 a->last_dc[component]+= diff;
00077 block[0] = a->last_dc[component]<<3;
00078 }
00079
00080 i = 0;
00081 {
00082 OPEN_READER(re, &a->gb);
00083
00084 for(;;) {
00085 UPDATE_CACHE(re, &a->gb);
00086 GET_RL_VLC(level, run, re, &a->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
00087
00088 if(level == 127){
00089 break;
00090 } else if(level != 0) {
00091 i += run;
00092 j = scantable[i];
00093 level= (level*qscale*quant_matrix[j])>>3;
00094
00095 level = (level ^ SHOW_SBITS(re, &a->gb, 1)) - SHOW_SBITS(re, &a->gb, 1);
00096 LAST_SKIP_BITS(re, &a->gb, 1);
00097 } else {
00098
00099 run = SHOW_UBITS(re, &a->gb, 6)+1; LAST_SKIP_BITS(re, &a->gb, 6);
00100 UPDATE_CACHE(re, &a->gb);
00101 level = SHOW_SBITS(re, &a->gb, 10); SKIP_BITS(re, &a->gb, 10);
00102 i += run;
00103 j = scantable[i];
00104 if(level<0){
00105 level= -level;
00106 level= (level*qscale*quant_matrix[j])>>3;
00107 level= (level-1)|1;
00108 level= -level;
00109 }else{
00110 level= (level*qscale*quant_matrix[j])>>3;
00111 level= (level-1)|1;
00112 }
00113 }
00114 if (i > 63){
00115 av_log(a->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", a->mb_x, a->mb_y);
00116 return -1;
00117 }
00118
00119 block[j] = level;
00120 }
00121 CLOSE_READER(re, &a->gb);
00122 }
00123 a->block_last_index[n] = i;
00124 return 0;
00125 }
00126
00127 static inline int decode_mb(MDECContext *a, DCTELEM block[6][64]){
00128 int i;
00129 const int block_index[6]= {5,4,0,1,2,3};
00130
00131 a->dsp.clear_blocks(block[0]);
00132
00133 for(i=0; i<6; i++){
00134 if( mdec_decode_block_intra(a, block[ block_index[i] ], block_index[i]) < 0)
00135 return -1;
00136 }
00137 return 0;
00138 }
00139
00140 static inline void idct_put(MDECContext *a, int mb_x, int mb_y){
00141 DCTELEM (*block)[64]= a->block;
00142 int linesize= a->picture.linesize[0];
00143
00144 uint8_t *dest_y = a->picture.data[0] + (mb_y * 16* linesize ) + mb_x * 16;
00145 uint8_t *dest_cb = a->picture.data[1] + (mb_y * 8 * a->picture.linesize[1]) + mb_x * 8;
00146 uint8_t *dest_cr = a->picture.data[2] + (mb_y * 8 * a->picture.linesize[2]) + mb_x * 8;
00147
00148 a->dsp.idct_put(dest_y , linesize, block[0]);
00149 a->dsp.idct_put(dest_y + 8, linesize, block[1]);
00150 a->dsp.idct_put(dest_y + 8*linesize , linesize, block[2]);
00151 a->dsp.idct_put(dest_y + 8*linesize + 8, linesize, block[3]);
00152
00153 if(!(a->avctx->flags&CODEC_FLAG_GRAY)){
00154 a->dsp.idct_put(dest_cb, a->picture.linesize[1], block[4]);
00155 a->dsp.idct_put(dest_cr, a->picture.linesize[2], block[5]);
00156 }
00157 }
00158
00159 static int decode_frame(AVCodecContext *avctx,
00160 void *data, int *data_size,
00161 const uint8_t *buf, int buf_size)
00162 {
00163 MDECContext * const a = avctx->priv_data;
00164 AVFrame *picture = data;
00165 AVFrame * const p= (AVFrame*)&a->picture;
00166 int i;
00167
00168 if(p->data[0])
00169 avctx->release_buffer(avctx, p);
00170
00171 p->reference= 0;
00172 if(avctx->get_buffer(avctx, p) < 0){
00173 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00174 return -1;
00175 }
00176 p->pict_type= I_TYPE;
00177 p->key_frame= 1;
00178
00179 a->bitstream_buffer= av_fast_realloc(a->bitstream_buffer, &a->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
00180 for(i=0; i<buf_size; i+=2){
00181 a->bitstream_buffer[i] = buf[i+1];
00182 a->bitstream_buffer[i+1]= buf[i ];
00183 }
00184 init_get_bits(&a->gb, a->bitstream_buffer, buf_size*8);
00185
00186
00187 skip_bits(&a->gb, 32);
00188
00189 a->qscale= get_bits(&a->gb, 16);
00190 a->version= get_bits(&a->gb, 16);
00191
00192 a->last_dc[0]=
00193 a->last_dc[1]=
00194 a->last_dc[2]= 128;
00195
00196
00197
00198 for(a->mb_x=0; a->mb_x<a->mb_width; a->mb_x++){
00199 for(a->mb_y=0; a->mb_y<a->mb_height; a->mb_y++){
00200 if( decode_mb(a, a->block) <0)
00201 return -1;
00202
00203 idct_put(a, a->mb_x, a->mb_y);
00204 }
00205 }
00206
00207
00208
00209
00210 *picture= *(AVFrame*)&a->picture;
00211 *data_size = sizeof(AVPicture);
00212
00213 emms_c();
00214
00215 return (get_bits_count(&a->gb)+31)/32*4;
00216 }
00217
00218 static void mdec_common_init(AVCodecContext *avctx){
00219 MDECContext * const a = avctx->priv_data;
00220
00221 dsputil_init(&a->dsp, avctx);
00222
00223 a->mb_width = (avctx->coded_width + 15) / 16;
00224 a->mb_height = (avctx->coded_height + 15) / 16;
00225
00226 avctx->coded_frame= (AVFrame*)&a->picture;
00227 a->avctx= avctx;
00228 }
00229
00230 static int decode_init(AVCodecContext *avctx){
00231 MDECContext * const a = avctx->priv_data;
00232 AVFrame *p= (AVFrame*)&a->picture;
00233
00234 mdec_common_init(avctx);
00235 init_vlcs();
00236 ff_init_scantable(a->dsp.idct_permutation, &a->scantable, ff_zigzag_direct);
00237
00238
00239
00240
00241
00242
00243 p->qstride= a->mb_width;
00244 p->qscale_table= av_mallocz( p->qstride * a->mb_height);
00245 avctx->pix_fmt= PIX_FMT_YUV420P;
00246
00247 return 0;
00248 }
00249
00250 static int decode_end(AVCodecContext *avctx){
00251 MDECContext * const a = avctx->priv_data;
00252
00253 av_freep(&a->bitstream_buffer);
00254 av_freep(&a->picture.qscale_table);
00255 a->bitstream_buffer_size=0;
00256
00257 return 0;
00258 }
00259
00260 AVCodec mdec_decoder = {
00261 "mdec",
00262 CODEC_TYPE_VIDEO,
00263 CODEC_ID_MDEC,
00264 sizeof(MDECContext),
00265 decode_init,
00266 NULL,
00267 decode_end,
00268 decode_frame,
00269 CODEC_CAP_DR1,
00270 };
00271