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