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