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