libavcodec/svq3.c

   1 /*
   2  * Copyright (c) 2003 The FFmpeg Project.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  *
  19  * How to use this decoder:
  20  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
  21  * have stsd atoms to describe media trak properties. A stsd atom for a
  22  * video trak contains 1 or more ImageDescription atoms. These atoms begin
  23  * with the 4-byte length of the atom followed by the codec fourcc. Some
  24  * decoders need information in this atom to operate correctly. Such
  25  * is the case with SVQ3. In order to get the best use out of this decoder,
  26  * the calling app must make the SVQ3 ImageDescription atom available
  27  * via the AVCodecContext's extradata[_size] field:
  28  *
  29  * AVCodecContext.extradata = pointer to ImageDescription, first characters
  30  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
  31  * AVCodecContext.extradata_size = size of ImageDescription atom memory
  32  * buffer (which will be the same as the ImageDescription atom size field
  33  * from the QT file, minus 4 bytes since the length is missing)
  34  *
  35  * You will know you have these parameters passed correctly when the decoder
  36  * correctly decodes this file:
  37  *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
  38  *
  39  */
  40
  41 /**
  42  * @file svq3.c
  43  * svq3 decoder.
  44  */
  45
  46 #define FULLPEL_MODE  1
  47 #define HALFPEL_MODE  2
  48 #define THIRDPEL_MODE 3
  49
  50 /* dual scan (from some older h264 draft)
  51  o-->o-->o   o
  52          |  /|
  53  o   o   o / o
  54  | / |   |/  |
  55  o   o   o   o
  56    /
  57  o-->o-->o-->o
  58 */
  59 static const uint8_t svq3_scan[16]={
  60  0+0*4, 1+0*4, 2+0*4, 2+1*4,
  61  2+2*4, 3+0*4, 3+1*4, 3+2*4,
  62  0+1*4, 0+2*4, 1+1*4, 1+2*4,
  63  0+3*4, 1+3*4, 2+3*4, 3+3*4,
  64 };
  65
  66 static const uint8_t svq3_pred_0[25][2] = {
  67   { 0, 0 },
  68   { 1, 0 }, { 0, 1 },
  69   { 0, 2 }, { 1, 1 }, { 2, 0 },
  70   { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
  71   { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
  72   { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
  73   { 2, 4 }, { 3, 3 }, { 4, 2 },
  74   { 4, 3 }, { 3, 4 },
  75   { 4, 4 }
  76 };
  77
  78 static const int8_t svq3_pred_1[6][6][5] = {
  79   { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
  80     { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
  81   { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
  82     { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
  83   { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
  84     { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
  85   { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
  86     { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
  87   { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
  88     { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
  89   { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
  90     { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
  91 };
  92
  93 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
  94   { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
  95     { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
  96   { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
  97     { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
  98 };
  99
 100 static const uint32_t svq3_dequant_coeff[32] = {
 101    3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
 102    9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
 103   24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
 104   61694, 68745, 77615, 89113,100253,109366,126635,141533
 105 };
 106
 107
 108 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
 109     const int qmul= svq3_dequant_coeff[qp];
 110 #define stride 16
 111     int i;
 112     int temp[16];
 113     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
 114     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
 115
 116     for(i=0; i<4; i++){
 117         const int offset= y_offset[i];
 118         const int z0= 13*(block[offset+stride*0] +    block[offset+stride*4]);
 119         const int z1= 13*(block[offset+stride*0] -    block[offset+stride*4]);
 120         const int z2=  7* block[offset+stride*1] - 17*block[offset+stride*5];
 121         const int z3= 17* block[offset+stride*1] +  7*block[offset+stride*5];
 122
 123         temp[4*i+0]= z0+z3;
 124         temp[4*i+1]= z1+z2;
 125         temp[4*i+2]= z1-z2;
 126         temp[4*i+3]= z0-z3;
 127     }
 128
 129     for(i=0; i<4; i++){
 130         const int offset= x_offset[i];
 131         const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
 132         const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
 133         const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
 134         const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
 135
 136         block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
 137         block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
 138         block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
 139         block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
 140     }
 141 }
 142 #undef stride
 143
 144 static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
 145     const int qmul= svq3_dequant_coeff[qp];
 146     int i;
 147     uint8_t *cm = cropTbl + MAX_NEG_CROP;
 148
 149     if (dc) {
 150         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
 151         block[0] = 0;
 152     }
 153
 154     for (i=0; i < 4; i++) {
 155         const int z0= 13*(block[0 + 4*i] +    block[2 + 4*i]);
 156         const int z1= 13*(block[0 + 4*i] -    block[2 + 4*i]);
 157         const int z2=  7* block[1 + 4*i] - 17*block[3 + 4*i];
 158         const int z3= 17* block[1 + 4*i] +  7*block[3 + 4*i];
 159
 160         block[0 + 4*i]= z0 + z3;
 161         block[1 + 4*i]= z1 + z2;
 162         block[2 + 4*i]= z1 - z2;
 163         block[3 + 4*i]= z0 - z3;
 164     }
 165
 166     for (i=0; i < 4; i++) {
 167         const int z0= 13*(block[i + 4*0] +    block[i + 4*2]);
 168         const int z1= 13*(block[i + 4*0] -    block[i + 4*2]);
 169         const int z2=  7* block[i + 4*1] - 17*block[i + 4*3];
 170         const int z3= 17* block[i + 4*1] +  7*block[i + 4*3];
 171         const int rr= (dc + 0x80000);
 172
 173         dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
 174         dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
 175         dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
 176         dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
 177     }
 178 }
 179
 180 static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
 181     LOAD_TOP_EDGE
 182     LOAD_LEFT_EDGE
 183     const __attribute__((unused)) int unu0= t0;
 184     const __attribute__((unused)) int unu1= l0;
 185
 186     src[0+0*stride]=(l1 + t1)>>1;
 187     src[1+0*stride]=
 188     src[0+1*stride]=(l2 + t2)>>1;
 189     src[2+0*stride]=
 190     src[1+1*stride]=
 191     src[0+2*stride]=
 192     src[3+0*stride]=
 193     src[2+1*stride]=
 194     src[1+2*stride]=
 195     src[0+3*stride]=
 196     src[3+1*stride]=
 197     src[2+2*stride]=
 198     src[1+3*stride]=
 199     src[3+2*stride]=
 200     src[2+3*stride]=
 201     src[3+3*stride]=(l3 + t3)>>1;
 202 }
 203
 204 static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
 205     pred16x16_plane_compat_c(src, stride, 1);
 206 }
 207
 208 static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
 209                                      int index, const int type) {
 210
 211   static const uint8_t *const scan_patterns[4] =
 212   { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
 213
 214   int run, level, sign, vlc, limit;
 215   const int intra = (3 * type) >> 2;
 216   const uint8_t *const scan = scan_patterns[type];
 217
 218   for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
 219     for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
 220
 221       if (vlc == INVALID_VLC)
 222         return -1;
 223
 224       sign = (vlc & 0x1) - 1;
 225       vlc  = (vlc + 1) >> 1;
 226
 227       if (type == 3) {
 228         if (vlc < 3) {
 229           run   = 0;
 230           level = vlc;
 231         } else if (vlc < 4) {
 232           run   = 1;
 233           level = 1;
 234         } else {
 235           run   = (vlc & 0x3);
 236           level = ((vlc + 9) >> 2) - run;
 237         }
 238       } else {
 239         if (vlc < 16) {
 240           run   = svq3_dct_tables[intra][vlc].run;
 241           level = svq3_dct_tables[intra][vlc].level;
 242         } else if (intra) {
 243           run   = (vlc & 0x7);
 244           level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 245         } else {
 246           run   = (vlc & 0xF);
 247           level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 248         }
 249       }
 250
 251       if ((index += run) >= limit)
 252         return -1;
 253
 254       block[scan[index]] = (level ^ sign) - sign;
 255     }
 256
 257     if (type != 2) {
 258       break;
 259     }
 260   }
 261
 262   return 0;
 263 }
 264
 265 static inline void svq3_mc_dir_part (MpegEncContext *s, int x, int y,
 266                                      int width, int height, int mx, int my, int dxy, int thirdpel) {
 267   uint8_t *src, *dest;
 268   int i, emu = 0;
 269   int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
 270
 271   mx += x;
 272   my += y;
 273
 274   if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
 275       my < 0 || my >= (s->v_edge_pos - height - 1)) {
 276
 277     if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
 278       emu = 1;
 279     }
 280
 281     mx = clip (mx, -16, (s->h_edge_pos - width  + 15));
 282     my = clip (my, -16, (s->v_edge_pos - height + 15));
 283   }
 284
 285   /* form component predictions */
 286   dest = s->current_picture.data[0] + x + y*s->linesize;
 287   src  = s->last_picture.data[0] + mx + my*s->linesize;
 288
 289   if (emu) {
 290     ff_emulated_edge_mc (s, src, s->linesize, (width + 1), (height + 1),
 291                          mx, my, s->h_edge_pos, s->v_edge_pos);
 292     src = s->edge_emu_buffer;
 293   }
 294   if(thirdpel)
 295     s->dsp.put_tpel_pixels_tab[dxy](dest, src, s->linesize, width, height);
 296   else
 297     s->dsp.put_pixels_tab[blocksize][dxy](dest, src, s->linesize, height);
 298
 299   if (!(s->flags & CODEC_FLAG_GRAY)) {
 300     mx     = (mx + (mx < (int) x)) >> 1;
 301     my     = (my + (my < (int) y)) >> 1;
 302     width  = (width  >> 1);
 303     height = (height >> 1);
 304     blocksize++;
 305
 306     for (i=1; i < 3; i++) {
 307       dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
 308       src  = s->last_picture.data[i] + mx + my*s->uvlinesize;
 309
 310       if (emu) {
 311         ff_emulated_edge_mc (s, src, s->uvlinesize, (width + 1), (height + 1),
 312                              mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
 313         src = s->edge_emu_buffer;
 314       }
 315       if(thirdpel)
 316         s->dsp.put_tpel_pixels_tab[dxy](dest, src, s->uvlinesize, width, height);
 317       else
 318         s->dsp.put_pixels_tab[blocksize][dxy](dest, src, s->uvlinesize, height);
 319     }
 320   }
 321 }
 322
 323 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
 324   int cbp, dir, mode, mx, my, dx, dy, x, y, part_width, part_height;
 325   int i, j, k, l, m;
 326   uint32_t vlc;
 327   int8_t *top, *left;
 328   MpegEncContext *const s = (MpegEncContext *) h;
 329   const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
 330   const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
 331
 332   h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 333   h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 334   h->topright_samples_available = 0xFFFF;
 335
 336   if (mb_type == 0) {           /* SKIP */
 337     svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0);
 338
 339     cbp = 0;
 340     mb_type = MB_TYPE_SKIP;
 341   } else if (mb_type < 8) {     /* INTER */
 342     if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) {
 343       mode = THIRDPEL_MODE;
 344     } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) {
 345       mode = HALFPEL_MODE;
 346     } else {
 347       mode = FULLPEL_MODE;
 348     }
 349
 350     /* fill caches */
 351     /* note ref_cache[0] should contain here:
 352         ????????
 353         ???11111
 354         N??11111
 355         N??11111
 356         N??11111
 357         N
 358     */
 359
 360     if (s->mb_x > 0) {
 361       for (i=0; i < 4; i++) {
 362         *(uint32_t *) h->mv_cache[0][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - 1 + i*h->b_stride];
 363       }
 364     } else {
 365       for (i=0; i < 4; i++) {
 366         *(uint32_t *) h->mv_cache[0][scan8[0] - 1 + i*8] = 0;
 367       }
 368     }
 369     if (s->mb_y > 0) {
 370       memcpy (h->mv_cache[0][scan8[0] - 1*8], s->current_picture.motion_val[0][b_xy - h->b_stride], 4*2*sizeof(int16_t));
 371       memset (&h->ref_cache[0][scan8[0] - 1*8], 1, 4);
 372
 373       if (s->mb_x < (s->mb_width - 1)) {
 374         *(uint32_t *) h->mv_cache[0][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - h->b_stride + 4];
 375         h->ref_cache[0][scan8[0] + 4 - 1*8] = 1;
 376       }else
 377         h->ref_cache[0][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
 378       if (s->mb_x > 0) {
 379         *(uint32_t *) h->mv_cache[0][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - h->b_stride - 1];
 380         h->ref_cache[0][scan8[0] - 1 - 1*8] = 1;
 381       }else
 382         h->ref_cache[0][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
 383     }else
 384       memset (&h->ref_cache[0][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
 385
 386     /* decode motion vector(s) and form prediction(s) */
 387     part_width  = ((mb_type & 5) == 5) ? 4 : 8 << (mb_type & 1);
 388     part_height = 16 >> ((unsigned) mb_type / 3);
 389
 390     for (i=0; i < 16; i+=part_height) {
 391       for (j=0; j < 16; j+=part_width) {
 392         int dxy;
 393         x = 16*s->mb_x + j;
 394         y = 16*s->mb_y + i;
 395         k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
 396
 397         pred_motion (h, k, (part_width >> 2), 0, 1, &mx, &my);
 398
 399         /* clip motion vector prediction to frame border */
 400         mx = clip (mx, -6*x, 6*(s->h_edge_pos - part_width  - x));
 401         my = clip (my, -6*y, 6*(s->v_edge_pos - part_height - y));
 402
 403         /* get motion vector differential */
 404         dy = svq3_get_se_golomb (&s->gb);
 405         dx = svq3_get_se_golomb (&s->gb);
 406
 407         if (dx == INVALID_VLC || dy == INVALID_VLC) {
 408           return -1;
 409         }
 410         /* compute motion vector */
 411         if (mode == THIRDPEL_MODE) {
 412           int fx, fy;
 413           mx = ((mx + 1)>>1) + dx;
 414           my = ((my + 1)>>1) + dy;
 415           fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
 416           fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
 417           dxy= (mx - 3*fx) + 4*(my - 3*fy);
 418
 419           svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1);
 420           mx += mx;
 421           my += my;
 422         } else if (mode == HALFPEL_MODE) {
 423           mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
 424           my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
 425           dxy= (mx&1) + 2*(my&1);
 426
 427           svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0);
 428           mx *= 3;
 429           my *= 3;
 430         } else {
 431           assert(mode == FULLPEL_MODE);
 432           mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
 433           my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
 434
 435           svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0);
 436           mx *= 6;
 437           my *= 6;
 438         }
 439
 440         /* update mv_cache */
 441         fill_rectangle(h->mv_cache[0][scan8[k]], part_width>>2, part_height>>2, 8, pack16to32(mx,my), 4);
 442       }
 443     }
 444
 445     for (i=0; i < 4; i++) {
 446       memcpy (s->current_picture.motion_val[0][b_xy + i*h->b_stride], h->mv_cache[0][scan8[0] + 8*i], 4*2*sizeof(int16_t));
 447     }
 448
 449     if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
 450       return -1;
 451
 452     cbp = golomb_to_inter_cbp[vlc];
 453     mb_type = MB_TYPE_16x16;
 454   } else if (mb_type == 8) {    /* INTRA4x4 */
 455     memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
 456
 457     if (s->mb_x > 0) {
 458       for (i=0; i < 4; i++) {
 459         h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
 460       }
 461     }
 462     if (s->mb_y > 0) {
 463       h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
 464       h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
 465       h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
 466       h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
 467     }
 468
 469     /* decode prediction codes for luma blocks */
 470     for (i=0; i < 16; i+=2) {
 471       vlc = svq3_get_ue_golomb (&s->gb);
 472
 473       if (vlc >= 25)
 474         return -1;
 475
 476       left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 477       top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 478
 479       left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 480       left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 481
 482       if (left[1] == -1 || left[2] == -1)
 483         return -1;
 484     }
 485
 486     write_back_intra_pred_mode (h);
 487     check_intra4x4_pred_mode (h);
 488
 489     if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48)
 490       return -1;
 491
 492     cbp = golomb_to_intra4x4_cbp[vlc];
 493     mb_type = MB_TYPE_INTRA4x4;
 494   } else {                      /* INTRA16x16 */
 495     dir = i_mb_type_info[mb_type - 8].pred_mode;
 496     dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
 497
 498     if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1)
 499       return -1;
 500
 501     cbp = i_mb_type_info[mb_type - 8].cbp;
 502     mb_type = MB_TYPE_INTRA16x16;
 503   }
 504
 505   if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
 506     for (i=0; i < 4; i++) {
 507       memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 508     }
 509   }
 510   if (!IS_INTRA4x4(mb_type)) {
 511     memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
 512   }
 513   if (!IS_SKIP(mb_type)) {
 514     memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
 515     s->dsp.clear_blocks(h->mb);
 516   }
 517
 518   if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
 519     s->qscale += svq3_get_se_golomb (&s->gb);
 520
 521     if (s->qscale > 31)
 522       return -1;
 523   }
 524   if (IS_INTRA16x16(mb_type)) {
 525     if (svq3_decode_block (&s->gb, h->mb, 0, 0))
 526       return -1;
 527   }
 528
 529   if (!IS_SKIP(mb_type) && cbp) {
 530     l = IS_INTRA16x16(mb_type) ? 1 : 0;
 531     m = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 532
 533     for (i=0; i < 4; i++) {
 534       if ((cbp & (1 << i))) {
 535         for (j=0; j < 4; j++) {
 536           k = l ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
 537           h->non_zero_count_cache[ scan8[k] ] = 1;
 538
 539           if (svq3_decode_block (&s->gb, &h->mb[16*k], l, m))
 540             return -1;
 541         }
 542       }
 543     }
 544
 545     if ((cbp & 0x30)) {
 546       for (i=0; i < 2; ++i) {
 547         if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3))
 548           return -1;
 549       }
 550
 551       if ((cbp & 0x20)) {
 552         for (i=0; i < 8; i++) {
 553           h->non_zero_count_cache[ scan8[16+i] ] = 1;
 554
 555           if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1))
 556             return -1;
 557         }
 558       }
 559     }
 560   }
 561
 562   s->current_picture.mb_type[mb_xy] = mb_type;
 563
 564   if (IS_INTRA(mb_type)) {
 565     h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
 566   }
 567
 568   return 0;
 569 }
 570
 571 static int svq3_decode_frame (AVCodecContext *avctx,
 572                               void *data, int *data_size,
 573                               uint8_t *buf, int buf_size) {
 574   MpegEncContext *const s = avctx->priv_data;
 575   H264Context *const h = avctx->priv_data;
 576   int i;
 577
 578   s->flags = avctx->flags;
 579
 580   if (!s->context_initialized) {
 581     s->width = avctx->width;
 582     s->height = avctx->height;
 583     h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
 584     h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
 585     h->halfpel_flag = 1;
 586     h->thirdpel_flag = 1;
 587     h->chroma_qp = 4;
 588
 589     if (MPV_common_init (s) < 0)
 590       return -1;
 591
 592     h->b_stride = 4*s->mb_width;
 593
 594     alloc_tables (h);
 595   }
 596
 597   s->low_delay= 1;
 598
 599   if (avctx->extradata && avctx->extradata_size >= 0x63
 600       && !memcmp (avctx->extradata, "SVQ3", 4)) {
 601
 602     uint8_t *stsd = (uint8_t *) avctx->extradata + 0x62;
 603
 604     if ((*stsd >> 5) != 7 || avctx->extradata_size >= 0x66) {
 605
 606       if ((*stsd >> 5) == 7) {
 607         stsd += 3;      /* skip width, height (12 bits each) */
 608       }
 609
 610       h->halfpel_flag = (*stsd >> 4) & 1;
 611       h->thirdpel_flag = (*stsd >> 3) & 1;
 612     }
 613   }
 614
 615   if ((buf[0] & 0x9F) != 1) {
 616     /* TODO: what? */
 617     fprintf (stderr, "unsupported header (%02X)\n", buf[0]);
 618     return -1;
 619   } else {
 620     int length = (buf[0] >> 5) & 3;
 621     int offset = 0;
 622
 623     for (i=0; i < length; i++) {
 624       offset = (offset << 8) | buf[i + 1];
 625     }
 626
 627     if (buf_size < (offset + length + 1) || length == 0)
 628       return -1;
 629
 630     memcpy (&buf[2], &buf[offset + 2], (length - 1));
 631   }
 632
 633   init_get_bits (&s->gb, &buf[2], 8*(buf_size - 2));
 634
 635   if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3)
 636     return -1;
 637
 638   s->pict_type = golomb_to_pict_type[i];
 639
 640   /* unknown fields */
 641   get_bits (&s->gb, 1);
 642   get_bits (&s->gb, 8);
 643
 644   s->qscale = get_bits (&s->gb, 5);
 645   s->adaptive_quant = get_bits (&s->gb, 1);
 646
 647   /* unknown fields */
 648   get_bits (&s->gb, 1);
 649   get_bits (&s->gb, 1);
 650   get_bits (&s->gb, 2);
 651
 652   while (get_bits (&s->gb, 1)) {
 653     get_bits (&s->gb, 8);
 654   }
 655
 656   if(avctx->debug&FF_DEBUG_PICT_INFO){
 657       printf("%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
 658       av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
 659       s->adaptive_quant, s->qscale
 660       );
 661   }
 662
 663   /* B-frames are not supported */
 664   if (s->pict_type == B_TYPE/* && avctx->hurry_up*/)
 665     return buf_size;
 666
 667   frame_start (h);
 668
 669   for(i=0; i<4; i++){
 670     int j;
 671     for(j=-1; j<4; j++)
 672       h->ref_cache[0][scan8[0] + 8*i + j]= 1;
 673     h->ref_cache[0][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
 674   }
 675
 676   for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
 677     for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
 678       int mb_type = svq3_get_ue_golomb (&s->gb);
 679
 680       if (s->pict_type == I_TYPE) {
 681         mb_type += 8;
 682       }
 683       if (mb_type > 32 || svq3_decode_mb (h, mb_type)) {
 684         fprintf (stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
 685         return -1;
 686       }
 687
 688       if (mb_type != 0) {
 689         hl_decode_mb (h);
 690       }
 691     }
 692
 693     ff_draw_horiz_band(s, 16*s->mb_y, 16);
 694   }
 695
 696   *(AVFrame *) data = *(AVFrame *) &s->current_picture;
 697   *data_size = sizeof(AVFrame);
 698
 699   MPV_frame_end(s);
 700
 701   return buf_size;
 702 }
 703
 704
 705 AVCodec svq3_decoder = {
 706     "svq3",
 707     CODEC_TYPE_VIDEO,
 708     CODEC_ID_SVQ3,
 709     sizeof(H264Context),
 710     decode_init,
 711     NULL,
 712     decode_end,
 713     svq3_decode_frame,
 714     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
 715 };