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