libavcodec/svq3.c

   1 /*
   2  * Copyright (c) 2003 The FFmpeg Project.
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /*
  22  * How to use this decoder:
  23  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
  24  * have stsd atoms to describe media trak properties. A stsd atom for a
  25  * video trak contains 1 or more ImageDescription atoms. These atoms begin
  26  * with the 4-byte length of the atom followed by the codec fourcc. Some
  27  * decoders need information in this atom to operate correctly. Such
  28  * is the case with SVQ3. In order to get the best use out of this decoder,
  29  * the calling app must make the SVQ3 ImageDescription atom available
  30  * via the AVCodecContext's extradata[_size] field:
  31  *
  32  * AVCodecContext.extradata = pointer to ImageDescription, first characters
  33  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
  34  * AVCodecContext.extradata_size = size of ImageDescription atom memory
  35  * buffer (which will be the same as the ImageDescription atom size field
  36  * from the QT file, minus 4 bytes since the length is missing)
  37  *
  38  * You will know you have these parameters passed correctly when the decoder
  39  * correctly decodes this file:
  40  *  ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
  41  */
  42
  43 /**
  44  * @file svq3.c
  45  * svq3 decoder.
  46  */
  47
  48 #define FULLPEL_MODE  1
  49 #define HALFPEL_MODE  2
  50 #define THIRDPEL_MODE 3
  51 #define PREDICT_MODE  4
  52
  53 /* dual scan (from some older h264 draft)
  54  o-->o-->o   o
  55          |  /|
  56  o   o   o / o
  57  | / |   |/  |
  58  o   o   o   o
  59    /
  60  o-->o-->o-->o
  61 */
  62 static const uint8_t svq3_scan[16]={
  63  0+0*4, 1+0*4, 2+0*4, 2+1*4,
  64  2+2*4, 3+0*4, 3+1*4, 3+2*4,
  65  0+1*4, 0+2*4, 1+1*4, 1+2*4,
  66  0+3*4, 1+3*4, 2+3*4, 3+3*4,
  67 };
  68
  69 static const uint8_t svq3_pred_0[25][2] = {
  70   { 0, 0 },
  71   { 1, 0 }, { 0, 1 },
  72   { 0, 2 }, { 1, 1 }, { 2, 0 },
  73   { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
  74   { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
  75   { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
  76   { 2, 4 }, { 3, 3 }, { 4, 2 },
  77   { 4, 3 }, { 3, 4 },
  78   { 4, 4 }
  79 };
  80
  81 static const int8_t svq3_pred_1[6][6][5] = {
  82   { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
  83     { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
  84   { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
  85     { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
  86   { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
  87     { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
  88   { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
  89     { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
  90   { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
  91     { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
  92   { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
  93     { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
  94 };
  95
  96 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
  97   { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
  98     { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
  99   { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
 100     { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
 101 };
 102
 103 static const uint32_t svq3_dequant_coeff[32] = {
 104    3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
 105    9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
 106   24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
 107   61694, 68745, 77615, 89113,100253,109366,126635,141533
 108 };
 109
 110
 111 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
 112     const int qmul= svq3_dequant_coeff[qp];
 113 #define stride 16
 114     int i;
 115     int temp[16];
 116     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
 117     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
 118
 119     for(i=0; i<4; i++){
 120         const int offset= y_offset[i];
 121         const int z0= 13*(block[offset+stride*0] +    block[offset+stride*4]);
 122         const int z1= 13*(block[offset+stride*0] -    block[offset+stride*4]);
 123         const int z2=  7* block[offset+stride*1] - 17*block[offset+stride*5];
 124         const int z3= 17* block[offset+stride*1] +  7*block[offset+stride*5];
 125
 126         temp[4*i+0]= z0+z3;
 127         temp[4*i+1]= z1+z2;
 128         temp[4*i+2]= z1-z2;
 129         temp[4*i+3]= z0-z3;
 130     }
 131
 132     for(i=0; i<4; i++){
 133         const int offset= x_offset[i];
 134         const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
 135         const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
 136         const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
 137         const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
 138
 139         block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
 140         block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
 141         block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
 142         block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
 143     }
 144 }
 145 #undef stride
 146
 147 static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
 148     const int qmul= svq3_dequant_coeff[qp];
 149     int i;
 150     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 151
 152     if (dc) {
 153         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
 154         block[0] = 0;
 155     }
 156
 157     for (i=0; i < 4; i++) {
 158         const int z0= 13*(block[0 + 4*i] +    block[2 + 4*i]);
 159         const int z1= 13*(block[0 + 4*i] -    block[2 + 4*i]);
 160         const int z2=  7* block[1 + 4*i] - 17*block[3 + 4*i];
 161         const int z3= 17* block[1 + 4*i] +  7*block[3 + 4*i];
 162
 163         block[0 + 4*i]= z0 + z3;
 164         block[1 + 4*i]= z1 + z2;
 165         block[2 + 4*i]= z1 - z2;
 166         block[3 + 4*i]= z0 - z3;
 167     }
 168
 169     for (i=0; i < 4; i++) {
 170         const int z0= 13*(block[i + 4*0] +    block[i + 4*2]);
 171         const int z1= 13*(block[i + 4*0] -    block[i + 4*2]);
 172         const int z2=  7* block[i + 4*1] - 17*block[i + 4*3];
 173         const int z3= 17* block[i + 4*1] +  7*block[i + 4*3];
 174         const int rr= (dc + 0x80000);
 175
 176         dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
 177         dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
 178         dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
 179         dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
 180     }
 181 }
 182
 183 static void pred4x4_down_left_svq3_c(uint8_t *src, uint8_t *topright, int stride){
 184     LOAD_TOP_EDGE
 185     LOAD_LEFT_EDGE
 186     const av_unused int unu0= t0;
 187     const av_unused int unu1= l0;
 188
 189     src[0+0*stride]=(l1 + t1)>>1;
 190     src[1+0*stride]=
 191     src[0+1*stride]=(l2 + t2)>>1;
 192     src[2+0*stride]=
 193     src[1+1*stride]=
 194     src[0+2*stride]=
 195     src[3+0*stride]=
 196     src[2+1*stride]=
 197     src[1+2*stride]=
 198     src[0+3*stride]=
 199     src[3+1*stride]=
 200     src[2+2*stride]=
 201     src[1+3*stride]=
 202     src[3+2*stride]=
 203     src[2+3*stride]=
 204     src[3+3*stride]=(l3 + t3)>>1;
 205 }
 206
 207 static void pred16x16_plane_svq3_c(uint8_t *src, int stride){
 208     pred16x16_plane_compat_c(src, stride, 1);
 209 }
 210
 211 static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
 212                                      int index, const int type) {
 213
 214   static const uint8_t *const scan_patterns[4] =
 215   { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
 216
 217   int run, level, sign, vlc, limit;
 218   const int intra = (3 * type) >> 2;
 219   const uint8_t *const scan = scan_patterns[type];
 220
 221   for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
 222     for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
 223
 224       if (vlc == INVALID_VLC)
 225         return -1;
 226
 227       sign = (vlc & 0x1) - 1;
 228       vlc  = (vlc + 1) >> 1;
 229
 230       if (type == 3) {
 231         if (vlc < 3) {
 232           run   = 0;
 233           level = vlc;
 234         } else if (vlc < 4) {
 235           run   = 1;
 236           level = 1;
 237         } else {
 238           run   = (vlc & 0x3);
 239           level = ((vlc + 9) >> 2) - run;
 240         }
 241       } else {
 242         if (vlc < 16) {
 243           run   = svq3_dct_tables[intra][vlc].run;
 244           level = svq3_dct_tables[intra][vlc].level;
 245         } else if (intra) {
 246           run   = (vlc & 0x7);
 247           level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 248         } else {
 249           run   = (vlc & 0xF);
 250           level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 251         }
 252       }
 253
 254       if ((index += run) >= limit)
 255         return -1;
 256
 257       block[scan[index]] = (level ^ sign) - sign;
 258     }
 259
 260     if (type != 2) {
 261       break;
 262     }
 263   }
 264
 265   return 0;
 266 }
 267
 268 static inline void svq3_mc_dir_part (MpegEncContext *s,
 269                                      int x, int y, int width, int height,
 270                                      int mx, int my, int dxy,
 271                                      int thirdpel, int dir, int avg) {
 272
 273   const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
 274   uint8_t *src, *dest;
 275   int i, emu = 0;
 276   int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
 277
 278   mx += x;
 279   my += y;
 280
 281   if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
 282       my < 0 || my >= (s->v_edge_pos - height - 1)) {
 283
 284     if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
 285       emu = 1;
 286     }
 287
 288     mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
 289     my = av_clip (my, -16, (s->v_edge_pos - height + 15));
 290   }
 291
 292   /* form component predictions */
 293   dest = s->current_picture.data[0] + x + y*s->linesize;
 294   src  = pic->data[0] + mx + my*s->linesize;
 295
 296   if (emu) {
 297     ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
 298                          mx, my, s->h_edge_pos, s->v_edge_pos);
 299     src = s->edge_emu_buffer;
 300   }
 301   if(thirdpel)
 302     (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
 303   else
 304     (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
 305
 306   if (!(s->flags & CODEC_FLAG_GRAY)) {
 307     mx     = (mx + (mx < (int) x)) >> 1;
 308     my     = (my + (my < (int) y)) >> 1;
 309     width  = (width  >> 1);
 310     height = (height >> 1);
 311     blocksize++;
 312
 313     for (i=1; i < 3; i++) {
 314       dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
 315       src  = pic->data[i] + mx + my*s->uvlinesize;
 316
 317       if (emu) {
 318         ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
 319                              mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
 320         src = s->edge_emu_buffer;
 321       }
 322       if(thirdpel)
 323         (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
 324       else
 325         (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
 326     }
 327   }
 328 }
 329
 330 static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
 331
 332   int i, j, k, mx, my, dx, dy, x, y;
 333   MpegEncContext *const s = (MpegEncContext *) h;
 334   const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 335   const int part_height = 16 >> ((unsigned) (size + 1) / 3);
 336   const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
 337   const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
 338   const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
 339
 340   for (i=0; i < 16; i+=part_height) {
 341     for (j=0; j < 16; j+=part_width) {
 342       const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
 343       int dxy;
 344       x = 16*s->mb_x + j;
 345       y = 16*s->mb_y + i;
 346       k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
 347
 348       if (mode != PREDICT_MODE) {
 349         pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
 350       } else {
 351         mx = s->next_picture.motion_val[0][b_xy][0]<<1;
 352         my = s->next_picture.motion_val[0][b_xy][1]<<1;
 353
 354         if (dir == 0) {
 355           mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
 356           my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
 357         } else {
 358           mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
 359           my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
 360         }
 361       }
 362
 363       /* clip motion vector prediction to frame border */
 364       mx = av_clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
 365       my = av_clip (my, extra_width - 6*y, v_edge_pos - 6*y);
 366
 367       /* get (optional) motion vector differential */
 368       if (mode == PREDICT_MODE) {
 369         dx = dy = 0;
 370       } else {
 371         dy = svq3_get_se_golomb (&s->gb);
 372         dx = svq3_get_se_golomb (&s->gb);
 373
 374         if (dx == INVALID_VLC || dy == INVALID_VLC) {
 375           av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 376           return -1;
 377         }
 378       }
 379
 380       /* compute motion vector */
 381       if (mode == THIRDPEL_MODE) {
 382         int fx, fy;
 383         mx = ((mx + 1)>>1) + dx;
 384         my = ((my + 1)>>1) + dy;
 385         fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
 386         fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
 387         dxy= (mx - 3*fx) + 4*(my - 3*fy);
 388
 389         svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
 390         mx += mx;
 391         my += my;
 392       } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 393         mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
 394         my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
 395         dxy= (mx&1) + 2*(my&1);
 396
 397         svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
 398         mx *= 3;
 399         my *= 3;
 400       } else {
 401         mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
 402         my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
 403
 404         svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
 405         mx *= 6;
 406         my *= 6;
 407       }
 408
 409       /* update mv_cache */
 410       if (mode != PREDICT_MODE) {
 411         int32_t mv = pack16to32(mx,my);
 412
 413         if (part_height == 8 && i < 8) {
 414           *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
 415
 416           if (part_width == 8 && j < 8) {
 417             *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
 418           }
 419         }
 420         if (part_width == 8 && j < 8) {
 421           *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
 422         }
 423         if (part_width == 4 || part_height == 4) {
 424           *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
 425         }
 426       }
 427
 428       /* write back motion vectors */
 429       fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
 430     }
 431   }
 432
 433   return 0;
 434 }
 435
 436 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
 437   int i, j, k, m, dir, mode;
 438   int cbp = 0;
 439   uint32_t vlc;
 440   int8_t *top, *left;
 441   MpegEncContext *const s = (MpegEncContext *) h;
 442   const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
 443   const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
 444
 445   h->top_samples_available        = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 446   h->left_samples_available        = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 447   h->topright_samples_available        = 0xFFFF;
 448
 449   if (mb_type == 0) {           /* SKIP */
 450     if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
 451       svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
 452
 453       if (s->pict_type == B_TYPE) {
 454         svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
 455       }
 456
 457       mb_type = MB_TYPE_SKIP;
 458     } else {
 459       mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
 460       if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
 461         return -1;
 462       if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
 463         return -1;
 464
 465       mb_type = MB_TYPE_16x16;
 466     }
 467   } else if (mb_type < 8) {     /* INTER */
 468     if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
 469       mode = THIRDPEL_MODE;
 470     } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
 471       mode = HALFPEL_MODE;
 472     } else {
 473       mode = FULLPEL_MODE;
 474     }
 475
 476     /* fill caches */
 477     /* note ref_cache should contain here:
 478         ????????
 479         ???11111
 480         N??11111
 481         N??11111
 482         N??11111
 483     */
 484
 485     for (m=0; m < 2; m++) {
 486       if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
 487         for (i=0; i < 4; i++) {
 488           *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
 489         }
 490       } else {
 491         for (i=0; i < 4; i++) {
 492           *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
 493         }
 494       }
 495       if (s->mb_y > 0) {
 496         memcpy (h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
 497         memset (&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 498
 499         if (s->mb_x < (s->mb_width - 1)) {
 500           *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
 501           h->ref_cache[m][scan8[0] + 4 - 1*8] =
 502                   (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
 503                    h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
 504         }else
 505           h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
 506         if (s->mb_x > 0) {
 507           *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
 508           h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
 509         }else
 510           h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
 511       }else
 512         memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
 513
 514       if (s->pict_type != B_TYPE)
 515         break;
 516     }
 517
 518     /* decode motion vector(s) and form prediction(s) */
 519     if (s->pict_type == P_TYPE) {
 520       if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
 521         return -1;
 522     } else {        /* B_TYPE */
 523       if (mb_type != 2) {
 524         if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
 525           return -1;
 526       } else {
 527         for (i=0; i < 4; i++) {
 528           memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 529         }
 530       }
 531       if (mb_type != 1) {
 532         if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
 533           return -1;
 534       } else {
 535         for (i=0; i < 4; i++) {
 536           memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 537         }
 538       }
 539     }
 540
 541     mb_type = MB_TYPE_16x16;
 542   } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 543     memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
 544
 545     if (mb_type == 8) {
 546       if (s->mb_x > 0) {
 547         for (i=0; i < 4; i++) {
 548           h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
 549         }
 550         if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
 551           h->left_samples_available = 0x5F5F;
 552         }
 553       }
 554       if (s->mb_y > 0) {
 555         h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
 556         h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
 557         h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
 558         h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
 559
 560         if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
 561           h->top_samples_available = 0x33FF;
 562         }
 563       }
 564
 565       /* decode prediction codes for luma blocks */
 566       for (i=0; i < 16; i+=2) {
 567         vlc = svq3_get_ue_golomb (&s->gb);
 568
 569         if (vlc >= 25){
 570           av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
 571           return -1;
 572         }
 573
 574         left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 575         top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 576
 577         left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 578         left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 579
 580         if (left[1] == -1 || left[2] == -1){
 581           av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
 582           return -1;
 583         }
 584       }
 585     } else {    /* mb_type == 33, DC_128_PRED block type */
 586       for (i=0; i < 4; i++) {
 587         memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
 588       }
 589     }
 590
 591     write_back_intra_pred_mode (h);
 592
 593     if (mb_type == 8) {
 594       check_intra4x4_pred_mode (h);
 595
 596       h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 597       h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 598     } else {
 599       for (i=0; i < 4; i++) {
 600         memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
 601       }
 602
 603       h->top_samples_available  = 0x33FF;
 604       h->left_samples_available = 0x5F5F;
 605     }
 606
 607     mb_type = MB_TYPE_INTRA4x4;
 608   } else {                      /* INTRA16x16 */
 609     dir = i_mb_type_info[mb_type - 8].pred_mode;
 610     dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
 611
 612     if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
 613       av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
 614       return -1;
 615     }
 616
 617     cbp = i_mb_type_info[mb_type - 8].cbp;
 618     mb_type = MB_TYPE_INTRA16x16;
 619   }
 620
 621   if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
 622     for (i=0; i < 4; i++) {
 623       memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 624     }
 625     if (s->pict_type == B_TYPE) {
 626       for (i=0; i < 4; i++) {
 627         memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 628       }
 629     }
 630   }
 631   if (!IS_INTRA4x4(mb_type)) {
 632     memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
 633   }
 634   if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
 635     memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
 636     s->dsp.clear_blocks(h->mb);
 637   }
 638
 639   if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
 640     if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
 641       av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
 642       return -1;
 643     }
 644
 645     cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
 646   }
 647   if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
 648     s->qscale += svq3_get_se_golomb (&s->gb);
 649
 650     if (s->qscale > 31){
 651       av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 652       return -1;
 653     }
 654   }
 655   if (IS_INTRA16x16(mb_type)) {
 656     if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
 657       av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
 658       return -1;
 659     }
 660   }
 661
 662   if (cbp) {
 663     const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 664     const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 665
 666     for (i=0; i < 4; i++) {
 667       if ((cbp & (1 << i))) {
 668         for (j=0; j < 4; j++) {
 669           k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
 670           h->non_zero_count_cache[ scan8[k] ] = 1;
 671
 672           if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
 673             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
 674             return -1;
 675           }
 676         }
 677       }
 678     }
 679
 680     if ((cbp & 0x30)) {
 681       for (i=0; i < 2; ++i) {
 682         if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
 683           av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
 684           return -1;
 685         }
 686       }
 687
 688       if ((cbp & 0x20)) {
 689         for (i=0; i < 8; i++) {
 690           h->non_zero_count_cache[ scan8[16+i] ] = 1;
 691
 692           if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1)){
 693             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
 694             return -1;
 695           }
 696         }
 697       }
 698     }
 699   }
 700
 701   s->current_picture.mb_type[mb_xy] = mb_type;
 702
 703   if (IS_INTRA(mb_type)) {
 704     h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
 705   }
 706
 707   return 0;
 708 }
 709
 710 static int svq3_decode_slice_header (H264Context *h) {
 711   MpegEncContext *const s = (MpegEncContext *) h;
 712   const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
 713   int i, header;
 714
 715   header = get_bits (&s->gb, 8);
 716
 717   if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 718     /* TODO: what? */
 719     av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 720     return -1;
 721   } else {
 722     int length = (header >> 5) & 3;
 723
 724     h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits (&s->gb, 8*length) + 8*length;
 725
 726     if (h->next_slice_index > s->gb.size_in_bits){
 727       av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 728       return -1;
 729     }
 730
 731     s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
 732     skip_bits(&s->gb, 8);
 733
 734     if (length > 0) {
 735       memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
 736              &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
 737     }
 738   }
 739
 740   if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
 741     av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
 742     return -1;
 743   }
 744
 745   h->slice_type = golomb_to_pict_type[i];
 746
 747   if ((header & 0x9F) == 2) {
 748     i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
 749     s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
 750   } else {
 751     get_bits1 (&s->gb);
 752     s->mb_skip_run = 0;
 753   }
 754
 755   h->slice_num = get_bits (&s->gb, 8);
 756   s->qscale = get_bits (&s->gb, 5);
 757   s->adaptive_quant = get_bits1 (&s->gb);
 758
 759   /* unknown fields */
 760   get_bits1 (&s->gb);
 761
 762   if (h->unknown_svq3_flag) {
 763     get_bits1 (&s->gb);
 764   }
 765
 766   get_bits1 (&s->gb);
 767   get_bits (&s->gb, 2);
 768
 769   while (get_bits1 (&s->gb)) {
 770     get_bits (&s->gb, 8);
 771   }
 772
 773   /* reset intra predictors and invalidate motion vector references */
 774   if (s->mb_x > 0) {
 775     memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
 776     memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
 777   }
 778   if (s->mb_y > 0) {
 779     memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
 780
 781     if (s->mb_x > 0) {
 782       h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
 783     }
 784   }
 785
 786   return 0;
 787 }
 788
 789 static int svq3_decode_frame (AVCodecContext *avctx,
 790                               void *data, int *data_size,
 791                               uint8_t *buf, int buf_size) {
 792   MpegEncContext *const s = avctx->priv_data;
 793   H264Context *const h = avctx->priv_data;
 794   int m, mb_type;
 795   unsigned char *extradata;
 796   unsigned int size;
 797
 798   s->flags = avctx->flags;
 799   s->flags2 = avctx->flags2;
 800   s->unrestricted_mv = 1;
 801
 802   if (!s->context_initialized) {
 803     s->width = avctx->width;
 804     s->height = avctx->height;
 805     h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c;
 806     h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c;
 807     h->halfpel_flag = 1;
 808     h->thirdpel_flag = 1;
 809     h->unknown_svq3_flag = 0;
 810     h->chroma_qp[0] = h->chroma_qp[1] = 4;
 811
 812     if (MPV_common_init (s) < 0)
 813       return -1;
 814
 815     h->b_stride = 4*s->mb_width;
 816
 817     alloc_tables (h);
 818
 819     /* prowl for the "SEQH" marker in the extradata */
 820     extradata = (unsigned char *)avctx->extradata;
 821     for (m = 0; m < avctx->extradata_size; m++) {
 822       if (!memcmp (extradata, "SEQH", 4))
 823         break;
 824       extradata++;
 825     }
 826
 827     /* if a match was found, parse the extra data */
 828     if (extradata && !memcmp (extradata, "SEQH", 4)) {
 829
 830       GetBitContext gb;
 831
 832       size = AV_RB32(&extradata[4]);
 833       init_get_bits (&gb, extradata + 8, size*8);
 834
 835       /* 'frame size code' and optional 'width, height' */
 836       if (get_bits (&gb, 3) == 7) {
 837         get_bits (&gb, 12);
 838         get_bits (&gb, 12);
 839       }
 840
 841       h->halfpel_flag = get_bits1 (&gb);
 842       h->thirdpel_flag = get_bits1 (&gb);
 843
 844       /* unknown fields */
 845       get_bits1 (&gb);
 846       get_bits1 (&gb);
 847       get_bits1 (&gb);
 848       get_bits1 (&gb);
 849
 850       s->low_delay = get_bits1 (&gb);
 851
 852       /* unknown field */
 853       get_bits1 (&gb);
 854
 855       while (get_bits1 (&gb)) {
 856         get_bits (&gb, 8);
 857       }
 858
 859       h->unknown_svq3_flag = get_bits1 (&gb);
 860       avctx->has_b_frames = !s->low_delay;
 861     }
 862   }
 863
 864   /* special case for last picture */
 865   if (buf_size == 0) {
 866     if (s->next_picture_ptr && !s->low_delay) {
 867       *(AVFrame *) data = *(AVFrame *) &s->next_picture;
 868       *data_size = sizeof(AVFrame);
 869     }
 870     return 0;
 871   }
 872
 873   init_get_bits (&s->gb, buf, 8*buf_size);
 874
 875   s->mb_x = s->mb_y = 0;
 876
 877   if (svq3_decode_slice_header (h))
 878     return -1;
 879
 880   s->pict_type = h->slice_type;
 881   s->picture_number = h->slice_num;
 882
 883   if(avctx->debug&FF_DEBUG_PICT_INFO){
 884       av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
 885       av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
 886       s->adaptive_quant, s->qscale
 887       );
 888   }
 889
 890   /* for hurry_up==5 */
 891   s->current_picture.pict_type = s->pict_type;
 892   s->current_picture.key_frame = (s->pict_type == I_TYPE);
 893
 894   /* Skip B-frames if we do not have reference frames. */
 895   if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
 896   /* Skip B-frames if we are in a hurry. */
 897   if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
 898   /* Skip everything if we are in a hurry >= 5. */
 899   if (avctx->hurry_up >= 5) return 0;
 900   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
 901      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
 902      || avctx->skip_frame >= AVDISCARD_ALL)
 903       return 0;
 904
 905   if (s->next_p_frame_damaged) {
 906     if (s->pict_type == B_TYPE)
 907       return 0;
 908     else
 909       s->next_p_frame_damaged = 0;
 910   }
 911
 912   if (frame_start (h) < 0)
 913     return -1;
 914
 915   if (s->pict_type == B_TYPE) {
 916     h->frame_num_offset = (h->slice_num - h->prev_frame_num);
 917
 918     if (h->frame_num_offset < 0) {
 919       h->frame_num_offset += 256;
 920     }
 921     if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
 922       av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
 923       return -1;
 924     }
 925   } else {
 926     h->prev_frame_num = h->frame_num;
 927     h->frame_num = h->slice_num;
 928     h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
 929
 930     if (h->prev_frame_num_offset < 0) {
 931       h->prev_frame_num_offset += 256;
 932     }
 933   }
 934
 935   for(m=0; m<2; m++){
 936     int i;
 937     for(i=0; i<4; i++){
 938       int j;
 939       for(j=-1; j<4; j++)
 940         h->ref_cache[m][scan8[0] + 8*i + j]= 1;
 941       if(i<3)
 942         h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
 943     }
 944   }
 945
 946   for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
 947     for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
 948
 949       if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
 950           ((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
 951
 952         skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
 953         s->gb.size_in_bits = 8*buf_size;
 954
 955         if (svq3_decode_slice_header (h))
 956           return -1;
 957
 958         /* TODO: support s->mb_skip_run */
 959       }
 960
 961       mb_type = svq3_get_ue_golomb (&s->gb);
 962
 963       if (s->pict_type == I_TYPE) {
 964         mb_type += 8;
 965       } else if (s->pict_type == B_TYPE && mb_type >= 4) {
 966         mb_type += 4;
 967       }
 968       if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
 969         av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
 970         return -1;
 971       }
 972
 973       if (mb_type != 0) {
 974         hl_decode_mb (h);
 975       }
 976
 977       if (s->pict_type != B_TYPE && !s->low_delay) {
 978         s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
 979                         (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
 980       }
 981     }
 982
 983     ff_draw_horiz_band(s, 16*s->mb_y, 16);
 984   }
 985
 986   MPV_frame_end(s);
 987
 988   if (s->pict_type == B_TYPE || s->low_delay) {
 989     *(AVFrame *) data = *(AVFrame *) &s->current_picture;
 990   } else {
 991     *(AVFrame *) data = *(AVFrame *) &s->last_picture;
 992   }
 993
 994   avctx->frame_number = s->picture_number - 1;
 995
 996   /* Do not output the last pic after seeking. */
 997   if (s->last_picture_ptr || s->low_delay) {
 998     *data_size = sizeof(AVFrame);
 999   }
1000
1001   return buf_size;
1002 }
1003
1004
1005 AVCodec svq3_decoder = {
1006     "svq3",
1007     CODEC_TYPE_VIDEO,
1008     CODEC_ID_SVQ3,
1009     sizeof(H264Context),
1010     decode_init,
1011     NULL,
1012     decode_end,
1013     svq3_decode_frame,
1014     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1015 };