git.sesse.net Git - ffmpeg/blob - libavcodec/msmpeg4.c

   1 /*
   2  * MSMPEG4 backend for encoder and decoder
   3  * Copyright (c) 2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * MSMPEG4 backend for encoder and decoder
  28  */
  29
  30 #include "avcodec.h"
  31 #include "dsputil.h"
  32 #include "mpegvideo.h"
  33 #include "msmpeg4.h"
  34 #include "libavutil/x86/asm.h"
  35 #include "h263.h"
  36 #include "mpeg4video.h"
  37 #include "msmpeg4data.h"
  38 #include "vc1data.h"
  39 #include "libavutil/imgutils.h"
  40
  41 /*
  42  * You can also call this codec : MPEG4 with a twist !
  43  *
  44  * TODO:
  45  *        - (encoding) select best mv table (two choices)
  46  *        - (encoding) select best vlc/dc table
  47  */
  48
  49 /* This table is practically identical to the one from h263
  50  * except that it is inverted. */
  51 static av_cold void init_h263_dc_for_msmpeg4(void)
  52 {
  53         int level, uni_code, uni_len;
  54
  55         if(ff_v2_dc_chroma_table[255 + 256][1])
  56             return;
  57
  58         for(level=-256; level<256; level++){
  59             int size, v, l;
  60             /* find number of bits */
  61             size = 0;
  62             v = abs(level);
  63             while (v) {
  64                 v >>= 1;
  65                     size++;
  66             }
  67
  68             if (level < 0)
  69                 l= (-level) ^ ((1 << size) - 1);
  70             else
  71                 l= level;
  72
  73             /* luminance h263 */
  74             uni_code= ff_mpeg4_DCtab_lum[size][0];
  75             uni_len = ff_mpeg4_DCtab_lum[size][1];
  76             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
  77
  78             if (size > 0) {
  79                 uni_code<<=size; uni_code|=l;
  80                 uni_len+=size;
  81                 if (size > 8){
  82                     uni_code<<=1; uni_code|=1;
  83                     uni_len++;
  84                 }
  85             }
  86             ff_v2_dc_lum_table[level + 256][0] = uni_code;
  87             ff_v2_dc_lum_table[level + 256][1] = uni_len;
  88
  89             /* chrominance h263 */
  90             uni_code= ff_mpeg4_DCtab_chrom[size][0];
  91             uni_len = ff_mpeg4_DCtab_chrom[size][1];
  92             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
  93
  94             if (size > 0) {
  95                 uni_code<<=size; uni_code|=l;
  96                 uni_len+=size;
  97                 if (size > 8){
  98                     uni_code<<=1; uni_code|=1;
  99                     uni_len++;
 100                 }
 101             }
 102             ff_v2_dc_chroma_table[level + 256][0] = uni_code;
 103             ff_v2_dc_chroma_table[level + 256][1] = uni_len;
 104
 105         }
 106 }
 107
 108 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
 109 {
 110     switch(s->msmpeg4_version){
 111     case 1:
 112     case 2:
 113         s->y_dc_scale_table=
 114         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 115         break;
 116     case 3:
 117         if(s->workaround_bugs){
 118             s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
 119             s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
 120         } else{
 121             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
 122             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
 123         }
 124         break;
 125     case 4:
 126     case 5:
 127         s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
 128         s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
 129         break;
 130 #if CONFIG_VC1_DECODER
 131     case 6:
 132         s->y_dc_scale_table= ff_wmv3_dc_scale_table;
 133         s->c_dc_scale_table= ff_wmv3_dc_scale_table;
 134         break;
 135 #endif
 136
 137     }
 138
 139
 140     if(s->msmpeg4_version>=4){
 141         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_wmv1_scantable[1]);
 142         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
 143         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
 144         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_wmv1_scantable[0]);
 145     }
 146     //Note the default tables are set in common_init in mpegvideo.c
 147
 148     init_h263_dc_for_msmpeg4();
 149 }
 150
 151 /* predict coded block */
 152 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
 153 {
 154     int xy, wrap, pred, a, b, c;
 155
 156     xy = s->block_index[n];
 157     wrap = s->b8_stride;
 158
 159     /* B C
 160      * A X
 161      */
 162     a = s->coded_block[xy - 1       ];
 163     b = s->coded_block[xy - 1 - wrap];
 164     c = s->coded_block[xy     - wrap];
 165
 166     if (b == c) {
 167         pred = a;
 168     } else {
 169         pred = c;
 170     }
 171
 172     /* store value */
 173     *coded_block_ptr = &s->coded_block[xy];
 174
 175     return pred;
 176 }
 177
 178 static int get_dc(uint8_t *src, int stride, int scale, int block_size)
 179 {
 180     int y;
 181     int sum=0;
 182     for(y=0; y<block_size; y++){
 183         int x;
 184         for(x=0; x<block_size; x++){
 185             sum+=src[x + y*stride];
 186         }
 187     }
 188     return FASTDIV((sum + (scale>>1)), scale);
 189 }
 190
 191 /* dir = 0: left, dir = 1: top prediction */
 192 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
 193                        int16_t **dc_val_ptr, int *dir_ptr)
 194 {
 195     int a, b, c, wrap, pred, scale;
 196     int16_t *dc_val;
 197
 198     /* find prediction */
 199     if (n < 4) {
 200         scale = s->y_dc_scale;
 201     } else {
 202         scale = s->c_dc_scale;
 203     }
 204
 205     wrap = s->block_wrap[n];
 206     dc_val= s->dc_val[0] + s->block_index[n];
 207
 208     /* B C
 209      * A X
 210      */
 211     a = dc_val[ - 1];
 212     b = dc_val[ - 1 - wrap];
 213     c = dc_val[ - wrap];
 214
 215     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
 216         b=c=1024;
 217     }
 218
 219     /* XXX: the following solution consumes divisions, but it does not
 220        necessitate to modify mpegvideo.c. The problem comes from the
 221        fact they decided to store the quantized DC (which would lead
 222        to problems if Q could vary !) */
 223 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
 224     __asm__ volatile(
 225         "movl %3, %%eax         \n\t"
 226         "shrl $1, %%eax         \n\t"
 227         "addl %%eax, %2         \n\t"
 228         "addl %%eax, %1         \n\t"
 229         "addl %0, %%eax         \n\t"
 230         "imull %4               \n\t"
 231         "movl %%edx, %0         \n\t"
 232         "movl %1, %%eax         \n\t"
 233         "imull %4               \n\t"
 234         "movl %%edx, %1         \n\t"
 235         "movl %2, %%eax         \n\t"
 236         "imull %4               \n\t"
 237         "movl %%edx, %2         \n\t"
 238         : "+b" (a), "+c" (b), "+D" (c)
 239         : "g" (scale), "S" (ff_inverse[scale])
 240         : "%eax", "%edx"
 241     );
 242 #else
 243     /* #elif ARCH_ALPHA */
 244     /* Divisions are extremely costly on Alpha; optimize the most
 245        common case. But they are costly everywhere...
 246      */
 247     if (scale == 8) {
 248         a = (a + (8 >> 1)) / 8;
 249         b = (b + (8 >> 1)) / 8;
 250         c = (c + (8 >> 1)) / 8;
 251     } else {
 252         a = FASTDIV((a + (scale >> 1)), scale);
 253         b = FASTDIV((b + (scale >> 1)), scale);
 254         c = FASTDIV((c + (scale >> 1)), scale);
 255     }
 256 #endif
 257     /* XXX: WARNING: they did not choose the same test as MPEG4. This
 258        is very important ! */
 259     if(s->msmpeg4_version>3){
 260         if(s->inter_intra_pred){
 261             uint8_t *dest;
 262             int wrap;
 263
 264             if(n==1){
 265                 pred=a;
 266                 *dir_ptr = 0;
 267             }else if(n==2){
 268                 pred=c;
 269                 *dir_ptr = 1;
 270             }else if(n==3){
 271                 if (abs(a - b) < abs(b - c)) {
 272                     pred = c;
 273                     *dir_ptr = 1;
 274                 } else {
 275                     pred = a;
 276                     *dir_ptr = 0;
 277                 }
 278             }else{
 279                 int bs = 8 >> s->avctx->lowres;
 280                 if(n<4){
 281                     wrap= s->linesize;
 282                     dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * bs*  wrap ) + ((n & 1) + 2*s->mb_x) * bs;
 283                 }else{
 284                     wrap= s->uvlinesize;
 285                     dest= s->current_picture.f.data[n - 3] + (s->mb_y * bs * wrap) + s->mb_x * bs;
 286                 }
 287                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
 288                 else           a= get_dc(dest-bs, wrap, scale*8>>(2*s->avctx->lowres), bs);
 289                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
 290                 else           c= get_dc(dest-bs*wrap, wrap, scale*8>>(2*s->avctx->lowres), bs);
 291
 292                 if (s->h263_aic_dir==0) {
 293                     pred= a;
 294                     *dir_ptr = 0;
 295                 }else if (s->h263_aic_dir==1) {
 296                     if(n==0){
 297                         pred= c;
 298                         *dir_ptr = 1;
 299                     }else{
 300                         pred= a;
 301                         *dir_ptr = 0;
 302                     }
 303                 }else if (s->h263_aic_dir==2) {
 304                     if(n==0){
 305                         pred= a;
 306                         *dir_ptr = 0;
 307                     }else{
 308                         pred= c;
 309                         *dir_ptr = 1;
 310                     }
 311                 } else {
 312                     pred= c;
 313                     *dir_ptr = 1;
 314                 }
 315             }
 316         }else{
 317             if (abs(a - b) < abs(b - c)) {
 318                 pred = c;
 319                 *dir_ptr = 1;
 320             } else {
 321                 pred = a;
 322                 *dir_ptr = 0;
 323             }
 324         }
 325     }else{
 326         if (abs(a - b) <= abs(b - c)) {
 327             pred = c;
 328             *dir_ptr = 1;
 329         } else {
 330             pred = a;
 331             *dir_ptr = 0;
 332         }
 333     }
 334
 335     /* update predictor */
 336     *dc_val_ptr = &dc_val[0];
 337     return pred;
 338 }
 339