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

   1 /*
   2  * Copyright (c) 2003 The FFmpeg Project
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /*
  22  * How to use this decoder:
  23  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
  24  * have stsd atoms to describe media trak properties. A stsd atom for a
  25  * video trak contains 1 or more ImageDescription atoms. These atoms begin
  26  * with the 4-byte length of the atom followed by the codec fourcc. Some
  27  * decoders need information in this atom to operate correctly. Such
  28  * is the case with SVQ3. In order to get the best use out of this decoder,
  29  * the calling app must make the SVQ3 ImageDescription atom available
  30  * via the AVCodecContext's extradata[_size] field:
  31  *
  32  * AVCodecContext.extradata = pointer to ImageDescription, first characters
  33  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
  34  * AVCodecContext.extradata_size = size of ImageDescription atom memory
  35  * buffer (which will be the same as the ImageDescription atom size field
  36  * from the QT file, minus 4 bytes since the length is missing)
  37  *
  38  * You will know you have these parameters passed correctly when the decoder
  39  * correctly decodes this file:
  40  *  http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
  41  */
  42 #include "internal.h"
  43 #include "dsputil.h"
  44 #include "avcodec.h"
  45 #include "mpegvideo.h"
  46 #include "h264.h"
  47
  48 #include "h264data.h" //FIXME FIXME FIXME
  49
  50 #include "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     uint8_t *buf;
  74     int buf_size;
  75 } SVQ3Context;
  76
  77 #define FULLPEL_MODE  1
  78 #define HALFPEL_MODE  2
  79 #define THIRDPEL_MODE 3
  80 #define PREDICT_MODE  4
  81
  82 /* dual scan (from some older h264 draft)
  83  o-->o-->o   o
  84          |  /|
  85  o   o   o / o
  86  | / |   |/  |
  87  o   o   o   o
  88    /
  89  o-->o-->o-->o
  90 */
  91 static const uint8_t svq3_scan[16] = {
  92     0+0*4, 1+0*4, 2+0*4, 2+1*4,
  93     2+2*4, 3+0*4, 3+1*4, 3+2*4,
  94     0+1*4, 0+2*4, 1+1*4, 1+2*4,
  95     0+3*4, 1+3*4, 2+3*4, 3+3*4,
  96 };
  97
  98 static const uint8_t svq3_pred_0[25][2] = {
  99     { 0, 0 },
 100     { 1, 0 }, { 0, 1 },
 101     { 0, 2 }, { 1, 1 }, { 2, 0 },
 102     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
 103     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
 104     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
 105     { 2, 4 }, { 3, 3 }, { 4, 2 },
 106     { 4, 3 }, { 3, 4 },
 107     { 4, 4 }
 108 };
 109
 110 static const int8_t svq3_pred_1[6][6][5] = {
 111     { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
 112       { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
 113     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
 114       { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
 115     { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
 116       { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
 117     { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
 118       { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
 119     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
 120       { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
 121     { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
 122       { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
 123 };
 124
 125 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
 126     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
 127       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
 128     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
 129       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
 130 };
 131
 132 static const uint32_t svq3_dequant_coeff[32] = {
 133      3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
 134      9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
 135     24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
 136     61694, 68745, 77615, 89113,100253,109366,126635,141533
 137 };
 138
 139 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
 140     const int qmul = svq3_dequant_coeff[qp];
 141 #define stride 16
 142     int i;
 143     int temp[16];
 144     static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
 145
 146     for(i=0; i<4; i++){
 147         const int z0 = 13*(input[4*i+0] +    input[4*i+2]);
 148         const int z1 = 13*(input[4*i+0] -    input[4*i+2]);
 149         const int z2 =  7* input[4*i+1] - 17*input[4*i+3];
 150         const int z3 = 17* input[4*i+1] +  7*input[4*i+3];
 151
 152         temp[4*i+0] = z0+z3;
 153         temp[4*i+1] = z1+z2;
 154         temp[4*i+2] = z1-z2;
 155         temp[4*i+3] = z0-z3;
 156     }
 157
 158     for(i=0; i<4; i++){
 159         const int offset= x_offset[i];
 160         const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
 161         const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
 162         const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
 163         const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
 164
 165         output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
 166         output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
 167         output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
 168         output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
 169     }
 170 }
 171 #undef stride
 172
 173 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
 174                             int dc)
 175 {
 176     const int qmul = svq3_dequant_coeff[qp];
 177     int i;
 178     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 179
 180     if (dc) {
 181         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
 182         block[0] = 0;
 183     }
 184
 185     for (i = 0; i < 4; i++) {
 186         const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
 187         const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
 188         const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
 189         const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
 190
 191         block[0 + 4*i] = z0 + z3;
 192         block[1 + 4*i] = z1 + z2;
 193         block[2 + 4*i] = z1 - z2;
 194         block[3 + 4*i] = z0 - z3;
 195     }
 196
 197     for (i = 0; i < 4; i++) {
 198         const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
 199         const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
 200         const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
 201         const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
 202         const int rr = (dc + 0x80000);
 203
 204         dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
 205         dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
 206         dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
 207         dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
 208     }
 209 }
 210
 211 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
 212                                     int index, const int type)
 213 {
 214     static const uint8_t *const scan_patterns[4] =
 215     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
 216
 217     int run, level, sign, vlc, limit;
 218     const int intra = (3 * type) >> 2;
 219     const uint8_t *const scan = scan_patterns[type];
 220
 221     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
 222         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
 223
 224           if (vlc == INVALID_VLC)
 225               return -1;
 226
 227           sign = (vlc & 0x1) - 1;
 228           vlc  = (vlc + 1) >> 1;
 229
 230           if (type == 3) {
 231               if (vlc < 3) {
 232                   run   = 0;
 233                   level = vlc;
 234               } else if (vlc < 4) {
 235                   run   = 1;
 236                   level = 1;
 237               } else {
 238                   run   = (vlc & 0x3);
 239                   level = ((vlc + 9) >> 2) - run;
 240               }
 241           } else {
 242               if (vlc < 16) {
 243                   run   = svq3_dct_tables[intra][vlc].run;
 244                   level = svq3_dct_tables[intra][vlc].level;
 245               } else if (intra) {
 246                   run   = (vlc & 0x7);
 247                   level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 248               } else {
 249                   run   = (vlc & 0xF);
 250                   level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 251               }
 252           }
 253
 254           if ((index += run) >= limit)
 255               return -1;
 256
 257           block[scan[index]] = (level ^ sign) - sign;
 258         }
 259
 260         if (type != 2) {
 261             break;
 262         }
 263     }
 264
 265     return 0;
 266 }
 267
 268 static inline void svq3_mc_dir_part(MpegEncContext *s,
 269                                     int x, int y, int width, int height,
 270                                     int mx, int my, int dxy,
 271                                     int thirdpel, int dir, int avg)
 272 {
 273     const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
 274     uint8_t *src, *dest;
 275     int i, emu = 0;
 276     int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
 277
 278     mx += x;
 279     my += y;
 280
 281     if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
 282         my < 0 || my >= (s->v_edge_pos - height - 1)) {
 283
 284         if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
 285             emu = 1;
 286         }
 287
 288         mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
 289         my = av_clip (my, -16, (s->v_edge_pos - height + 15));
 290     }
 291
 292     /* form component predictions */
 293     dest = s->current_picture.data[0] + x + y*s->linesize;
 294     src  = pic->data[0] + mx + my*s->linesize;
 295
 296     if (emu) {
 297         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
 298                             mx, my, s->h_edge_pos, s->v_edge_pos);
 299         src = s->edge_emu_buffer;
 300     }
 301     if (thirdpel)
 302         (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
 303     else
 304         (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
 305
 306     if (!(s->flags & CODEC_FLAG_GRAY)) {
 307         mx     = (mx + (mx < (int) x)) >> 1;
 308         my     = (my + (my < (int) y)) >> 1;
 309         width  = (width  >> 1);
 310         height = (height >> 1);
 311         blocksize++;
 312
 313         for (i = 1; i < 3; i++) {
 314             dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
 315             src  = pic->data[i] + mx + my*s->uvlinesize;
 316
 317             if (emu) {
 318                 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
 319                                     mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
 320                 src = s->edge_emu_buffer;
 321             }
 322             if (thirdpel)
 323                 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
 324             else
 325                 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
 326         }
 327     }
 328 }
 329
 330 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
 331                               int avg)
 332 {
 333     int i, j, k, mx, my, dx, dy, x, y;
 334     MpegEncContext *const s = (MpegEncContext *) h;
 335     const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 336     const int part_height = 16 >> ((unsigned) (size + 1) / 3);
 337     const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
 338     const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
 339     const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
 340
 341     for (i = 0; i < 16; i += part_height) {
 342         for (j = 0; j < 16; j += part_width) {
 343             const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
 344             int dxy;
 345             x = 16*s->mb_x + j;
 346             y = 16*s->mb_y + i;
 347             k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
 348
 349             if (mode != PREDICT_MODE) {
 350                 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
 351             } else {
 352                 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
 353                 my = s->next_picture.motion_val[0][b_xy][1]<<1;
 354
 355                 if (dir == 0) {
 356                     mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 357                     my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 358                 } else {
 359                     mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 360                     my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 361                 }
 362             }
 363
 364             /* clip motion vector prediction to frame border */
 365             mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
 366             my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
 367
 368             /* get (optional) motion vector differential */
 369             if (mode == PREDICT_MODE) {
 370                 dx = dy = 0;
 371             } else {
 372                 dy = svq3_get_se_golomb(&s->gb);
 373                 dx = svq3_get_se_golomb(&s->gb);
 374
 375                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 376                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 377                     return -1;
 378                 }
 379             }
 380
 381             /* compute motion vector */
 382             if (mode == THIRDPEL_MODE) {
 383                 int fx, fy;
 384                 mx  = ((mx + 1)>>1) + dx;
 385                 my  = ((my + 1)>>1) + dy;
 386                 fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
 387                 fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
 388                 dxy = (mx - 3*fx) + 4*(my - 3*fy);
 389
 390                 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
 391                 mx += mx;
 392                 my += my;
 393             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 394                 mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
 395                 my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
 396                 dxy = (mx&1) + 2*(my&1);
 397
 398                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
 399                 mx *= 3;
 400                 my *= 3;
 401             } else {
 402                 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
 403                 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
 404
 405                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
 406                 mx *= 6;
 407                 my *= 6;
 408             }
 409
 410             /* update mv_cache */
 411             if (mode != PREDICT_MODE) {
 412                 int32_t mv = pack16to32(mx,my);
 413
 414                 if (part_height == 8 && i < 8) {
 415                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
 416
 417                     if (part_width == 8 && j < 8) {
 418                         *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
 419                     }
 420                 }
 421                 if (part_width == 8 && j < 8) {
 422                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
 423                 }
 424                 if (part_width == 4 || part_height == 4) {
 425                     *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
 426                 }
 427             }
 428
 429             /* write back motion vectors */
 430             fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, 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.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.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.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.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.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.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.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.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.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.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.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
 833         /* prowl for the "SEQH" marker in the extradata */
 834         extradata = (unsigned char *)avctx->extradata;
 835         for (m = 0; m < avctx->extradata_size; m++) {
 836             if (!memcmp(extradata, "SEQH", 4))
 837                 break;
 838             extradata++;
 839         }
 840
 841         /* if a match was found, parse the extra data */
 842         if (extradata && !memcmp(extradata, "SEQH", 4)) {
 843
 844             GetBitContext gb;
 845             int frame_size_code;
 846
 847             size = AV_RB32(&extradata[4]);
 848             init_get_bits(&gb, extradata + 8, size*8);
 849
 850             /* 'frame size code' and optional 'width, height' */
 851             frame_size_code = get_bits(&gb, 3);
 852             switch (frame_size_code) {
 853                 case 0: avctx->width = 160; avctx->height = 120; break;
 854                 case 1: avctx->width = 128; avctx->height =  96; break;
 855                 case 2: avctx->width = 176; avctx->height = 144; break;
 856                 case 3: avctx->width = 352; avctx->height = 288; break;
 857                 case 4: avctx->width = 704; avctx->height = 576; break;
 858                 case 5: avctx->width = 240; avctx->height = 180; break;
 859                 case 6: avctx->width = 320; avctx->height = 240; break;
 860                 case 7:
 861                     avctx->width  = get_bits(&gb, 12);
 862                     avctx->height = get_bits(&gb, 12);
 863                     break;
 864             }
 865
 866             svq3->halfpel_flag  = get_bits1(&gb);
 867             svq3->thirdpel_flag = get_bits1(&gb);
 868
 869             /* unknown fields */
 870             skip_bits1(&gb);
 871             skip_bits1(&gb);
 872             skip_bits1(&gb);
 873             skip_bits1(&gb);
 874
 875             s->low_delay = get_bits1(&gb);
 876
 877             /* unknown field */
 878             skip_bits1(&gb);
 879
 880             while (get_bits1(&gb)) {
 881                 skip_bits(&gb, 8);
 882             }
 883
 884             svq3->unknown_flag = get_bits1(&gb);
 885             avctx->has_b_frames = !s->low_delay;
 886             if (svq3->unknown_flag) {
 887 #if CONFIG_ZLIB
 888                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 889                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
 890                 int u1 = svq3_get_ue_golomb(&gb);
 891                 int u2 = get_bits(&gb, 8);
 892                 int u3 = get_bits(&gb, 2);
 893                 int u4 = svq3_get_ue_golomb(&gb);
 894                 unsigned long buf_len = watermark_width*watermark_height*4;
 895                 int offset = (get_bits_count(&gb)+7)>>3;
 896                 uint8_t *buf;
 897
 898                 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
 899                     return -1;
 900
 901                 buf = av_malloc(buf_len);
 902                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
 903                 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
 904                 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
 905                     av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
 906                     av_free(buf);
 907                     return -1;
 908                 }
 909                 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
 910                 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
 911                 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
 912                 av_free(buf);
 913 #else
 914                 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
 915                 return -1;
 916 #endif
 917             }
 918         }
 919
 920         s->width  = avctx->width;
 921         s->height = avctx->height;
 922
 923         if (MPV_common_init(s) < 0)
 924             return -1;
 925
 926         h->b_stride = 4*s->mb_width;
 927
 928         ff_h264_alloc_tables(h);
 929     }
 930
 931     return 0;
 932 }
 933
 934 static int svq3_decode_frame(AVCodecContext *avctx,
 935                              void *data, int *data_size,
 936                              AVPacket *avpkt)
 937 {
 938     SVQ3Context *svq3 = avctx->priv_data;
 939     H264Context *h = &svq3->h;
 940     MpegEncContext *s = &h->s;
 941     int buf_size = avpkt->size;
 942     int m, mb_type, left;
 943     uint8_t *buf;
 944
 945     /* special case for last picture */
 946     if (buf_size == 0) {
 947         if (s->next_picture_ptr && !s->low_delay) {
 948             *(AVFrame *) data = *(AVFrame *) &s->next_picture;
 949             s->next_picture_ptr = NULL;
 950             *data_size = sizeof(AVFrame);
 951         }
 952         return 0;
 953     }
 954
 955     s->mb_x = s->mb_y = h->mb_xy = 0;
 956
 957     if (svq3->watermark_key) {
 958         av_fast_malloc(&svq3->buf, &svq3->buf_size,
 959                        buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
 960         if (!svq3->buf)
 961             return AVERROR(ENOMEM);
 962         memcpy(svq3->buf, avpkt->data, buf_size);
 963         buf = svq3->buf;
 964     } else {
 965         buf = avpkt->data;
 966     }
 967
 968     init_get_bits(&s->gb, buf, 8*buf_size);
 969
 970     if (svq3_decode_slice_header(avctx))
 971         return -1;
 972
 973     s->pict_type = h->slice_type;
 974     s->picture_number = h->slice_num;
 975
 976     if (avctx->debug&FF_DEBUG_PICT_INFO){
 977         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
 978                av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
 979                s->adaptive_quant, s->qscale, h->slice_num);
 980     }
 981
 982     /* for skipping the frame */
 983     s->current_picture.pict_type = s->pict_type;
 984     s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
 985
 986     /* Skip B-frames if we do not have reference frames. */
 987     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
 988         return 0;
 989     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
 990         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
 991         || avctx->skip_frame >= AVDISCARD_ALL)
 992         return 0;
 993
 994     if (s->next_p_frame_damaged) {
 995         if (s->pict_type == AV_PICTURE_TYPE_B)
 996             return 0;
 997         else
 998             s->next_p_frame_damaged = 0;
 999     }
1000
1001     if (ff_h264_frame_start(h) < 0)
1002         return -1;
1003
1004     if (s->pict_type == AV_PICTURE_TYPE_B) {
1005         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1006
1007         if (h->frame_num_offset < 0) {
1008             h->frame_num_offset += 256;
1009         }
1010         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1011             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1012             return -1;
1013         }
1014     } else {
1015         h->prev_frame_num = h->frame_num;
1016         h->frame_num = h->slice_num;
1017         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1018
1019         if (h->prev_frame_num_offset < 0) {
1020             h->prev_frame_num_offset += 256;
1021         }
1022     }
1023
1024     for (m = 0; m < 2; m++){
1025         int i;
1026         for (i = 0; i < 4; i++){
1027             int j;
1028             for (j = -1; j < 4; j++)
1029                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1030             if (i < 3)
1031                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1032         }
1033     }
1034
1035     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1036         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1037             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1038
1039             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1040                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1041
1042                 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1043                 s->gb.size_in_bits = 8*buf_size;
1044
1045                 if (svq3_decode_slice_header(avctx))
1046                     return -1;
1047
1048                 /* TODO: support s->mb_skip_run */
1049             }
1050
1051             mb_type = svq3_get_ue_golomb(&s->gb);
1052
1053             if (s->pict_type == AV_PICTURE_TYPE_I) {
1054                 mb_type += 8;
1055             } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1056                 mb_type += 4;
1057             }
1058             if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1059                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1060                 return -1;
1061             }
1062
1063             if (mb_type != 0) {
1064                 ff_h264_hl_decode_mb (h);
1065             }
1066
1067             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1068                 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1069                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1070             }
1071         }
1072
1073         ff_draw_horiz_band(s, 16*s->mb_y, 16);
1074     }
1075
1076     left = buf_size*8 - get_bits_count(&s->gb);
1077
1078     if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1079         av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, s->mb_y, s->mb_x, left);
1080         //av_hex_dump(stderr, buf+buf_size-8, 8);
1081     }
1082
1083     if (left < 0) {
1084         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1085         return -1;
1086     }
1087
1088     MPV_frame_end(s);
1089
1090     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1091         *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1092     } else {
1093         *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1094     }
1095
1096     /* Do not output the last pic after seeking. */
1097     if (s->last_picture_ptr || s->low_delay) {
1098         *data_size = sizeof(AVFrame);
1099     }
1100
1101     return buf_size;
1102 }
1103
1104 static int svq3_decode_end(AVCodecContext *avctx)
1105 {
1106     SVQ3Context *svq3 = avctx->priv_data;
1107     H264Context *h = &svq3->h;
1108     MpegEncContext *s = &h->s;
1109
1110     ff_h264_free_context(h);
1111
1112     MPV_common_end(s);
1113
1114     av_freep(&svq3->buf);
1115     svq3->buf_size = 0;
1116
1117     return 0;
1118 }
1119
1120 AVCodec ff_svq3_decoder = {
1121     "svq3",
1122     AVMEDIA_TYPE_VIDEO,
1123     CODEC_ID_SVQ3,
1124     sizeof(SVQ3Context),
1125     svq3_decode_init,
1126     NULL,
1127     svq3_decode_end,
1128     svq3_decode_frame,
1129     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1130     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1131     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1132 };