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

   1 /*
   2  * Copyright (c) 2003 The Libav Project
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libav is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Libav; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /*
  22  * How to use this decoder:
  23  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
  24  * have stsd atoms to describe media trak properties. A stsd atom for a
  25  * video trak contains 1 or more ImageDescription atoms. These atoms begin
  26  * with the 4-byte length of the atom followed by the codec fourcc. Some
  27  * decoders need information in this atom to operate correctly. Such
  28  * is the case with SVQ3. In order to get the best use out of this decoder,
  29  * the calling app must make the SVQ3 ImageDescription atom available
  30  * via the AVCodecContext's extradata[_size] field:
  31  *
  32  * AVCodecContext.extradata = pointer to ImageDescription, first characters
  33  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
  34  * AVCodecContext.extradata_size = size of ImageDescription atom memory
  35  * buffer (which will be the same as the ImageDescription atom size field
  36  * from the QT file, minus 4 bytes since the length is missing)
  37  *
  38  * You will know you have these parameters passed correctly when the decoder
  39  * correctly decodes this file:
  40  *  http://samples.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
  41  */
  42
  43 #include <inttypes.h>
  44
  45 #include "libavutil/attributes.h"
  46
  47 #include "bitstream.h"
  48 #include "golomb.h"
  49 #include "internal.h"
  50 #include "avcodec.h"
  51 #include "mpegutils.h"
  52 #include "h264dec.h"
  53 #include "h264data.h"
  54 #include "hpeldsp.h"
  55 #include "mathops.h"
  56 #include "rectangle.h"
  57 #include "tpeldsp.h"
  58
  59 #if CONFIG_ZLIB
  60 #include <zlib.h>
  61 #endif
  62
  63 #include "svq1.h"
  64
  65 /**
  66  * @file
  67  * svq3 decoder.
  68  */
  69
  70 typedef struct SVQ3Frame {
  71     AVFrame *f;
  72
  73     AVBufferRef *motion_val_buf[2];
  74     int16_t (*motion_val[2])[2];
  75
  76     AVBufferRef *mb_type_buf;
  77     uint32_t *mb_type;
  78
  79
  80     AVBufferRef *ref_index_buf[2];
  81     int8_t *ref_index[2];
  82 } SVQ3Frame;
  83
  84 typedef struct SVQ3Context {
  85     AVCodecContext *avctx;
  86
  87     H264DSPContext  h264dsp;
  88     H264PredContext hpc;
  89     HpelDSPContext hdsp;
  90     TpelDSPContext tdsp;
  91     VideoDSPContext vdsp;
  92
  93     SVQ3Frame *cur_pic;
  94     SVQ3Frame *next_pic;
  95     SVQ3Frame *last_pic;
  96     BitstreamContext bc;
  97     BitstreamContext bc_slice;
  98     uint8_t *slice_buf;
  99     int slice_size;
 100     int halfpel_flag;
 101     int thirdpel_flag;
 102     int unknown_flag;
 103     uint32_t watermark_key;
 104     int adaptive_quant;
 105     int next_p_frame_damaged;
 106     int h_edge_pos;
 107     int v_edge_pos;
 108     int last_frame_output;
 109     int slice_num;
 110     int qscale;
 111     int cbp;
 112     int frame_num;
 113     int frame_num_offset;
 114     int prev_frame_num_offset;
 115     int prev_frame_num;
 116
 117     enum AVPictureType pict_type;
 118     int low_delay;
 119
 120     int mb_x, mb_y;
 121     int mb_xy;
 122     int mb_width, mb_height;
 123     int mb_stride, mb_num;
 124     int b_stride;
 125
 126     uint32_t *mb2br_xy;
 127
 128     int chroma_pred_mode;
 129     int intra16x16_pred_mode;
 130
 131     int8_t   intra4x4_pred_mode_cache[5 * 8];
 132     int8_t (*intra4x4_pred_mode);
 133
 134     unsigned int top_samples_available;
 135     unsigned int topright_samples_available;
 136     unsigned int left_samples_available;
 137
 138     uint8_t *edge_emu_buffer;
 139
 140     DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
 141     DECLARE_ALIGNED(8,  int8_t, ref_cache)[2][5 * 8];
 142     DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
 143     DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
 144     DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
 145     uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
 146     int block_offset[2 * (16 * 3)];
 147 } SVQ3Context;
 148
 149 #define FULLPEL_MODE  1
 150 #define HALFPEL_MODE  2
 151 #define THIRDPEL_MODE 3
 152 #define PREDICT_MODE  4
 153
 154 /* dual scan (from some older H.264 draft)
 155  * o-->o-->o   o
 156  *         |  /|
 157  * o   o   o / o
 158  * | / |   |/  |
 159  * o   o   o   o
 160  *   /
 161  * o-->o-->o-->o
 162  */
 163 static const uint8_t svq3_scan[16] = {
 164     0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
 165     2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
 166     0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
 167     0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
 168 };
 169
 170 static const uint8_t luma_dc_zigzag_scan[16] = {
 171     0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
 172     3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
 173     1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
 174     3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
 175 };
 176
 177 static const uint8_t svq3_pred_0[25][2] = {
 178     { 0, 0 },
 179     { 1, 0 }, { 0, 1 },
 180     { 0, 2 }, { 1, 1 }, { 2, 0 },
 181     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
 182     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
 183     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
 184     { 2, 4 }, { 3, 3 }, { 4, 2 },
 185     { 4, 3 }, { 3, 4 },
 186     { 4, 4 }
 187 };
 188
 189 static const int8_t svq3_pred_1[6][6][5] = {
 190     { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
 191       { 2,  1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
 192     { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  4,  3 }, { 0, 1,  2,  4,  3 },
 193       { 0,  2,  1,  4,  3 }, { 2, 0,  1,  3,  4 }, { 0, 4,  2,  1,  3 } },
 194     { { 2,  0, -1, -1, -1 }, { 2, 1,  0,  4,  3 }, { 1, 2,  4,  0,  3 },
 195       { 2,  1,  0,  4,  3 }, { 2, 1,  4,  3,  0 }, { 1, 2,  4,  0,  3 } },
 196     { { 2,  0, -1, -1, -1 }, { 2, 0,  1,  4,  3 }, { 1, 2,  0,  4,  3 },
 197       { 2,  1,  0,  4,  3 }, { 2, 1,  3,  4,  0 }, { 2, 4,  1,  0,  3 } },
 198     { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  3,  4 }, { 1, 2,  3,  0,  4 },
 199       { 2,  0,  1,  3,  4 }, { 2, 1,  3,  0,  4 }, { 2, 0,  4,  3,  1 } },
 200     { { 0,  2, -1, -1, -1 }, { 0, 2,  4,  1,  3 }, { 1, 4,  2,  0,  3 },
 201       { 4,  2,  0,  1,  3 }, { 2, 0,  1,  4,  3 }, { 4, 2,  1,  0,  3 } },
 202 };
 203
 204 static const struct {
 205     uint8_t run;
 206     uint8_t level;
 207 } svq3_dct_tables[2][16] = {
 208     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
 209       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
 210     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
 211       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
 212 };
 213
 214 static const uint32_t svq3_dequant_coeff[32] = {
 215      3881,  4351,  4890,  5481,   6154,   6914,   7761,   8718,
 216      9781, 10987, 12339, 13828,  15523,  17435,  19561,  21873,
 217     24552, 27656, 30847, 34870,  38807,  43747,  49103,  54683,
 218     61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
 219 };
 220
 221 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
 222 {
 223     const int qmul = svq3_dequant_coeff[qp];
 224 #define stride 16
 225     int i;
 226     int temp[16];
 227     static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
 228
 229     for (i = 0; i < 4; i++) {
 230         const int z0 = 13 * (input[4 * i + 0] +      input[4 * i + 2]);
 231         const int z1 = 13 * (input[4 * i + 0] -      input[4 * i + 2]);
 232         const int z2 =  7 *  input[4 * i + 1] - 17 * input[4 * i + 3];
 233         const int z3 = 17 *  input[4 * i + 1] +  7 * input[4 * i + 3];
 234
 235         temp[4 * i + 0] = z0 + z3;
 236         temp[4 * i + 1] = z1 + z2;
 237         temp[4 * i + 2] = z1 - z2;
 238         temp[4 * i + 3] = z0 - z3;
 239     }
 240
 241     for (i = 0; i < 4; i++) {
 242         const int offset = x_offset[i];
 243         const int z0     = 13 * (temp[4 * 0 + i] +      temp[4 * 2 + i]);
 244         const int z1     = 13 * (temp[4 * 0 + i] -      temp[4 * 2 + i]);
 245         const int z2     =  7 *  temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
 246         const int z3     = 17 *  temp[4 * 1 + i] +  7 * temp[4 * 3 + i];
 247
 248         output[stride *  0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
 249         output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
 250         output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
 251         output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
 252     }
 253 }
 254 #undef stride
 255
 256 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
 257                             int stride, int qp, int dc)
 258 {
 259     const int qmul = svq3_dequant_coeff[qp];
 260     int i;
 261
 262     if (dc) {
 263         dc       = 13 * 13 * (dc == 1 ? 1538 * block[0]
 264                                       : qmul * (block[0] >> 3) / 2);
 265         block[0] = 0;
 266     }
 267
 268     for (i = 0; i < 4; i++) {
 269         const int z0 = 13 * (block[0 + 4 * i] +      block[2 + 4 * i]);
 270         const int z1 = 13 * (block[0 + 4 * i] -      block[2 + 4 * i]);
 271         const int z2 =  7 *  block[1 + 4 * i] - 17 * block[3 + 4 * i];
 272         const int z3 = 17 *  block[1 + 4 * i] +  7 * block[3 + 4 * i];
 273
 274         block[0 + 4 * i] = z0 + z3;
 275         block[1 + 4 * i] = z1 + z2;
 276         block[2 + 4 * i] = z1 - z2;
 277         block[3 + 4 * i] = z0 - z3;
 278     }
 279
 280     for (i = 0; i < 4; i++) {
 281         const int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
 282         const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
 283         const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
 284         const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
 285         const int rr = (dc + 0x80000);
 286
 287         dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
 288         dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
 289         dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
 290         dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
 291     }
 292
 293     memset(block, 0, 16 * sizeof(int16_t));
 294 }
 295
 296 static inline int svq3_decode_block(BitstreamContext *bc, int16_t *block,
 297                                     int index, const int type)
 298 {
 299     static const uint8_t *const scan_patterns[4] = {
 300         luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
 301     };
 302
 303     int run, level, limit;
 304     unsigned vlc;
 305     const int intra           = 3 * type >> 2;
 306     const uint8_t *const scan = scan_patterns[type];
 307
 308     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
 309         for (; (vlc = get_interleaved_ue_golomb(bc)) != 0; index++) {
 310             int sign = (vlc & 1) ? 0 : -1;
 311             vlc      = vlc + 1 >> 1;
 312
 313             if (type == 3) {
 314                 if (vlc < 3) {
 315                     run   = 0;
 316                     level = vlc;
 317                 } else if (vlc < 4) {
 318                     run   = 1;
 319                     level = 1;
 320                 } else {
 321                     run   = vlc & 0x3;
 322                     level = (vlc + 9 >> 2) - run;
 323                 }
 324             } else {
 325                 if (vlc < 16) {
 326                     run   = svq3_dct_tables[intra][vlc].run;
 327                     level = svq3_dct_tables[intra][vlc].level;
 328                 } else if (intra) {
 329                     run   = vlc & 0x7;
 330                     level = (vlc >> 3) +
 331                             ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 332                 } else {
 333                     run   = vlc & 0xF;
 334                     level = (vlc >> 4) +
 335                             ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 336                 }
 337             }
 338
 339             if ((index += run) >= limit)
 340                 return -1;
 341
 342             block[scan[index]] = (level ^ sign) - sign;
 343         }
 344
 345         if (type != 2) {
 346             break;
 347         }
 348     }
 349
 350     return 0;
 351 }
 352
 353 static av_always_inline int
 354 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
 355                        int i, int list, int part_width)
 356 {
 357     const int topright_ref = s->ref_cache[list][i - 8 + part_width];
 358
 359     if (topright_ref != PART_NOT_AVAILABLE) {
 360         *C = s->mv_cache[list][i - 8 + part_width];
 361         return topright_ref;
 362     } else {
 363         *C = s->mv_cache[list][i - 8 - 1];
 364         return s->ref_cache[list][i - 8 - 1];
 365     }
 366 }
 367
 368 /**
 369  * Get the predicted MV.
 370  * @param n the block index
 371  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
 372  * @param mx the x component of the predicted motion vector
 373  * @param my the y component of the predicted motion vector
 374  */
 375 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
 376                                               int part_width, int list,
 377                                               int ref, int *const mx, int *const my)
 378 {
 379     const int index8       = scan8[n];
 380     const int top_ref      = s->ref_cache[list][index8 - 8];
 381     const int left_ref     = s->ref_cache[list][index8 - 1];
 382     const int16_t *const A = s->mv_cache[list][index8 - 1];
 383     const int16_t *const B = s->mv_cache[list][index8 - 8];
 384     const int16_t *C;
 385     int diagonal_ref, match_count;
 386
 387 /* mv_cache
 388  * B . . A T T T T
 389  * U . . L . . , .
 390  * U . . L . . . .
 391  * U . . L . . , .
 392  * . . . L . . . .
 393  */
 394
 395     diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
 396     match_count  = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
 397     if (match_count > 1) { //most common
 398         *mx = mid_pred(A[0], B[0], C[0]);
 399         *my = mid_pred(A[1], B[1], C[1]);
 400     } else if (match_count == 1) {
 401         if (left_ref == ref) {
 402             *mx = A[0];
 403             *my = A[1];
 404         } else if (top_ref == ref) {
 405             *mx = B[0];
 406             *my = B[1];
 407         } else {
 408             *mx = C[0];
 409             *my = C[1];
 410         }
 411     } else {
 412         if (top_ref      == PART_NOT_AVAILABLE &&
 413             diagonal_ref == PART_NOT_AVAILABLE &&
 414             left_ref     != PART_NOT_AVAILABLE) {
 415             *mx = A[0];
 416             *my = A[1];
 417         } else {
 418             *mx = mid_pred(A[0], B[0], C[0]);
 419             *my = mid_pred(A[1], B[1], C[1]);
 420         }
 421     }
 422 }
 423
 424 static inline void svq3_mc_dir_part(SVQ3Context *s,
 425                                     int x, int y, int width, int height,
 426                                     int mx, int my, int dxy,
 427                                     int thirdpel, int dir, int avg)
 428 {
 429     const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
 430     uint8_t *src, *dest;
 431     int i, emu = 0;
 432     int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
 433     int linesize   = s->cur_pic->f->linesize[0];
 434     int uvlinesize = s->cur_pic->f->linesize[1];
 435
 436     mx += x;
 437     my += y;
 438
 439     if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
 440         my < 0 || my >= s->v_edge_pos - height - 1) {
 441         emu = 1;
 442         mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
 443         my = av_clip(my, -16, s->v_edge_pos - height + 15);
 444     }
 445
 446     /* form component predictions */
 447     dest = s->cur_pic->f->data[0] + x + y * linesize;
 448     src  = pic->f->data[0] + mx + my * linesize;
 449
 450     if (emu) {
 451         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
 452                                  linesize, linesize,
 453                                  width + 1, height + 1,
 454                                  mx, my, s->h_edge_pos, s->v_edge_pos);
 455         src = s->edge_emu_buffer;
 456     }
 457     if (thirdpel)
 458         (avg ? s->tdsp.avg_tpel_pixels_tab
 459              : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
 460                                                  width, height);
 461     else
 462         (avg ? s->hdsp.avg_pixels_tab
 463              : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
 464                                                        height);
 465
 466     if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
 467         mx     = mx + (mx < (int) x) >> 1;
 468         my     = my + (my < (int) y) >> 1;
 469         width  = width  >> 1;
 470         height = height >> 1;
 471         blocksize++;
 472
 473         for (i = 1; i < 3; i++) {
 474             dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
 475             src  = pic->f->data[i] + mx + my * uvlinesize;
 476
 477             if (emu) {
 478                 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
 479                                          uvlinesize, uvlinesize,
 480                                          width + 1, height + 1,
 481                                          mx, my, (s->h_edge_pos >> 1),
 482                                          s->v_edge_pos >> 1);
 483                 src = s->edge_emu_buffer;
 484             }
 485             if (thirdpel)
 486                 (avg ? s->tdsp.avg_tpel_pixels_tab
 487                      : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
 488                                                          uvlinesize,
 489                                                          width, height);
 490             else
 491                 (avg ? s->hdsp.avg_pixels_tab
 492                      : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
 493                                                                uvlinesize,
 494                                                                height);
 495         }
 496     }
 497 }
 498
 499 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
 500                               int dir, int avg)
 501 {
 502     int i, j, k, mx, my, dx, dy, x, y;
 503     const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 504     const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
 505     const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
 506     const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
 507     const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
 508
 509     for (i = 0; i < 16; i += part_height)
 510         for (j = 0; j < 16; j += part_width) {
 511             const int b_xy = (4 * s->mb_x + (j >> 2)) +
 512                              (4 * s->mb_y + (i >> 2)) * s->b_stride;
 513             int dxy;
 514             x = 16 * s->mb_x + j;
 515             y = 16 * s->mb_y + i;
 516             k = (j >> 2 & 1) + (i >> 1 & 2) +
 517                 (j >> 1 & 4) + (i      & 8);
 518
 519             if (mode != PREDICT_MODE) {
 520                 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
 521             } else {
 522                 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
 523                 my = s->next_pic->motion_val[0][b_xy][1] << 1;
 524
 525                 if (dir == 0) {
 526                     mx = mx * s->frame_num_offset /
 527                          s->prev_frame_num_offset + 1 >> 1;
 528                     my = my * s->frame_num_offset /
 529                          s->prev_frame_num_offset + 1 >> 1;
 530                 } else {
 531                     mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
 532                          s->prev_frame_num_offset + 1 >> 1;
 533                     my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
 534                          s->prev_frame_num_offset + 1 >> 1;
 535                 }
 536             }
 537
 538             /* clip motion vector prediction to frame border */
 539             mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
 540             my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
 541
 542             /* get (optional) motion vector differential */
 543             if (mode == PREDICT_MODE) {
 544                 dx = dy = 0;
 545             } else {
 546                 dy = get_interleaved_se_golomb(&s->bc_slice);
 547                 dx = get_interleaved_se_golomb(&s->bc_slice);
 548
 549                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 550                     av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 551                     return -1;
 552                 }
 553             }
 554
 555             /* compute motion vector */
 556             if (mode == THIRDPEL_MODE) {
 557                 int fx, fy;
 558                 mx  = (mx + 1 >> 1) + dx;
 559                 my  = (my + 1 >> 1) + dy;
 560                 fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
 561                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 562                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
 563
 564                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 565                                  fx, fy, dxy, 1, dir, avg);
 566                 mx += mx;
 567                 my += my;
 568             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 569                 mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
 570                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 571                 dxy = (mx & 1) + 2 * (my & 1);
 572
 573                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 574                                  mx >> 1, my >> 1, dxy, 0, dir, avg);
 575                 mx *= 3;
 576                 my *= 3;
 577             } else {
 578                 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
 579                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
 580
 581                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 582                                  mx, my, 0, 0, dir, avg);
 583                 mx *= 6;
 584                 my *= 6;
 585             }
 586
 587             /* update mv_cache */
 588             if (mode != PREDICT_MODE) {
 589                 int32_t mv = pack16to32(mx, my);
 590
 591                 if (part_height == 8 && i < 8) {
 592                     AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
 593
 594                     if (part_width == 8 && j < 8)
 595                         AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
 596                 }
 597                 if (part_width == 8 && j < 8)
 598                     AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
 599                 if (part_width == 4 || part_height == 4)
 600                     AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
 601             }
 602
 603             /* write back motion vectors */
 604             fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
 605                            part_width >> 2, part_height >> 2, s->b_stride,
 606                            pack16to32(mx, my), 4);
 607         }
 608
 609     return 0;
 610 }
 611
 612 static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s,
 613                                                     int mb_type, const int *block_offset,
 614                                                     int linesize, uint8_t *dest_y)
 615 {
 616     int i;
 617     if (!IS_INTRA4x4(mb_type)) {
 618         for (i = 0; i < 16; i++)
 619             if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
 620                 uint8_t *const ptr = dest_y + block_offset[i];
 621                 svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
 622                                 s->qscale, IS_INTRA(mb_type) ? 1 : 0);
 623             }
 624     }
 625 }
 626
 627 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
 628                                                        int mb_type,
 629                                                        const int *block_offset,
 630                                                        int linesize,
 631                                                        uint8_t *dest_y)
 632 {
 633     int i;
 634     int qscale = s->qscale;
 635
 636     if (IS_INTRA4x4(mb_type)) {
 637         for (i = 0; i < 16; i++) {
 638             uint8_t *const ptr = dest_y + block_offset[i];
 639             const int dir      = s->intra4x4_pred_mode_cache[scan8[i]];
 640
 641             uint8_t *topright;
 642             int nnz, tr;
 643             if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
 644                 const int topright_avail = (s->topright_samples_available << i) & 0x8000;
 645                 assert(s->mb_y || linesize <= block_offset[i]);
 646                 if (!topright_avail) {
 647                     tr       = ptr[3 - linesize] * 0x01010101u;
 648                     topright = (uint8_t *)&tr;
 649                 } else
 650                     topright = ptr + 4 - linesize;
 651             } else
 652                 topright = NULL;
 653
 654             s->hpc.pred4x4[dir](ptr, topright, linesize);
 655             nnz = s->non_zero_count_cache[scan8[i]];
 656             if (nnz) {
 657                 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
 658             }
 659         }
 660     } else {
 661         s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
 662         svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
 663     }
 664 }
 665
 666 static void hl_decode_mb(SVQ3Context *s)
 667 {
 668     const int mb_x    = s->mb_x;
 669     const int mb_y    = s->mb_y;
 670     const int mb_xy   = s->mb_xy;
 671     const int mb_type = s->cur_pic->mb_type[mb_xy];
 672     uint8_t *dest_y, *dest_cb, *dest_cr;
 673     int linesize, uvlinesize;
 674     int i, j;
 675     const int *block_offset = &s->block_offset[0];
 676     const int block_h   = 16 >> 1;
 677
 678     linesize   = s->cur_pic->f->linesize[0];
 679     uvlinesize = s->cur_pic->f->linesize[1];
 680
 681     dest_y  = s->cur_pic->f->data[0] + (mb_x     + mb_y * linesize)  * 16;
 682     dest_cb = s->cur_pic->f->data[1] +  mb_x * 8 + mb_y * uvlinesize * block_h;
 683     dest_cr = s->cur_pic->f->data[2] +  mb_x * 8 + mb_y * uvlinesize * block_h;
 684
 685     s->vdsp.prefetch(dest_y  + (s->mb_x & 3) * 4 * linesize   + 64, linesize,      4);
 686     s->vdsp.prefetch(dest_cb + (s->mb_x & 7)     * uvlinesize + 64, dest_cr - dest_cb, 2);
 687
 688     if (IS_INTRA(mb_type)) {
 689         s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
 690         s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
 691
 692         hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
 693     }
 694
 695     hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
 696
 697     if (s->cbp & 0x30) {
 698         uint8_t *dest[2] = { dest_cb, dest_cr };
 699         s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
 700                                                s->dequant4_coeff[4][0]);
 701         s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
 702                                                s->dequant4_coeff[4][0]);
 703         for (j = 1; j < 3; j++) {
 704             for (i = j * 16; i < j * 16 + 4; i++)
 705                 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
 706                     uint8_t *const ptr = dest[j - 1] + block_offset[i];
 707                     svq3_add_idct_c(ptr, s->mb + i * 16,
 708                                     uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
 709                 }
 710         }
 711     }
 712 }
 713
 714 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
 715 {
 716     int i, j, k, m, dir, mode;
 717     int cbp = 0;
 718     uint32_t vlc;
 719     int8_t *top, *left;
 720     const int mb_xy = s->mb_xy;
 721     const int b_xy  = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
 722
 723     s->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 724     s->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 725     s->topright_samples_available = 0xFFFF;
 726
 727     if (mb_type == 0) {           /* SKIP */
 728         if (s->pict_type == AV_PICTURE_TYPE_P ||
 729             s->next_pic->mb_type[mb_xy] == -1) {
 730             svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 731                              0, 0, 0, 0, 0, 0);
 732
 733             if (s->pict_type == AV_PICTURE_TYPE_B)
 734                 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 735                                  0, 0, 0, 0, 1, 1);
 736
 737             mb_type = MB_TYPE_SKIP;
 738         } else {
 739             mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
 740             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
 741                 return -1;
 742             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
 743                 return -1;
 744
 745             mb_type = MB_TYPE_16x16;
 746         }
 747     } else if (mb_type < 8) {     /* INTER */
 748         if (s->thirdpel_flag && s->halfpel_flag == !bitstream_read_bit(&s->bc_slice))
 749             mode = THIRDPEL_MODE;
 750         else if (s->halfpel_flag &&
 751                  s->thirdpel_flag == !bitstream_read_bit(&s->bc_slice))
 752             mode = HALFPEL_MODE;
 753         else
 754             mode = FULLPEL_MODE;
 755
 756         /* fill caches */
 757         /* note ref_cache should contain here:
 758          *  ????????
 759          *  ???11111
 760          *  N??11111
 761          *  N??11111
 762          *  N??11111
 763          */
 764
 765         for (m = 0; m < 2; m++) {
 766             if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
 767                 for (i = 0; i < 4; i++)
 768                     AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
 769                               s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
 770             } else {
 771                 for (i = 0; i < 4; i++)
 772                     AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
 773             }
 774             if (s->mb_y > 0) {
 775                 memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
 776                        s->cur_pic->motion_val[m][b_xy - s->b_stride],
 777                        4 * 2 * sizeof(int16_t));
 778                 memset(&s->ref_cache[m][scan8[0] - 1 * 8],
 779                        (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 780
 781                 if (s->mb_x < s->mb_width - 1) {
 782                     AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
 783                               s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
 784                     s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 785                         (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
 786                          s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 787                 } else
 788                     s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
 789                 if (s->mb_x > 0) {
 790                     AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
 791                               s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
 792                     s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 793                         (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 794                 } else
 795                     s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 796             } else
 797                 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
 798                        PART_NOT_AVAILABLE, 8);
 799
 800             if (s->pict_type != AV_PICTURE_TYPE_B)
 801                 break;
 802         }
 803
 804         /* decode motion vector(s) and form prediction(s) */
 805         if (s->pict_type == AV_PICTURE_TYPE_P) {
 806             if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
 807                 return -1;
 808         } else {        /* AV_PICTURE_TYPE_B */
 809             if (mb_type != 2) {
 810                 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
 811                     return -1;
 812             } else {
 813                 for (i = 0; i < 4; i++)
 814                     memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
 815                            0, 4 * 2 * sizeof(int16_t));
 816             }
 817             if (mb_type != 1) {
 818                 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
 819                     return -1;
 820             } else {
 821                 for (i = 0; i < 4; i++)
 822                     memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
 823                            0, 4 * 2 * sizeof(int16_t));
 824             }
 825         }
 826
 827         mb_type = MB_TYPE_16x16;
 828     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 829         int8_t *i4x4       = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
 830         int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
 831
 832         memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
 833
 834         if (mb_type == 8) {
 835             if (s->mb_x > 0) {
 836                 for (i = 0; i < 4; i++)
 837                     s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
 838                 if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
 839                     s->left_samples_available = 0x5F5F;
 840             }
 841             if (s->mb_y > 0) {
 842                 s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
 843                 s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
 844                 s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
 845                 s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
 846
 847                 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
 848                     s->top_samples_available = 0x33FF;
 849             }
 850
 851             /* decode prediction codes for luma blocks */
 852             for (i = 0; i < 16; i += 2) {
 853                 vlc = get_interleaved_ue_golomb(&s->bc_slice);
 854
 855                 if (vlc >= 25) {
 856                     av_log(s->avctx, AV_LOG_ERROR,
 857                            "luma prediction:%"PRIu32"\n", vlc);
 858                     return -1;
 859                 }
 860
 861                 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
 862                 top  = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
 863
 864                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 865                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 866
 867                 if (left[1] == -1 || left[2] == -1) {
 868                     av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
 869                     return -1;
 870                 }
 871             }
 872         } else {    /* mb_type == 33, DC_128_PRED block type */
 873             for (i = 0; i < 4; i++)
 874                 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
 875         }
 876
 877         AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
 878         i4x4[4] = i4x4_cache[7 + 8 * 3];
 879         i4x4[5] = i4x4_cache[7 + 8 * 2];
 880         i4x4[6] = i4x4_cache[7 + 8 * 1];
 881
 882         if (mb_type == 8) {
 883             ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
 884                                              s->avctx, s->top_samples_available,
 885                                              s->left_samples_available);
 886
 887             s->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 888             s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 889         } else {
 890             for (i = 0; i < 4; i++)
 891                 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
 892
 893             s->top_samples_available  = 0x33FF;
 894             s->left_samples_available = 0x5F5F;
 895         }
 896
 897         mb_type = MB_TYPE_INTRA4x4;
 898     } else {                      /* INTRA16x16 */
 899         dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
 900         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
 901
 902         if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
 903                                                                      s->left_samples_available, dir, 0)) < 0) {
 904             av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
 905             return s->intra16x16_pred_mode;
 906         }
 907
 908         cbp     = ff_h264_i_mb_type_info[mb_type - 8].cbp;
 909         mb_type = MB_TYPE_INTRA16x16;
 910     }
 911
 912     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 913         for (i = 0; i < 4; i++)
 914             memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
 915                    0, 4 * 2 * sizeof(int16_t));
 916         if (s->pict_type == AV_PICTURE_TYPE_B) {
 917             for (i = 0; i < 4; i++)
 918                 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
 919                        0, 4 * 2 * sizeof(int16_t));
 920         }
 921     }
 922     if (!IS_INTRA4x4(mb_type)) {
 923         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
 924     }
 925     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 926         memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 927     }
 928
 929     if (!IS_INTRA16x16(mb_type) &&
 930         (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 931         if ((vlc = get_interleaved_ue_golomb(&s->bc_slice)) >= 48) {
 932             av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
 933             return -1;
 934         }
 935
 936         cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
 937                                 : ff_h264_golomb_to_inter_cbp[vlc];
 938     }
 939     if (IS_INTRA16x16(mb_type) ||
 940         (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 941         s->qscale += get_interleaved_se_golomb(&s->bc_slice);
 942
 943         if (s->qscale > 31u) {
 944             av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 945             return -1;
 946         }
 947     }
 948     if (IS_INTRA16x16(mb_type)) {
 949         AV_ZERO128(s->mb_luma_dc[0] + 0);
 950         AV_ZERO128(s->mb_luma_dc[0] + 8);
 951         if (svq3_decode_block(&s->bc_slice, s->mb_luma_dc[0], 0, 1)) {
 952             av_log(s->avctx, AV_LOG_ERROR,
 953                    "error while decoding intra luma dc\n");
 954             return -1;
 955         }
 956     }
 957
 958     if (cbp) {
 959         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 960         const int type  = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 961
 962         for (i = 0; i < 4; i++)
 963             if ((cbp & (1 << i))) {
 964                 for (j = 0; j < 4; j++) {
 965                     k = index ? (1 * (j & 1) + 2 * (i & 1) +
 966                                  2 * (j & 2) + 4 * (i & 2))
 967                               : (4 * i + j);
 968                     s->non_zero_count_cache[scan8[k]] = 1;
 969
 970                     if (svq3_decode_block(&s->bc_slice, &s->mb[16 * k], index, type)) {
 971                         av_log(s->avctx, AV_LOG_ERROR,
 972                                "error while decoding block\n");
 973                         return -1;
 974                     }
 975                 }
 976             }
 977
 978         if ((cbp & 0x30)) {
 979             for (i = 1; i < 3; ++i)
 980                 if (svq3_decode_block(&s->bc_slice, &s->mb[16 * 16 * i], 0, 3)) {
 981                     av_log(s->avctx, AV_LOG_ERROR,
 982                            "error while decoding chroma dc block\n");
 983                     return -1;
 984                 }
 985
 986             if ((cbp & 0x20)) {
 987                 for (i = 1; i < 3; i++) {
 988                     for (j = 0; j < 4; j++) {
 989                         k                                 = 16 * i + j;
 990                         s->non_zero_count_cache[scan8[k]] = 1;
 991
 992                         if (svq3_decode_block(&s->bc_slice, &s->mb[16 * k], 1, 1)) {
 993                             av_log(s->avctx, AV_LOG_ERROR,
 994                                    "error while decoding chroma ac block\n");
 995                             return -1;
 996                         }
 997                     }
 998                 }
 999             }
1000         }
1001     }
1002
1003     s->cbp                     = cbp;
1004     s->cur_pic->mb_type[mb_xy] = mb_type;
1005
1006     if (IS_INTRA(mb_type))
1007         s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1008                                                             s->left_samples_available, DC_PRED8x8, 1);
1009
1010     return 0;
1011 }
1012
1013 static int svq3_decode_slice_header(AVCodecContext *avctx)
1014 {
1015     SVQ3Context *s = avctx->priv_data;
1016     const int mb_xy   = s->mb_xy;
1017     int i, header;
1018     unsigned slice_id;
1019
1020     header = bitstream_read(&s->bc, 8);
1021
1022     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1023         /* TODO: what? */
1024         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1025         return -1;
1026     } else {
1027         int slice_bits, slice_bytes, slice_length;
1028         int length = header >> 5 & 3;
1029
1030         slice_length = bitstream_peek(&s->bc, 8 * length);
1031         slice_bits   = slice_length * 8;
1032         slice_bytes  = slice_length + length - 1;
1033
1034         bitstream_skip(&s->bc, 8);
1035
1036         av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
1037         if (!s->slice_buf)
1038             return AVERROR(ENOMEM);
1039
1040         if (slice_bytes * 8 > bitstream_bits_left(&s->bc)) {
1041             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1042             return AVERROR_INVALIDDATA;
1043         }
1044         memcpy(s->slice_buf, s->bc.buffer + bitstream_tell(&s->bc) / 8, slice_bytes);
1045
1046         if (s->watermark_key) {
1047             uint32_t header = AV_RL32(&s->bc_slice.buffer[1]);
1048             AV_WL32(&s->bc_slice.buffer[1], header ^ s->watermark_key);
1049         }
1050         if (length > 0) {
1051             memcpy(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1052         }
1053         bitstream_skip(&s->bc, slice_bytes * 8);
1054         bitstream_init(&s->bc_slice, s->slice_buf, slice_bits);
1055     }
1056
1057     if ((slice_id = get_interleaved_ue_golomb(&s->bc_slice)) >= 3) {
1058         av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1059         return -1;
1060     }
1061
1062     s->pict_type = ff_h264_golomb_to_pict_type[slice_id];
1063
1064     if ((header & 0x9F) == 2) {
1065         i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1066         bitstream_read(&s->bc_slice, i);
1067     } else {
1068         bitstream_skip(&s->bc_slice, 1);
1069     }
1070
1071     s->slice_num      = bitstream_read(&s->bc_slice, 8);
1072     s->qscale         = bitstream_read(&s->bc_slice, 5);
1073     s->adaptive_quant = bitstream_read_bit(&s->bc_slice);
1074
1075     /* unknown fields */
1076     bitstream_skip(&s->bc_slice, 1);
1077
1078     if (s->unknown_flag)
1079         bitstream_skip(&s->bc_slice, 1);
1080
1081     bitstream_skip(&s->bc_slice, 1);
1082     bitstream_skip(&s->bc_slice, 2);
1083
1084     while (bitstream_read_bit(&s->bc_slice))
1085         bitstream_skip(&s->bc_slice, 8);
1086
1087     /* reset intra predictors and invalidate motion vector references */
1088     if (s->mb_x > 0) {
1089         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1090                -1, 4 * sizeof(int8_t));
1091         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1092                -1, 8 * sizeof(int8_t) * s->mb_x);
1093     }
1094     if (s->mb_y > 0) {
1095         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1096                -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1097
1098         if (s->mb_x > 0)
1099             s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1100     }
1101
1102     return 0;
1103 }
1104
1105 static void init_dequant4_coeff_table(SVQ3Context *s)
1106 {
1107     int q, x;
1108     const int max_qp = 51;
1109
1110     for (q = 0; q < max_qp + 1; q++) {
1111         int shift = ff_h264_quant_div6[q] + 2;
1112         int idx   = ff_h264_quant_rem6[q];
1113         for (x = 0; x < 16; x++)
1114             s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1115                 ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1116     }
1117 }
1118
1119 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1120 {
1121     SVQ3Context *s = avctx->priv_data;
1122     int m, x, y;
1123     unsigned char *extradata;
1124     unsigned char *extradata_end;
1125     unsigned int size;
1126     int marker_found = 0;
1127
1128     s->cur_pic  = av_mallocz(sizeof(*s->cur_pic));
1129     s->last_pic = av_mallocz(sizeof(*s->last_pic));
1130     s->next_pic = av_mallocz(sizeof(*s->next_pic));
1131     if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1132         av_freep(&s->cur_pic);
1133         av_freep(&s->last_pic);
1134         av_freep(&s->next_pic);
1135         return AVERROR(ENOMEM);
1136     }
1137
1138     s->cur_pic->f  = av_frame_alloc();
1139     s->last_pic->f = av_frame_alloc();
1140     s->next_pic->f = av_frame_alloc();
1141     if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1142         return AVERROR(ENOMEM);
1143
1144     ff_h264dsp_init(&s->h264dsp, 8, 1);
1145     ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1146     ff_videodsp_init(&s->vdsp, 8);
1147
1148     ff_hpeldsp_init(&s->hdsp, avctx->flags);
1149     ff_tpeldsp_init(&s->tdsp);
1150
1151     avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
1152     avctx->color_range = AVCOL_RANGE_JPEG;
1153
1154     s->avctx         = avctx;
1155     s->halfpel_flag  = 1;
1156     s->thirdpel_flag = 1;
1157     s->unknown_flag  = 0;
1158
1159     /* prowl for the "SEQH" marker in the extradata */
1160     extradata     = (unsigned char *)avctx->extradata;
1161     extradata_end = avctx->extradata + avctx->extradata_size;
1162     if (extradata) {
1163         for (m = 0; m + 8 < avctx->extradata_size; m++) {
1164             if (!memcmp(extradata, "SEQH", 4)) {
1165                 marker_found = 1;
1166                 break;
1167             }
1168             extradata++;
1169         }
1170     }
1171
1172     /* if a match was found, parse the extra data */
1173     if (marker_found) {
1174         BitstreamContext bc;
1175         int frame_size_code;
1176
1177         size = AV_RB32(&extradata[4]);
1178         if (size > extradata_end - extradata - 8)
1179             return AVERROR_INVALIDDATA;
1180         bitstream_init8(&bc, extradata + 8, size);
1181
1182         /* 'frame size code' and optional 'width, height' */
1183         frame_size_code = bitstream_read(&bc, 3);
1184         switch (frame_size_code) {
1185         case 0:
1186             avctx->width  = 160;
1187             avctx->height = 120;
1188             break;
1189         case 1:
1190             avctx->width  = 128;
1191             avctx->height =  96;
1192             break;
1193         case 2:
1194             avctx->width  = 176;
1195             avctx->height = 144;
1196             break;
1197         case 3:
1198             avctx->width  = 352;
1199             avctx->height = 288;
1200             break;
1201         case 4:
1202             avctx->width  = 704;
1203             avctx->height = 576;
1204             break;
1205         case 5:
1206             avctx->width  = 240;
1207             avctx->height = 180;
1208             break;
1209         case 6:
1210             avctx->width  = 320;
1211             avctx->height = 240;
1212             break;
1213         case 7:
1214             avctx->width  = bitstream_read(&bc, 12);
1215             avctx->height = bitstream_read(&bc, 12);
1216             break;
1217         }
1218
1219         s->halfpel_flag  = bitstream_read_bit(&bc);
1220         s->thirdpel_flag = bitstream_read_bit(&bc);
1221
1222         /* unknown fields */
1223         bitstream_skip(&bc, 1);
1224         bitstream_skip(&bc, 1);
1225         bitstream_skip(&bc, 1);
1226         bitstream_skip(&bc, 1);
1227
1228         s->low_delay = bitstream_read_bit(&bc);
1229
1230         /* unknown field */
1231         bitstream_skip(&bc, 1);
1232
1233         while (bitstream_read_bit(&bc))
1234             bitstream_skip(&bc, 8);
1235
1236         s->unknown_flag  = bitstream_read_bit(&bc);
1237         avctx->has_b_frames = !s->low_delay;
1238         if (s->unknown_flag) {
1239 #if CONFIG_ZLIB
1240             unsigned watermark_width  = get_interleaved_ue_golomb(&bc);
1241             unsigned watermark_height = get_interleaved_ue_golomb(&bc);
1242             int u1                    = get_interleaved_ue_golomb(&bc);
1243             int u2                    = bitstream_read(&bc, 8);
1244             int u3                    = bitstream_read(&bc, 2);
1245             int u4                    = get_interleaved_ue_golomb(&bc);
1246             unsigned long buf_len     = watermark_width *
1247                                         watermark_height * 4;
1248             int offset                = bitstream_tell(&bc) + 7 >> 3;
1249             uint8_t *buf;
1250
1251             if (watermark_height > 0 &&
1252                 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1253                 return -1;
1254
1255             buf = av_malloc(buf_len);
1256             av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1257                    watermark_width, watermark_height);
1258             av_log(avctx, AV_LOG_DEBUG,
1259                    "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1260                    u1, u2, u3, u4, offset);
1261             if (uncompress(buf, &buf_len, extradata + 8 + offset,
1262                            size - offset) != Z_OK) {
1263                 av_log(avctx, AV_LOG_ERROR,
1264                        "could not uncompress watermark logo\n");
1265                 av_free(buf);
1266                 return -1;
1267             }
1268             s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1269             s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1270             av_log(avctx, AV_LOG_DEBUG,
1271                    "watermark key %#"PRIx32"\n", s->watermark_key);
1272             av_free(buf);
1273 #else
1274             av_log(avctx, AV_LOG_ERROR,
1275                    "this svq3 file contains watermark which need zlib support compiled in\n");
1276             return -1;
1277 #endif
1278         }
1279     }
1280
1281     s->mb_width   = (avctx->width + 15) / 16;
1282     s->mb_height  = (avctx->height + 15) / 16;
1283     s->mb_stride  = s->mb_width + 1;
1284     s->mb_num     = s->mb_width * s->mb_height;
1285     s->b_stride   = 4 * s->mb_width;
1286     s->h_edge_pos = s->mb_width * 16;
1287     s->v_edge_pos = s->mb_height * 16;
1288
1289     s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1290     if (!s->intra4x4_pred_mode)
1291         return AVERROR(ENOMEM);
1292
1293     s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1294                              sizeof(*s->mb2br_xy));
1295     if (!s->mb2br_xy)
1296         return AVERROR(ENOMEM);
1297
1298     for (y = 0; y < s->mb_height; y++)
1299         for (x = 0; x < s->mb_width; x++) {
1300             const int mb_xy = x + y * s->mb_stride;
1301
1302             s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1303         }
1304
1305     init_dequant4_coeff_table(s);
1306
1307     return 0;
1308 }
1309
1310 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1311 {
1312     int i;
1313     for (i = 0; i < 2; i++) {
1314         av_buffer_unref(&pic->motion_val_buf[i]);
1315         av_buffer_unref(&pic->ref_index_buf[i]);
1316     }
1317     av_buffer_unref(&pic->mb_type_buf);
1318
1319     av_frame_unref(pic->f);
1320 }
1321
1322 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1323 {
1324     SVQ3Context *s = avctx->priv_data;
1325     const int big_mb_num    = s->mb_stride * (s->mb_height + 1) + 1;
1326     const int mb_array_size = s->mb_stride * s->mb_height;
1327     const int b4_stride     = s->mb_width * 4 + 1;
1328     const int b4_array_size = b4_stride * s->mb_height * 4;
1329     int ret;
1330
1331     if (!pic->motion_val_buf[0]) {
1332         int i;
1333
1334         pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
1335         if (!pic->mb_type_buf)
1336             return AVERROR(ENOMEM);
1337         pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
1338
1339         for (i = 0; i < 2; i++) {
1340             pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1341             pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
1342             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1343                 ret = AVERROR(ENOMEM);
1344                 goto fail;
1345             }
1346
1347             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1348             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1349         }
1350     }
1351
1352     ret = ff_get_buffer(avctx, pic->f,
1353                         (s->pict_type != AV_PICTURE_TYPE_B) ?
1354                          AV_GET_BUFFER_FLAG_REF : 0);
1355     if (ret < 0)
1356         goto fail;
1357
1358     if (!s->edge_emu_buffer) {
1359         s->edge_emu_buffer = av_mallocz(pic->f->linesize[0] * 17);
1360         if (!s->edge_emu_buffer)
1361             return AVERROR(ENOMEM);
1362     }
1363
1364     return 0;
1365 fail:
1366     free_picture(avctx, pic);
1367     return ret;
1368 }
1369
1370 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1371                              int *got_frame, AVPacket *avpkt)
1372 {
1373     const uint8_t *buf = avpkt->data;
1374     SVQ3Context *s     = avctx->priv_data;
1375     int buf_size       = avpkt->size;
1376     int ret, m, i;
1377
1378     /* special case for last picture */
1379     if (buf_size == 0) {
1380         if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1381             ret = av_frame_ref(data, s->next_pic->f);
1382             if (ret < 0)
1383                 return ret;
1384             s->last_frame_output = 1;
1385             *got_frame          = 1;
1386         }
1387         return 0;
1388     }
1389
1390     ret = bitstream_init8(&s->bc, buf, buf_size);
1391     if (ret < 0)
1392         return ret;
1393
1394     s->mb_x = s->mb_y = s->mb_xy = 0;
1395
1396     if (svq3_decode_slice_header(avctx))
1397         return -1;
1398
1399     if (s->pict_type != AV_PICTURE_TYPE_B)
1400         FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1401
1402     av_frame_unref(s->cur_pic->f);
1403
1404     /* for skipping the frame */
1405     s->cur_pic->f->pict_type = s->pict_type;
1406     s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1407
1408     ret = get_buffer(avctx, s->cur_pic);
1409     if (ret < 0)
1410         return ret;
1411
1412     for (i = 0; i < 16; i++) {
1413         s->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1414         s->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1415     }
1416     for (i = 0; i < 16; i++) {
1417         s->block_offset[16 + i]      =
1418         s->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1419         s->block_offset[48 + 16 + i] =
1420         s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1421     }
1422
1423     if (s->pict_type != AV_PICTURE_TYPE_I) {
1424         if (!s->last_pic->f->data[0]) {
1425             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1426             ret = get_buffer(avctx, s->last_pic);
1427             if (ret < 0)
1428                 return ret;
1429             memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1430             memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1431                    s->last_pic->f->linesize[1]);
1432             memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1433                    s->last_pic->f->linesize[2]);
1434         }
1435
1436         if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1437             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1438             ret = get_buffer(avctx, s->next_pic);
1439             if (ret < 0)
1440                 return ret;
1441             memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1442             memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1443                    s->next_pic->f->linesize[1]);
1444             memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1445                    s->next_pic->f->linesize[2]);
1446         }
1447     }
1448
1449     if (avctx->debug & FF_DEBUG_PICT_INFO)
1450         av_log(s->avctx, AV_LOG_DEBUG,
1451                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1452                av_get_picture_type_char(s->pict_type),
1453                s->halfpel_flag, s->thirdpel_flag,
1454                s->adaptive_quant, s->qscale, s->slice_num);
1455
1456     if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1457         avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1458         avctx->skip_frame >= AVDISCARD_ALL)
1459         return 0;
1460
1461     if (s->next_p_frame_damaged) {
1462         if (s->pict_type == AV_PICTURE_TYPE_B)
1463             return 0;
1464         else
1465             s->next_p_frame_damaged = 0;
1466     }
1467
1468     if (s->pict_type == AV_PICTURE_TYPE_B) {
1469         s->frame_num_offset = s->slice_num - s->prev_frame_num;
1470
1471         if (s->frame_num_offset < 0)
1472             s->frame_num_offset += 256;
1473         if (s->frame_num_offset == 0 ||
1474             s->frame_num_offset >= s->prev_frame_num_offset) {
1475             av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1476             return -1;
1477         }
1478     } else {
1479         s->prev_frame_num        = s->frame_num;
1480         s->frame_num             = s->slice_num;
1481         s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1482
1483         if (s->prev_frame_num_offset < 0)
1484             s->prev_frame_num_offset += 256;
1485     }
1486
1487     for (m = 0; m < 2; m++) {
1488         int i;
1489         for (i = 0; i < 4; i++) {
1490             int j;
1491             for (j = -1; j < 4; j++)
1492                 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1493             if (i < 3)
1494                 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1495         }
1496     }
1497
1498     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1499         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1500             unsigned mb_type;
1501             s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1502
1503             if ((bitstream_bits_left(&s->bc_slice)) <= 7) {
1504                 if (((bitstream_tell(&s->bc_slice) & 7) == 0 ||
1505                     bitstream_peek(&s->bc_slice, bitstream_bits_left(&s->bc_slice) & 7) == 0)) {
1506
1507                     if (svq3_decode_slice_header(avctx))
1508                         return -1;
1509                 }
1510                 /* TODO: support s->mb_skip_run */
1511             }
1512
1513             mb_type = get_interleaved_ue_golomb(&s->bc_slice);
1514
1515             if (s->pict_type == AV_PICTURE_TYPE_I)
1516                 mb_type += 8;
1517             else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1518                 mb_type += 4;
1519             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1520                 av_log(s->avctx, AV_LOG_ERROR,
1521                        "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1522                 return -1;
1523             }
1524
1525             if (mb_type != 0)
1526                 hl_decode_mb(s);
1527
1528             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1529                 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1530                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1531         }
1532
1533         ff_draw_horiz_band(avctx, s->cur_pic->f,
1534                            s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1535                            16 * s->mb_y, 16, PICT_FRAME, 0,
1536                            s->low_delay);
1537     }
1538
1539     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1540         ret = av_frame_ref(data, s->cur_pic->f);
1541     else if (s->last_pic->f->data[0])
1542         ret = av_frame_ref(data, s->last_pic->f);
1543     if (ret < 0)
1544         return ret;
1545
1546     /* Do not output the last pic after seeking. */
1547     if (s->last_pic->f->data[0] || s->low_delay)
1548         *got_frame = 1;
1549
1550     if (s->pict_type != AV_PICTURE_TYPE_B) {
1551         FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1552     } else {
1553         av_frame_unref(s->cur_pic->f);
1554     }
1555
1556     return buf_size;
1557 }
1558
1559 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1560 {
1561     SVQ3Context *s = avctx->priv_data;
1562
1563     free_picture(avctx, s->cur_pic);
1564     free_picture(avctx, s->next_pic);
1565     free_picture(avctx, s->last_pic);
1566     av_frame_free(&s->cur_pic->f);
1567     av_frame_free(&s->next_pic->f);
1568     av_frame_free(&s->last_pic->f);
1569     av_freep(&s->cur_pic);
1570     av_freep(&s->next_pic);
1571     av_freep(&s->last_pic);
1572     av_freep(&s->slice_buf);
1573     av_freep(&s->intra4x4_pred_mode);
1574     av_freep(&s->edge_emu_buffer);
1575     av_freep(&s->mb2br_xy);
1576
1577     return 0;
1578 }
1579
1580 AVCodec ff_svq3_decoder = {
1581     .name           = "svq3",
1582     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1583     .type           = AVMEDIA_TYPE_VIDEO,
1584     .id             = AV_CODEC_ID_SVQ3,
1585     .priv_data_size = sizeof(SVQ3Context),
1586     .init           = svq3_decode_init,
1587     .close          = svq3_decode_end,
1588     .decode         = svq3_decode_frame,
1589     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1590                       AV_CODEC_CAP_DR1             |
1591                       AV_CODEC_CAP_DELAY,
1592     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1593                                                      AV_PIX_FMT_NONE},
1594 };