GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/svq1dec.c Lines: 290 344 84.3 %
Date: 2020-10-23 17:01:47 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
37
#include "avcodec.h"
38
#include "get_bits.h"
39
#include "h263.h"
40
#include "hpeldsp.h"
41
#include "internal.h"
42
#include "mathops.h"
43
#include "svq1.h"
44
45
static VLC svq1_block_type;
46
static VLC svq1_motion_component;
47
static VLC svq1_intra_multistage[6];
48
static VLC svq1_inter_multistage[6];
49
static VLC svq1_intra_mean;
50
static VLC svq1_inter_mean;
51
52
/* motion vector (prediction) */
53
typedef struct svq1_pmv_s {
54
    int x;
55
    int y;
56
} svq1_pmv;
57
58
typedef struct SVQ1Context {
59
    HpelDSPContext hdsp;
60
    GetBitContext gb;
61
    AVFrame *prev;
62
63
    uint8_t *pkt_swapped;
64
    int pkt_swapped_allocated;
65
66
    int width;
67
    int height;
68
    int frame_code;
69
    int nonref;         // 1 if the current frame won't be referenced
70
} SVQ1Context;
71
72
static const uint8_t string_table[256] = {
73
    0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
74
    0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
75
    0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
76
    0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
77
    0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
78
    0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
79
    0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
80
    0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
81
    0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
82
    0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
83
    0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
84
    0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
85
    0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
86
    0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
87
    0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
88
    0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
89
    0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
90
    0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
91
    0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
92
    0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
93
    0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
94
    0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
95
    0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
96
    0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
97
    0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
98
    0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
99
    0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
100
    0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
101
    0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
102
    0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
103
    0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
104
    0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
105
};
106
107
#define SVQ1_PROCESS_VECTOR()                                           \
108
    for (; level > 0; i++) {                                            \
109
        /* process next depth */                                        \
110
        if (i == m) {                                                   \
111
            m = n;                                                      \
112
            if (--level == 0)                                           \
113
                break;                                                  \
114
        }                                                               \
115
        /* divide block if next bit set */                              \
116
        if (!get_bits1(bitbuf))                                         \
117
            break;                                                      \
118
        /* add child nodes */                                           \
119
        list[n++] = list[i];                                            \
120
        list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
121
    }
122
123
#define SVQ1_ADD_CODEBOOK()                                             \
124
    /* add codebook entries to vector */                                \
125
    for (j = 0; j < stages; j++) {                                      \
126
        n3  = codebook[entries[j]] ^ 0x80808080;                        \
127
        n1 += (n3 & 0xFF00FF00) >> 8;                                   \
128
        n2 +=  n3 & 0x00FF00FF;                                         \
129
    }                                                                   \
130
                                                                        \
131
    /* clip to [0..255] */                                              \
132
    if (n1 & 0xFF00FF00) {                                              \
133
        n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
134
        n1 += 0x7F007F00;                                               \
135
        n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
136
        n1 &= n3 & 0x00FF00FF;                                          \
137
    }                                                                   \
138
                                                                        \
139
    if (n2 & 0xFF00FF00) {                                              \
140
        n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
141
        n2 += 0x7F007F00;                                               \
142
        n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
143
        n2 &= n3 & 0x00FF00FF;                                          \
144
    }
145
146
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
147
    codebook = (const uint32_t *)cbook[level];                          \
148
    if (stages > 0)                                                     \
149
        bit_cache = get_bits(bitbuf, 4 * stages);                       \
150
    /* calculate codebook entries for this vector */                    \
151
    for (j = 0; j < stages; j++) {                                      \
152
        entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
153
                      16 * j) << (level + 1);                           \
154
    }                                                                   \
155
    mean -= stages * 128;                                               \
156
    n4    = (mean << 16) + mean;
157
158
12351
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
159
                                   ptrdiff_t pitch)
160
{
161
    uint32_t bit_cache;
162
    uint8_t *list[63];
163
    uint32_t *dst;
164
    const uint32_t *codebook;
165
    int entries[6];
166
    int i, j, m, n;
167
    int stages;
168
    unsigned mean;
169
    unsigned x, y, width, height, level;
170
    uint32_t n1, n2, n3, n4;
171
172
    /* initialize list for breadth first processing of vectors */
173
12351
    list[0] = pixels;
174
175
    /* recursively process vector */
176
256176
    for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
177


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

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

1133305
            SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
208
209
682355
            for (y = 0; y < height; y++) {
210
1079708
                for (x = 0; x < width / 4; x++, codebook++) {
211
581038
                    n1 = n4;
212
581038
                    n2 = n4;
213

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


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

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

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

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

75341
    if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
462
9645
        motion[0].x         =
463
9645
        motion[0].y         =
464
9645
        motion[x / 8 + 2].x =
465
9645
        motion[x / 8 + 2].y =
466
9645
        motion[x / 8 + 3].x =
467
9645
        motion[x / 8 + 3].y = 0;
468
    }
469
470

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

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

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

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

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

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

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