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