GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/svq1dec.c Lines: 292 345 84.6 %
Date: 2021-04-15 16:04:23 Branches: 163 215 75.8 %

Line Branch Exec Source
1
/*
2
 * SVQ1 decoder
3
 * ported to MPlayer by Arpi <arpi@thot.banki.hu>
4
 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
5
 *
6
 * Copyright (c) 2002 The Xine project
7
 * Copyright (c) 2002 The FFmpeg project
8
 *
9
 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
10
 *
11
 * This file is part of FFmpeg.
12
 *
13
 * FFmpeg is free software; you can redistribute it and/or
14
 * modify it under the terms of the GNU Lesser General Public
15
 * License as published by the Free Software Foundation; either
16
 * version 2.1 of the License, or (at your option) any later version.
17
 *
18
 * FFmpeg is distributed in the hope that it will be useful,
19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21
 * Lesser General Public License for more details.
22
 *
23
 * You should have received a copy of the GNU Lesser General Public
24
 * License along with FFmpeg; if not, write to the Free Software
25
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26
 */
27
28
/**
29
 * @file
30
 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
31
 * For more information of the SVQ1 algorithm, visit:
32
 *   http://www.pcisys.net/~melanson/codecs/
33
 */
34
35
#include "libavutil/crc.h"
36
#include "libavutil/thread.h"
37
38
#include "avcodec.h"
39
#include "get_bits.h"
40
#include "h263.h"
41
#include "hpeldsp.h"
42
#include "internal.h"
43
#include "mathops.h"
44
#include "svq1.h"
45
46
#define SVQ1_BLOCK_TYPE_VLC_BITS 3
47
static VLC svq1_block_type;
48
static VLC svq1_motion_component;
49
static VLC svq1_intra_multistage[6];
50
static VLC svq1_inter_multistage[6];
51
static VLC svq1_intra_mean;
52
static VLC svq1_inter_mean;
53
54
/* motion vector (prediction) */
55
typedef struct svq1_pmv_s {
56
    int x;
57
    int y;
58
} svq1_pmv;
59
60
typedef struct SVQ1Context {
61
    HpelDSPContext hdsp;
62
    GetBitContext gb;
63
    AVFrame *prev;
64
65
    uint8_t *pkt_swapped;
66
    int pkt_swapped_allocated;
67
68
    svq1_pmv *pmv;
69
    int pmv_allocated;
70
71
    int width;
72
    int height;
73
    int frame_code;
74
    int nonref;         // 1 if the current frame won't be referenced
75
} SVQ1Context;
76
77
static const uint8_t string_table[256] = {
78
    0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
79
    0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
80
    0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
81
    0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
82
    0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
83
    0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
84
    0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
85
    0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
86
    0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
87
    0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
88
    0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
89
    0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
90
    0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
91
    0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
92
    0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
93
    0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
94
    0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
95
    0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
96
    0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
97
    0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
98
    0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
99
    0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
100
    0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
101
    0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
102
    0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
103
    0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
104
    0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
105
    0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
106
    0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
107
    0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
108
    0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
109
    0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
110
};
111
112
#define SVQ1_PROCESS_VECTOR()                                           \
113
    for (; level > 0; i++) {                                            \
114
        /* process next depth */                                        \
115
        if (i == m) {                                                   \
116
            m = n;                                                      \
117
            if (--level == 0)                                           \
118
                break;                                                  \
119
        }                                                               \
120
        /* divide block if next bit set */                              \
121
        if (!get_bits1(bitbuf))                                         \
122
            break;                                                      \
123
        /* add child nodes */                                           \
124
        list[n++] = list[i];                                            \
125
        list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
126
    }
127
128
#define SVQ1_ADD_CODEBOOK()                                             \
129
    /* add codebook entries to vector */                                \
130
    for (j = 0; j < stages; j++) {                                      \
131
        n3  = codebook[entries[j]] ^ 0x80808080;                        \
132
        n1 += (n3 & 0xFF00FF00) >> 8;                                   \
133
        n2 +=  n3 & 0x00FF00FF;                                         \
134
    }                                                                   \
135
                                                                        \
136
    /* clip to [0..255] */                                              \
137
    if (n1 & 0xFF00FF00) {                                              \
138
        n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
139
        n1 += 0x7F007F00;                                               \
140
        n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
141
        n1 &= n3 & 0x00FF00FF;                                          \
142
    }                                                                   \
143
                                                                        \
144
    if (n2 & 0xFF00FF00) {                                              \
145
        n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
146
        n2 += 0x7F007F00;                                               \
147
        n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
148
        n2 &= n3 & 0x00FF00FF;                                          \
149
    }
150
151
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
152
    codebook = (const uint32_t *)cbook[level];                          \
153
    if (stages > 0)                                                     \
154
        bit_cache = get_bits(bitbuf, 4 * stages);                       \
155
    /* calculate codebook entries for this vector */                    \
156
    for (j = 0; j < stages; j++) {                                      \
157
        entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
158
                      16 * j) << (level + 1);                           \
159
    }                                                                   \
160
    mean -= stages * 128;                                               \
161
    n4    = (mean << 16) + mean;
162
163
12351
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
164
                                   ptrdiff_t pitch)
165
{
166
    uint32_t bit_cache;
167
    uint8_t *list[63];
168
    uint32_t *dst;
169
    const uint32_t *codebook;
170
    int entries[6];
171
    int i, j, m, n;
172
    int stages;
173
    unsigned mean;
174
    unsigned x, y, width, height, level;
175
    uint32_t n1, n2, n3, n4;
176
177
    /* initialize list for breadth first processing of vectors */
178
12351
    list[0] = pixels;
179
180
    /* recursively process vector */
181
256176
    for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
182


475299
        SVQ1_PROCESS_VECTOR();
183
184
        /* destination address and vector size */
185
243825
        dst    = (uint32_t *)list[i];
186
243825
        width  = 1 << ((4 + level) / 2);
187
243825
        height = 1 << ((3 + level) / 2);
188
189
        /* get number of stages (-1 skips vector, 0 for mean only) */
190
243825
        stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
191
192
243825
        if (stages == -1) {
193
4493
            for (y = 0; y < height; y++)
194
4122
                memset(&dst[y * (pitch / 4)], 0, width);
195
371
            continue;   /* skip vector */
196
        }
197
198

243454
        if ((stages > 0 && level >= 4)) {
199
            ff_dlog(NULL,
200
                    "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
201
                    stages, level);
202
            return AVERROR_INVALIDDATA;  /* invalid vector */
203
        }
204
243454
        av_assert0(stages >= 0);
205
206
243454
        mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
207
208
243454
        if (stages == 0) {
209
218229
            for (y = 0; y < height; y++)
210
158460
                memset(&dst[y * (pitch / 4)], mean, width);
211
        } else {
212

1133305
            SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
213
214
682355
            for (y = 0; y < height; y++) {
215
1079708
                for (x = 0; x < width / 4; x++, codebook++) {
216
581038
                    n1 = n4;
217
581038
                    n2 = n4;
218

3510202
                    SVQ1_ADD_CODEBOOK()
219
                    /* store result */
220
581038
                    dst[x] = n1 << 8 | n2;
221
                }
222
498670
                dst += pitch / 4;
223
            }
224
        }
225
    }
226
227
12351
    return 0;
228
}
229
230
65696
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
231
                                       ptrdiff_t pitch)
232
{
233
    uint32_t bit_cache;
234
    uint8_t *list[63];
235
    uint32_t *dst;
236
    const uint32_t *codebook;
237
    int entries[6];
238
    int i, j, m, n;
239
    int stages;
240
    unsigned mean;
241
    int x, y, width, height, level;
242
    uint32_t n1, n2, n3, n4;
243
244
    /* initialize list for breadth first processing of vectors */
245
65696
    list[0] = pixels;
246
247
    /* recursively process vector */
248
1298962
    for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
249


2400836
        SVQ1_PROCESS_VECTOR();
250
251
        /* destination address and vector size */
252
1233266
        dst    = (uint32_t *)list[i];
253
1233266
        width  = 1 << ((4 + level) / 2);
254
1233266
        height = 1 << ((3 + level) / 2);
255
256
        /* get number of stages (-1 skips vector, 0 for mean only) */
257
1233266
        stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
258
259
1233266
        if (stages == -1)
260
29737
            continue;           /* skip vector */
261
262

1203529
        if ((stages > 0 && level >= 4)) {
263
            ff_dlog(NULL,
264
                    "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
265
                    stages, level);
266
            return AVERROR_INVALIDDATA;  /* invalid vector */
267
        }
268
1203529
        av_assert0(stages >= 0);
269
270
1203529
        mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
271
272

3371355
        SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
273
274
4430939
        for (y = 0; y < height; y++) {
275
7237216
            for (x = 0; x < width / 4; x++, codebook++) {
276
4009806
                n3 = dst[x];
277
                /* add mean value to vector */
278
4009806
                n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
279
4009806
                n2 = n4 +  (n3 & 0x00FF00FF);
280

9362040
                SVQ1_ADD_CODEBOOK()
281
                /* store result */
282
4009806
                dst[x] = n1 << 8 | n2;
283
            }
284
3227410
            dst += pitch / 4;
285
        }
286
    }
287
65696
    return 0;
288
}
289
290
79616
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
291
                                     svq1_pmv **pmv)
292
{
293
    int diff;
294
    int i;
295
296
238848
    for (i = 0; i < 2; i++) {
297
        /* get motion code */
298
159232
        diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
299
159232
        if (diff < 0)
300
            return AVERROR_INVALIDDATA;
301
159232
        else if (diff) {
302
78989
            if (get_bits1(bitbuf))
303
34286
                diff = -diff;
304
        }
305
306
        /* add median of motion vector predictors and clip result */
307
159232
        if (i == 1)
308
79616
            mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
309
        else
310
79616
            mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
311
    }
312
313
79616
    return 0;
314
}
315
316
5827
static void svq1_skip_block(uint8_t *current, uint8_t *previous,
317
                            ptrdiff_t pitch, int x, int y)
318
{
319
    uint8_t *src;
320
    uint8_t *dst;
321
    int i;
322
323
5827
    src = &previous[x + y * pitch];
324
5827
    dst = current;
325
326
99059
    for (i = 0; i < 16; i++) {
327
93232
        memcpy(dst, src, 16);
328
93232
        src += pitch;
329
93232
        dst += pitch;
330
    }
331
5827
}
332
333
61056
static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
334
                                   uint8_t *current, uint8_t *previous,
335
                                   ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
336
                                   int width, int height)
337
{
338
    uint8_t *src;
339
    uint8_t *dst;
340
    svq1_pmv mv;
341
    svq1_pmv *pmv[3];
342
    int result;
343
344
    /* predict and decode motion vector */
345
61056
    pmv[0] = &motion[0];
346
61056
    if (y == 0) {
347
5027
        pmv[1] =
348
5027
        pmv[2] = pmv[0];
349
    } else {
350
56029
        pmv[1] = &motion[x / 8 + 2];
351
56029
        pmv[2] = &motion[x / 8 + 4];
352
    }
353
354
61056
    result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
355
61056
    if (result)
356
        return result;
357
358
61056
    motion[0].x         =
359
61056
    motion[x / 8 + 2].x =
360
61056
    motion[x / 8 + 3].x = mv.x;
361
61056
    motion[0].y         =
362
61056
    motion[x / 8 + 2].y =
363
61056
    motion[x / 8 + 3].y = mv.y;
364
365
61056
    mv.x = av_clip(mv.x, -2 * x, 2 * (width  - x - 16));
366
61056
    mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
367
368
61056
    src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
369
61056
    dst = current;
370
371
61056
    hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
372
373
61056
    return 0;
374
}
375
376
4640
static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
377
                                      uint8_t *current, uint8_t *previous,
378
                                      ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
379
                                      int width, int height)
380
{
381
    uint8_t *src;
382
    uint8_t *dst;
383
    svq1_pmv mv;
384
    svq1_pmv *pmv[4];
385
    int i, result;
386
387
    /* predict and decode motion vector (0) */
388
4640
    pmv[0] = &motion[0];
389
4640
    if (y == 0) {
390
729
        pmv[1] =
391
729
        pmv[2] = pmv[0];
392
    } else {
393
3911
        pmv[1] = &motion[(x / 8) + 2];
394
3911
        pmv[2] = &motion[(x / 8) + 4];
395
    }
396
397
4640
    result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
398
4640
    if (result)
399
        return result;
400
401
    /* predict and decode motion vector (1) */
402
4640
    pmv[0] = &mv;
403
4640
    if (y == 0) {
404
729
        pmv[1] =
405
729
        pmv[2] = pmv[0];
406
    } else {
407
3911
        pmv[1] = &motion[(x / 8) + 3];
408
    }
409
4640
    result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
410
4640
    if (result)
411
        return result;
412
413
    /* predict and decode motion vector (2) */
414
4640
    pmv[1] = &motion[0];
415
4640
    pmv[2] = &motion[(x / 8) + 1];
416
417
4640
    result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
418
4640
    if (result)
419
        return result;
420
421
    /* predict and decode motion vector (3) */
422
4640
    pmv[2] = &motion[(x / 8) + 2];
423
4640
    pmv[3] = &motion[(x / 8) + 3];
424
425
4640
    result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
426
4640
    if (result)
427
        return result;
428
429
    /* form predictions */
430
23200
    for (i = 0; i < 4; i++) {
431
18560
        int mvx = pmv[i]->x + (i  & 1) * 16;
432
18560
        int mvy = pmv[i]->y + (i >> 1) * 16;
433
434
        // FIXME: clipping or padding?
435
18560
        mvx = av_clip(mvx, -2 * x, 2 * (width  - x - 8));
436
18560
        mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
437
438
18560
        src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
439
18560
        dst = current;
440
441
18560
        hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
442
443
        /* select next block */
444
18560
        if (i & 1)
445
9280
            current += 8 * (pitch - 1);
446
        else
447
9280
            current += 8;
448
    }
449
450
4640
    return 0;
451
}
452
453
75341
static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
454
                                   GetBitContext *bitbuf,
455
                                   uint8_t *current, uint8_t *previous,
456
                                   ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
457
                                   int width, int height)
458
{
459
    uint32_t block_type;
460
75341
    int result = 0;
461
462
    /* get block type */
463
75341
    block_type = get_vlc2(bitbuf, svq1_block_type.table,
464
                          SVQ1_BLOCK_TYPE_VLC_BITS, 1);
465
466
    /* reset motion vectors */
467

75341
    if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
468
9645
        motion[0].x         =
469
9645
        motion[0].y         =
470
9645
        motion[x / 8 + 2].x =
471
9645
        motion[x / 8 + 2].y =
472
9645
        motion[x / 8 + 3].x =
473
9645
        motion[x / 8 + 3].y = 0;
474
    }
475
476

75341
    switch (block_type) {
477
5827
    case SVQ1_BLOCK_SKIP:
478
5827
        svq1_skip_block(current, previous, pitch, x, y);
479
5827
        break;
480
481
61056
    case SVQ1_BLOCK_INTER:
482
61056
        result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
483
                                         pitch, motion, x, y, width, height);
484
485
61056
        if (result != 0) {
486
            ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
487
            break;
488
        }
489
61056
        result = svq1_decode_block_non_intra(bitbuf, current, pitch);
490
61056
        break;
491
492
4640
    case SVQ1_BLOCK_INTER_4V:
493
4640
        result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
494
                                            pitch, motion, x, y, width, height);
495
496
4640
        if (result != 0) {
497
            ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
498
            break;
499
        }
500
4640
        result = svq1_decode_block_non_intra(bitbuf, current, pitch);
501
4640
        break;
502
503
3818
    case SVQ1_BLOCK_INTRA:
504
3818
        result = svq1_decode_block_intra(bitbuf, current, pitch);
505
3818
        break;
506
    }
507
508
75341
    return result;
509
}
510
511
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
512
{
513
    uint8_t seed;
514
    int i;
515
516
    out[0] = get_bits(bitbuf, 8);
517
    seed   = string_table[out[0]];
518
519
    for (i = 1; i <= out[0]; i++) {
520
        out[i] = get_bits(bitbuf, 8) ^ seed;
521
        seed   = string_table[out[i] ^ seed];
522
    }
523
    out[i] = 0;
524
}
525
526
355
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
527
{
528
355
    SVQ1Context *s = avctx->priv_data;
529
355
    GetBitContext *bitbuf = &s->gb;
530
    int frame_size_code;
531
355
    int width  = s->width;
532
355
    int height = s->height;
533
534
355
    skip_bits(bitbuf, 8); /* temporal_reference */
535
536
    /* frame type */
537
355
    s->nonref = 0;
538

355
    switch (get_bits(bitbuf, 2)) {
539
36
    case 0:
540
36
        frame->pict_type = AV_PICTURE_TYPE_I;
541
36
        break;
542
    case 2:
543
        s->nonref = 1;
544
319
    case 1:
545
319
        frame->pict_type = AV_PICTURE_TYPE_P;
546
319
        break;
547
    default:
548
        av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
549
        return AVERROR_INVALIDDATA;
550
    }
551
552
355
    if (frame->pict_type == AV_PICTURE_TYPE_I) {
553
        /* unknown fields */
554

36
        if (s->frame_code == 0x50 || s->frame_code == 0x60) {
555
1
            int csum = get_bits(bitbuf, 16);
556
557
1
            csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
558
559
            ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
560
                    (csum == 0) ? "correct" : "incorrect", csum);
561
        }
562
563
36
        if ((s->frame_code ^ 0x10) >= 0x50) {
564
            uint8_t msg[257];
565
566
            svq1_parse_string(bitbuf, msg);
567
568
            av_log(avctx, AV_LOG_INFO,
569
                   "embedded message:\n%s\n", ((char *)msg) + 1);
570
        }
571
572
36
        skip_bits(bitbuf, 2);
573
36
        skip_bits(bitbuf, 2);
574
36
        skip_bits1(bitbuf);
575
576
        /* load frame size */
577
36
        frame_size_code = get_bits(bitbuf, 3);
578
579
36
        if (frame_size_code == 7) {
580
            /* load width, height (12 bits each) */
581
6
            width  = get_bits(bitbuf, 12);
582
6
            height = get_bits(bitbuf, 12);
583
584

6
            if (!width || !height)
585
                return AVERROR_INVALIDDATA;
586
        } else {
587
            /* get width, height from table */
588
30
            width  = ff_svq1_frame_size_table[frame_size_code][0];
589
30
            height = ff_svq1_frame_size_table[frame_size_code][1];
590
        }
591
    }
592
593
    /* unknown fields */
594
355
    if (get_bits1(bitbuf)) {
595
        skip_bits1(bitbuf);    /* use packet checksum if (1) */
596
        skip_bits1(bitbuf);    /* component checksums after image data if (1) */
597
598
        if (get_bits(bitbuf, 2) != 0)
599
            return AVERROR_INVALIDDATA;
600
    }
601
602
355
    if (get_bits1(bitbuf)) {
603
155
        skip_bits1(bitbuf);
604
155
        skip_bits(bitbuf, 4);
605
155
        skip_bits1(bitbuf);
606
155
        skip_bits(bitbuf, 2);
607
608
155
        if (skip_1stop_8data_bits(bitbuf) < 0)
609
            return AVERROR_INVALIDDATA;
610
    }
611
355
    if (get_bits_left(bitbuf) <= 0)
612
        return AVERROR_INVALIDDATA;
613
614
355
    s->width  = width;
615
355
    s->height = height;
616
355
    return 0;
617
}
618
619
355
static int svq1_decode_frame(AVCodecContext *avctx, void *data,
620
                             int *got_frame, AVPacket *avpkt)
621
{
622
355
    const uint8_t *buf = avpkt->data;
623
355
    int buf_size       = avpkt->size;
624
355
    SVQ1Context     *s = avctx->priv_data;
625
355
    AVFrame       *cur = data;
626
    uint8_t *current;
627
    int result, i, x, y, width, height;
628
    int ret;
629
630
    /* initialize bit buffer */
631
355
    ret = init_get_bits8(&s->gb, buf, buf_size);
632
355
    if (ret < 0)
633
        return ret;
634
635
    /* decode frame header */
636
355
    s->frame_code = get_bits(&s->gb, 22);
637
638

355
    if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
639
        return AVERROR_INVALIDDATA;
640
641
    /* swap some header bytes (why?) */
642
355
    if (s->frame_code != 0x20) {
643
        uint32_t *src;
644
645
4
        if (buf_size < 9 * 4) {
646
            av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
647
            return AVERROR_INVALIDDATA;
648
        }
649
650
4
        av_fast_padded_malloc(&s->pkt_swapped,
651
4
                              &s->pkt_swapped_allocated,
652
                              buf_size);
653
4
        if (!s->pkt_swapped)
654
            return AVERROR(ENOMEM);
655
656
4
        memcpy(s->pkt_swapped, buf, buf_size);
657
4
        buf = s->pkt_swapped;
658
4
        init_get_bits(&s->gb, buf, buf_size * 8);
659
4
        skip_bits(&s->gb, 22);
660
661
4
        src = (uint32_t *)(s->pkt_swapped + 4);
662
663
20
        for (i = 0; i < 4; i++)
664
16
            src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
665
    }
666
667
355
    result = svq1_decode_frame_header(avctx, cur);
668
355
    if (result != 0) {
669
        ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
670
        return result;
671
    }
672
673
355
    result = ff_set_dimensions(avctx, s->width, s->height);
674
355
    if (result < 0)
675
        return result;
676
677

355
    if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
678
355
        (avctx->skip_frame >= AVDISCARD_NONKEY &&
679
         cur->pict_type != AV_PICTURE_TYPE_I) ||
680
355
        avctx->skip_frame >= AVDISCARD_ALL)
681
        return buf_size;
682
683
355
    result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
684
355
    if (result < 0)
685
        return result;
686
687
355
    av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));
688
355
    if (!s->pmv)
689
        return AVERROR(ENOMEM);
690
691
    /* decode y, u and v components */
692
1420
    for (i = 0; i < 3; i++) {
693
1065
        int linesize = cur->linesize[i];
694
1065
        if (i == 0) {
695
355
            width    = FFALIGN(s->width,  16);
696
355
            height   = FFALIGN(s->height, 16);
697
        } else {
698
710
            if (avctx->flags & AV_CODEC_FLAG_GRAY)
699
                break;
700
710
            width    = FFALIGN(s->width  / 4, 16);
701
710
            height   = FFALIGN(s->height / 4, 16);
702
        }
703
704
1065
        current = cur->data[i];
705
706
1065
        if (cur->pict_type == AV_PICTURE_TYPE_I) {
707
            /* keyframe */
708
751
            for (y = 0; y < height; y += 16) {
709
9176
                for (x = 0; x < width; x += 16) {
710
8533
                    result = svq1_decode_block_intra(&s->gb, &current[x],
711
                                                     linesize);
712
8533
                    if (result) {
713
                        av_log(avctx, AV_LOG_ERROR,
714
                               "Error in svq1_decode_block %i (keyframe)\n",
715
                               result);
716
                        return result;
717
                    }
718
                }
719
643
                current += 16 * linesize;
720
            }
721
        } else {
722
            /* delta frame */
723
957
            uint8_t *previous = s->prev->data[i];
724
957
            if (!previous ||
725

957
                s->prev->width != s->width || s->prev->height != s->height) {
726
                av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
727
                return AVERROR_INVALIDDATA;
728
            }
729
730
957
            memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
731
732
6648
            for (y = 0; y < height; y += 16) {
733
81032
                for (x = 0; x < width; x += 16) {
734
75341
                    result = svq1_decode_delta_block(avctx, &s->hdsp,
735
                                                     &s->gb, &current[x],
736
                                                     previous, linesize,
737
                                                     s->pmv, x, y, width, height);
738
75341
                    if (result != 0) {
739
                        ff_dlog(avctx,
740
                                "Error in svq1_decode_delta_block %i\n",
741
                                result);
742
                        return result;
743
                    }
744
                }
745
746
5691
                s->pmv[0].x =
747
5691
                s->pmv[0].y = 0;
748
749
5691
                current += 16 * linesize;
750
            }
751
        }
752
    }
753
754
355
    if (!s->nonref) {
755
355
        av_frame_unref(s->prev);
756
355
        result = av_frame_ref(s->prev, cur);
757
355
        if (result < 0)
758
            return result;
759
    }
760
761
355
    *got_frame = 1;
762
355
    result     = buf_size;
763
764
355
    return result;
765
}
766
767
7
static av_cold void svq1_static_init(void)
768
{
769
7
    INIT_VLC_STATIC(&svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4,
770
                    &ff_svq1_block_type_vlc[0][1], 2, 1,
771
                    &ff_svq1_block_type_vlc[0][0], 2, 1, 8);
772
773
7
    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
774
                    &ff_mvtab[0][1], 2, 1,
775
                    &ff_mvtab[0][0], 2, 1, 176);
776
777
49
    for (int i = 0, offset = 0; i < 6; i++) {
778
        static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
779
                                             { 10, 10, 14, 14, 14, 16 } };
780
        static VLC_TYPE table[168][2];
781
42
        svq1_intra_multistage[i].table           = &table[offset];
782
42
        svq1_intra_multistage[i].table_allocated = sizes[0][i];
783
42
        offset                                  += sizes[0][i];
784
42
        init_vlc(&svq1_intra_multistage[i], 3, 8,
785
                 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
786
                 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
787
                 INIT_VLC_USE_NEW_STATIC);
788
42
        svq1_inter_multistage[i].table           = &table[offset];
789
42
        svq1_inter_multistage[i].table_allocated = sizes[1][i];
790
42
        offset                                  += sizes[1][i];
791
42
        init_vlc(&svq1_inter_multistage[i], 3, 8,
792
                 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
793
                 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
794
                 INIT_VLC_USE_NEW_STATIC);
795
    }
796
797
7
    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
798
                    &ff_svq1_intra_mean_vlc[0][1], 4, 2,
799
                    &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
800
801
7
    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
802
                    &ff_svq1_inter_mean_vlc[0][1], 4, 2,
803
                    &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
804
7
}
805
806
13
static av_cold int svq1_decode_init(AVCodecContext *avctx)
807
{
808
    static AVOnce init_static_once = AV_ONCE_INIT;
809
13
    SVQ1Context *s = avctx->priv_data;
810
811
13
    s->prev = av_frame_alloc();
812
13
    if (!s->prev)
813
        return AVERROR(ENOMEM);
814
815
13
    s->width            = avctx->width  + 3 & ~3;
816
13
    s->height           = avctx->height + 3 & ~3;
817
13
    avctx->pix_fmt      = AV_PIX_FMT_YUV410P;
818
819
13
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
820
821
13
    ff_thread_once(&init_static_once, svq1_static_init);
822
823
13
    return 0;
824
}
825
826
13
static av_cold int svq1_decode_end(AVCodecContext *avctx)
827
{
828
13
    SVQ1Context *s = avctx->priv_data;
829
830
13
    av_frame_free(&s->prev);
831
13
    av_freep(&s->pkt_swapped);
832
13
    s->pkt_swapped_allocated = 0;
833
13
    av_freep(&s->pmv);
834
13
    s->pmv_allocated = 0;
835
836
13
    return 0;
837
}
838
839
static void svq1_flush(AVCodecContext *avctx)
840
{
841
    SVQ1Context *s = avctx->priv_data;
842
843
    av_frame_unref(s->prev);
844
}
845
846
AVCodec ff_svq1_decoder = {
847
    .name           = "svq1",
848
    .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
849
    .type           = AVMEDIA_TYPE_VIDEO,
850
    .id             = AV_CODEC_ID_SVQ1,
851
    .priv_data_size = sizeof(SVQ1Context),
852
    .init           = svq1_decode_init,
853
    .close          = svq1_decode_end,
854
    .decode         = svq1_decode_frame,
855
    .capabilities   = AV_CODEC_CAP_DR1,
856
    .flush          = svq1_flush,
857
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
858
                                                     AV_PIX_FMT_NONE },
859
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
860
};