git.sesse.net Git - ffmpeg/blob - libavcodec/svq3.c

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