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