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