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 "mpegutils.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     H264Picture *cur_pic;
  73     H264Picture *next_pic;
  74     H264Picture *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 H264Picture *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     = AV_PIX_FMT_YUVJ420P;
 892     avctx->color_range = AVCOL_RANGE_JPEG;
 893
 894     h->chroma_qp[0] = h->chroma_qp[1] = 4;
 895     h->chroma_x_shift = h->chroma_y_shift = 1;
 896
 897     s->halfpel_flag  = 1;
 898     s->thirdpel_flag = 1;
 899     s->unknown_flag  = 0;
 900
 901     /* prowl for the "SEQH" marker in the extradata */
 902     extradata     = (unsigned char *)avctx->extradata;
 903     extradata_end = avctx->extradata + avctx->extradata_size;
 904     if (extradata) {
 905         for (m = 0; m + 8 < avctx->extradata_size; m++) {
 906             if (!memcmp(extradata, "SEQH", 4)) {
 907                 marker_found = 1;
 908                 break;
 909             }
 910             extradata++;
 911         }
 912     }
 913
 914     /* if a match was found, parse the extra data */
 915     if (marker_found) {
 916         GetBitContext gb;
 917         int frame_size_code;
 918
 919         size = AV_RB32(&extradata[4]);
 920         if (size > extradata_end - extradata - 8) {
 921             ret = AVERROR_INVALIDDATA;
 922             goto fail;
 923         }
 924         init_get_bits(&gb, extradata + 8, size * 8);
 925
 926         /* 'frame size code' and optional 'width, height' */
 927         frame_size_code = get_bits(&gb, 3);
 928         switch (frame_size_code) {
 929         case 0:
 930             avctx->width  = 160;
 931             avctx->height = 120;
 932             break;
 933         case 1:
 934             avctx->width  = 128;
 935             avctx->height =  96;
 936             break;
 937         case 2:
 938             avctx->width  = 176;
 939             avctx->height = 144;
 940             break;
 941         case 3:
 942             avctx->width  = 352;
 943             avctx->height = 288;
 944             break;
 945         case 4:
 946             avctx->width  = 704;
 947             avctx->height = 576;
 948             break;
 949         case 5:
 950             avctx->width  = 240;
 951             avctx->height = 180;
 952             break;
 953         case 6:
 954             avctx->width  = 320;
 955             avctx->height = 240;
 956             break;
 957         case 7:
 958             avctx->width  = get_bits(&gb, 12);
 959             avctx->height = get_bits(&gb, 12);
 960             break;
 961         }
 962
 963         s->halfpel_flag  = get_bits1(&gb);
 964         s->thirdpel_flag = get_bits1(&gb);
 965
 966         /* unknown fields */
 967         skip_bits1(&gb);
 968         skip_bits1(&gb);
 969         skip_bits1(&gb);
 970         skip_bits1(&gb);
 971
 972         h->low_delay = get_bits1(&gb);
 973
 974         /* unknown field */
 975         skip_bits1(&gb);
 976
 977         if (skip_1stop_8data_bits(&gb) < 0) {
 978             ret = AVERROR_INVALIDDATA;
 979             goto fail;
 980         }
 981
 982         s->unknown_flag  = get_bits1(&gb);
 983         avctx->has_b_frames = !h->low_delay;
 984         if (s->unknown_flag) {
 985 #if CONFIG_ZLIB
 986             unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 987             unsigned watermark_height = svq3_get_ue_golomb(&gb);
 988             int u1                    = svq3_get_ue_golomb(&gb);
 989             int u2                    = get_bits(&gb, 8);
 990             int u3                    = get_bits(&gb, 2);
 991             int u4                    = svq3_get_ue_golomb(&gb);
 992             unsigned long buf_len     = watermark_width *
 993                                         watermark_height * 4;
 994             int offset                = get_bits_count(&gb) + 7 >> 3;
 995             uint8_t *buf;
 996
 997             if (watermark_height <= 0 ||
 998                 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
 999                 ret = -1;
1000                 goto fail;
1001             }
1002
1003             buf = av_malloc(buf_len);
1004             av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
1005                    watermark_width, watermark_height);
1006             av_log(avctx, AV_LOG_DEBUG,
1007                    "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1008                    u1, u2, u3, u4, offset);
1009             if (uncompress(buf, &buf_len, extradata + 8 + offset,
1010                            size - offset) != Z_OK) {
1011                 av_log(avctx, AV_LOG_ERROR,
1012                        "could not uncompress watermark logo\n");
1013                 av_free(buf);
1014                 ret = -1;
1015                 goto fail;
1016             }
1017             s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1018             s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1019             av_log(avctx, AV_LOG_DEBUG,
1020                    "watermark key %#x\n", s->watermark_key);
1021             av_free(buf);
1022 #else
1023             av_log(avctx, AV_LOG_ERROR,
1024                    "this svq3 file contains watermark which need zlib support compiled in\n");
1025             ret = -1;
1026             goto fail;
1027 #endif
1028         }
1029     }
1030
1031     h->width  = avctx->width;
1032     h->height = avctx->height;
1033     h->mb_width  = (h->width + 15) / 16;
1034     h->mb_height = (h->height + 15) / 16;
1035     h->mb_stride = h->mb_width + 1;
1036     h->mb_num    = h->mb_width * h->mb_height;
1037     h->b_stride = 4 * h->mb_width;
1038     s->h_edge_pos = h->mb_width * 16;
1039     s->v_edge_pos = h->mb_height * 16;
1040
1041     if ((ret = ff_h264_alloc_tables(h)) < 0) {
1042         av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1043         goto fail;
1044     }
1045
1046     return 0;
1047 fail:
1048     svq3_decode_end(avctx);
1049     return ret;
1050 }
1051
1052 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1053 {
1054     int i;
1055     for (i = 0; i < 2; i++) {
1056         av_buffer_unref(&pic->motion_val_buf[i]);
1057         av_buffer_unref(&pic->ref_index_buf[i]);
1058     }
1059     av_buffer_unref(&pic->mb_type_buf);
1060
1061     av_frame_unref(&pic->f);
1062 }
1063
1064 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1065 {
1066     SVQ3Context *s = avctx->priv_data;
1067     H264Context *h = &s->h;
1068     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
1069     const int mb_array_size = h->mb_stride * h->mb_height;
1070     const int b4_stride     = h->mb_width * 4 + 1;
1071     const int b4_array_size = b4_stride * h->mb_height * 4;
1072     int ret;
1073
1074     if (!pic->motion_val_buf[0]) {
1075         int i;
1076
1077         pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1078         if (!pic->mb_type_buf)
1079             return AVERROR(ENOMEM);
1080         pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1081
1082         for (i = 0; i < 2; i++) {
1083             pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1084             pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
1085             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1086                 ret = AVERROR(ENOMEM);
1087                 goto fail;
1088             }
1089
1090             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1091             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1092         }
1093     }
1094     pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1095
1096     ret = ff_get_buffer(avctx, &pic->f,
1097                         pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1098     if (ret < 0)
1099         goto fail;
1100
1101     if (!h->edge_emu_buffer) {
1102         h->edge_emu_buffer = av_mallocz(pic->f.linesize[0] * 17);
1103         if (!h->edge_emu_buffer)
1104             return AVERROR(ENOMEM);
1105     }
1106
1107     h->linesize   = pic->f.linesize[0];
1108     h->uvlinesize = pic->f.linesize[1];
1109
1110     return 0;
1111 fail:
1112     free_picture(avctx, pic);
1113     return ret;
1114 }
1115
1116 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1117                              int *got_frame, AVPacket *avpkt)
1118 {
1119     SVQ3Context *s     = avctx->priv_data;
1120     H264Context *h     = &s->h;
1121     int buf_size       = avpkt->size;
1122     int left;
1123     uint8_t *buf;
1124     int ret, m, i;
1125
1126     /* special case for last picture */
1127     if (buf_size == 0) {
1128         if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
1129             ret = av_frame_ref(data, &s->next_pic->f);
1130             if (ret < 0)
1131                 return ret;
1132             s->last_frame_output = 1;
1133             *got_frame          = 1;
1134         }
1135         return 0;
1136     }
1137
1138     h->mb_x = h->mb_y = h->mb_xy = 0;
1139
1140     if (s->watermark_key) {
1141         av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1142         if (!s->buf)
1143             return AVERROR(ENOMEM);
1144         memcpy(s->buf, avpkt->data, buf_size);
1145         buf = s->buf;
1146     } else {
1147         buf = avpkt->data;
1148     }
1149
1150     init_get_bits(&h->gb, buf, 8 * buf_size);
1151
1152     if (svq3_decode_slice_header(avctx))
1153         return -1;
1154
1155     h->pict_type = h->slice_type;
1156
1157     if (h->pict_type != AV_PICTURE_TYPE_B)
1158         FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1159
1160     av_frame_unref(&s->cur_pic->f);
1161
1162     /* for skipping the frame */
1163     s->cur_pic->f.pict_type = h->pict_type;
1164     s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1165
1166     ret = get_buffer(avctx, s->cur_pic);
1167     if (ret < 0)
1168         return ret;
1169
1170     h->cur_pic_ptr = s->cur_pic;
1171     av_frame_unref(&h->cur_pic.f);
1172     h->cur_pic     = *s->cur_pic;
1173     ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1174     if (ret < 0)
1175         return ret;
1176
1177     for (i = 0; i < 16; i++) {
1178         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1179         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1180     }
1181     for (i = 0; i < 16; i++) {
1182         h->block_offset[16 + i]      =
1183         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1184         h->block_offset[48 + 16 + i] =
1185         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1186     }
1187
1188     if (h->pict_type != AV_PICTURE_TYPE_I) {
1189         if (!s->last_pic->f.data[0]) {
1190             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1191             av_frame_unref(s->last_pic);
1192             ret = get_buffer(avctx, s->last_pic);
1193             if (ret < 0)
1194                 return ret;
1195             memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1196             memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1197                    s->last_pic->f.linesize[1]);
1198             memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1199                    s->last_pic->f.linesize[2]);
1200         }
1201
1202         if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1203             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1204             av_frame_unref(s->next_pic);
1205             ret = get_buffer(avctx, s->next_pic);
1206             if (ret < 0)
1207                 return ret;
1208             memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1209             memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1210                    s->next_pic->f.linesize[1]);
1211             memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1212                    s->next_pic->f.linesize[2]);
1213         }
1214     }
1215
1216     if (avctx->debug & FF_DEBUG_PICT_INFO)
1217         av_log(h->avctx, AV_LOG_DEBUG,
1218                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1219                av_get_picture_type_char(h->pict_type),
1220                s->halfpel_flag, s->thirdpel_flag,
1221                s->adaptive_quant, h->qscale, h->slice_num);
1222
1223     if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1224         avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1225         avctx->skip_frame >= AVDISCARD_ALL)
1226         return 0;
1227
1228     if (s->next_p_frame_damaged) {
1229         if (h->pict_type == AV_PICTURE_TYPE_B)
1230             return 0;
1231         else
1232             s->next_p_frame_damaged = 0;
1233     }
1234
1235     if (h->pict_type == AV_PICTURE_TYPE_B) {
1236         h->frame_num_offset = h->slice_num - h->prev_frame_num;
1237
1238         if (h->frame_num_offset < 0)
1239             h->frame_num_offset += 256;
1240         if (h->frame_num_offset == 0 ||
1241             h->frame_num_offset >= h->prev_frame_num_offset) {
1242             av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1243             return -1;
1244         }
1245     } else {
1246         h->prev_frame_num        = h->frame_num;
1247         h->frame_num             = h->slice_num;
1248         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1249
1250         if (h->prev_frame_num_offset < 0)
1251             h->prev_frame_num_offset += 256;
1252     }
1253
1254     for (m = 0; m < 2; m++) {
1255         int i;
1256         for (i = 0; i < 4; i++) {
1257             int j;
1258             for (j = -1; j < 4; j++)
1259                 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1260             if (i < 3)
1261                 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1262         }
1263     }
1264
1265     for (h->mb_y = 0; h->mb_y < h->mb_height; h->mb_y++) {
1266         for (h->mb_x = 0; h->mb_x < h->mb_width; h->mb_x++) {
1267             unsigned mb_type;
1268             h->mb_xy = h->mb_x + h->mb_y * h->mb_stride;
1269
1270             if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1271                 ((get_bits_count(&h->gb) & 7) == 0 ||
1272                  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1273                 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1274                 h->gb.size_in_bits = 8 * buf_size;
1275
1276                 if (svq3_decode_slice_header(avctx))
1277                     return -1;
1278
1279                 /* TODO: support s->mb_skip_run */
1280             }
1281
1282             mb_type = svq3_get_ue_golomb(&h->gb);
1283
1284             if (h->pict_type == AV_PICTURE_TYPE_I)
1285                 mb_type += 8;
1286             else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1287                 mb_type += 4;
1288             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1289                 av_log(h->avctx, AV_LOG_ERROR,
1290                        "error while decoding MB %d %d\n", h->mb_x, h->mb_y);
1291                 return -1;
1292             }
1293
1294             if (mb_type != 0 || h->cbp)
1295                 ff_h264_hl_decode_mb(h);
1296
1297             if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1298                 h->cur_pic.mb_type[h->mb_x + h->mb_y * h->mb_stride] =
1299                     (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1300         }
1301
1302         ff_draw_horiz_band(avctx, &s->cur_pic->f,
1303                            s->last_pic->f.data[0] ? &s->last_pic->f : NULL,
1304                            16 * h->mb_y, 16, h->picture_structure, 0,
1305                            h->low_delay);
1306     }
1307
1308     left = buf_size*8 - get_bits_count(&h->gb);
1309
1310     if (h->mb_y != h->mb_height || h->mb_x != h->mb_width) {
1311         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);
1312         //av_hex_dump(stderr, buf+buf_size-8, 8);
1313     }
1314
1315     if (left < 0) {
1316         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1317         return -1;
1318     }
1319
1320     if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1321         ret = av_frame_ref(data, &s->cur_pic->f);
1322     else if (s->last_pic->f.data[0])
1323         ret = av_frame_ref(data, &s->last_pic->f);
1324     if (ret < 0)
1325         return ret;
1326
1327     /* Do not output the last pic after seeking. */
1328     if (s->last_pic->f.data[0] || h->low_delay)
1329         *got_frame = 1;
1330
1331     if (h->pict_type != AV_PICTURE_TYPE_B) {
1332         FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1333     } else {
1334         av_frame_unref(&s->cur_pic->f);
1335     }
1336
1337     return buf_size;
1338 }
1339
1340 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1341 {
1342     SVQ3Context *s = avctx->priv_data;
1343     H264Context *h = &s->h;
1344
1345     free_picture(avctx, s->cur_pic);
1346     free_picture(avctx, s->next_pic);
1347     free_picture(avctx, s->last_pic);
1348     av_freep(&s->cur_pic);
1349     av_freep(&s->next_pic);
1350     av_freep(&s->last_pic);
1351
1352     av_frame_unref(&h->cur_pic.f);
1353
1354     ff_h264_free_context(h);
1355
1356     av_freep(&s->buf);
1357     s->buf_size = 0;
1358     av_freep(&h->edge_emu_buffer);
1359
1360     return 0;
1361 }
1362
1363 AVCodec ff_svq3_decoder = {
1364     .name           = "svq3",
1365     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1366     .type           = AVMEDIA_TYPE_VIDEO,
1367     .id             = AV_CODEC_ID_SVQ3,
1368     .priv_data_size = sizeof(SVQ3Context),
1369     .init           = svq3_decode_init,
1370     .close          = svq3_decode_end,
1371     .decode         = svq3_decode_frame,
1372     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
1373                       CODEC_CAP_DR1             |
1374                       CODEC_CAP_DELAY,
1375     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1376                                                      AV_PIX_FMT_NONE},
1377 };