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