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.f.data[0] + x + y*s->linesize;
 292     src  = pic->f.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.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
 313             src  = pic->f.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.f.motion_val[0][b_xy][0] << 1;
 351                 my = s->next_picture.f.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.f.motion_val[dir][b_xy],
 429                            part_width >> 2, part_height >> 2, h->b_stride,
 430                            pack16to32(mx, my), 4);
 431         }
 432     }
 433
 434     return 0;
 435 }
 436
 437 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
 438 {
 439     H264Context *h = &svq3->h;
 440     int i, j, k, m, dir, mode;
 441     int cbp = 0;
 442     uint32_t vlc;
 443     int8_t *top, *left;
 444     MpegEncContext *const s = (MpegEncContext *) h;
 445     const int mb_xy = h->mb_xy;
 446     const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
 447
 448     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 449     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 450     h->topright_samples_available = 0xFFFF;
 451
 452     if (mb_type == 0) {           /* SKIP */
 453         if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.f.mb_type[mb_xy] == -1) {
 454             svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
 455
 456             if (s->pict_type == AV_PICTURE_TYPE_B) {
 457                 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
 458             }
 459
 460             mb_type = MB_TYPE_SKIP;
 461         } else {
 462             mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
 463             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
 464                 return -1;
 465             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
 466                 return -1;
 467
 468             mb_type = MB_TYPE_16x16;
 469         }
 470     } else if (mb_type < 8) {     /* INTER */
 471         if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
 472             mode = THIRDPEL_MODE;
 473         } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
 474             mode = HALFPEL_MODE;
 475         } else {
 476             mode = FULLPEL_MODE;
 477         }
 478
 479         /* fill caches */
 480         /* note ref_cache should contain here:
 481             ????????
 482             ???11111
 483             N??11111
 484             N??11111
 485             N??11111
 486         */
 487
 488         for (m = 0; m < 2; m++) {
 489             if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
 490                 for (i = 0; i < 4; i++) {
 491                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - 1 + i*h->b_stride];
 492                 }
 493             } else {
 494                 for (i = 0; i < 4; i++) {
 495                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
 496                 }
 497             }
 498             if (s->mb_y > 0) {
 499                 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
 500                 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);
 501
 502                 if (s->mb_x < (s->mb_width - 1)) {
 503                     *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4];
 504                     h->ref_cache[m][scan8[0] + 4 - 1*8] =
 505                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
 506                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
 507                 }else
 508                     h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
 509                 if (s->mb_x > 0) {
 510                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1];
 511                     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;
 512                 }else
 513                     h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
 514             }else
 515                 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
 516
 517             if (s->pict_type != AV_PICTURE_TYPE_B)
 518                 break;
 519         }
 520
 521         /* decode motion vector(s) and form prediction(s) */
 522         if (s->pict_type == AV_PICTURE_TYPE_P) {
 523             if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
 524                 return -1;
 525         } else {        /* AV_PICTURE_TYPE_B */
 526             if (mb_type != 2) {
 527                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
 528                     return -1;
 529             } else {
 530                 for (i = 0; i < 4; i++) {
 531                     memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 532                 }
 533             }
 534             if (mb_type != 1) {
 535                 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
 536                     return -1;
 537             } else {
 538                 for (i = 0; i < 4; i++) {
 539                     memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 540                 }
 541             }
 542         }
 543
 544         mb_type = MB_TYPE_16x16;
 545     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 546         memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
 547
 548         if (mb_type == 8) {
 549             if (s->mb_x > 0) {
 550                 for (i = 0; i < 4; i++) {
 551                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
 552                 }
 553                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
 554                     h->left_samples_available = 0x5F5F;
 555                 }
 556             }
 557             if (s->mb_y > 0) {
 558                 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
 559                 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
 560                 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
 561                 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
 562
 563                 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
 564                     h->top_samples_available = 0x33FF;
 565                 }
 566             }
 567
 568             /* decode prediction codes for luma blocks */
 569             for (i = 0; i < 16; i+=2) {
 570                 vlc = svq3_get_ue_golomb(&s->gb);
 571
 572                 if (vlc >= 25){
 573                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
 574                     return -1;
 575                 }
 576
 577                 left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 578                 top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 579
 580                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 581                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 582
 583                 if (left[1] == -1 || left[2] == -1){
 584                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
 585                     return -1;
 586                 }
 587             }
 588         } else {    /* mb_type == 33, DC_128_PRED block type */
 589             for (i = 0; i < 4; i++) {
 590                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
 591             }
 592         }
 593
 594         write_back_intra_pred_mode(h);
 595
 596         if (mb_type == 8) {
 597             ff_h264_check_intra4x4_pred_mode(h);
 598
 599             h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 600             h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 601         } else {
 602             for (i = 0; i < 4; i++) {
 603                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
 604             }
 605
 606             h->top_samples_available  = 0x33FF;
 607             h->left_samples_available = 0x5F5F;
 608         }
 609
 610         mb_type = MB_TYPE_INTRA4x4;
 611     } else {                      /* INTRA16x16 */
 612         dir = i_mb_type_info[mb_type - 8].pred_mode;
 613         dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
 614
 615         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
 616             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
 617             return -1;
 618         }
 619
 620         cbp = i_mb_type_info[mb_type - 8].cbp;
 621         mb_type = MB_TYPE_INTRA16x16;
 622     }
 623
 624     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 625         for (i = 0; i < 4; i++) {
 626             memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 627         }
 628         if (s->pict_type == AV_PICTURE_TYPE_B) {
 629             for (i = 0; i < 4; i++) {
 630                 memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 631             }
 632         }
 633     }
 634     if (!IS_INTRA4x4(mb_type)) {
 635         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
 636     }
 637     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 638         memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
 639         s->dsp.clear_blocks(h->mb+  0);
 640         s->dsp.clear_blocks(h->mb+384);
 641     }
 642
 643     if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 644         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
 645             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
 646             return -1;
 647         }
 648
 649         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
 650     }
 651     if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 652         s->qscale += svq3_get_se_golomb(&s->gb);
 653
 654         if (s->qscale > 31){
 655             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 656             return -1;
 657         }
 658     }
 659     if (IS_INTRA16x16(mb_type)) {
 660         AV_ZERO128(h->mb_luma_dc[0]+0);
 661         AV_ZERO128(h->mb_luma_dc[0]+8);
 662         if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
 663             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
 664             return -1;
 665         }
 666     }
 667
 668     if (cbp) {
 669         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 670         const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 671
 672         for (i = 0; i < 4; i++) {
 673             if ((cbp & (1 << i))) {
 674                 for (j = 0; j < 4; j++) {
 675                     k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
 676                     h->non_zero_count_cache[ scan8[k] ] = 1;
 677
 678                     if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
 679                         av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
 680                         return -1;
 681                     }
 682                 }
 683             }
 684         }
 685
 686         if ((cbp & 0x30)) {
 687             for (i = 1; i < 3; ++i) {
 688               if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
 689                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
 690                 return -1;
 691               }
 692             }
 693
 694             if ((cbp & 0x20)) {
 695                 for (i = 1; i < 3; i++) {
 696                     for (j = 0; j < 4; j++) {
 697                         k = 16*i + j;
 698                         h->non_zero_count_cache[ scan8[k] ] = 1;
 699
 700                         if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
 701                             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
 702                             return -1;
 703                         }
 704                     }
 705                 }
 706             }
 707         }
 708     }
 709
 710     h->cbp= cbp;
 711     s->current_picture.f.mb_type[mb_xy] = mb_type;
 712
 713     if (IS_INTRA(mb_type)) {
 714         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
 715     }
 716
 717     return 0;
 718 }
 719
 720 static int svq3_decode_slice_header(AVCodecContext *avctx)
 721 {
 722     SVQ3Context *svq3 = avctx->priv_data;
 723     H264Context *h = &svq3->h;
 724     MpegEncContext *s = &h->s;
 725     const int mb_xy = h->mb_xy;
 726     int i, header;
 727
 728     header = get_bits(&s->gb, 8);
 729
 730     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 731         /* TODO: what? */
 732         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 733         return -1;
 734     } else {
 735         int length = (header >> 5) & 3;
 736
 737         svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
 738
 739         if (svq3->next_slice_index > s->gb.size_in_bits) {
 740             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 741             return -1;
 742     }
 743
 744         s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
 745         skip_bits(&s->gb, 8);
 746
 747         if (svq3->watermark_key) {
 748             uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
 749             AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
 750         }
 751         if (length > 0) {
 752             memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
 753                    &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
 754         }
 755         skip_bits_long(&s->gb, 0);
 756     }
 757
 758     if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
 759         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
 760         return -1;
 761     }
 762
 763     h->slice_type = golomb_to_pict_type[i];
 764
 765     if ((header & 0x9F) == 2) {
 766         i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
 767         s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
 768     } else {
 769         skip_bits1(&s->gb);
 770         s->mb_skip_run = 0;
 771     }
 772
 773     h->slice_num = get_bits(&s->gb, 8);
 774     s->qscale = get_bits(&s->gb, 5);
 775     s->adaptive_quant = get_bits1(&s->gb);
 776
 777     /* unknown fields */
 778     skip_bits1(&s->gb);
 779
 780     if (svq3->unknown_flag) {
 781         skip_bits1(&s->gb);
 782     }
 783
 784     skip_bits1(&s->gb);
 785     skip_bits(&s->gb, 2);
 786
 787     while (get_bits1(&s->gb)) {
 788         skip_bits(&s->gb, 8);
 789     }
 790
 791     /* reset intra predictors and invalidate motion vector references */
 792     if (s->mb_x > 0) {
 793         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
 794         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
 795     }
 796     if (s->mb_y > 0) {
 797         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
 798
 799         if (s->mb_x > 0) {
 800             h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
 801         }
 802     }
 803
 804     return 0;
 805 }
 806
 807 static av_cold int svq3_decode_init(AVCodecContext *avctx)
 808 {
 809     SVQ3Context *svq3 = avctx->priv_data;
 810     H264Context *h = &svq3->h;
 811     MpegEncContext *s = &h->s;
 812     int m;
 813     unsigned char *extradata;
 814     unsigned int size;
 815
 816     if (ff_h264_decode_init(avctx) < 0)
 817         return -1;
 818
 819     s->flags  = avctx->flags;
 820     s->flags2 = avctx->flags2;
 821     s->unrestricted_mv = 1;
 822     h->is_complex=1;
 823     avctx->pix_fmt = avctx->codec->pix_fmts[0];
 824
 825     if (!s->context_initialized) {
 826         h->chroma_qp[0] = h->chroma_qp[1] = 4;
 827
 828         svq3->halfpel_flag  = 1;
 829         svq3->thirdpel_flag = 1;
 830         svq3->unknown_flag  = 0;
 831
 832         /* prowl for the "SEQH" marker in the extradata */
 833         extradata = (unsigned char *)avctx->extradata;
 834         for (m = 0; m < avctx->extradata_size; m++) {
 835             if (!memcmp(extradata, "SEQH", 4))
 836                 break;
 837             extradata++;
 838         }
 839
 840         /* if a match was found, parse the extra data */
 841         if (extradata && !memcmp(extradata, "SEQH", 4)) {
 842
 843             GetBitContext gb;
 844             int frame_size_code;
 845
 846             size = AV_RB32(&extradata[4]);
 847             init_get_bits(&gb, extradata + 8, size*8);
 848
 849             /* 'frame size code' and optional 'width, height' */
 850             frame_size_code = get_bits(&gb, 3);
 851             switch (frame_size_code) {
 852                 case 0: avctx->width = 160; avctx->height = 120; break;
 853                 case 1: avctx->width = 128; avctx->height =  96; break;
 854                 case 2: avctx->width = 176; avctx->height = 144; break;
 855                 case 3: avctx->width = 352; avctx->height = 288; break;
 856                 case 4: avctx->width = 704; avctx->height = 576; break;
 857                 case 5: avctx->width = 240; avctx->height = 180; break;
 858                 case 6: avctx->width = 320; avctx->height = 240; break;
 859                 case 7:
 860                     avctx->width  = get_bits(&gb, 12);
 861                     avctx->height = get_bits(&gb, 12);
 862                     break;
 863             }
 864
 865             svq3->halfpel_flag  = get_bits1(&gb);
 866             svq3->thirdpel_flag = get_bits1(&gb);
 867
 868             /* unknown fields */
 869             skip_bits1(&gb);
 870             skip_bits1(&gb);
 871             skip_bits1(&gb);
 872             skip_bits1(&gb);
 873
 874             s->low_delay = get_bits1(&gb);
 875
 876             /* unknown field */
 877             skip_bits1(&gb);
 878
 879             while (get_bits1(&gb)) {
 880                 skip_bits(&gb, 8);
 881             }
 882
 883             svq3->unknown_flag = get_bits1(&gb);
 884             avctx->has_b_frames = !s->low_delay;
 885             if (svq3->unknown_flag) {
 886 #if CONFIG_ZLIB
 887                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 888                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
 889                 int u1 = svq3_get_ue_golomb(&gb);
 890                 int u2 = get_bits(&gb, 8);
 891                 int u3 = get_bits(&gb, 2);
 892                 int u4 = svq3_get_ue_golomb(&gb);
 893                 unsigned long buf_len = watermark_width*watermark_height*4;
 894                 int offset = (get_bits_count(&gb)+7)>>3;
 895                 uint8_t *buf;
 896
 897                 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
 898                     return -1;
 899
 900                 buf = av_malloc(buf_len);
 901                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
 902                 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
 903                 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
 904                     av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
 905                     av_free(buf);
 906                     return -1;
 907                 }
 908                 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
 909                 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
 910                 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
 911                 av_free(buf);
 912 #else
 913                 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
 914                 return -1;
 915 #endif
 916             }
 917         }
 918
 919         s->width  = avctx->width;
 920         s->height = avctx->height;
 921
 922         if (MPV_common_init(s) < 0)
 923             return -1;
 924
 925         h->b_stride = 4*s->mb_width;
 926
 927         if (ff_h264_alloc_tables(h) < 0) {
 928             av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
 929             return AVERROR(ENOMEM);
 930         }
 931     }
 932
 933     return 0;
 934 }
 935
 936 static int svq3_decode_frame(AVCodecContext *avctx,
 937                              void *data, int *data_size,
 938                              AVPacket *avpkt)
 939 {
 940     const uint8_t *buf = avpkt->data;
 941     SVQ3Context *svq3 = avctx->priv_data;
 942     H264Context *h = &svq3->h;
 943     MpegEncContext *s = &h->s;
 944     int buf_size = avpkt->size;
 945     int m, mb_type;
 946
 947     /* special case for last picture */
 948     if (buf_size == 0) {
 949         if (s->next_picture_ptr && !s->low_delay) {
 950             *(AVFrame *) data = *(AVFrame *) &s->next_picture;
 951             s->next_picture_ptr = NULL;
 952             *data_size = sizeof(AVFrame);
 953         }
 954         return 0;
 955     }
 956
 957     init_get_bits (&s->gb, buf, 8*buf_size);
 958
 959     s->mb_x = s->mb_y = h->mb_xy = 0;
 960
 961     if (svq3_decode_slice_header(avctx))
 962         return -1;
 963
 964     s->pict_type = h->slice_type;
 965     s->picture_number = h->slice_num;
 966
 967     if (avctx->debug&FF_DEBUG_PICT_INFO){
 968         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
 969                av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
 970                s->adaptive_quant, s->qscale, h->slice_num);
 971     }
 972
 973     /* for skipping the frame */
 974     s->current_picture.f.pict_type = s->pict_type;
 975     s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
 976
 977     /* Skip B-frames if we do not have reference frames. */
 978     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
 979         return 0;
 980     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
 981         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
 982         || avctx->skip_frame >= AVDISCARD_ALL)
 983         return 0;
 984
 985     if (s->next_p_frame_damaged) {
 986         if (s->pict_type == AV_PICTURE_TYPE_B)
 987             return 0;
 988         else
 989             s->next_p_frame_damaged = 0;
 990     }
 991
 992     if (ff_h264_frame_start(h) < 0)
 993         return -1;
 994
 995     if (s->pict_type == AV_PICTURE_TYPE_B) {
 996         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
 997
 998         if (h->frame_num_offset < 0) {
 999             h->frame_num_offset += 256;
1000         }
1001         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1002             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1003             return -1;
1004         }
1005     } else {
1006         h->prev_frame_num = h->frame_num;
1007         h->frame_num = h->slice_num;
1008         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1009
1010         if (h->prev_frame_num_offset < 0) {
1011             h->prev_frame_num_offset += 256;
1012         }
1013     }
1014
1015     for (m = 0; m < 2; m++){
1016         int i;
1017         for (i = 0; i < 4; i++){
1018             int j;
1019             for (j = -1; j < 4; j++)
1020                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1021             if (i < 3)
1022                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1023         }
1024     }
1025
1026     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1027         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1028             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1029
1030             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1031                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1032
1033                 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1034                 s->gb.size_in_bits = 8*buf_size;
1035
1036                 if (svq3_decode_slice_header(avctx))
1037                     return -1;
1038
1039                 /* TODO: support s->mb_skip_run */
1040             }
1041
1042             mb_type = svq3_get_ue_golomb(&s->gb);
1043
1044             if (s->pict_type == AV_PICTURE_TYPE_I) {
1045                 mb_type += 8;
1046             } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1047                 mb_type += 4;
1048             }
1049             if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1050                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1051                 return -1;
1052             }
1053
1054             if (mb_type != 0) {
1055                 ff_h264_hl_decode_mb (h);
1056             }
1057
1058             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1059                 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1060                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1061             }
1062         }
1063
1064         ff_draw_horiz_band(s, 16*s->mb_y, 16);
1065     }
1066
1067     MPV_frame_end(s);
1068
1069     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1070         *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1071     } else {
1072         *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1073     }
1074
1075     /* Do not output the last pic after seeking. */
1076     if (s->last_picture_ptr || s->low_delay) {
1077         *data_size = sizeof(AVFrame);
1078     }
1079
1080     return buf_size;
1081 }
1082
1083 static int svq3_decode_end(AVCodecContext *avctx)
1084 {
1085     SVQ3Context *svq3 = avctx->priv_data;
1086     H264Context *h = &svq3->h;
1087     MpegEncContext *s = &h->s;
1088
1089     ff_h264_free_context(h);
1090
1091     MPV_common_end(s);
1092
1093     return 0;
1094 }
1095
1096 AVCodec ff_svq3_decoder = {
1097     .name           = "svq3",
1098     .type           = AVMEDIA_TYPE_VIDEO,
1099     .id             = CODEC_ID_SVQ3,
1100     .priv_data_size = sizeof(SVQ3Context),
1101     .init           = svq3_decode_init,
1102     .close          = svq3_decode_end,
1103     .decode         = svq3_decode_frame,
1104     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1105     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1106     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1107 };