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
 179     if (dc) {
 180         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
 181         block[0] = 0;
 182     }
 183
 184     for (i = 0; i < 4; i++) {
 185         const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
 186         const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
 187         const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
 188         const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
 189
 190         block[0 + 4*i] = z0 + z3;
 191         block[1 + 4*i] = z1 + z2;
 192         block[2 + 4*i] = z1 - z2;
 193         block[3 + 4*i] = z0 - z3;
 194     }
 195
 196     for (i = 0; i < 4; i++) {
 197         const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
 198         const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
 199         const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
 200         const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
 201         const int rr = (dc + 0x80000);
 202
 203         dst[i + stride*0] = av_clip_uint8( dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) );
 204         dst[i + stride*1] = av_clip_uint8( dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) );
 205         dst[i + stride*2] = av_clip_uint8( dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) );
 206         dst[i + stride*3] = av_clip_uint8( dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) );
 207     }
 208 }
 209
 210 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
 211                                     int index, const int type)
 212 {
 213     static const uint8_t *const scan_patterns[4] =
 214     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
 215
 216     int run, level, sign, vlc, limit;
 217     const int intra = (3 * type) >> 2;
 218     const uint8_t *const scan = scan_patterns[type];
 219
 220     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
 221         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
 222
 223           if (vlc < 0)
 224               return -1;
 225
 226           sign = (vlc & 0x1) - 1;
 227           vlc  = (vlc + 1) >> 1;
 228
 229           if (type == 3) {
 230               if (vlc < 3) {
 231                   run   = 0;
 232                   level = vlc;
 233               } else if (vlc < 4) {
 234                   run   = 1;
 235                   level = 1;
 236               } else {
 237                   run   = (vlc & 0x3);
 238                   level = ((vlc + 9) >> 2) - run;
 239               }
 240           } else {
 241               if (vlc < 16U) {
 242                   run   = svq3_dct_tables[intra][vlc].run;
 243                   level = svq3_dct_tables[intra][vlc].level;
 244               } else if (intra) {
 245                   run   = (vlc & 0x7);
 246                   level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 247               } else {
 248                   run   = (vlc & 0xF);
 249                   level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 250               }
 251           }
 252
 253           if ((index += run) >= limit)
 254               return -1;
 255
 256           block[scan[index]] = (level ^ sign) - sign;
 257         }
 258
 259         if (type != 2) {
 260             break;
 261         }
 262     }
 263
 264     return 0;
 265 }
 266
 267 static inline void svq3_mc_dir_part(MpegEncContext *s,
 268                                     int x, int y, int width, int height,
 269                                     int mx, int my, int dxy,
 270                                     int thirdpel, int dir, int avg)
 271 {
 272     const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
 273     uint8_t *src, *dest;
 274     int i, emu = 0;
 275     int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
 276
 277     mx += x;
 278     my += y;
 279
 280     if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
 281         my < 0 || my >= (s->v_edge_pos - height - 1)) {
 282
 283         if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
 284             emu = 1;
 285         }
 286
 287         mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
 288         my = av_clip (my, -16, (s->v_edge_pos - height + 15));
 289     }
 290
 291     /* form component predictions */
 292     dest = s->current_picture.f.data[0] + x + y*s->linesize;
 293     src  = pic->f.data[0] + mx + my*s->linesize;
 294
 295     if (emu) {
 296         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
 297                             mx, my, s->h_edge_pos, s->v_edge_pos);
 298         src = s->edge_emu_buffer;
 299     }
 300     if (thirdpel)
 301         (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
 302     else
 303         (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
 304
 305     if (!(s->flags & CODEC_FLAG_GRAY)) {
 306         mx     = (mx + (mx < (int) x)) >> 1;
 307         my     = (my + (my < (int) y)) >> 1;
 308         width  = (width  >> 1);
 309         height = (height >> 1);
 310         blocksize++;
 311
 312         for (i = 1; i < 3; i++) {
 313             dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
 314             src  = pic->f.data[i] + mx + my * s->uvlinesize;
 315
 316             if (emu) {
 317                 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
 318                                     mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
 319                 src = s->edge_emu_buffer;
 320             }
 321             if (thirdpel)
 322                 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
 323             else
 324                 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
 325         }
 326     }
 327 }
 328
 329 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
 330                               int avg)
 331 {
 332     int i, j, k, mx, my, dx, dy, x, y;
 333     MpegEncContext *const s = (MpegEncContext *) h;
 334     const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 335     const int part_height = 16 >> ((unsigned) (size + 1) / 3);
 336     const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
 337     const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
 338     const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
 339
 340     for (i = 0; i < 16; i += part_height) {
 341         for (j = 0; j < 16; j += part_width) {
 342             const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
 343             int dxy;
 344             x = 16*s->mb_x + j;
 345             y = 16*s->mb_y + i;
 346             k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
 347
 348             if (mode != PREDICT_MODE) {
 349                 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
 350             } else {
 351                 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
 352                 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
 353
 354                 if (dir == 0) {
 355                     mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 356                     my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 357                 } else {
 358                     mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 359                     my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 360                 }
 361             }
 362
 363             /* clip motion vector prediction to frame border */
 364             mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
 365             my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
 366
 367             /* get (optional) motion vector differential */
 368             if (mode == PREDICT_MODE) {
 369                 dx = dy = 0;
 370             } else {
 371                 dy = svq3_get_se_golomb(&s->gb);
 372                 dx = svq3_get_se_golomb(&s->gb);
 373
 374                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 375                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 376                     return -1;
 377                 }
 378             }
 379
 380             /* compute motion vector */
 381             if (mode == THIRDPEL_MODE) {
 382                 int fx, fy;
 383                 mx  = ((mx + 1)>>1) + dx;
 384                 my  = ((my + 1)>>1) + dy;
 385                 fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
 386                 fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
 387                 dxy = (mx - 3*fx) + 4*(my - 3*fy);
 388
 389                 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
 390                 mx += mx;
 391                 my += my;
 392             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 393                 mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
 394                 my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
 395                 dxy = (mx&1) + 2*(my&1);
 396
 397                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
 398                 mx *= 3;
 399                 my *= 3;
 400             } else {
 401                 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
 402                 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
 403
 404                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
 405                 mx *= 6;
 406                 my *= 6;
 407             }
 408
 409             /* update mv_cache */
 410             if (mode != PREDICT_MODE) {
 411                 int32_t mv = pack16to32(mx,my);
 412
 413                 if (part_height == 8 && i < 8) {
 414                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
 415
 416                     if (part_width == 8 && j < 8) {
 417                         *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
 418                     }
 419                 }
 420                 if (part_width == 8 && j < 8) {
 421                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
 422                 }
 423                 if (part_width == 4 || part_height == 4) {
 424                     *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
 425                 }
 426             }
 427
 428             /* write back motion vectors */
 429             fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
 430                            part_width >> 2, part_height >> 2, h->b_stride,
 431                            pack16to32(mx, my), 4);
 432         }
 433     }
 434
 435     return 0;
 436 }
 437
 438 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
 439 {
 440     H264Context *h = &svq3->h;
 441     int i, j, k, m, dir, mode;
 442     int cbp = 0;
 443     uint32_t vlc;
 444     int8_t *top, *left;
 445     MpegEncContext *const s = (MpegEncContext *) h;
 446     const int mb_xy = h->mb_xy;
 447     const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
 448
 449     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 450     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 451     h->topright_samples_available = 0xFFFF;
 452
 453     if (mb_type == 0) {           /* SKIP */
 454         if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.f.mb_type[mb_xy] == -1) {
 455             svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
 456
 457             if (s->pict_type == AV_PICTURE_TYPE_B) {
 458                 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
 459             }
 460
 461             mb_type = MB_TYPE_SKIP;
 462         } else {
 463             mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
 464             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
 465                 return -1;
 466             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
 467                 return -1;
 468
 469             mb_type = MB_TYPE_16x16;
 470         }
 471     } else if (mb_type < 8) {     /* INTER */
 472         if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
 473             mode = THIRDPEL_MODE;
 474         } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
 475             mode = HALFPEL_MODE;
 476         } else {
 477             mode = FULLPEL_MODE;
 478         }
 479
 480         /* fill caches */
 481         /* note ref_cache should contain here:
 482             ????????
 483             ???11111
 484             N??11111
 485             N??11111
 486             N??11111
 487         */
 488
 489         for (m = 0; m < 2; m++) {
 490             if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
 491                 for (i = 0; i < 4; i++) {
 492                     *(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];
 493                 }
 494             } else {
 495                 for (i = 0; i < 4; i++) {
 496                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
 497                 }
 498             }
 499             if (s->mb_y > 0) {
 500                 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));
 501                 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);
 502
 503                 if (s->mb_x < (s->mb_width - 1)) {
 504                     *(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];
 505                     h->ref_cache[m][scan8[0] + 4 - 1*8] =
 506                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
 507                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
 508                 }else
 509                     h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
 510                 if (s->mb_x > 0) {
 511                     *(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];
 512                     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;
 513                 }else
 514                     h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
 515             }else
 516                 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
 517
 518             if (s->pict_type != AV_PICTURE_TYPE_B)
 519                 break;
 520         }
 521
 522         /* decode motion vector(s) and form prediction(s) */
 523         if (s->pict_type == AV_PICTURE_TYPE_P) {
 524             if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
 525                 return -1;
 526         } else {        /* AV_PICTURE_TYPE_B */
 527             if (mb_type != 2) {
 528                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
 529                     return -1;
 530             } else {
 531                 for (i = 0; i < 4; i++) {
 532                     memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 533                 }
 534             }
 535             if (mb_type != 1) {
 536                 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
 537                     return -1;
 538             } else {
 539                 for (i = 0; i < 4; i++) {
 540                     memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 541                 }
 542             }
 543         }
 544
 545         mb_type = MB_TYPE_16x16;
 546     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 547         memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
 548
 549         if (mb_type == 8) {
 550             if (s->mb_x > 0) {
 551                 for (i = 0; i < 4; i++) {
 552                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
 553                 }
 554                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
 555                     h->left_samples_available = 0x5F5F;
 556                 }
 557             }
 558             if (s->mb_y > 0) {
 559                 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
 560                 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
 561                 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
 562                 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
 563
 564                 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
 565                     h->top_samples_available = 0x33FF;
 566                 }
 567             }
 568
 569             /* decode prediction codes for luma blocks */
 570             for (i = 0; i < 16; i+=2) {
 571                 vlc = svq3_get_ue_golomb(&s->gb);
 572
 573                 if (vlc >= 25U){
 574                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
 575                     return -1;
 576                 }
 577
 578                 left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 579                 top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 580
 581                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 582                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 583
 584                 if (left[1] == -1 || left[2] == -1){
 585                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
 586                     return -1;
 587                 }
 588             }
 589         } else {    /* mb_type == 33, DC_128_PRED block type */
 590             for (i = 0; i < 4; i++) {
 591                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
 592             }
 593         }
 594
 595         write_back_intra_pred_mode(h);
 596
 597         if (mb_type == 8) {
 598             ff_h264_check_intra4x4_pred_mode(h);
 599
 600             h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 601             h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 602         } else {
 603             for (i = 0; i < 4; i++) {
 604                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
 605             }
 606
 607             h->top_samples_available  = 0x33FF;
 608             h->left_samples_available = 0x5F5F;
 609         }
 610
 611         mb_type = MB_TYPE_INTRA4x4;
 612     } else {                      /* INTRA16x16 */
 613         dir = i_mb_type_info[mb_type - 8].pred_mode;
 614         dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
 615
 616         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1){
 617             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
 618             return -1;
 619         }
 620
 621         cbp = i_mb_type_info[mb_type - 8].cbp;
 622         mb_type = MB_TYPE_INTRA16x16;
 623     }
 624
 625     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 626         for (i = 0; i < 4; i++) {
 627             memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 628         }
 629         if (s->pict_type == AV_PICTURE_TYPE_B) {
 630             for (i = 0; i < 4; i++) {
 631                 memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
 632             }
 633         }
 634     }
 635     if (!IS_INTRA4x4(mb_type)) {
 636         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
 637     }
 638     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 639         memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
 640         s->dsp.clear_blocks(h->mb+  0);
 641         s->dsp.clear_blocks(h->mb+384);
 642     }
 643
 644     if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 645         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48U){
 646             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
 647             return -1;
 648         }
 649
 650         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
 651     }
 652     if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 653         s->qscale += svq3_get_se_golomb(&s->gb);
 654
 655         if (s->qscale > 31U){
 656             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 657             return -1;
 658         }
 659     }
 660     if (IS_INTRA16x16(mb_type)) {
 661         AV_ZERO128(h->mb_luma_dc[0]+0);
 662         AV_ZERO128(h->mb_luma_dc[0]+8);
 663         if (svq3_decode_block(&s->gb, *h->mb_luma_dc, 0, 1)){
 664             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
 665             return -1;
 666         }
 667     }
 668
 669     if (cbp) {
 670         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 671         const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 672
 673         for (i = 0; i < 4; i++) {
 674             if ((cbp & (1 << i))) {
 675                 for (j = 0; j < 4; j++) {
 676                     k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
 677                     h->non_zero_count_cache[ scan8[k] ] = 1;
 678
 679                     if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
 680                         av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
 681                         return -1;
 682                     }
 683                 }
 684             }
 685         }
 686
 687         if ((cbp & 0x30)) {
 688             for (i = 1; i < 3; ++i) {
 689               if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
 690                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
 691                 return -1;
 692               }
 693             }
 694
 695             if ((cbp & 0x20)) {
 696                 for (i = 1; i < 3; i++) {
 697                     for (j = 0; j < 4; j++) {
 698                         k = 16*i + j;
 699                         h->non_zero_count_cache[ scan8[k] ] = 1;
 700
 701                         if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
 702                             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
 703                             return -1;
 704                         }
 705                     }
 706                 }
 707             }
 708         }
 709     }
 710
 711     h->cbp= cbp;
 712     s->current_picture.f.mb_type[mb_xy] = mb_type;
 713
 714     if (IS_INTRA(mb_type)) {
 715         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
 716     }
 717
 718     return 0;
 719 }
 720
 721 static int svq3_decode_slice_header(AVCodecContext *avctx)
 722 {
 723     SVQ3Context *svq3 = avctx->priv_data;
 724     H264Context *h = &svq3->h;
 725     MpegEncContext *s = &h->s;
 726     const int mb_xy = h->mb_xy;
 727     int i, header;
 728
 729     header = get_bits(&s->gb, 8);
 730
 731     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 732         /* TODO: what? */
 733         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 734         return -1;
 735     } else {
 736         int length = (header >> 5) & 3;
 737
 738         svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
 739
 740         if (svq3->next_slice_index > s->gb.size_in_bits) {
 741             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 742             return -1;
 743     }
 744
 745         s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
 746         skip_bits(&s->gb, 8);
 747
 748         if (svq3->watermark_key) {
 749             uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
 750             AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
 751         }
 752         if (length > 0) {
 753             memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
 754                    &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
 755         }
 756         skip_bits_long(&s->gb, 0);
 757     }
 758
 759     if ((i = svq3_get_ue_golomb(&s->gb)) >= 3U){
 760         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
 761         return -1;
 762     }
 763
 764     h->slice_type = golomb_to_pict_type[i];
 765
 766     if ((header & 0x9F) == 2) {
 767         i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
 768         s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
 769     } else {
 770         skip_bits1(&s->gb);
 771         s->mb_skip_run = 0;
 772     }
 773
 774     h->slice_num = get_bits(&s->gb, 8);
 775     s->qscale = get_bits(&s->gb, 5);
 776     s->adaptive_quant = get_bits1(&s->gb);
 777
 778     /* unknown fields */
 779     skip_bits1(&s->gb);
 780
 781     if (svq3->unknown_flag) {
 782         skip_bits1(&s->gb);
 783     }
 784
 785     skip_bits1(&s->gb);
 786     skip_bits(&s->gb, 2);
 787
 788     while (get_bits1(&s->gb)) {
 789         skip_bits(&s->gb, 8);
 790     }
 791
 792     /* reset intra predictors and invalidate motion vector references */
 793     if (s->mb_x > 0) {
 794         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
 795         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
 796     }
 797     if (s->mb_y > 0) {
 798         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
 799
 800         if (s->mb_x > 0) {
 801             h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
 802         }
 803     }
 804
 805     return 0;
 806 }
 807
 808 static av_cold int svq3_decode_init(AVCodecContext *avctx)
 809 {
 810     SVQ3Context *svq3 = avctx->priv_data;
 811     H264Context *h = &svq3->h;
 812     MpegEncContext *s = &h->s;
 813     int m;
 814     unsigned char *extradata;
 815     unsigned char *extradata_end;
 816     unsigned int size;
 817     int marker_found = 0;
 818
 819     if (ff_h264_decode_init(avctx) < 0)
 820         return -1;
 821
 822     s->flags  = avctx->flags;
 823     s->flags2 = avctx->flags2;
 824     s->unrestricted_mv = 1;
 825     h->is_complex=1;
 826     h->sps.chroma_format_idc = 1;
 827     avctx->pix_fmt = avctx->codec->pix_fmts[0];
 828
 829     if (!s->context_initialized) {
 830         h->chroma_qp[0] = h->chroma_qp[1] = 4;
 831
 832         svq3->halfpel_flag  = 1;
 833         svq3->thirdpel_flag = 1;
 834         svq3->unknown_flag  = 0;
 835
 836
 837         /* prowl for the "SEQH" marker in the extradata */
 838         extradata = (unsigned char *)avctx->extradata;
 839         extradata_end = avctx->extradata + avctx->extradata_size;
 840         if (extradata) {
 841             for (m = 0; m + 8 < avctx->extradata_size; m++) {
 842                 if (!memcmp(extradata, "SEQH", 4)) {
 843                     marker_found = 1;
 844                     break;
 845                 }
 846                 extradata++;
 847             }
 848         }
 849
 850         /* if a match was found, parse the extra data */
 851         if (marker_found) {
 852
 853             GetBitContext gb;
 854             int frame_size_code;
 855
 856             size = AV_RB32(&extradata[4]);
 857             if (size > extradata_end - extradata - 8)
 858                 return AVERROR_INVALIDDATA;
 859             init_get_bits(&gb, extradata + 8, size*8);
 860
 861             /* 'frame size code' and optional 'width, height' */
 862             frame_size_code = get_bits(&gb, 3);
 863             switch (frame_size_code) {
 864                 case 0: avctx->width = 160; avctx->height = 120; break;
 865                 case 1: avctx->width = 128; avctx->height =  96; break;
 866                 case 2: avctx->width = 176; avctx->height = 144; break;
 867                 case 3: avctx->width = 352; avctx->height = 288; break;
 868                 case 4: avctx->width = 704; avctx->height = 576; break;
 869                 case 5: avctx->width = 240; avctx->height = 180; break;
 870                 case 6: avctx->width = 320; avctx->height = 240; break;
 871                 case 7:
 872                     avctx->width  = get_bits(&gb, 12);
 873                     avctx->height = get_bits(&gb, 12);
 874                     break;
 875             }
 876
 877             svq3->halfpel_flag  = get_bits1(&gb);
 878             svq3->thirdpel_flag = get_bits1(&gb);
 879
 880             /* unknown fields */
 881             skip_bits1(&gb);
 882             skip_bits1(&gb);
 883             skip_bits1(&gb);
 884             skip_bits1(&gb);
 885
 886             s->low_delay = get_bits1(&gb);
 887
 888             /* unknown field */
 889             skip_bits1(&gb);
 890
 891             while (get_bits1(&gb)) {
 892                 skip_bits(&gb, 8);
 893             }
 894
 895             svq3->unknown_flag = get_bits1(&gb);
 896             avctx->has_b_frames = !s->low_delay;
 897             if (svq3->unknown_flag) {
 898 #if CONFIG_ZLIB
 899                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 900                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
 901                 int u1 = svq3_get_ue_golomb(&gb);
 902                 int u2 = get_bits(&gb, 8);
 903                 int u3 = get_bits(&gb, 2);
 904                 int u4 = svq3_get_ue_golomb(&gb);
 905                 unsigned long buf_len = watermark_width*watermark_height*4;
 906                 int offset = (get_bits_count(&gb)+7)>>3;
 907                 uint8_t *buf;
 908
 909                 if (watermark_height<=0 || (uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
 910                     return -1;
 911
 912                 buf = av_malloc(buf_len);
 913                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
 914                 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
 915                 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
 916                     av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
 917                     av_free(buf);
 918                     return -1;
 919                 }
 920                 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
 921                 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
 922                 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
 923                 av_free(buf);
 924 #else
 925                 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
 926                 return -1;
 927 #endif
 928             }
 929         }
 930
 931         s->width  = avctx->width;
 932         s->height = avctx->height;
 933
 934         if (ff_MPV_common_init(s) < 0)
 935             return -1;
 936
 937         h->b_stride = 4*s->mb_width;
 938
 939         if (ff_h264_alloc_tables(h) < 0) {
 940             av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
 941             return AVERROR(ENOMEM);
 942         }
 943     }
 944
 945     return 0;
 946 }
 947
 948 static int svq3_decode_frame(AVCodecContext *avctx,
 949                              void *data, int *data_size,
 950                              AVPacket *avpkt)
 951 {
 952     SVQ3Context *svq3 = avctx->priv_data;
 953     H264Context *h = &svq3->h;
 954     MpegEncContext *s = &h->s;
 955     int buf_size = avpkt->size;
 956     int m, mb_type, left;
 957     uint8_t *buf;
 958
 959     /* special case for last picture */
 960     if (buf_size == 0) {
 961         if (s->next_picture_ptr && !s->low_delay) {
 962             *(AVFrame *) data   = s->next_picture.f;
 963             s->next_picture_ptr = NULL;
 964             *data_size = sizeof(AVFrame);
 965         }
 966         return 0;
 967     }
 968
 969     s->mb_x = s->mb_y = h->mb_xy = 0;
 970
 971     if (svq3->watermark_key) {
 972         av_fast_malloc(&svq3->buf, &svq3->buf_size,
 973                        buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
 974         if (!svq3->buf)
 975             return AVERROR(ENOMEM);
 976         memcpy(svq3->buf, avpkt->data, buf_size);
 977         buf = svq3->buf;
 978     } else {
 979         buf = avpkt->data;
 980     }
 981
 982     init_get_bits(&s->gb, buf, 8*buf_size);
 983
 984     if (svq3_decode_slice_header(avctx))
 985         return -1;
 986
 987     s->pict_type = h->slice_type;
 988     s->picture_number = h->slice_num;
 989
 990     if (avctx->debug&FF_DEBUG_PICT_INFO){
 991         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
 992                av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
 993                s->adaptive_quant, s->qscale, h->slice_num);
 994     }
 995
 996     /* for skipping the frame */
 997     s->current_picture.f.pict_type = s->pict_type;
 998     s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
 999
1000     /* Skip B-frames if we do not have reference frames. */
1001     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1002         return 0;
1003     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
1004         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
1005         || avctx->skip_frame >= AVDISCARD_ALL)
1006         return 0;
1007
1008     if (s->next_p_frame_damaged) {
1009         if (s->pict_type == AV_PICTURE_TYPE_B)
1010             return 0;
1011         else
1012             s->next_p_frame_damaged = 0;
1013     }
1014
1015     if (ff_h264_frame_start(h) < 0)
1016         return -1;
1017
1018     if (s->pict_type == AV_PICTURE_TYPE_B) {
1019         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1020
1021         if (h->frame_num_offset < 0) {
1022             h->frame_num_offset += 256;
1023         }
1024         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1025             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1026             return -1;
1027         }
1028     } else {
1029         h->prev_frame_num = h->frame_num;
1030         h->frame_num = h->slice_num;
1031         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1032
1033         if (h->prev_frame_num_offset < 0) {
1034             h->prev_frame_num_offset += 256;
1035         }
1036     }
1037
1038     for (m = 0; m < 2; m++){
1039         int i;
1040         for (i = 0; i < 4; i++){
1041             int j;
1042             for (j = -1; j < 4; j++)
1043                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1044             if (i < 3)
1045                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1046         }
1047     }
1048
1049     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1050         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1051             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1052
1053             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1054                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1055
1056                 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1057                 s->gb.size_in_bits = 8*buf_size;
1058
1059                 if (svq3_decode_slice_header(avctx))
1060                     return -1;
1061
1062                 /* TODO: support s->mb_skip_run */
1063             }
1064
1065             mb_type = svq3_get_ue_golomb(&s->gb);
1066
1067             if (s->pict_type == AV_PICTURE_TYPE_I) {
1068                 mb_type += 8;
1069             } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1070                 mb_type += 4;
1071             }
1072             if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1073                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1074                 return -1;
1075             }
1076
1077             if (mb_type != 0) {
1078                 ff_h264_hl_decode_mb (h);
1079             }
1080
1081             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1082                 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1083                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1084             }
1085         }
1086
1087         ff_draw_horiz_band(s, 16*s->mb_y, 16);
1088     }
1089
1090     left = buf_size*8 - get_bits_count(&s->gb);
1091
1092     if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1093         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);
1094         //av_hex_dump(stderr, buf+buf_size-8, 8);
1095     }
1096
1097     if (left < 0) {
1098         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1099         return -1;
1100     }
1101
1102     ff_MPV_frame_end(s);
1103
1104     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1105         *(AVFrame *) data = s->current_picture.f;
1106     } else {
1107         *(AVFrame *) data = s->last_picture.f;
1108     }
1109
1110     /* Do not output the last pic after seeking. */
1111     if (s->last_picture_ptr || s->low_delay) {
1112         *data_size = sizeof(AVFrame);
1113     }
1114
1115     return buf_size;
1116 }
1117
1118 static int svq3_decode_end(AVCodecContext *avctx)
1119 {
1120     SVQ3Context *svq3 = avctx->priv_data;
1121     H264Context *h = &svq3->h;
1122     MpegEncContext *s = &h->s;
1123
1124     ff_h264_free_context(h);
1125
1126     ff_MPV_common_end(s);
1127
1128     av_freep(&svq3->buf);
1129     svq3->buf_size = 0;
1130
1131     return 0;
1132 }
1133
1134 AVCodec ff_svq3_decoder = {
1135     .name           = "svq3",
1136     .type           = AVMEDIA_TYPE_VIDEO,
1137     .id             = CODEC_ID_SVQ3,
1138     .priv_data_size = sizeof(SVQ3Context),
1139     .init           = svq3_decode_init,
1140     .close          = svq3_decode_end,
1141     .decode         = svq3_decode_frame,
1142     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
1143                       CODEC_CAP_DELAY,
1144     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1145     .pix_fmts       = (const enum PixelFormat[]){ PIX_FMT_YUVJ420P, PIX_FMT_NONE },
1146 };