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

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