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