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 int 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] = (z0 + z3) * qmul + 0x80000 >> 20;
 252         output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
 253         output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
 254         output[stride * 10 + offset] = (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 ? 1538 * 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 int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
 285         const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
 286         const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
 287         const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
 288         const int rr = (dc + 0x80000);
 289
 290         dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
 291         dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
 292         dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
 293         dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((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] << 1;
 528                 my = s->next_pic->motion_val[0][b_xy][1] << 1;
 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 == INVALID_VLC || dy == INVALID_VLC) {
 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 + 0x3000) / 3 - 0x1000;
 566                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 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 + 0x3000) / 3 + dx - 0x1000;
 575                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 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 + 0x6000) / 6 + dx - 0x1000;
 584                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
 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 int dctcoef_get(int16_t *mb, int index)
 633 {
 634     return AV_RN16A(mb + index);
 635 }
 636
 637 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
 638                                                        int mb_type,
 639                                                        const int *block_offset,
 640                                                        int linesize,
 641                                                        uint8_t *dest_y)
 642 {
 643     int i;
 644     int qscale = s->qscale;
 645
 646     if (IS_INTRA4x4(mb_type)) {
 647         for (i = 0; i < 16; i++) {
 648             uint8_t *const ptr = dest_y + block_offset[i];
 649             const int dir      = s->intra4x4_pred_mode_cache[scan8[i]];
 650
 651             uint8_t *topright;
 652             int nnz, tr;
 653             if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
 654                 const int topright_avail = (s->topright_samples_available << i) & 0x8000;
 655                 av_assert2(s->mb_y || linesize <= block_offset[i]);
 656                 if (!topright_avail) {
 657                     tr       = ptr[3 - linesize] * 0x01010101u;
 658                     topright = (uint8_t *)&tr;
 659                 } else
 660                     topright = ptr + 4 - linesize;
 661             } else
 662                 topright = NULL;
 663
 664             s->hpc.pred4x4[dir](ptr, topright, linesize);
 665             nnz = s->non_zero_count_cache[scan8[i]];
 666             if (nnz) {
 667                 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
 668             }
 669         }
 670     } else {
 671         s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
 672         svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
 673     }
 674 }
 675
 676 static void hl_decode_mb(SVQ3Context *s)
 677 {
 678     const int mb_x    = s->mb_x;
 679     const int mb_y    = s->mb_y;
 680     const int mb_xy   = s->mb_xy;
 681     const int mb_type = s->cur_pic->mb_type[mb_xy];
 682     uint8_t *dest_y, *dest_cb, *dest_cr;
 683     int linesize, uvlinesize;
 684     int i, j;
 685     const int *block_offset = &s->block_offset[0];
 686     const int block_h   = 16 >> 1;
 687
 688     linesize   = s->cur_pic->f->linesize[0];
 689     uvlinesize = s->cur_pic->f->linesize[1];
 690
 691     dest_y  = s->cur_pic->f->data[0] + (mb_x     + mb_y * linesize)  * 16;
 692     dest_cb = s->cur_pic->f->data[1] +  mb_x * 8 + mb_y * uvlinesize * block_h;
 693     dest_cr = s->cur_pic->f->data[2] +  mb_x * 8 + mb_y * uvlinesize * block_h;
 694
 695     s->vdsp.prefetch(dest_y  + (s->mb_x & 3) * 4 * linesize   + 64, linesize,      4);
 696     s->vdsp.prefetch(dest_cb + (s->mb_x & 7)     * uvlinesize + 64, dest_cr - dest_cb, 2);
 697
 698     if (IS_INTRA(mb_type)) {
 699         s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
 700         s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
 701
 702         hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
 703     }
 704
 705     hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
 706
 707     if (s->cbp & 0x30) {
 708         uint8_t *dest[2] = { dest_cb, dest_cr };
 709         s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
 710                                                s->dequant4_coeff[4][0]);
 711         s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
 712                                                s->dequant4_coeff[4][0]);
 713         for (j = 1; j < 3; j++) {
 714             for (i = j * 16; i < j * 16 + 4; i++)
 715                 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
 716                     uint8_t *const ptr = dest[j - 1] + block_offset[i];
 717                     svq3_add_idct_c(ptr, s->mb + i * 16,
 718                                     uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
 719                 }
 720         }
 721     }
 722 }
 723
 724 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
 725 {
 726     int i, j, k, m, dir, mode;
 727     int cbp = 0;
 728     uint32_t vlc;
 729     int8_t *top, *left;
 730     const int mb_xy = s->mb_xy;
 731     const int b_xy  = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
 732
 733     s->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 734     s->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 735     s->topright_samples_available = 0xFFFF;
 736
 737     if (mb_type == 0) {           /* SKIP */
 738         if (s->pict_type == AV_PICTURE_TYPE_P ||
 739             s->next_pic->mb_type[mb_xy] == -1) {
 740             svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 741                              0, 0, 0, 0, 0, 0);
 742
 743             if (s->pict_type == AV_PICTURE_TYPE_B)
 744                 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 745                                  0, 0, 0, 0, 1, 1);
 746
 747             mb_type = MB_TYPE_SKIP;
 748         } else {
 749             mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
 750             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
 751                 return -1;
 752             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
 753                 return -1;
 754
 755             mb_type = MB_TYPE_16x16;
 756         }
 757     } else if (mb_type < 8) {     /* INTER */
 758         if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
 759             mode = THIRDPEL_MODE;
 760         else if (s->halfpel_flag &&
 761                  s->thirdpel_flag == !get_bits1(&s->gb_slice))
 762             mode = HALFPEL_MODE;
 763         else
 764             mode = FULLPEL_MODE;
 765
 766         /* fill caches */
 767         /* note ref_cache should contain here:
 768          *  ????????
 769          *  ???11111
 770          *  N??11111
 771          *  N??11111
 772          *  N??11111
 773          */
 774
 775         for (m = 0; m < 2; m++) {
 776             if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
 777                 for (i = 0; i < 4; i++)
 778                     AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
 779                               s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
 780             } else {
 781                 for (i = 0; i < 4; i++)
 782                     AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
 783             }
 784             if (s->mb_y > 0) {
 785                 memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
 786                        s->cur_pic->motion_val[m][b_xy - s->b_stride],
 787                        4 * 2 * sizeof(int16_t));
 788                 memset(&s->ref_cache[m][scan8[0] - 1 * 8],
 789                        (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 790
 791                 if (s->mb_x < s->mb_width - 1) {
 792                     AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
 793                               s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
 794                     s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 795                         (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
 796                          s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 797                 } else
 798                     s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
 799                 if (s->mb_x > 0) {
 800                     AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
 801                               s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
 802                     s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 803                         (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 804                 } else
 805                     s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 806             } else
 807                 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
 808                        PART_NOT_AVAILABLE, 8);
 809
 810             if (s->pict_type != AV_PICTURE_TYPE_B)
 811                 break;
 812         }
 813
 814         /* decode motion vector(s) and form prediction(s) */
 815         if (s->pict_type == AV_PICTURE_TYPE_P) {
 816             if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
 817                 return -1;
 818         } else {        /* AV_PICTURE_TYPE_B */
 819             if (mb_type != 2) {
 820                 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
 821                     return -1;
 822             } else {
 823                 for (i = 0; i < 4; i++)
 824                     memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
 825                            0, 4 * 2 * sizeof(int16_t));
 826             }
 827             if (mb_type != 1) {
 828                 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
 829                     return -1;
 830             } else {
 831                 for (i = 0; i < 4; i++)
 832                     memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
 833                            0, 4 * 2 * sizeof(int16_t));
 834             }
 835         }
 836
 837         mb_type = MB_TYPE_16x16;
 838     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 839         int8_t *i4x4       = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
 840         int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
 841
 842         memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
 843
 844         if (mb_type == 8) {
 845             if (s->mb_x > 0) {
 846                 for (i = 0; i < 4; i++)
 847                     s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
 848                 if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
 849                     s->left_samples_available = 0x5F5F;
 850             }
 851             if (s->mb_y > 0) {
 852                 s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
 853                 s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
 854                 s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
 855                 s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
 856
 857                 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
 858                     s->top_samples_available = 0x33FF;
 859             }
 860
 861             /* decode prediction codes for luma blocks */
 862             for (i = 0; i < 16; i += 2) {
 863                 vlc = get_interleaved_ue_golomb(&s->gb_slice);
 864
 865                 if (vlc >= 25U) {
 866                     av_log(s->avctx, AV_LOG_ERROR,
 867                            "luma prediction:%"PRIu32"\n", vlc);
 868                     return -1;
 869                 }
 870
 871                 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
 872                 top  = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
 873
 874                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 875                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 876
 877                 if (left[1] == -1 || left[2] == -1) {
 878                     av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
 879                     return -1;
 880                 }
 881             }
 882         } else {    /* mb_type == 33, DC_128_PRED block type */
 883             for (i = 0; i < 4; i++)
 884                 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
 885         }
 886
 887         AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
 888         i4x4[4] = i4x4_cache[7 + 8 * 3];
 889         i4x4[5] = i4x4_cache[7 + 8 * 2];
 890         i4x4[6] = i4x4_cache[7 + 8 * 1];
 891
 892         if (mb_type == 8) {
 893             ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
 894                                              s->avctx, s->top_samples_available,
 895                                              s->left_samples_available);
 896
 897             s->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 898             s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 899         } else {
 900             for (i = 0; i < 4; i++)
 901                 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
 902
 903             s->top_samples_available  = 0x33FF;
 904             s->left_samples_available = 0x5F5F;
 905         }
 906
 907         mb_type = MB_TYPE_INTRA4x4;
 908     } else {                      /* INTRA16x16 */
 909         dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
 910         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
 911
 912         if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
 913                                                                      s->left_samples_available, dir, 0)) < 0) {
 914             av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
 915             return s->intra16x16_pred_mode;
 916         }
 917
 918         cbp     = ff_h264_i_mb_type_info[mb_type - 8].cbp;
 919         mb_type = MB_TYPE_INTRA16x16;
 920     }
 921
 922     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 923         for (i = 0; i < 4; i++)
 924             memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
 925                    0, 4 * 2 * sizeof(int16_t));
 926         if (s->pict_type == AV_PICTURE_TYPE_B) {
 927             for (i = 0; i < 4; i++)
 928                 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
 929                        0, 4 * 2 * sizeof(int16_t));
 930         }
 931     }
 932     if (!IS_INTRA4x4(mb_type)) {
 933         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
 934     }
 935     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 936         memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 937     }
 938
 939     if (!IS_INTRA16x16(mb_type) &&
 940         (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 941         if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
 942             av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
 943             return -1;
 944         }
 945
 946         cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
 947                                 : ff_h264_golomb_to_inter_cbp[vlc];
 948     }
 949     if (IS_INTRA16x16(mb_type) ||
 950         (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 951         s->qscale += get_interleaved_se_golomb(&s->gb_slice);
 952
 953         if (s->qscale > 31u) {
 954             av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 955             return -1;
 956         }
 957     }
 958     if (IS_INTRA16x16(mb_type)) {
 959         AV_ZERO128(s->mb_luma_dc[0] + 0);
 960         AV_ZERO128(s->mb_luma_dc[0] + 8);
 961         if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
 962             av_log(s->avctx, AV_LOG_ERROR,
 963                    "error while decoding intra luma dc\n");
 964             return -1;
 965         }
 966     }
 967
 968     if (cbp) {
 969         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 970         const int type  = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 971
 972         for (i = 0; i < 4; i++)
 973             if ((cbp & (1 << i))) {
 974                 for (j = 0; j < 4; j++) {
 975                     k = index ? (1 * (j & 1) + 2 * (i & 1) +
 976                                  2 * (j & 2) + 4 * (i & 2))
 977                               : (4 * i + j);
 978                     s->non_zero_count_cache[scan8[k]] = 1;
 979
 980                     if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
 981                         av_log(s->avctx, AV_LOG_ERROR,
 982                                "error while decoding block\n");
 983                         return -1;
 984                     }
 985                 }
 986             }
 987
 988         if ((cbp & 0x30)) {
 989             for (i = 1; i < 3; ++i)
 990                 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
 991                     av_log(s->avctx, AV_LOG_ERROR,
 992                            "error while decoding chroma dc block\n");
 993                     return -1;
 994                 }
 995
 996             if ((cbp & 0x20)) {
 997                 for (i = 1; i < 3; i++) {
 998                     for (j = 0; j < 4; j++) {
 999                         k                                 = 16 * i + j;
1000                         s->non_zero_count_cache[scan8[k]] = 1;
1001
1002                         if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
1003                             av_log(s->avctx, AV_LOG_ERROR,
1004                                    "error while decoding chroma ac block\n");
1005                             return -1;
1006                         }
1007                     }
1008                 }
1009             }
1010         }
1011     }
1012
1013     s->cbp                     = cbp;
1014     s->cur_pic->mb_type[mb_xy] = mb_type;
1015
1016     if (IS_INTRA(mb_type))
1017         s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1018                                                             s->left_samples_available, DC_PRED8x8, 1);
1019
1020     return 0;
1021 }
1022
1023 static int svq3_decode_slice_header(AVCodecContext *avctx)
1024 {
1025     SVQ3Context *s = avctx->priv_data;
1026     const int mb_xy   = s->mb_xy;
1027     int i, header;
1028     unsigned slice_id;
1029
1030     header = get_bits(&s->gb, 8);
1031
1032     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1033         /* TODO: what? */
1034         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1035         return -1;
1036     } else {
1037         int slice_bits, slice_bytes, slice_length;
1038         int length = header >> 5 & 3;
1039
1040         slice_length = show_bits(&s->gb, 8 * length);
1041         slice_bits   = slice_length * 8;
1042         slice_bytes  = slice_length + length - 1;
1043
1044         if (8LL*slice_bytes > get_bits_left(&s->gb)) {
1045             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1046             return -1;
1047         }
1048
1049         skip_bits(&s->gb, 8);
1050
1051         av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
1052         if (!s->slice_buf)
1053             return AVERROR(ENOMEM);
1054
1055         memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1056
1057         init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1058
1059         if (s->watermark_key) {
1060             uint32_t header = AV_RL32(&s->gb_slice.buffer[1]);
1061             AV_WL32(&s->gb_slice.buffer[1], header ^ s->watermark_key);
1062         }
1063         if (length > 0) {
1064             memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1065         }
1066         skip_bits_long(&s->gb, slice_bytes * 8);
1067     }
1068
1069     if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1070         av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1071         return -1;
1072     }
1073     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_type = ff_h264_golomb_to_pict_type[slice_id];
1079
1080     if ((header & 0x9F) == 2) {
1081         i = (s->mb_num < 64) ? 5 : av_log2(s->mb_num - 1);
1082         get_bits(&s->gb_slice, i);
1083     }
1084
1085     s->slice_num      = get_bits(&s->gb_slice, 8);
1086     s->qscale         = get_bits(&s->gb_slice, 5);
1087     s->adaptive_quant = get_bits1(&s->gb_slice);
1088
1089     /* unknown fields */
1090     skip_bits1(&s->gb_slice);
1091
1092     if (s->has_watermark)
1093         skip_bits1(&s->gb_slice);
1094
1095     skip_bits1(&s->gb_slice);
1096     skip_bits(&s->gb_slice, 2);
1097
1098     if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1099         return AVERROR_INVALIDDATA;
1100
1101     /* reset intra predictors and invalidate motion vector references */
1102     if (s->mb_x > 0) {
1103         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1104                -1, 4 * sizeof(int8_t));
1105         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1106                -1, 8 * sizeof(int8_t) * s->mb_x);
1107     }
1108     if (s->mb_y > 0) {
1109         memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1110                -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1111
1112         if (s->mb_x > 0)
1113             s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1114     }
1115
1116     return 0;
1117 }
1118
1119 static void init_dequant4_coeff_table(SVQ3Context *s)
1120 {
1121     int q, x;
1122     const int max_qp = 51;
1123
1124     for (q = 0; q < max_qp + 1; q++) {
1125         int shift = ff_h264_quant_div6[q] + 2;
1126         int idx   = ff_h264_quant_rem6[q];
1127         for (x = 0; x < 16; x++)
1128             s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1129                 ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1130     }
1131 }
1132
1133 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1134 {
1135     SVQ3Context *s = avctx->priv_data;
1136     int m, x, y;
1137     unsigned char *extradata;
1138     unsigned char *extradata_end;
1139     unsigned int size;
1140     int marker_found = 0;
1141     int ret;
1142
1143     s->cur_pic  = av_mallocz(sizeof(*s->cur_pic));
1144     s->last_pic = av_mallocz(sizeof(*s->last_pic));
1145     s->next_pic = av_mallocz(sizeof(*s->next_pic));
1146     if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1147         ret = AVERROR(ENOMEM);
1148         goto fail;
1149     }
1150
1151     s->cur_pic->f  = av_frame_alloc();
1152     s->last_pic->f = av_frame_alloc();
1153     s->next_pic->f = av_frame_alloc();
1154     if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1155         return AVERROR(ENOMEM);
1156
1157     ff_h264dsp_init(&s->h264dsp, 8, 1);
1158     ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1159     ff_videodsp_init(&s->vdsp, 8);
1160
1161
1162     avctx->bits_per_raw_sample = 8;
1163
1164     ff_hpeldsp_init(&s->hdsp, avctx->flags);
1165     ff_tpeldsp_init(&s->tdsp);
1166
1167     avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
1168     avctx->color_range = AVCOL_RANGE_JPEG;
1169
1170     s->avctx         = avctx;
1171     s->halfpel_flag  = 1;
1172     s->thirdpel_flag = 1;
1173     s->has_watermark = 0;
1174
1175     /* prowl for the "SEQH" marker in the extradata */
1176     extradata     = (unsigned char *)avctx->extradata;
1177     extradata_end = avctx->extradata + avctx->extradata_size;
1178     if (extradata) {
1179         for (m = 0; m + 8 < avctx->extradata_size; m++) {
1180             if (!memcmp(extradata, "SEQH", 4)) {
1181                 marker_found = 1;
1182                 break;
1183             }
1184             extradata++;
1185         }
1186     }
1187
1188     /* if a match was found, parse the extra data */
1189     if (marker_found) {
1190         GetBitContext gb;
1191         int frame_size_code;
1192         int unk0, unk1, unk2, unk3, unk4;
1193
1194         size = AV_RB32(&extradata[4]);
1195         if (size > extradata_end - extradata - 8) {
1196             ret = AVERROR_INVALIDDATA;
1197             goto fail;
1198         }
1199         init_get_bits(&gb, extradata + 8, size * 8);
1200
1201         /* 'frame size code' and optional 'width, height' */
1202         frame_size_code = get_bits(&gb, 3);
1203         switch (frame_size_code) {
1204         case 0:
1205             avctx->width  = 160;
1206             avctx->height = 120;
1207             break;
1208         case 1:
1209             avctx->width  = 128;
1210             avctx->height =  96;
1211             break;
1212         case 2:
1213             avctx->width  = 176;
1214             avctx->height = 144;
1215             break;
1216         case 3:
1217             avctx->width  = 352;
1218             avctx->height = 288;
1219             break;
1220         case 4:
1221             avctx->width  = 704;
1222             avctx->height = 576;
1223             break;
1224         case 5:
1225             avctx->width  = 240;
1226             avctx->height = 180;
1227             break;
1228         case 6:
1229             avctx->width  = 320;
1230             avctx->height = 240;
1231             break;
1232         case 7:
1233             avctx->width  = get_bits(&gb, 12);
1234             avctx->height = get_bits(&gb, 12);
1235             break;
1236         }
1237
1238         s->halfpel_flag  = get_bits1(&gb);
1239         s->thirdpel_flag = get_bits1(&gb);
1240
1241         /* unknown fields */
1242         unk0 = get_bits1(&gb);
1243         unk1 = get_bits1(&gb);
1244         unk2 = get_bits1(&gb);
1245         unk3 = get_bits1(&gb);
1246
1247         s->low_delay = get_bits1(&gb);
1248
1249         /* unknown field */
1250         unk4 = get_bits1(&gb);
1251
1252         av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1253                unk0, unk1, unk2, unk3, unk4);
1254
1255         if (skip_1stop_8data_bits(&gb) < 0) {
1256             ret = AVERROR_INVALIDDATA;
1257             goto fail;
1258         }
1259
1260         s->has_watermark  = get_bits1(&gb);
1261         avctx->has_b_frames = !s->low_delay;
1262         if (s->has_watermark) {
1263 #if CONFIG_ZLIB
1264             unsigned watermark_width  = get_interleaved_ue_golomb(&gb);
1265             unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1266             int u1                    = get_interleaved_ue_golomb(&gb);
1267             int u2                    = get_bits(&gb, 8);
1268             int u3                    = get_bits(&gb, 2);
1269             int u4                    = get_interleaved_ue_golomb(&gb);
1270             unsigned long buf_len     = watermark_width *
1271                                         watermark_height * 4;
1272             int offset                = get_bits_count(&gb) + 7 >> 3;
1273             uint8_t *buf;
1274
1275             if (watermark_height <= 0 ||
1276                 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1277                 ret = -1;
1278                 goto fail;
1279             }
1280
1281             buf = av_malloc(buf_len);
1282             if (!buf) {
1283                 ret = AVERROR(ENOMEM);
1284                 goto fail;
1285             }
1286             av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1287                    watermark_width, watermark_height);
1288             av_log(avctx, AV_LOG_DEBUG,
1289                    "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1290                    u1, u2, u3, u4, offset);
1291             if (uncompress(buf, &buf_len, extradata + 8 + offset,
1292                            size - offset) != Z_OK) {
1293                 av_log(avctx, AV_LOG_ERROR,
1294                        "could not uncompress watermark logo\n");
1295                 av_free(buf);
1296                 ret = -1;
1297                 goto fail;
1298             }
1299             s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1300             s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1301             av_log(avctx, AV_LOG_DEBUG,
1302                    "watermark key %#"PRIx32"\n", s->watermark_key);
1303             av_free(buf);
1304 #else
1305             av_log(avctx, AV_LOG_ERROR,
1306                    "this svq3 file contains watermark which need zlib support compiled in\n");
1307             ret = -1;
1308             goto fail;
1309 #endif
1310         }
1311     }
1312
1313     s->mb_width   = (avctx->width + 15) / 16;
1314     s->mb_height  = (avctx->height + 15) / 16;
1315     s->mb_stride  = s->mb_width + 1;
1316     s->mb_num     = s->mb_width * s->mb_height;
1317     s->b_stride   = 4 * s->mb_width;
1318     s->h_edge_pos = s->mb_width * 16;
1319     s->v_edge_pos = s->mb_height * 16;
1320
1321     s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1322     if (!s->intra4x4_pred_mode)
1323         return AVERROR(ENOMEM);
1324
1325     s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1326                              sizeof(*s->mb2br_xy));
1327     if (!s->mb2br_xy)
1328         return AVERROR(ENOMEM);
1329
1330     for (y = 0; y < s->mb_height; y++)
1331         for (x = 0; x < s->mb_width; x++) {
1332             const int mb_xy = x + y * s->mb_stride;
1333
1334             s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1335         }
1336
1337     init_dequant4_coeff_table(s);
1338
1339     return 0;
1340 fail:
1341     svq3_decode_end(avctx);
1342     return ret;
1343 }
1344
1345 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1346 {
1347     int i;
1348     for (i = 0; i < 2; i++) {
1349         av_buffer_unref(&pic->motion_val_buf[i]);
1350         av_buffer_unref(&pic->ref_index_buf[i]);
1351     }
1352     av_buffer_unref(&pic->mb_type_buf);
1353
1354     av_frame_unref(pic->f);
1355 }
1356
1357 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1358 {
1359     SVQ3Context *s = avctx->priv_data;
1360     const int big_mb_num    = s->mb_stride * (s->mb_height + 1) + 1;
1361     const int mb_array_size = s->mb_stride * s->mb_height;
1362     const int b4_stride     = s->mb_width * 4 + 1;
1363     const int b4_array_size = b4_stride * s->mb_height * 4;
1364     int ret;
1365
1366     if (!pic->motion_val_buf[0]) {
1367         int i;
1368
1369         pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
1370         if (!pic->mb_type_buf)
1371             return AVERROR(ENOMEM);
1372         pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
1373
1374         for (i = 0; i < 2; i++) {
1375             pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1376             pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
1377             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1378                 ret = AVERROR(ENOMEM);
1379                 goto fail;
1380             }
1381
1382             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1383             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1384         }
1385     }
1386
1387     ret = ff_get_buffer(avctx, pic->f,
1388                         (s->pict_type != AV_PICTURE_TYPE_B) ?
1389                          AV_GET_BUFFER_FLAG_REF : 0);
1390     if (ret < 0)
1391         goto fail;
1392
1393     if (!s->edge_emu_buffer) {
1394         s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1395         if (!s->edge_emu_buffer)
1396             return AVERROR(ENOMEM);
1397     }
1398
1399     return 0;
1400 fail:
1401     free_picture(avctx, pic);
1402     return ret;
1403 }
1404
1405 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1406                              int *got_frame, AVPacket *avpkt)
1407 {
1408     SVQ3Context *s     = avctx->priv_data;
1409     int buf_size       = avpkt->size;
1410     int left;
1411     uint8_t *buf;
1412     int ret, m, i;
1413
1414     /* special case for last picture */
1415     if (buf_size == 0) {
1416         if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1417             ret = av_frame_ref(data, s->next_pic->f);
1418             if (ret < 0)
1419                 return ret;
1420             s->last_frame_output = 1;
1421             *got_frame          = 1;
1422         }
1423         return 0;
1424     }
1425
1426     s->mb_x = s->mb_y = s->mb_xy = 0;
1427
1428     if (s->watermark_key) {
1429         av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1430         if (!s->buf)
1431             return AVERROR(ENOMEM);
1432         memcpy(s->buf, avpkt->data, buf_size);
1433         buf = s->buf;
1434     } else {
1435         buf = avpkt->data;
1436     }
1437
1438     ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1439     if (ret < 0)
1440         return ret;
1441
1442     if (svq3_decode_slice_header(avctx))
1443         return -1;
1444
1445     s->pict_type = s->slice_type;
1446
1447     if (s->pict_type != AV_PICTURE_TYPE_B)
1448         FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1449
1450     av_frame_unref(s->cur_pic->f);
1451
1452     /* for skipping the frame */
1453     s->cur_pic->f->pict_type = s->pict_type;
1454     s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1455
1456     ret = get_buffer(avctx, s->cur_pic);
1457     if (ret < 0)
1458         return ret;
1459
1460     for (i = 0; i < 16; i++) {
1461         s->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1462         s->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1463     }
1464     for (i = 0; i < 16; i++) {
1465         s->block_offset[16 + i]      =
1466         s->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1467         s->block_offset[48 + 16 + i] =
1468         s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1469     }
1470
1471     if (s->pict_type != AV_PICTURE_TYPE_I) {
1472         if (!s->last_pic->f->data[0]) {
1473             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1474             av_frame_unref(s->last_pic->f);
1475             ret = get_buffer(avctx, s->last_pic);
1476             if (ret < 0)
1477                 return ret;
1478             memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1479             memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1480                    s->last_pic->f->linesize[1]);
1481             memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1482                    s->last_pic->f->linesize[2]);
1483         }
1484
1485         if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1486             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1487             av_frame_unref(s->next_pic->f);
1488             ret = get_buffer(avctx, s->next_pic);
1489             if (ret < 0)
1490                 return ret;
1491             memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1492             memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1493                    s->next_pic->f->linesize[1]);
1494             memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1495                    s->next_pic->f->linesize[2]);
1496         }
1497     }
1498
1499     if (avctx->debug & FF_DEBUG_PICT_INFO)
1500         av_log(s->avctx, AV_LOG_DEBUG,
1501                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1502                av_get_picture_type_char(s->pict_type),
1503                s->halfpel_flag, s->thirdpel_flag,
1504                s->adaptive_quant, s->qscale, s->slice_num);
1505
1506     if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1507         avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1508         avctx->skip_frame >= AVDISCARD_ALL)
1509         return 0;
1510
1511     if (s->next_p_frame_damaged) {
1512         if (s->pict_type == AV_PICTURE_TYPE_B)
1513             return 0;
1514         else
1515             s->next_p_frame_damaged = 0;
1516     }
1517
1518     if (s->pict_type == AV_PICTURE_TYPE_B) {
1519         s->frame_num_offset = s->slice_num - s->prev_frame_num;
1520
1521         if (s->frame_num_offset < 0)
1522             s->frame_num_offset += 256;
1523         if (s->frame_num_offset == 0 ||
1524             s->frame_num_offset >= s->prev_frame_num_offset) {
1525             av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1526             return -1;
1527         }
1528     } else {
1529         s->prev_frame_num        = s->frame_num;
1530         s->frame_num             = s->slice_num;
1531         s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1532
1533         if (s->prev_frame_num_offset < 0)
1534             s->prev_frame_num_offset += 256;
1535     }
1536
1537     for (m = 0; m < 2; m++) {
1538         int i;
1539         for (i = 0; i < 4; i++) {
1540             int j;
1541             for (j = -1; j < 4; j++)
1542                 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1543             if (i < 3)
1544                 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1545         }
1546     }
1547
1548     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1549         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1550             unsigned mb_type;
1551             s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1552
1553             if ((get_bits_left(&s->gb_slice)) <= 7) {
1554                 if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1555                     show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1556
1557                     if (svq3_decode_slice_header(avctx))
1558                         return -1;
1559                 }
1560                 if (s->slice_type != s->pict_type) {
1561                     avpriv_request_sample(avctx, "non constant slice type");
1562                 }
1563                 /* TODO: support s->mb_skip_run */
1564             }
1565
1566             mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1567
1568             if (s->pict_type == AV_PICTURE_TYPE_I)
1569                 mb_type += 8;
1570             else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1571                 mb_type += 4;
1572             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1573                 av_log(s->avctx, AV_LOG_ERROR,
1574                        "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1575                 return -1;
1576             }
1577
1578             if (mb_type != 0 || s->cbp)
1579                 hl_decode_mb(s);
1580
1581             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1582                 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1583                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1584         }
1585
1586         ff_draw_horiz_band(avctx, s->cur_pic->f,
1587                            s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1588                            16 * s->mb_y, 16, PICT_FRAME, 0,
1589                            s->low_delay);
1590     }
1591
1592     left = buf_size*8 - get_bits_count(&s->gb_slice);
1593
1594     if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1595         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);
1596         //av_hex_dump(stderr, buf+buf_size-8, 8);
1597     }
1598
1599     if (left < 0) {
1600         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1601         return -1;
1602     }
1603
1604     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1605         ret = av_frame_ref(data, s->cur_pic->f);
1606     else if (s->last_pic->f->data[0])
1607         ret = av_frame_ref(data, s->last_pic->f);
1608     if (ret < 0)
1609         return ret;
1610
1611     /* Do not output the last pic after seeking. */
1612     if (s->last_pic->f->data[0] || s->low_delay)
1613         *got_frame = 1;
1614
1615     if (s->pict_type != AV_PICTURE_TYPE_B) {
1616         FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1617     } else {
1618         av_frame_unref(s->cur_pic->f);
1619     }
1620
1621     return buf_size;
1622 }
1623
1624 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1625 {
1626     SVQ3Context *s = avctx->priv_data;
1627
1628     free_picture(avctx, s->cur_pic);
1629     free_picture(avctx, s->next_pic);
1630     free_picture(avctx, s->last_pic);
1631     av_frame_free(&s->cur_pic->f);
1632     av_frame_free(&s->next_pic->f);
1633     av_frame_free(&s->last_pic->f);
1634     av_freep(&s->cur_pic);
1635     av_freep(&s->next_pic);
1636     av_freep(&s->last_pic);
1637     av_freep(&s->slice_buf);
1638     av_freep(&s->intra4x4_pred_mode);
1639     av_freep(&s->edge_emu_buffer);
1640     av_freep(&s->mb2br_xy);
1641
1642
1643     av_freep(&s->buf);
1644     s->buf_size = 0;
1645
1646     return 0;
1647 }
1648
1649 AVCodec ff_svq3_decoder = {
1650     .name           = "svq3",
1651     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1652     .type           = AVMEDIA_TYPE_VIDEO,
1653     .id             = AV_CODEC_ID_SVQ3,
1654     .priv_data_size = sizeof(SVQ3Context),
1655     .init           = svq3_decode_init,
1656     .close          = svq3_decode_end,
1657     .decode         = svq3_decode_frame,
1658     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1659                       AV_CODEC_CAP_DR1             |
1660                       AV_CODEC_CAP_DELAY,
1661     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1662                                                      AV_PIX_FMT_NONE},
1663 };