svq3.c 50.2 KB
Newer Older
1
/*
2
 * Copyright (c) 2003 The FFmpeg Project
3
 *
4 5 6
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
7 8
 * modify it under the terms of the GNU Lesser General Public
 * 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 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 23
 * How to use this decoder:
 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24 25 26 27 28 29
 * have stsd atoms to describe media trak properties. A stsd atom for a
 * video trak contains 1 or more ImageDescription atoms. These atoms begin
 * with the 4-byte length of the atom followed by the codec fourcc. Some
 * decoders need information in this atom to operate correctly. Such
 * is the case with SVQ3. In order to get the best use out of this decoder,
 * the calling app must make the SVQ3 ImageDescription atom available
30 31
 * via the AVCodecContext's extradata[_size] field:
 *
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 35
 * AVCodecContext.extradata_size = size of ImageDescription atom memory
 * buffer (which will be the same as the ImageDescription atom size field
36 37 38 39
 * from the QT file, minus 4 bytes since the length is missing)
 *
 * You will know you have these parameters passed correctly when the decoder
 * correctly decodes this file:
Diego Biurrun's avatar
Diego Biurrun committed
40
 *  http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41
 */
42

43 44
#include <inttypes.h>

45
#include "libavutil/attributes.h"
46 47
#include "internal.h"
#include "avcodec.h"
48
#include "mpegutils.h"
49 50
#include "h264.h"

51
#include "h264data.h" // FIXME FIXME FIXME
52

53
#include "h264_mvpred.h"
54
#include "golomb.h"
55
#include "hpeldsp.h"
56
#include "rectangle.h"
57
#include "tpeldsp.h"
58
#include "vdpau_internal.h"
59

60
#if CONFIG_ZLIB
61 62 63
#include <zlib.h>
#endif

64
#include "svq1.h"
65
#include "svq3.h"
66

67
/**
68
 * @file
69 70 71
 * svq3 decoder.
 */

72
typedef struct SVQ3Context {
73
    H264Context h;
74
    HpelDSPContext hdsp;
75
    TpelDSPContext tdsp;
76 77 78
    H264Picture *cur_pic;
    H264Picture *next_pic;
    H264Picture *last_pic;
79 80
    int halfpel_flag;
    int thirdpel_flag;
81
    int has_watermark;
82 83
    int next_slice_index;
    uint32_t watermark_key;
84 85
    uint8_t *buf;
    int buf_size;
86 87 88 89 90
    int adaptive_quant;
    int next_p_frame_damaged;
    int h_edge_pos;
    int v_edge_pos;
    int last_frame_output;
91 92
} SVQ3Context;

93 94
#define FULLPEL_MODE  1
#define HALFPEL_MODE  2
Michael Niedermayer's avatar
Michael Niedermayer committed
95
#define THIRDPEL_MODE 3
96
#define PREDICT_MODE  4
97

Michael Niedermayer's avatar
Michael Niedermayer committed
98
/* dual scan (from some older h264 draft)
99 100 101 102 103 104 105 106
 * o-->o-->o   o
 *         |  /|
 * o   o   o / o
 * | / |   |/  |
 * o   o   o   o
 *   /
 * o-->o-->o-->o
 */
107
static const uint8_t svq3_scan[16] = {
108 109 110 111
    0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
    2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
    0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
    0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
112 113
};

114 115 116 117 118 119 120
static const uint8_t luma_dc_zigzag_scan[16] = {
    0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
    3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
    1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
    3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
};

121
static const uint8_t svq3_pred_0[25][2] = {
122 123 124 125 126 127 128 129 130
    { 0, 0 },
    { 1, 0 }, { 0, 1 },
    { 0, 2 }, { 1, 1 }, { 2, 0 },
    { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
    { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
    { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
    { 2, 4 }, { 3, 3 }, { 4, 2 },
    { 4, 3 }, { 3, 4 },
    { 4, 4 }
131 132 133
};

static const int8_t svq3_pred_1[6][6][5] = {
134 135 136 137 138 139 140 141 142 143 144 145
    { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
      { 2,  1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
    { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  4,  3 }, { 0, 1,  2,  4,  3 },
      { 0,  2,  1,  4,  3 }, { 2, 0,  1,  3,  4 }, { 0, 4,  2,  1,  3 } },
    { { 2,  0, -1, -1, -1 }, { 2, 1,  0,  4,  3 }, { 1, 2,  4,  0,  3 },
      { 2,  1,  0,  4,  3 }, { 2, 1,  4,  3,  0 }, { 1, 2,  4,  0,  3 } },
    { { 2,  0, -1, -1, -1 }, { 2, 0,  1,  4,  3 }, { 1, 2,  0,  4,  3 },
      { 2,  1,  0,  4,  3 }, { 2, 1,  3,  4,  0 }, { 2, 4,  1,  0,  3 } },
    { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  3,  4 }, { 1, 2,  3,  0,  4 },
      { 2,  0,  1,  3,  4 }, { 2, 1,  3,  0,  4 }, { 2, 0,  4,  3,  1 } },
    { { 0,  2, -1, -1, -1 }, { 0, 2,  4,  1,  3 }, { 1, 4,  2,  0,  3 },
      { 4,  2,  0,  1,  3 }, { 2, 0,  1,  4,  3 }, { 4, 2,  1,  0,  3 } },
146 147
};

148 149 150 151
static const struct {
    uint8_t run;
    uint8_t level;
} svq3_dct_tables[2][16] = {
152 153 154 155
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
      { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
      { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
156 157 158
};

static const uint32_t svq3_dequant_coeff[32] = {
159 160 161 162
     3881,  4351,  4890,  5481,   6154,   6914,   7761,   8718,
     9781, 10987, 12339, 13828,  15523,  17435,  19561,  21873,
    24552, 27656, 30847, 34870,  38807,  43747,  49103,  54683,
    61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
163 164
};

165 166
static int svq3_decode_end(AVCodecContext *avctx);

Diego Biurrun's avatar
Diego Biurrun committed
167
void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
168
{
169
    const int qmul = svq3_dequant_coeff[qp];
170 171 172
#define stride 16
    int i;
    int temp[16];
173 174 175 176 177 178 179 180 181 182 183 184
    static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };

    for (i = 0; i < 4; i++) {
        const int z0 = 13 * (input[4 * i + 0] +      input[4 * i + 2]);
        const int z1 = 13 * (input[4 * i + 0] -      input[4 * i + 2]);
        const int z2 =  7 *  input[4 * i + 1] - 17 * input[4 * i + 3];
        const int z3 = 17 *  input[4 * i + 1] +  7 * input[4 * i + 3];

        temp[4 * i + 0] = z0 + z3;
        temp[4 * i + 1] = z1 + z2;
        temp[4 * i + 2] = z1 - z2;
        temp[4 * i + 3] = z0 - z3;
185 186
    }

187 188 189 190 191 192 193
    for (i = 0; i < 4; i++) {
        const int offset = x_offset[i];
        const int z0     = 13 * (temp[4 * 0 + i] +      temp[4 * 2 + i]);
        const int z1     = 13 * (temp[4 * 0 + i] -      temp[4 * 2 + i]);
        const int z2     =  7 *  temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
        const int z3     = 17 *  temp[4 * 1 + i] +  7 * temp[4 * 3 + i];

194 195 196 197
        output[stride *  0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
        output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
        output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
        output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
198 199 200 201
    }
}
#undef stride

Diego Biurrun's avatar
Diego Biurrun committed
202
void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
203
                        int stride, int qp, int dc)
204
{
205
    const int qmul = svq3_dequant_coeff[qp];
206 207 208
    int i;

    if (dc) {
209 210
        dc       = 13 * 13 * (dc == 1 ? 1538 * block[0]
                                      : qmul * (block[0] >> 3) / 2);
211 212 213
        block[0] = 0;
    }

214
    for (i = 0; i < 4; i++) {
215 216 217 218 219 220 221 222 223
        const int z0 = 13 * (block[0 + 4 * i] +      block[2 + 4 * i]);
        const int z1 = 13 * (block[0 + 4 * i] -      block[2 + 4 * i]);
        const int z2 =  7 *  block[1 + 4 * i] - 17 * block[3 + 4 * i];
        const int z3 = 17 *  block[1 + 4 * i] +  7 * block[3 + 4 * i];

        block[0 + 4 * i] = z0 + z3;
        block[1 + 4 * i] = z1 + z2;
        block[2 + 4 * i] = z1 - z2;
        block[3 + 4 * i] = z0 - z3;
224 225
    }

226
    for (i = 0; i < 4; i++) {
227 228 229 230
        const int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
        const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
        const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
        const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
231 232
        const int rr = (dc + 0x80000);

233 234 235 236
        dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
        dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
        dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
        dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
237
    }
238 239

    memset(block, 0, 16 * sizeof(int16_t));
240 241
}

Diego Biurrun's avatar
Diego Biurrun committed
242
static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
243 244
                                    int index, const int type)
{
245 246
    static const uint8_t *const scan_patterns[4] =
    { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
247

248
    int run, level, sign, limit;
249
    unsigned vlc;
250
    const int intra           = 3 * type >> 2;
251
    const uint8_t *const scan = scan_patterns[type];
252

253 254
    for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
        for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
255
            if ((int32_t)vlc < 0)
256
                return -1;
257

258
            sign     = (vlc & 1) ? 0 : -1;
259
            vlc      = vlc + 1 >> 1;
260 261 262 263 264 265 266 267 268

            if (type == 3) {
                if (vlc < 3) {
                    run   = 0;
                    level = vlc;
                } else if (vlc < 4) {
                    run   = 1;
                    level = 1;
                } else {
269 270
                    run   = vlc & 0x3;
                    level = (vlc + 9 >> 2) - run;
271 272
                }
            } else {
273
                if (vlc < 16U) {
274 275 276
                    run   = svq3_dct_tables[intra][vlc].run;
                    level = svq3_dct_tables[intra][vlc].level;
                } else if (intra) {
277
                    run   = vlc & 0x7;
278
                    level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
279
                } else {
280
                    run   = vlc & 0xF;
281
                    level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
282 283
                }
            }
284

285

286 287 288 289
            if ((index += run) >= limit)
                return -1;

            block[scan[index]] = (level ^ sign) - sign;
290
        }
291

292 293 294
        if (type != 2) {
            break;
        }
295 296
    }

297
    return 0;
298 299
}

300
static inline void svq3_mc_dir_part(SVQ3Context *s,
301 302 303 304
                                    int x, int y, int width, int height,
                                    int mx, int my, int dxy,
                                    int thirdpel, int dir, int avg)
{
305
    H264Context *h = &s->h;
306
    H264SliceContext *sl = &h->slice_ctx[0];
307
    const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
308 309
    uint8_t *src, *dest;
    int i, emu = 0;
310
    int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
311 312 313

    mx += x;
    my += y;
314

315 316
    if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
        my < 0 || my >= s->v_edge_pos - height - 1) {
317
        emu = 1;
318 319
        mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
        my = av_clip(my, -16, s->v_edge_pos - height + 15);
320 321
    }

322
    /* form component predictions */
323 324
    dest = h->cur_pic.f->data[0] + x + y * sl->linesize;
    src  = pic->f->data[0] + mx + my * sl->linesize;
325 326

    if (emu) {
327
        h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
328
                                 sl->linesize, sl->linesize,
329 330
                                 width + 1, height + 1,
                                 mx, my, s->h_edge_pos, s->v_edge_pos);
331
        src = sl->edge_emu_buffer;
332
    }
333
    if (thirdpel)
334
        (avg ? s->tdsp.avg_tpel_pixels_tab
335
             : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, sl->linesize,
336
                                                 width, height);
337
    else
338
        (avg ? s->hdsp.avg_pixels_tab
339
             : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, sl->linesize,
340
                                                       height);
341

342
    if (!(h->flags & CODEC_FLAG_GRAY)) {
343 344 345 346
        mx     = mx + (mx < (int) x) >> 1;
        my     = my + (my < (int) y) >> 1;
        width  = width  >> 1;
        height = height >> 1;
347 348 349
        blocksize++;

        for (i = 1; i < 3; i++) {
350 351
            dest = h->cur_pic.f->data[i] + (x >> 1) + (y >> 1) * sl->uvlinesize;
            src  = pic->f->data[i] + mx + my * sl->uvlinesize;
352 353

            if (emu) {
354
                h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
355
                                         sl->uvlinesize, sl->uvlinesize,
356 357 358
                                         width + 1, height + 1,
                                         mx, my, (s->h_edge_pos >> 1),
                                         s->v_edge_pos >> 1);
359
                src = sl->edge_emu_buffer;
360 361
            }
            if (thirdpel)
362 363
                (avg ? s->tdsp.avg_tpel_pixels_tab
                     : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
364
                                                         sl->uvlinesize,
365
                                                         width, height);
366
            else
367 368
                (avg ? s->hdsp.avg_pixels_tab
                     : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
369
                                                               sl->uvlinesize,
370
                                                               height);
371 372
        }
    }
373 374
}

375
static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
376
                              int dir, int avg)
377
{
378
    int i, j, k, mx, my, dx, dy, x, y;
379
    H264Context *h          = &s->h;
380
    H264SliceContext *sl    = &h->slice_ctx[0];
381 382 383 384 385 386 387
    const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
    const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
    const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
    const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
    const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;

    for (i = 0; i < 16; i += part_height)
388
        for (j = 0; j < 16; j += part_width) {
389 390
            const int b_xy = (4 * sl->mb_x + (j >> 2)) +
                             (4 * sl->mb_y + (i >> 2)) * h->b_stride;
391
            int dxy;
392 393
            x = 16 * sl->mb_x + j;
            y = 16 * sl->mb_y + i;
394 395
            k = (j >> 2 & 1) + (i >> 1 & 2) +
                (j >> 1 & 4) + (i      & 8);
396 397

            if (mode != PREDICT_MODE) {
398
                pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
399
            } else {
400 401
                mx = s->next_pic->motion_val[0][b_xy][0] << 1;
                my = s->next_pic->motion_val[0][b_xy][1] << 1;
402 403

                if (dir == 0) {
404 405 406 407
                    mx = mx * h->frame_num_offset /
                         h->prev_frame_num_offset + 1 >> 1;
                    my = my * h->frame_num_offset /
                         h->prev_frame_num_offset + 1 >> 1;
408
                } else {
409 410 411 412
                    mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
                         h->prev_frame_num_offset + 1 >> 1;
                    my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
                         h->prev_frame_num_offset + 1 >> 1;
413 414 415 416
                }
            }

            /* clip motion vector prediction to frame border */
417 418
            mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
            my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
419 420 421 422 423

            /* get (optional) motion vector differential */
            if (mode == PREDICT_MODE) {
                dx = dy = 0;
            } else {
424 425
                dy = svq3_get_se_golomb(&h->gb);
                dx = svq3_get_se_golomb(&h->gb);
426 427

                if (dx == INVALID_VLC || dy == INVALID_VLC) {
428
                    av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
429 430 431 432 433 434 435
                    return -1;
                }
            }

            /* compute motion vector */
            if (mode == THIRDPEL_MODE) {
                int fx, fy;
436 437 438 439
                mx  = (mx + 1 >> 1) + dx;
                my  = (my + 1 >> 1) + dy;
                fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
                fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
440 441 442 443
                dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);

                svq3_mc_dir_part(s, x, y, part_width, part_height,
                                 fx, fy, dxy, 1, dir, avg);
444 445 446
                mx += mx;
                my += my;
            } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
447 448
                mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
                my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
449
                dxy = (mx & 1) + 2 * (my & 1);
450

451 452
                svq3_mc_dir_part(s, x, y, part_width, part_height,
                                 mx >> 1, my >> 1, dxy, 0, dir, avg);
453 454 455
                mx *= 3;
                my *= 3;
            } else {
456 457
                mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
                my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
458

459 460
                svq3_mc_dir_part(s, x, y, part_width, part_height,
                                 mx, my, 0, 0, dir, avg);
461 462 463 464 465 466
                mx *= 6;
                my *= 6;
            }

            /* update mv_cache */
            if (mode != PREDICT_MODE) {
467
                int32_t mv = pack16to32(mx, my);
468 469

                if (part_height == 8 && i < 8) {
470
                    AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
471

472
                    if (part_width == 8 && j < 8)
473
                        AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
474
                }
475
                if (part_width == 8 && j < 8)
476
                    AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
477
                if (part_width == 4 || part_height == 4)
478
                    AV_WN32A(sl->mv_cache[dir][scan8[k]], mv);
479 480 481
            }

            /* write back motion vectors */
482
            fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
483 484
                           part_width >> 2, part_height >> 2, h->b_stride,
                           pack16to32(mx, my), 4);
485
        }
486

487
    return 0;
488 489
}

490
static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
491
{
492
    H264Context *h = &s->h;
493
    H264SliceContext *sl = &h->slice_ctx[0];
494 495 496 497
    int i, j, k, m, dir, mode;
    int cbp = 0;
    uint32_t vlc;
    int8_t *top, *left;
498
    const int mb_xy         = sl->mb_xy;
499
    const int b_xy          = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride;
500

501 502
    sl->top_samples_available      = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
    sl->left_samples_available     = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
503
    sl->topright_samples_available = 0xFFFF;
504 505

    if (mb_type == 0) {           /* SKIP */
506
        if (h->pict_type == AV_PICTURE_TYPE_P ||
507
            s->next_pic->mb_type[mb_xy] == -1) {
508
            svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
509
                             0, 0, 0, 0, 0, 0);
510

511
            if (h->pict_type == AV_PICTURE_TYPE_B)
512
                svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
513
                                 0, 0, 0, 0, 1, 1);
514 515 516

            mb_type = MB_TYPE_SKIP;
        } else {
517
            mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
518
            if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
519
                return -1;
520
            if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
521
                return -1;
522

523
            mb_type = MB_TYPE_16x16;
524
        }
525
    } else if (mb_type < 8) {     /* INTER */
526
        if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
527
            mode = THIRDPEL_MODE;
528 529
        else if (s->halfpel_flag &&
                 s->thirdpel_flag == !get_bits1(&h->gb))
530
            mode = HALFPEL_MODE;
531
        else
532
            mode = FULLPEL_MODE;
533

534 535
        /* fill caches */
        /* note ref_cache should contain here:
536 537 538 539 540 541
         *  ????????
         *  ???11111
         *  N??11111
         *  N??11111
         *  N??11111
         */
542 543

        for (m = 0; m < 2; m++) {
544
            if (sl->mb_x > 0 && sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
545
                for (i = 0; i < 4; i++)
546
                    AV_COPY32(sl->mv_cache[m][scan8[0] - 1 + i * 8],
547
                              h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
548
            } else {
549
                for (i = 0; i < 4; i++)
550
                    AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
551
            }
552
            if (sl->mb_y > 0) {
553
                memcpy(sl->mv_cache[m][scan8[0] - 1 * 8],
554
                       h->cur_pic.motion_val[m][b_xy - h->b_stride],
555
                       4 * 2 * sizeof(int16_t));
556
                memset(&sl->ref_cache[m][scan8[0] - 1 * 8],
557
                       (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
558

559
                if (sl->mb_x < h->mb_width - 1) {
560
                    AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
561
                              h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
562
                    sl->ref_cache[m][scan8[0] + 4 - 1 * 8] =
563 564
                        (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
                         sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
565
                } else
566
                    sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
567
                if (sl->mb_x > 0) {
568
                    AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
569
                              h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
570
                    sl->ref_cache[m][scan8[0] - 1 - 1 * 8] =
571
                        (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
572
                } else
573
                    sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
574
            } else
575
                memset(&sl->ref_cache[m][scan8[0] - 1 * 8 - 1],
576
                       PART_NOT_AVAILABLE, 8);
577

578
            if (h->pict_type != AV_PICTURE_TYPE_B)
579
                break;
580
        }
581

582
        /* decode motion vector(s) and form prediction(s) */
583 584
        if (h->pict_type == AV_PICTURE_TYPE_P) {
            if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
585
                return -1;
586
        } else {        /* AV_PICTURE_TYPE_B */
587
            if (mb_type != 2) {
588
                if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
589 590
                    return -1;
            } else {
591
                for (i = 0; i < 4; i++)
592
                    memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
593
                           0, 4 * 2 * sizeof(int16_t));
594 595
            }
            if (mb_type != 1) {
596
                if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
597 598
                    return -1;
            } else {
599
                for (i = 0; i < 4; i++)
600
                    memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
601
                           0, 4 * 2 * sizeof(int16_t));
602
            }
603
        }
604

605 606
        mb_type = MB_TYPE_16x16;
    } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
607
        memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
608 609

        if (mb_type == 8) {
610
            if (sl->mb_x > 0) {
611
                for (i = 0; i < 4; i++)
612 613
                    sl->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
                if (sl->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
614
                    sl->left_samples_available = 0x5F5F;
615
            }
616
            if (sl->mb_y > 0) {
617 618 619 620
                sl->intra4x4_pred_mode_cache[4 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
                sl->intra4x4_pred_mode_cache[5 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
                sl->intra4x4_pred_mode_cache[6 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
                sl->intra4x4_pred_mode_cache[7 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
621

622
                if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
623
                    sl->top_samples_available = 0x33FF;
624 625 626
            }

            /* decode prediction codes for luma blocks */
627
            for (i = 0; i < 16; i += 2) {
628
                vlc = svq3_get_ue_golomb(&h->gb);
629

630
                if (vlc >= 25U) {
631 632
                    av_log(h->avctx, AV_LOG_ERROR,
                           "luma prediction:%"PRIu32"\n", vlc);
633 634 635
                    return -1;
                }

636 637
                left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
                top  = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
638 639 640 641

                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];

642
                if (left[1] == -1 || left[2] == -1) {
643
                    av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
644 645 646 647
                    return -1;
                }
            }
        } else {    /* mb_type == 33, DC_128_PRED block type */
648
            for (i = 0; i < 4; i++)
649
                memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
650
        }
651

652
        write_back_intra_pred_mode(h, sl);
653

654
        if (mb_type == 8) {
655
            ff_h264_check_intra4x4_pred_mode(h, sl);
656

657 658
            sl->top_samples_available  = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
            sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
659
        } else {
660
            for (i = 0; i < 4; i++)
661
                memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
662

663 664
            sl->top_samples_available  = 0x33FF;
            sl->left_samples_available = 0x5F5F;
665
        }
666

667 668 669
        mb_type = MB_TYPE_INTRA4x4;
    } else {                      /* INTRA16x16 */
        dir = i_mb_type_info[mb_type - 8].pred_mode;
670
        dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
671

672
        if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
673
            av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
674
            return sl->intra16x16_pred_mode;
675
        }
676

677
        cbp     = i_mb_type_info[mb_type - 8].cbp;
678
        mb_type = MB_TYPE_INTRA16x16;
679
    }
680

681
    if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
682
        for (i = 0; i < 4; i++)
683
            memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
684
                   0, 4 * 2 * sizeof(int16_t));
685
        if (h->pict_type == AV_PICTURE_TYPE_B) {
686
            for (i = 0; i < 4; i++)
687
                memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
688
                       0, 4 * 2 * sizeof(int16_t));
689
        }
690
    }
691
    if (!IS_INTRA4x4(mb_type)) {
692
        memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
693
    }
694
    if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
695
        memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
696
    }
697

698
    if (!IS_INTRA16x16(mb_type) &&
699
        (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
700
        if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48U){
701
            av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
702 703
            return -1;
        }
704

705 706
        cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
                                : golomb_to_inter_cbp[vlc];
707
    }
708
    if (IS_INTRA16x16(mb_type) ||
709
        (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
710
        sl->qscale += svq3_get_se_golomb(&h->gb);
711

712 713
        if (sl->qscale > 31u) {
            av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
714 715
            return -1;
        }
716
    }
717
    if (IS_INTRA16x16(mb_type)) {
718 719 720
        AV_ZERO128(sl->mb_luma_dc[0] + 0);
        AV_ZERO128(sl->mb_luma_dc[0] + 8);
        if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
721
            av_log(h->avctx, AV_LOG_ERROR,
722
                   "error while decoding intra luma dc\n");
723
            return -1;
724
        }
725
    }
726

727 728
    if (cbp) {
        const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
729
        const int type  = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
730

731
        for (i = 0; i < 4; i++)
732 733
            if ((cbp & (1 << i))) {
                for (j = 0; j < 4; j++) {
734 735 736
                    k = index ? (1 * (j & 1) + 2 * (i & 1) +
                                 2 * (j & 2) + 4 * (i & 2))
                              : (4 * i + j);
737
                    sl->non_zero_count_cache[scan8[k]] = 1;
738

739
                    if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
740
                        av_log(h->avctx, AV_LOG_ERROR,
741
                               "error while decoding block\n");
742 743 744 745
                        return -1;
                    }
                }
            }
746

747
        if ((cbp & 0x30)) {
748
            for (i = 1; i < 3; ++i)
749
                if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
750
                    av_log(h->avctx, AV_LOG_ERROR,
751 752 753
                           "error while decoding chroma dc block\n");
                    return -1;
                }
754 755

            if ((cbp & 0x20)) {
756 757
                for (i = 1; i < 3; i++) {
                    for (j = 0; j < 4; j++) {
758
                        k                                 = 16 * i + j;
759
                        sl->non_zero_count_cache[scan8[k]] = 1;
760

761
                        if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
762
                            av_log(h->avctx, AV_LOG_ERROR,
763
                                   "error while decoding chroma ac block\n");
764 765
                            return -1;
                        }
766 767 768
                    }
                }
            }
769
        }
770 771
    }

772
    sl->cbp                   = cbp;
773
    h->cur_pic.mb_type[mb_xy] = mb_type;
774

775
    if (IS_INTRA(mb_type))
776
        sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
777

778
    return 0;
779 780
}

781
static int svq3_decode_slice_header(AVCodecContext *avctx)
782
{
783 784
    SVQ3Context *s = avctx->priv_data;
    H264Context *h    = &s->h;
785
    H264SliceContext *sl = &h->slice_ctx[0];
786
    const int mb_xy   = sl->mb_xy;
787
    int i, header;
788
    unsigned slice_id;
789

790
    header = get_bits(&h->gb, 8);
791

792 793
    if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
        /* TODO: what? */
794
        av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
795 796
        return -1;
    } else {
797
        int length = header >> 5 & 3;
798

799 800 801
        s->next_slice_index = get_bits_count(&h->gb) +
                              8 * show_bits(&h->gb, 8 * length) +
                              8 * length;
802

803
        if (s->next_slice_index > h->gb.size_in_bits) {
804
            av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
805
            return -1;
806
        }
807

808 809
        h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
        skip_bits(&h->gb, 8);
810

811 812 813 814
        if (s->watermark_key) {
            uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
            AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
                    header ^ s->watermark_key);
815 816
        }
        if (length > 0) {
817 818
            memmove((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
                    &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
819
        }
820
        skip_bits_long(&h->gb, 0);
821 822
    }

823
    if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
824
        av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
825 826
        return -1;
    }
827

828
    sl->slice_type = golomb_to_pict_type[slice_id];
829

830
    if ((header & 0x9F) == 2) {
831
        i              = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
832
        sl->mb_skip_run = get_bits(&h->gb, i) -
833
                         (sl->mb_y * h->mb_width + sl->mb_x);
834
    } else {
835
        skip_bits1(&h->gb);
836
        sl->mb_skip_run = 0;
837
    }
838

839 840
    sl->slice_num     = get_bits(&h->gb, 8);
    sl->qscale        = get_bits(&h->gb, 5);
841
    s->adaptive_quant = get_bits1(&h->gb);
842

843
    /* unknown fields */
844
    skip_bits1(&h->gb);
845

846
    if (s->has_watermark)
847
        skip_bits1(&h->gb);
848

849 850
    skip_bits1(&h->gb);
    skip_bits(&h->gb, 2);
851

852 853
    if (skip_1stop_8data_bits(&h->gb) < 0)
        return AVERROR_INVALIDDATA;
854

855
    /* reset intra predictors and invalidate motion vector references */
856
    if (sl->mb_x > 0) {
857
        memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
858
               -1, 4 * sizeof(int8_t));
859 860
        memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
               -1, 8 * sizeof(int8_t) * sl->mb_x);
861
    }
862
    if (sl->mb_y > 0) {
863
        memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
864
               -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
865

866
        if (sl->mb_x > 0)
867
            sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
868 869
    }

870
    return 0;
871 872
}

873
static av_cold int svq3_decode_init(AVCodecContext *avctx)
874
{
875 876
    SVQ3Context *s = avctx->priv_data;
    H264Context *h = &s->h;
877
    H264SliceContext *sl;
878
    int m;
879
    unsigned char *extradata;
880
    unsigned char *extradata_end;
881
    unsigned int size;
882
    int marker_found = 0;
883
    int ret;
884

885 886 887 888
    s->cur_pic  = av_mallocz(sizeof(*s->cur_pic));
    s->last_pic = av_mallocz(sizeof(*s->last_pic));
    s->next_pic = av_mallocz(sizeof(*s->next_pic));
    if (!s->next_pic || !s->last_pic || !s->cur_pic) {
889 890
        ret = AVERROR(ENOMEM);
        goto fail;
891 892
    }

893 894 895 896 897 898
    s->cur_pic->f  = av_frame_alloc();
    s->last_pic->f = av_frame_alloc();
    s->next_pic->f = av_frame_alloc();
    if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
        return AVERROR(ENOMEM);

899 900
    if ((ret = ff_h264_decode_init(avctx)) < 0)
        goto fail;
901

902 903 904
    // we will overwrite it later during decoding
    av_frame_free(&h->cur_pic.f);

905 906
    av_frame_free(&h->last_pic_for_ec.f);

907 908
    ff_h264dsp_init(&h->h264dsp, 8, 1);
    av_assert0(h->sps.bit_depth_chroma == 0);
909
    ff_h264_pred_init(&h->hpc, AV_CODEC_ID_SVQ3, 8, 1);
910
    ff_videodsp_init(&h->vdsp, 8);
911

912 913
    memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
    memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
914

915
    avctx->bits_per_raw_sample = 8;
916 917 918
    h->sps.bit_depth_luma = 8;
    h->chroma_format_idc = 1;

919
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
920 921
    ff_tpeldsp_init(&s->tdsp);

922 923
    sl = h->slice_ctx;

924
    h->flags           = avctx->flags;
925
    sl->is_complex     = 1;
926
    h->sps.chroma_format_idc = 1;
927
    h->picture_structure = PICT_FRAME;
928 929
    avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
    avctx->color_range = AVCOL_RANGE_JPEG;
930

931
    h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
932
    h->chroma_x_shift = h->chroma_y_shift = 1;
933

934 935
    s->halfpel_flag  = 1;
    s->thirdpel_flag = 1;
936
    s->has_watermark = 0;
937 938 939 940 941 942 943 944 945

    /* prowl for the "SEQH" marker in the extradata */
    extradata     = (unsigned char *)avctx->extradata;
    extradata_end = avctx->extradata + avctx->extradata_size;
    if (extradata) {
        for (m = 0; m + 8 < avctx->extradata_size; m++) {
            if (!memcmp(extradata, "SEQH", 4)) {
                marker_found = 1;
                break;
946
            }
947
            extradata++;
948
        }
949
    }
950

951 952 953 954
    /* if a match was found, parse the extra data */
    if (marker_found) {
        GetBitContext gb;
        int frame_size_code;
955
        int unk0, unk1, unk2, unk3, unk4;
956 957

        size = AV_RB32(&extradata[4]);
958 959 960 961
        if (size > extradata_end - extradata - 8) {
            ret = AVERROR_INVALIDDATA;
            goto fail;
        }
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999
        init_get_bits(&gb, extradata + 8, size * 8);

        /* 'frame size code' and optional 'width, height' */
        frame_size_code = get_bits(&gb, 3);
        switch (frame_size_code) {
        case 0:
            avctx->width  = 160;
            avctx->height = 120;
            break;
        case 1:
            avctx->width  = 128;
            avctx->height =  96;
            break;
        case 2:
            avctx->width  = 176;
            avctx->height = 144;
            break;
        case 3:
            avctx->width  = 352;
            avctx->height = 288;
            break;
        case 4:
            avctx->width  = 704;
            avctx->height = 576;
            break;
        case 5:
            avctx->width  = 240;
            avctx->height = 180;
            break;
        case 6:
            avctx->width  = 320;
            avctx->height = 240;
            break;
        case 7:
            avctx->width  = get_bits(&gb, 12);
            avctx->height = get_bits(&gb, 12);
            break;
        }
1000

1001 1002
        s->halfpel_flag  = get_bits1(&gb);
        s->thirdpel_flag = get_bits1(&gb);
1003

1004
        /* unknown fields */
1005 1006 1007 1008
        unk0 = get_bits1(&gb);
        unk1 = get_bits1(&gb);
        unk2 = get_bits1(&gb);
        unk3 = get_bits1(&gb);
1009

1010
        h->low_delay = get_bits1(&gb);
1011

1012
        /* unknown field */
1013 1014 1015 1016
        unk4 = get_bits1(&gb);

        av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
               unk0, unk1, unk2, unk3, unk4);
1017

1018 1019 1020 1021
        if (skip_1stop_8data_bits(&gb) < 0) {
            ret = AVERROR_INVALIDDATA;
            goto fail;
        }
1022

1023
        s->has_watermark  = get_bits1(&gb);
1024
        avctx->has_b_frames = !h->low_delay;
1025
        if (s->has_watermark) {
1026
#if CONFIG_ZLIB
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
            unsigned watermark_width  = svq3_get_ue_golomb(&gb);
            unsigned watermark_height = svq3_get_ue_golomb(&gb);
            int u1                    = svq3_get_ue_golomb(&gb);
            int u2                    = get_bits(&gb, 8);
            int u3                    = get_bits(&gb, 2);
            int u4                    = svq3_get_ue_golomb(&gb);
            unsigned long buf_len     = watermark_width *
                                        watermark_height * 4;
            int offset                = get_bits_count(&gb) + 7 >> 3;
            uint8_t *buf;

1038
            if (watermark_height <= 0 ||
1039 1040 1041 1042
                (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
                ret = -1;
                goto fail;
            }
1043

1044
            buf = av_malloc(buf_len);
1045 1046 1047 1048
            if (!buf) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
1049
            av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1050 1051 1052 1053 1054 1055
                   watermark_width, watermark_height);
            av_log(avctx, AV_LOG_DEBUG,
                   "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
                   u1, u2, u3, u4, offset);
            if (uncompress(buf, &buf_len, extradata + 8 + offset,
                           size - offset) != Z_OK) {
1056
                av_log(avctx, AV_LOG_ERROR,
1057 1058
                       "could not uncompress watermark logo\n");
                av_free(buf);
1059 1060
                ret = -1;
                goto fail;
1061
            }
1062 1063
            s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
            s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1064
            av_log(avctx, AV_LOG_DEBUG,
1065
                   "watermark key %#"PRIx32"\n", s->watermark_key);
1066 1067 1068 1069
            av_free(buf);
#else
            av_log(avctx, AV_LOG_ERROR,
                   "this svq3 file contains watermark which need zlib support compiled in\n");
1070 1071
            ret = -1;
            goto fail;
1072
#endif
1073
        }
1074
    }
1075

1076 1077 1078 1079 1080 1081 1082 1083 1084
    h->width  = avctx->width;
    h->height = avctx->height;
    h->mb_width  = (h->width + 15) / 16;
    h->mb_height = (h->height + 15) / 16;
    h->mb_stride = h->mb_width + 1;
    h->mb_num    = h->mb_width * h->mb_height;
    h->b_stride = 4 * h->mb_width;
    s->h_edge_pos = h->mb_width * 16;
    s->v_edge_pos = h->mb_height * 16;
1085

1086
    if ((ret = ff_h264_alloc_tables(h)) < 0) {
1087
        av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1088
        goto fail;
1089
    }
1090

1091
    return 0;
1092 1093 1094
fail:
    svq3_decode_end(avctx);
    return ret;
1095 1096
}

1097
static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1098 1099 1100 1101 1102 1103 1104 1105
{
    int i;
    for (i = 0; i < 2; i++) {
        av_buffer_unref(&pic->motion_val_buf[i]);
        av_buffer_unref(&pic->ref_index_buf[i]);
    }
    av_buffer_unref(&pic->mb_type_buf);

1106
    av_frame_unref(pic->f);
1107 1108
}

1109
static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1110 1111 1112
{
    SVQ3Context *s = avctx->priv_data;
    H264Context *h = &s->h;
1113
    H264SliceContext *sl = &h->slice_ctx[0];
1114 1115 1116 1117 1118 1119
    const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
    const int mb_array_size = h->mb_stride * h->mb_height;
    const int b4_stride     = h->mb_width * 4 + 1;
    const int b4_array_size = b4_stride * h->mb_height * 4;
    int ret;

1120
    if (!pic->motion_val_buf[0]) {
1121 1122
        int i;

1123 1124
        pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
        if (!pic->mb_type_buf)
1125
            return AVERROR(ENOMEM);
1126
        pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1127 1128

        for (i = 0; i < 2; i++) {
1129 1130 1131 1132 1133 1134
            pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
            pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
            if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
1135

1136 1137
            pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
            pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1138 1139
        }
    }
1140 1141
    pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);

1142
    ret = ff_get_buffer(avctx, pic->f,
1143 1144 1145
                        pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
    if (ret < 0)
        goto fail;
1146

1147
    if (!sl->edge_emu_buffer) {
1148
        sl->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1149
        if (!sl->edge_emu_buffer)
1150 1151
            return AVERROR(ENOMEM);
    }
1152

1153 1154
    sl->linesize   = pic->f->linesize[0];
    sl->uvlinesize = pic->f->linesize[1];
1155

1156 1157 1158
    return 0;
fail:
    free_picture(avctx, pic);
1159 1160 1161
    return ret;
}

1162
static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1163
                             int *got_frame, AVPacket *avpkt)
1164
{
1165 1166
    SVQ3Context *s     = avctx->priv_data;
    H264Context *h     = &s->h;
1167
    H264SliceContext *sl = &h->slice_ctx[0];
1168
    int buf_size       = avpkt->size;
1169
    int left;
1170
    uint8_t *buf;
1171
    int ret, m, i;
1172

1173 1174
    /* special case for last picture */
    if (buf_size == 0) {
1175 1176
        if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
            ret = av_frame_ref(data, s->next_pic->f);
1177 1178
            if (ret < 0)
                return ret;
1179
            s->last_frame_output = 1;
1180
            *got_frame          = 1;
1181 1182
        }
        return 0;
1183
    }
1184

1185
    sl->mb_x = sl->mb_y = sl->mb_xy = 0;
1186

1187
    if (s->watermark_key) {
1188
        av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1189
        if (!s->buf)
1190
            return AVERROR(ENOMEM);
1191 1192
        memcpy(s->buf, avpkt->data, buf_size);
        buf = s->buf;
1193 1194 1195 1196
    } else {
        buf = avpkt->data;
    }

1197
    init_get_bits(&h->gb, buf, 8 * buf_size);
1198

1199
    if (svq3_decode_slice_header(avctx))
1200
        return -1;
1201

1202
    h->pict_type = sl->slice_type;
1203

1204
    if (h->pict_type != AV_PICTURE_TYPE_B)
1205
        FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1206

1207
    av_frame_unref(s->cur_pic->f);
1208

1209
    /* for skipping the frame */
1210 1211
    s->cur_pic->f->pict_type = h->pict_type;
    s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1212

1213 1214 1215 1216 1217 1218 1219 1220
    ret = get_buffer(avctx, s->cur_pic);
    if (ret < 0)
        return ret;

    h->cur_pic_ptr = s->cur_pic;
    h->cur_pic     = *s->cur_pic;

    for (i = 0; i < 16; i++) {
1221 1222
        h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
        h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1223 1224 1225
    }
    for (i = 0; i < 16; i++) {
        h->block_offset[16 + i]      =
1226
        h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1227
        h->block_offset[48 + 16 + i] =
1228
        h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1229 1230 1231
    }

    if (h->pict_type != AV_PICTURE_TYPE_I) {
1232
        if (!s->last_pic->f->data[0]) {
1233
            av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1234
            av_frame_unref(s->last_pic->f);
1235 1236 1237
            ret = get_buffer(avctx, s->last_pic);
            if (ret < 0)
                return ret;
1238 1239 1240 1241 1242
            memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
            memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
                   s->last_pic->f->linesize[1]);
            memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
                   s->last_pic->f->linesize[2]);
1243 1244
        }

1245
        if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1246
            av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1247
            av_frame_unref(s->next_pic->f);
1248 1249 1250
            ret = get_buffer(avctx, s->next_pic);
            if (ret < 0)
                return ret;
1251 1252 1253 1254 1255
            memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
            memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
                   s->next_pic->f->linesize[1]);
            memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
                   s->next_pic->f->linesize[2]);
1256 1257 1258 1259 1260 1261 1262 1263
        }
    }

    if (avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(h->avctx, AV_LOG_DEBUG,
               "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
               av_get_picture_type_char(h->pict_type),
               s->halfpel_flag, s->thirdpel_flag,
1264
               s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1265 1266 1267

    if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
        avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1268
        avctx->skip_frame >= AVDISCARD_ALL)
1269 1270 1271
        return 0;

    if (s->next_p_frame_damaged) {
1272
        if (h->pict_type == AV_PICTURE_TYPE_B)
1273 1274 1275 1276
            return 0;
        else
            s->next_p_frame_damaged = 0;
    }
1277

1278
    if (h->pict_type == AV_PICTURE_TYPE_B) {
1279
        h->frame_num_offset = sl->slice_num - h->prev_frame_num;
1280

1281
        if (h->frame_num_offset < 0)
1282
            h->frame_num_offset += 256;
1283 1284
        if (h->frame_num_offset == 0 ||
            h->frame_num_offset >= h->prev_frame_num_offset) {
1285
            av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1286 1287 1288
            return -1;
        }
    } else {
1289
        h->prev_frame_num        = h->frame_num;
1290
        h->frame_num             = sl->slice_num;
1291
        h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1292

1293
        if (h->prev_frame_num_offset < 0)
1294
            h->prev_frame_num_offset += 256;
1295 1296
    }

1297
    for (m = 0; m < 2; m++) {
1298
        int i;
1299
        for (i = 0; i < 4; i++) {
1300 1301
            int j;
            for (j = -1; j < 4; j++)
1302
                sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1303
            if (i < 3)
1304
                sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1305
        }
1306 1307
    }

1308 1309
    for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
        for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
1310
            unsigned mb_type;
1311
            sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
1312

1313 1314 1315 1316 1317
            if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
                ((get_bits_count(&h->gb) & 7) == 0 ||
                 show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
                skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
                h->gb.size_in_bits = 8 * buf_size;
1318

1319
                if (svq3_decode_slice_header(avctx))
1320
                    return -1;
1321

1322 1323
                /* TODO: support s->mb_skip_run */
            }
1324

1325
            mb_type = svq3_get_ue_golomb(&h->gb);
1326

1327
            if (h->pict_type == AV_PICTURE_TYPE_I)
1328
                mb_type += 8;
1329
            else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1330
                mb_type += 4;
1331 1332
            if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
                av_log(h->avctx, AV_LOG_ERROR,
1333
                       "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
1334 1335
                return -1;
            }
1336

1337
            if (mb_type != 0 || sl->cbp)
1338
                ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
1339

1340
            if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1341
                h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
1342
                    (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1343
        }
1344

1345 1346
        ff_draw_horiz_band(avctx, s->cur_pic->f,
                           s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1347
                           16 * sl->mb_y, 16, h->picture_structure, 0,
1348
                           h->low_delay);
1349
    }
1350

1351
    left = buf_size*8 - get_bits_count(&h->gb);
1352

1353 1354
    if (sl->mb_y != h->mb_height || sl->mb_x != h->mb_width) {
        av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, sl->mb_y, sl->mb_x, left);
1355 1356 1357 1358 1359 1360 1361 1362
        //av_hex_dump(stderr, buf+buf_size-8, 8);
    }

    if (left < 0) {
        av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
        return -1;
    }

1363
    if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1364 1365 1366
        ret = av_frame_ref(data, s->cur_pic->f);
    else if (s->last_pic->f->data[0])
        ret = av_frame_ref(data, s->last_pic->f);
1367 1368
    if (ret < 0)
        return ret;
1369

1370
    /* Do not output the last pic after seeking. */
1371
    if (s->last_pic->f->data[0] || h->low_delay)
1372
        *got_frame = 1;
1373

1374
    if (h->pict_type != AV_PICTURE_TYPE_B) {
1375
        FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1376
    } else {
1377
        av_frame_unref(s->cur_pic->f);
1378 1379
    }

1380
    return buf_size;
1381 1382
}

1383
static av_cold int svq3_decode_end(AVCodecContext *avctx)
1384
{
1385 1386
    SVQ3Context *s = avctx->priv_data;
    H264Context *h = &s->h;
1387

1388 1389 1390
    free_picture(avctx, s->cur_pic);
    free_picture(avctx, s->next_pic);
    free_picture(avctx, s->last_pic);
1391 1392 1393
    av_frame_free(&s->cur_pic->f);
    av_frame_free(&s->next_pic->f);
    av_frame_free(&s->last_pic->f);
1394 1395 1396 1397
    av_freep(&s->cur_pic);
    av_freep(&s->next_pic);
    av_freep(&s->last_pic);

1398
    memset(&h->cur_pic, 0, sizeof(h->cur_pic));
1399

1400
    ff_h264_free_context(h);
1401

1402 1403
    av_freep(&s->buf);
    s->buf_size = 0;
1404

1405 1406
    return 0;
}
1407

1408
AVCodec ff_svq3_decoder = {
1409
    .name           = "svq3",
1410
    .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1411
    .type           = AVMEDIA_TYPE_VIDEO,
1412
    .id             = AV_CODEC_ID_SVQ3,
1413 1414 1415 1416
    .priv_data_size = sizeof(SVQ3Context),
    .init           = svq3_decode_init,
    .close          = svq3_decode_end,
    .decode         = svq3_decode_frame,
1417 1418
    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
                      CODEC_CAP_DR1             |
1419
                      CODEC_CAP_DELAY,
1420 1421
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
                                                     AV_PIX_FMT_NONE},
1422
};