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