git.sesse.net Git - ffmpeg/blob - libavcodec/svq3.c

   1 /*
   2  * Copyright (c) 2003 The Libav Project
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav 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  * Libav 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 Libav; 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.libav.org/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 "h264_mvpred.h"
  51 #include "golomb.h"
  52 #include "rectangle.h"
  53 #include "vdpau_internal.h"
  54
  55 #if CONFIG_ZLIB
  56 #include <zlib.h>
  57 #endif
  58
  59 #include "svq1.h"
  60
  61 /**
  62  * @file
  63  * svq3 decoder.
  64  */
  65
  66 typedef struct {
  67     H264Context h;
  68     int halfpel_flag;
  69     int thirdpel_flag;
  70     int unknown_flag;
  71     int next_slice_index;
  72     uint32_t watermark_key;
  73 } SVQ3Context;
  74
  75 #define FULLPEL_MODE  1
  76 #define HALFPEL_MODE  2
  77 #define THIRDPEL_MODE 3
  78 #define PREDICT_MODE  4
  79
  80 /* dual scan (from some older h264 draft)
  81  o-->o-->o   o
  82          |  /|
  83  o   o   o / o
  84  | / |   |/  |
  85  o   o   o   o
  86    /
  87  o-->o-->o-->o
  88 */
  89 static const uint8_t svq3_scan[16] = {
  90     0+0*4, 1+0*4, 2+0*4, 2+1*4,
  91     2+2*4, 3+0*4, 3+1*4, 3+2*4,
  92     0+1*4, 0+2*4, 1+1*4, 1+2*4,
  93     0+3*4, 1+3*4, 2+3*4, 3+3*4,
  94 };
  95
  96 static const uint8_t svq3_pred_0[25][2] = {
  97     { 0, 0 },
  98     { 1, 0 }, { 0, 1 },
  99     { 0, 2 }, { 1, 1 }, { 2, 0 },
 100     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
 101     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
 102     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
 103     { 2, 4 }, { 3, 3 }, { 4, 2 },
 104     { 4, 3 }, { 3, 4 },
 105     { 4, 4 }
 106 };
 107
 108 static const int8_t svq3_pred_1[6][6][5] = {
 109     { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
 110       { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
 111     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
 112       { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
 113     { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
 114       { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
 115     { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
 116       { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
 117     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
 118       { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
 119     { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
 120       { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
 121 };
 122
 123 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
 124     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
 125       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
 126     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
 127       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
 128 };
 129
 130 static const uint32_t svq3_dequant_coeff[32] = {
 131      3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
 132      9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
 133     24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
 134     61694, 68745, 77615, 89113,100253,109366,126635,141533
 135 };
 136
 137 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
 138     const int qmul = svq3_dequant_coeff[qp];
 139 #define stride 16
 140     int i;
 141     int temp[16];
 142     static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
 143
 144     for(i=0; i<4; i++){
 145         const int z0 = 13*(input[4*i+0] +    input[4*i+2]);
 146         const int z1 = 13*(input[4*i+0] -    input[4*i+2]);
 147         const int z2 =  7* input[4*i+1] - 17*input[4*i+3];
 148         const int z3 = 17* input[4*i+1] +  7*input[4*i+3];
 149
 150         temp[4*i+0] = z0+z3;
 151         temp[4*i+1] = z1+z2;
 152         temp[4*i+2] = z1-z2;
 153         temp[4*i+3] = z0-z3;
 154     }
 155
 156     for(i=0; i<4; i++){
 157         const int offset= x_offset[i];
 158         const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
 159         const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
 160         const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
 161         const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
 162
 163         output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
 164         output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
 165         output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
 166         output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
 167     }
 168 }
 169 #undef stride
 170
 171 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
 172                             int dc)
 173 {
 174     const int qmul = svq3_dequant_coeff[qp];
 175     int i;
 176     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 177
 178     if (dc) {
 179         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
 180         block[0] = 0;
 181     }
 182
 183     for (i = 0; i < 4; i++) {
 184         const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
 185         const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
 186         const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
 187         const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
 188
 189         block[0 + 4*i] = z0 + z3;
 190         block[1 + 4*i] = z1 + z2;
 191         block[2 + 4*i] = z1 - z2;
 192         block[3 + 4*i] = z0 - z3;
 193     }
 194
 195     for (i = 0; i < 4; i++) {
 196         const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
 197         const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
 198         const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
 199         const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
 200         const int rr = (dc + 0x80000);
 201
 202         dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
 203         dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
 204         dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
 205         dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
 206     }
 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 = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
 287         my = av_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         s->dsp.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                 s->dsp.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,
 329                               int avg)
 330 {
 331     int i, j, k, mx, my, dx, dy, x, y;
 332     MpegEncContext *const s = (MpegEncContext *) h;
 333     const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 334     const int part_height = 16 >> ((unsigned) (size + 1) / 3);
 335     const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
 336     const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
 337     const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
 338
 339     for (i = 0; i < 16; i += part_height) {
 340         for (j = 0; j < 16; j += part_width) {
 341             const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
 342             int dxy;
 343             x = 16*s->mb_x + j;
 344             y = 16*s->mb_y + i;
 345             k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
 346
 347             if (mode != PREDICT_MODE) {
 348                 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
 349             } else {
 350                 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
 351                 my = s->next_picture.motion_val[0][b_xy][1]<<1;
 352
 353                 if (dir == 0) {
 354                     mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 355                     my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 356                 } else {
 357                     mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 358                     my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 359                 }
 360             }
 361
 362             /* clip motion vector prediction to frame border */
 363             mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
 364             my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
 365
 366             /* get (optional) motion vector differential */
 367             if (mode == PREDICT_MODE) {
 368                 dx = dy = 0;
 369             } else {
 370                 dy = svq3_get_se_golomb(&s->gb);
 371                 dx = svq3_get_se_golomb(&s->gb);
 372
 373                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 374                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 375                     return -1;
 376                 }
 377             }
 378
 379             /* compute motion vector */
 380             if (mode == THIRDPEL_MODE) {
 381                 int fx, fy;
 382                 mx  = ((mx + 1)>>1) + dx;
 383                 my  = ((my + 1)>>1) + dy;
 384                 fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
 385                 fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
 386                 dxy = (mx - 3*fx) + 4*(my - 3*fy);
 387
 388                 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
 389                 mx += mx;
 390                 my += my;
 391             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 392                 mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
 393                 my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
 394                 dxy = (mx&1) + 2*(my&1);
 395
 396                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
 397                 mx *= 3;
 398                 my *= 3;
 399             } else {
 400                 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
 401                 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
 402
 403                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
 404                 mx *= 6;
 405                 my *= 6;
 406             }
 407
 408             /* update mv_cache */
 409             if (mode != PREDICT_MODE) {
 410                 int32_t mv = pack16to32(mx,my);
 411
 412                 if (part_height == 8 && i < 8) {
 413                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
 414
 415                     if (part_width == 8 && j < 8) {
 416                         *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
 417                     }
 418                 }
 419                 if (part_width == 8 && j < 8) {
 420                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
 421                 }
 422                 if (part_width == 4 || part_height == 4) {
 423                     *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
 424                 }
 425             }
 426
 427             /* write back motion vectors */
 428             fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
 429         }
 430     }
 431
 432     return 0;
 433 }
 434
 435 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
 436 {
 437     H264Context *h = &svq3->h;
 438     int i, j, k, m, dir, mode;
 439     int cbp = 0;
 440     uint32_t vlc;
 441     int8_t *top, *left;
 442     MpegEncContext *const s = (MpegEncContext *) h;
 443     const int mb_xy = h->mb_xy;
 444     const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
 445
 446     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 447     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 448     h->topright_samples_available = 0xFFFF;
 449
 450     if (mb_type == 0) {           /* SKIP */
 451         if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.mb_type[mb_xy] == -1) {
 452             svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
 453
 454             if (s->pict_type == AV_PICTURE_TYPE_B) {
 455                 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
 456             }
 457
 458             mb_type = MB_TYPE_SKIP;
 459         } else {
 460             mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
 461             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
 462                 return -1;
 463             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
 464                 return -1;
 465
 466             mb_type = MB_TYPE_16x16;
 467         }
 468     } else if (mb_type < 8) {     /* INTER */
 469         if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
 470             mode = THIRDPEL_MODE;
 471         } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
 472             mode = HALFPEL_MODE;
 473         } else {
 474             mode = FULLPEL_MODE;
 475         }
 476
 477         /* fill caches */
 478         /* note ref_cache should contain here:
 479             ????????
 480             ???11111
 481             N??11111
 482             N??11111
 483             N??11111
 484         */
 485
 486         for (m = 0; m < 2; m++) {
 487             if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
 488                 for (i = 0; i < 4; i++) {
 489                     *(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];
 490                 }
 491             } else {
 492                 for (i = 0; i < 4; i++) {
 493                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
 494                 }
 495             }
 496             if (s->mb_y > 0) {
 497                 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));
 498                 memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 499
 500                 if (s->mb_x < (s->mb_width - 1)) {
 501                     *(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];
 502                     h->ref_cache[m][scan8[0] + 4 - 1*8] =
 503                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
 504                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
 505                 }else
 506                     h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
 507                 if (s->mb_x > 0) {
 508                     *(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];
 509                     h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
 510                 }else
 511                     h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
 512             }else
 513                 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
 514
 515             if (s->pict_type != AV_PICTURE_TYPE_B)
 516                 break;
 517         }
 518
 519         /* decode motion vector(s) and form prediction(s) */
 520         if (s->pict_type == AV_PICTURE_TYPE_P) {
 521             if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
 522                 return -1;
 523         } else {        /* AV_PICTURE_TYPE_B */
 524             if (mb_type != 2) {
 525                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
 526                     return -1;
 527             } else {
 528                 for (i = 0; i < 4; i++) {
 529                     memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 530                 }
 531             }
 532             if (mb_type != 1) {
 533                 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
 534                     return -1;
 535             } else {
 536                 for (i = 0; i < 4; i++) {
 537                     memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 538                 }
 539             }
 540         }
 541
 542         mb_type = MB_TYPE_16x16;
 543     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 544         memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
 545
 546         if (mb_type == 8) {
 547             if (s->mb_x > 0) {
 548                 for (i = 0; i < 4; i++) {
 549                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
 550                 }
 551                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
 552                     h->left_samples_available = 0x5F5F;
 553                 }
 554             }
 555             if (s->mb_y > 0) {
 556                 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
 557                 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
 558                 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
 559                 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
 560
 561                 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
 562                     h->top_samples_available = 0x33FF;
 563                 }
 564             }
 565
 566             /* decode prediction codes for luma blocks */
 567             for (i = 0; i < 16; i+=2) {
 568                 vlc = svq3_get_ue_golomb(&s->gb);
 569
 570                 if (vlc >= 25){
 571                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
 572                     return -1;
 573                 }
 574
 575                 left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 576                 top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 577
 578                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 579                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 580
 581                 if (left[1] == -1 || left[2] == -1){
 582                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
 583                     return -1;
 584                 }
 585             }
 586         } else {    /* mb_type == 33, DC_128_PRED block type */
 587             for (i = 0; i < 4; i++) {
 588                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
 589             }
 590         }
 591
 592         ff_h264_write_back_intra_pred_mode(h);
 593
 594         if (mb_type == 8) {
 595             ff_h264_check_intra4x4_pred_mode(h);
 596
 597             h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 598             h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 599         } else {
 600             for (i = 0; i < 4; i++) {
 601                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
 602             }
 603
 604             h->top_samples_available  = 0x33FF;
 605             h->left_samples_available = 0x5F5F;
 606         }
 607
 608         mb_type = MB_TYPE_INTRA4x4;
 609     } else {                      /* INTRA16x16 */
 610         dir = i_mb_type_info[mb_type - 8].pred_mode;
 611         dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
 612
 613         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
 614             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
 615             return -1;
 616         }
 617
 618         cbp = i_mb_type_info[mb_type - 8].cbp;
 619         mb_type = MB_TYPE_INTRA16x16;
 620     }
 621
 622     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 623         for (i = 0; i < 4; i++) {
 624             memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 625         }
 626         if (s->pict_type == AV_PICTURE_TYPE_B) {
 627             for (i = 0; i < 4; i++) {
 628                 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 629             }
 630         }
 631     }
 632     if (!IS_INTRA4x4(mb_type)) {
 633         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
 634     }
 635     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 636         memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
 637         s->dsp.clear_blocks(h->mb+  0);
 638         s->dsp.clear_blocks(h->mb+384);
 639     }
 640
 641     if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 642         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
 643             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
 644             return -1;
 645         }
 646
 647         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
 648     }
 649     if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 650         s->qscale += svq3_get_se_golomb(&s->gb);
 651
 652         if (s->qscale > 31){
 653             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 654             return -1;
 655         }
 656     }
 657     if (IS_INTRA16x16(mb_type)) {
 658         AV_ZERO128(h->mb_luma_dc[0]+0);
 659         AV_ZERO128(h->mb_luma_dc[0]+8);
 660         if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
 661             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
 662             return -1;
 663         }
 664     }
 665
 666     if (cbp) {
 667         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 668         const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 669
 670         for (i = 0; i < 4; i++) {
 671             if ((cbp & (1 << i))) {
 672                 for (j = 0; j < 4; j++) {
 673                     k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
 674                     h->non_zero_count_cache[ scan8[k] ] = 1;
 675
 676                     if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
 677                         av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
 678                         return -1;
 679                     }
 680                 }
 681             }
 682         }
 683
 684         if ((cbp & 0x30)) {
 685             for (i = 1; i < 3; ++i) {
 686               if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
 687                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
 688                 return -1;
 689               }
 690             }
 691
 692             if ((cbp & 0x20)) {
 693                 for (i = 1; i < 3; i++) {
 694                     for (j = 0; j < 4; j++) {
 695                         k = 16*i + j;
 696                         h->non_zero_count_cache[ scan8[k] ] = 1;
 697
 698                         if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
 699                             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
 700                             return -1;
 701                         }
 702                     }
 703                 }
 704             }
 705         }
 706     }
 707
 708     h->cbp= cbp;
 709     s->current_picture.mb_type[mb_xy] = mb_type;
 710
 711     if (IS_INTRA(mb_type)) {
 712         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
 713     }
 714
 715     return 0;
 716 }
 717
 718 static int svq3_decode_slice_header(AVCodecContext *avctx)
 719 {
 720     SVQ3Context *svq3 = avctx->priv_data;
 721     H264Context *h = &svq3->h;
 722     MpegEncContext *s = &h->s;
 723     const int mb_xy = h->mb_xy;
 724     int i, header;
 725
 726     header = get_bits(&s->gb, 8);
 727
 728     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 729         /* TODO: what? */
 730         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 731         return -1;
 732     } else {
 733         int length = (header >> 5) & 3;
 734
 735         svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
 736
 737         if (svq3->next_slice_index > s->gb.size_in_bits) {
 738             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 739             return -1;
 740     }
 741
 742         s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
 743         skip_bits(&s->gb, 8);
 744
 745         if (svq3->watermark_key) {
 746             uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
 747             AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
 748         }
 749         if (length > 0) {
 750             memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
 751                    &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
 752         }
 753         skip_bits_long(&s->gb, 0);
 754     }
 755
 756     if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
 757         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
 758         return -1;
 759     }
 760
 761     h->slice_type = golomb_to_pict_type[i];
 762
 763     if ((header & 0x9F) == 2) {
 764         i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
 765         s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
 766     } else {
 767         skip_bits1(&s->gb);
 768         s->mb_skip_run = 0;
 769     }
 770
 771     h->slice_num = get_bits(&s->gb, 8);
 772     s->qscale = get_bits(&s->gb, 5);
 773     s->adaptive_quant = get_bits1(&s->gb);
 774
 775     /* unknown fields */
 776     skip_bits1(&s->gb);
 777
 778     if (svq3->unknown_flag) {
 779         skip_bits1(&s->gb);
 780     }
 781
 782     skip_bits1(&s->gb);
 783     skip_bits(&s->gb, 2);
 784
 785     while (get_bits1(&s->gb)) {
 786         skip_bits(&s->gb, 8);
 787     }
 788
 789     /* reset intra predictors and invalidate motion vector references */
 790     if (s->mb_x > 0) {
 791         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
 792         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
 793     }
 794     if (s->mb_y > 0) {
 795         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
 796
 797         if (s->mb_x > 0) {
 798             h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
 799         }
 800     }
 801
 802     return 0;
 803 }
 804
 805 static av_cold int svq3_decode_init(AVCodecContext *avctx)
 806 {
 807     SVQ3Context *svq3 = avctx->priv_data;
 808     H264Context *h = &svq3->h;
 809     MpegEncContext *s = &h->s;
 810     int m;
 811     unsigned char *extradata;
 812     unsigned int size;
 813
 814     if (ff_h264_decode_init(avctx) < 0)
 815         return -1;
 816
 817     s->flags  = avctx->flags;
 818     s->flags2 = avctx->flags2;
 819     s->unrestricted_mv = 1;
 820     h->is_complex=1;
 821     avctx->pix_fmt = avctx->codec->pix_fmts[0];
 822
 823     if (!s->context_initialized) {
 824         h->chroma_qp[0] = h->chroma_qp[1] = 4;
 825
 826         svq3->halfpel_flag  = 1;
 827         svq3->thirdpel_flag = 1;
 828         svq3->unknown_flag  = 0;
 829
 830         /* prowl for the "SEQH" marker in the extradata */
 831         extradata = (unsigned char *)avctx->extradata;
 832         for (m = 0; m < avctx->extradata_size; m++) {
 833             if (!memcmp(extradata, "SEQH", 4))
 834                 break;
 835             extradata++;
 836         }
 837
 838         /* if a match was found, parse the extra data */
 839         if (extradata && !memcmp(extradata, "SEQH", 4)) {
 840
 841             GetBitContext gb;
 842             int frame_size_code;
 843
 844             size = AV_RB32(&extradata[4]);
 845             init_get_bits(&gb, extradata + 8, size*8);
 846
 847             /* 'frame size code' and optional 'width, height' */
 848             frame_size_code = get_bits(&gb, 3);
 849             switch (frame_size_code) {
 850                 case 0: avctx->width = 160; avctx->height = 120; break;
 851                 case 1: avctx->width = 128; avctx->height =  96; break;
 852                 case 2: avctx->width = 176; avctx->height = 144; break;
 853                 case 3: avctx->width = 352; avctx->height = 288; break;
 854                 case 4: avctx->width = 704; avctx->height = 576; break;
 855                 case 5: avctx->width = 240; avctx->height = 180; break;
 856                 case 6: avctx->width = 320; avctx->height = 240; break;
 857                 case 7:
 858                     avctx->width  = get_bits(&gb, 12);
 859                     avctx->height = get_bits(&gb, 12);
 860                     break;
 861             }
 862
 863             svq3->halfpel_flag  = get_bits1(&gb);
 864             svq3->thirdpel_flag = get_bits1(&gb);
 865
 866             /* unknown fields */
 867             skip_bits1(&gb);
 868             skip_bits1(&gb);
 869             skip_bits1(&gb);
 870             skip_bits1(&gb);
 871
 872             s->low_delay = get_bits1(&gb);
 873
 874             /* unknown field */
 875             skip_bits1(&gb);
 876
 877             while (get_bits1(&gb)) {
 878                 skip_bits(&gb, 8);
 879             }
 880
 881             svq3->unknown_flag = get_bits1(&gb);
 882             avctx->has_b_frames = !s->low_delay;
 883             if (svq3->unknown_flag) {
 884 #if CONFIG_ZLIB
 885                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 886                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
 887                 int u1 = svq3_get_ue_golomb(&gb);
 888                 int u2 = get_bits(&gb, 8);
 889                 int u3 = get_bits(&gb, 2);
 890                 int u4 = svq3_get_ue_golomb(&gb);
 891                 unsigned long buf_len = watermark_width*watermark_height*4;
 892                 int offset = (get_bits_count(&gb)+7)>>3;
 893                 uint8_t *buf;
 894
 895                 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
 896                     return -1;
 897
 898                 buf = av_malloc(buf_len);
 899                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
 900                 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
 901                 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
 902                     av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
 903                     av_free(buf);
 904                     return -1;
 905                 }
 906                 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
 907                 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
 908                 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
 909                 av_free(buf);
 910 #else
 911                 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
 912                 return -1;
 913 #endif
 914             }
 915         }
 916
 917         s->width  = avctx->width;
 918         s->height = avctx->height;
 919
 920         if (MPV_common_init(s) < 0)
 921             return -1;
 922
 923         h->b_stride = 4*s->mb_width;
 924
 925         ff_h264_alloc_tables(h);
 926     }
 927
 928     return 0;
 929 }
 930
 931 static int svq3_decode_frame(AVCodecContext *avctx,
 932                              void *data, int *data_size,
 933                              AVPacket *avpkt)
 934 {
 935     const uint8_t *buf = avpkt->data;
 936     SVQ3Context *svq3 = avctx->priv_data;
 937     H264Context *h = &svq3->h;
 938     MpegEncContext *s = &h->s;
 939     int buf_size = avpkt->size;
 940     int m, mb_type;
 941
 942     /* special case for last picture */
 943     if (buf_size == 0) {
 944         if (s->next_picture_ptr && !s->low_delay) {
 945             *(AVFrame *) data = *(AVFrame *) &s->next_picture;
 946             s->next_picture_ptr = NULL;
 947             *data_size = sizeof(AVFrame);
 948         }
 949         return 0;
 950     }
 951
 952     init_get_bits (&s->gb, buf, 8*buf_size);
 953
 954     s->mb_x = s->mb_y = h->mb_xy = 0;
 955
 956     if (svq3_decode_slice_header(avctx))
 957         return -1;
 958
 959     s->pict_type = h->slice_type;
 960     s->picture_number = h->slice_num;
 961
 962     if (avctx->debug&FF_DEBUG_PICT_INFO){
 963         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
 964                av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
 965                s->adaptive_quant, s->qscale, h->slice_num);
 966     }
 967
 968     /* for skipping the frame */
 969     s->current_picture.pict_type = s->pict_type;
 970     s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
 971
 972     /* Skip B-frames if we do not have reference frames. */
 973     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
 974         return 0;
 975     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
 976         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
 977         || avctx->skip_frame >= AVDISCARD_ALL)
 978         return 0;
 979
 980     if (s->next_p_frame_damaged) {
 981         if (s->pict_type == AV_PICTURE_TYPE_B)
 982             return 0;
 983         else
 984             s->next_p_frame_damaged = 0;
 985     }
 986
 987     if (ff_h264_frame_start(h) < 0)
 988         return -1;
 989
 990     if (s->pict_type == AV_PICTURE_TYPE_B) {
 991         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
 992
 993         if (h->frame_num_offset < 0) {
 994             h->frame_num_offset += 256;
 995         }
 996         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
 997             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
 998             return -1;
 999         }
1000     } else {
1001         h->prev_frame_num = h->frame_num;
1002         h->frame_num = h->slice_num;
1003         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1004
1005         if (h->prev_frame_num_offset < 0) {
1006             h->prev_frame_num_offset += 256;
1007         }
1008     }
1009
1010     for (m = 0; m < 2; m++){
1011         int i;
1012         for (i = 0; i < 4; i++){
1013             int j;
1014             for (j = -1; j < 4; j++)
1015                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1016             if (i < 3)
1017                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1018         }
1019     }
1020
1021     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1022         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1023             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1024
1025             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1026                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1027
1028                 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1029                 s->gb.size_in_bits = 8*buf_size;
1030
1031                 if (svq3_decode_slice_header(avctx))
1032                     return -1;
1033
1034                 /* TODO: support s->mb_skip_run */
1035             }
1036
1037             mb_type = svq3_get_ue_golomb(&s->gb);
1038
1039             if (s->pict_type == AV_PICTURE_TYPE_I) {
1040                 mb_type += 8;
1041             } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1042                 mb_type += 4;
1043             }
1044             if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1045                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1046                 return -1;
1047             }
1048
1049             if (mb_type != 0) {
1050                 ff_h264_hl_decode_mb (h);
1051             }
1052
1053             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1054                 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1055                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1056             }
1057         }
1058
1059         ff_draw_horiz_band(s, 16*s->mb_y, 16);
1060     }
1061
1062     MPV_frame_end(s);
1063
1064     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1065         *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1066     } else {
1067         *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1068     }
1069
1070     /* Do not output the last pic after seeking. */
1071     if (s->last_picture_ptr || s->low_delay) {
1072         *data_size = sizeof(AVFrame);
1073     }
1074
1075     return buf_size;
1076 }
1077
1078 static int svq3_decode_end(AVCodecContext *avctx)
1079 {
1080     SVQ3Context *svq3 = avctx->priv_data;
1081     H264Context *h = &svq3->h;
1082     MpegEncContext *s = &h->s;
1083
1084     ff_h264_free_context(h);
1085
1086     MPV_common_end(s);
1087
1088     return 0;
1089 }
1090
1091 AVCodec ff_svq3_decoder = {
1092     "svq3",
1093     AVMEDIA_TYPE_VIDEO,
1094     CODEC_ID_SVQ3,
1095     sizeof(SVQ3Context),
1096     svq3_decode_init,
1097     NULL,
1098     svq3_decode_end,
1099     svq3_decode_frame,
1100     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1101     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1102     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1103 };