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