GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mss4.c Lines: 280 316 88.6 %
Date: 2019-11-18 18:00:01 Branches: 161 192 83.9 %

Line Branch Exec Source
1
/*
2
 * Microsoft Screen 4 (aka Microsoft Expression Encoder Screen) decoder
3
 * Copyright (c) 2012 Konstantin Shishkov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * Microsoft Screen 4 (aka Microsoft Titanium Screen 2,
25
 * aka Microsoft Expression Encoder Screen) decoder
26
 */
27
28
#include "avcodec.h"
29
#include "bytestream.h"
30
#include "get_bits.h"
31
#include "internal.h"
32
#include "mss34dsp.h"
33
#include "unary.h"
34
35
#define HEADER_SIZE 8
36
37
enum FrameType {
38
    INTRA_FRAME = 0,
39
    INTER_FRAME,
40
    SKIP_FRAME
41
};
42
43
enum BlockType {
44
    SKIP_BLOCK = 0,
45
    DCT_BLOCK,
46
    IMAGE_BLOCK,
47
};
48
49
enum CachePos {
50
    LEFT = 0,
51
    TOP_LEFT,
52
    TOP,
53
};
54
55
static const uint8_t mss4_dc_vlc_lens[2][16] = {
56
    { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
57
    { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
58
};
59
60
static const uint8_t mss4_ac_vlc_lens[2][16] = {
61
    { 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125 },
62
    { 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119 }
63
};
64
65
static const uint8_t mss4_ac_vlc_syms[2][162] = {
66
  { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
67
    0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
68
    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
69
    0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
70
    0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
71
    0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
72
    0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
73
    0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
74
    0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
75
    0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
76
    0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
77
    0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
78
    0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
79
    0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
80
    0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
81
    0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
82
    0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
83
    0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
84
    0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
85
    0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
86
    0xF9, 0xFA  },
87
  { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
88
    0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
89
    0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
90
    0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
91
    0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
92
    0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
93
    0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
94
    0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
95
    0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
96
    0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
97
    0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
98
    0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
99
    0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
100
    0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
101
    0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
102
    0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
103
    0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
104
    0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
105
    0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
106
    0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
107
    0xF9, 0xFA  }
108
};
109
110
static const uint8_t vec_len_syms[2][4] = {
111
    { 4, 2, 3, 1 },
112
    { 4, 1, 2, 3 }
113
};
114
115
static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
116
    { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
117
    { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
118
};
119
120
static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
121
    { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
122
    { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
123
};
124
125
#define MAX_ENTRIES  162
126
127
typedef struct MSS4Context {
128
    AVFrame    *pic;
129
130
    VLC        dc_vlc[2], ac_vlc[2];
131
    VLC        vec_entry_vlc[2];
132
    int        block[64];
133
    uint8_t    imgbuf[3][16 * 16];
134
135
    int        quality;
136
    uint16_t   quant_mat[2][64];
137
138
    int        *prev_dc[3];
139
    ptrdiff_t  dc_stride[3];
140
    int        dc_cache[4][4];
141
142
    int        prev_vec[3][4];
143
} MSS4Context;
144
145
24
static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,
146
                                 const uint8_t *syms, int num_syms)
147
{
148
    uint8_t  bits[MAX_ENTRIES];
149
    uint16_t codes[MAX_ENTRIES];
150
    int i, j;
151
24
    int prefix = 0, max_bits = 0, idx = 0;
152
153
408
    for (i = 0; i < 16; i++) {
154
1848
        for (j = 0; j < lens[i]; j++) {
155
1464
            bits[idx]  = i + 1;
156
1464
            codes[idx] = prefix++;
157
1464
            max_bits   = i + 1;
158
1464
            idx++;
159
        }
160
384
        prefix <<= 1;
161
    }
162
163
24
    return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
164
                              codes, 2, 2, syms, 1, 1, 0);
165
}
166
167
4
static av_cold int mss4_init_vlcs(MSS4Context *ctx)
168
{
169
    int ret, i;
170
171
12
    for (i = 0; i < 2; i++) {
172
8
        ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
173
8
        if (ret)
174
            return ret;
175
8
        ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
176
8
                            mss4_ac_vlc_syms[i], 162);
177
8
        if (ret)
178
            return ret;
179
8
        ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
180
8
                            mss4_vec_entry_vlc_syms[i], 9);
181
8
        if (ret)
182
            return ret;
183
    }
184
4
    return 0;
185
}
186
187
4
static av_cold void mss4_free_vlcs(MSS4Context *ctx)
188
{
189
    int i;
190
191
12
    for (i = 0; i < 2; i++) {
192
8
        ff_free_vlc(&ctx->dc_vlc[i]);
193
8
        ff_free_vlc(&ctx->ac_vlc[i]);
194
8
        ff_free_vlc(&ctx->vec_entry_vlc[i]);
195
    }
196
4
}
197
198
/* This function returns values in the range
199
 * (-range + 1; -range/2] U [range/2; range - 1)
200
 * i.e.
201
 * nbits = 0 -> 0
202
 * nbits = 1 -> -1, 1
203
 * nbits = 2 -> -3, -2, 2, 3
204
 */
205
315916
static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
206
{
207
    int val;
208
209
315916
    if (!nbits)
210
133329
        return 0;
211
212
182587
    val = get_bits(gb, nbits);
213
182587
    if (val < (1 << (nbits - 1)))
214
98069
        val -= (1 << nbits) - 1;
215
216
182587
    return val;
217
}
218
219
180586
static inline int get_coeff(GetBitContext *gb, VLC *vlc)
220
{
221
180586
    int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
222
223
180586
    return get_coeff_bits(gb, val);
224
}
225
226
85284
static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
227
                           int *block, int *dc_cache,
228
                           int bx, int by, uint16_t *quant_mat)
229
{
230
85284
    int skip, val, pos = 1, zz_pos, dc;
231
232
85284
    memset(block, 0, sizeof(*block) * 64);
233
234
85284
    dc = get_coeff(gb, dc_vlc);
235
    // DC prediction is the same as in MSS3
236
85284
    if (by) {
237
84904
        if (bx) {
238
            int l, tl, t;
239
240
83868
            l  = dc_cache[LEFT];
241
83868
            tl = dc_cache[TOP_LEFT];
242
83868
            t  = dc_cache[TOP];
243
244
83868
            if (FFABS(t - tl) <= FFABS(l - tl))
245
80876
                dc += l;
246
            else
247
2992
                dc += t;
248
        } else {
249
1036
            dc += dc_cache[TOP];
250
        }
251
380
    } else if (bx) {
252
380
        dc += dc_cache[LEFT];
253
    }
254
85284
    dc_cache[LEFT] = dc;
255
85284
    block[0]       = dc * quant_mat[0];
256
257
220682
    while (pos < 64) {
258
219785
        val = get_vlc2(gb, ac_vlc->table, 9, 2);
259
219785
        if (!val)
260
84387
            return 0;
261
135398
        if (val == -1)
262
            return -1;
263
135398
        if (val == 0xF0) {
264
68
            pos += 16;
265
68
            continue;
266
        }
267
135330
        skip = val >> 4;
268
135330
        val  = get_coeff_bits(gb, val & 0xF);
269
135330
        pos += skip;
270
135330
        if (pos >= 64)
271
            return -1;
272
273
135330
        zz_pos = ff_zigzag_direct[pos];
274
135330
        block[zz_pos] = val * quant_mat[zz_pos];
275
135330
        pos++;
276
    }
277
278
897
    return pos == 64 ? 0 : -1;
279
}
280
281
14214
static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
282
                                 uint8_t *dst[3], int mb_x, int mb_y)
283
{
284
    int i, j, k, ret;
285
14214
    uint8_t *out = dst[0];
286
287
42642
    for (j = 0; j < 2; j++) {
288
85284
        for (i = 0; i < 2; i++) {
289
56856
            int xpos = mb_x * 2 + i;
290
56856
            c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
291
56856
            c->dc_cache[j][TOP]      = c->prev_dc[0][mb_x * 2 + i];
292
56856
            ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
293
56856
                                  c->dc_cache[j],
294
56856
                                  xpos, mb_y * 2 + j, c->quant_mat[0]);
295
56856
            if (ret)
296
                return ret;
297
56856
            c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
298
299
56856
            ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
300
56856
                             c->block);
301
        }
302
28428
        out += 8 * c->pic->linesize[0];
303
    }
304
305
42642
    for (i = 1; i < 3; i++) {
306
28428
        c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
307
28428
        c->dc_cache[i + 1][TOP]      = c->prev_dc[i][mb_x];
308
28428
        ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
309
28428
                              c->block, c->dc_cache[i + 1], mb_x, mb_y,
310
28428
                              c->quant_mat[1]);
311
28428
        if (ret)
312
            return ret;
313
28428
        c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
314
315
28428
        ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
316
28428
        out = dst[i] + mb_x * 16;
317
        // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
318
        // we need to scale chroma.
319
483276
        for (j = 0; j < 16; j++) {
320
4093632
            for (k = 0; k < 8; k++)
321
3638784
                AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
322
454848
            out += c->pic->linesize[i];
323
        }
324
    }
325
326
14214
    return 0;
327
}
328
329
281245
static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
330
                         int *sel_len, int *prev)
331
{
332
281245
    int i, y_flag = 0;
333
334
1124980
    for (i = 2; i >= 0; i--) {
335
843735
        if (!sel_flag[i]) {
336
192630
            vec_pos[i] = 0;
337
192630
            continue;
338
        }
339

651105
        if ((!i && !y_flag) || get_bits1(gb)) {
340
554066
            if (sel_len[i] > 0) {
341
549560
                int pval = prev[i];
342
549560
                vec_pos[i] = get_bits(gb, sel_len[i]);
343
549560
                if (vec_pos[i] >= pval)
344
297455
                    vec_pos[i]++;
345
            } else {
346
4506
                vec_pos[i] = !prev[i];
347
            }
348
554066
            y_flag = 1;
349
        } else {
350
97039
            vec_pos[i] = prev[i];
351
        }
352
    }
353
281245
}
354
355
8739072
static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
356
                            int vec_size, int component, int shift, int *prev)
357
{
358
8739072
    if (vec_pos < vec_size)
359
8442194
        return vec[vec_pos];
360
296878
    if (!get_bits1(gb))
361
46525
        return prev[component];
362
250353
    prev[component] = get_bits(gb, 8 - shift) << shift;
363
250353
    return prev[component];
364
}
365
366
#define MKVAL(vals)  ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))
367
368
/* Image mode - the hardest to comprehend MSS4 coding mode.
369
 *
370
 * In this mode all three 16x16 blocks are coded together with a method
371
 * remotely similar to the methods employed in MSS1-MSS3.
372
 * The idea is that every component has a vector of 1-4 most common symbols
373
 * and an escape mode for reading new value from the bitstream. Decoding
374
 * consists of retrieving pixel values from the vector or reading new ones
375
 * from the bitstream; depending on flags read from the bitstream, these vector
376
 * positions can be updated or reused from the state of the previous line
377
 * or previous pixel.
378
 */
379
11379
static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
380
                                   uint8_t *picdst[3], int mb_x, int mb_y)
381
{
382
    uint8_t vec[3][4];
383
    int     vec_len[3];
384
    int     sel_len[3], sel_flag[3];
385
    int     i, j, k, mode, split;
386
11379
    int     prev_vec1 = 0, prev_split = 0;
387
11379
    int     vals[3] = { 0 };
388
11379
    int     prev_pix[3] = { 0 };
389
11379
    int     prev_mode[16] = { 0 };
390
    uint8_t *dst[3];
391
392
11379
    const int val_shift = ctx->quality == 100 ? 0 : 2;
393
394
45516
    for (i = 0; i < 3; i++)
395
34137
        dst[i] = ctx->imgbuf[i];
396
397
45516
    for (i = 0; i < 3; i++) {
398
34137
        vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
399
129439
        for (j = 0; j < vec_len[i]; j++) {
400
95302
            vec[i][j]  = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
401
95302
            vec[i][j] += ctx->prev_vec[i][j];
402
95302
            ctx->prev_vec[i][j] = vec[i][j];
403
        }
404
34137
        sel_flag[i] = vec_len[i] > 1;
405
34137
        sel_len[i]  = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
406
    }
407
408
193443
    for (j = 0; j < 16; j++) {
409
182064
        if (get_bits1(gb)) {
410
56004
            split = 0;
411
56004
            if (get_bits1(gb)) {
412
35860
                prev_mode[0] = 0;
413
35860
                vals[0] = vals[1] = vals[2] = 0;
414
35860
                mode = 2;
415
            } else {
416
20144
                mode = get_bits1(gb);
417
20144
                if (mode)
418
3817
                    split = get_bits(gb, 4);
419
            }
420
952068
            for (i = 0; i < 16; i++) {
421
896064
                if (mode <= 1) {
422
322304
                    vals[0] =  prev_mode[i]       & 7;
423
322304
                    vals[1] = (prev_mode[i] >> 3) & 7;
424
322304
                    vals[2] =  prev_mode[i] >> 6;
425

322304
                    if (mode == 1 && i == split) {
426
3817
                        read_vec_pos(gb, vals, sel_flag, sel_len, vals);
427
                    }
428
573760
                } else if (mode == 2) {
429
573760
                    if (get_bits1(gb))
430
261389
                        read_vec_pos(gb, vals, sel_flag, sel_len, vals);
431
                }
432
3584256
                for (k = 0; k < 3; k++)
433
2688192
                    *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
434
                                                 vec_len[k], k,
435
                                                 val_shift, prev_pix);
436
896064
                prev_mode[i] = MKVAL(vals);
437
            }
438
        } else {
439
126060
            if (get_bits1(gb)) {
440
21425
                split = get_bits(gb, 4);
441
21425
                if (split >= prev_split)
442
15525
                    split++;
443
21425
                prev_split = split;
444
            } else {
445
104635
                split = prev_split;
446
            }
447
126060
            if (split) {
448
109261
                vals[0] =  prev_mode[0]       & 7;
449
109261
                vals[1] = (prev_mode[0] >> 3) & 7;
450
109261
                vals[2] =  prev_mode[0] >> 6;
451
437044
                for (i = 0; i < 3; i++) {
452
5442705
                    for (k = 0; k < split; k++) {
453
5114922
                        *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
454
                                                     vec_len[i], i, val_shift,
455
                                                     prev_pix);
456
5114922
                        prev_mode[k] = MKVAL(vals);
457
                    }
458
                }
459
            }
460
461
126060
            if (split != 16) {
462
22314
                vals[0] =  prev_vec1       & 7;
463
22314
                vals[1] = (prev_vec1 >> 3) & 7;
464
22314
                vals[2] =  prev_vec1 >> 6;
465
22314
                if (get_bits1(gb)) {
466
16039
                    read_vec_pos(gb, vals, sel_flag, sel_len, vals);
467
16039
                    prev_vec1 = MKVAL(vals);
468
                }
469
89256
                for (i = 0; i < 3; i++) {
470
1002900
                    for (k = 0; k < 16 - split; k++) {
471
935958
                        *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
472
                                                     vec_len[i], i, val_shift,
473
                                                     prev_pix);
474
935958
                        prev_mode[split + k] = MKVAL(vals);
475
                    }
476
                }
477
            }
478
        }
479
    }
480
481
45516
    for (i = 0; i < 3; i++)
482
580329
        for (j = 0; j < 16; j++)
483
546192
            memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
484
546192
                   ctx->imgbuf[i] + j * 16, 16);
485
486
11379
    return 0;
487
}
488
489
175050
static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
490
{
491
    int i;
492
493
175050
    c->dc_cache[0][TOP]  = c->prev_dc[0][mb_x * 2 + 1];
494
175050
    c->dc_cache[0][LEFT] = 0;
495
175050
    c->dc_cache[1][TOP]  = 0;
496
175050
    c->dc_cache[1][LEFT] = 0;
497
498
525150
    for (i = 0; i < 2; i++)
499
350100
        c->prev_dc[0][mb_x * 2 + i] = 0;
500
501
525150
    for (i = 1; i < 3; i++) {
502
350100
        c->dc_cache[i + 1][TOP]  = c->prev_dc[i][mb_x];
503
350100
        c->dc_cache[i + 1][LEFT] = 0;
504
350100
        c->prev_dc[i][mb_x]      = 0;
505
    }
506
175050
}
507
508
145
static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
509
                             AVPacket *avpkt)
510
{
511
145
    const uint8_t *buf = avpkt->data;
512
145
    int buf_size = avpkt->size;
513
145
    MSS4Context *c = avctx->priv_data;
514
    GetBitContext gb;
515
    GetByteContext bc;
516
    uint8_t *dst[3];
517
    int width, height, quality, frame_type;
518
    int x, y, i, mb_width, mb_height, blk_type;
519
    int ret;
520
521
145
    if (buf_size < HEADER_SIZE) {
522
        av_log(avctx, AV_LOG_ERROR,
523
               "Frame should have at least %d bytes, got %d instead\n",
524
               HEADER_SIZE, buf_size);
525
        return AVERROR_INVALIDDATA;
526
    }
527
528
145
    bytestream2_init(&bc, buf, buf_size);
529
145
    width      = bytestream2_get_be16(&bc);
530
145
    height     = bytestream2_get_be16(&bc);
531
145
    bytestream2_skip(&bc, 2);
532
145
    quality    = bytestream2_get_byte(&bc);
533
145
    frame_type = bytestream2_get_byte(&bc);
534
535
145
    if (width > avctx->width ||
536
145
        height != avctx->height) {
537
        av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
538
               width, height);
539
        return AVERROR_INVALIDDATA;
540
    }
541

145
    if (quality < 1 || quality > 100) {
542
        av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
543
        return AVERROR_INVALIDDATA;
544
    }
545

145
    if ((frame_type & ~3) || frame_type == 3) {
546
        av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
547
        return AVERROR_INVALIDDATA;
548
    }
549
550

145
    if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
551
        av_log(avctx, AV_LOG_ERROR,
552
               "Empty frame found but it is not a skip frame.\n");
553
        return AVERROR_INVALIDDATA;
554
    }
555
145
    mb_width  = FFALIGN(width,  16) >> 4;
556
145
    mb_height = FFALIGN(height, 16) >> 4;
557
558

145
    if (frame_type != SKIP_FRAME && 8*buf_size < 8*HEADER_SIZE + mb_width*mb_height)
559
        return AVERROR_INVALIDDATA;
560
561
145
    if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
562
        return ret;
563
145
    c->pic->key_frame = (frame_type == INTRA_FRAME);
564
145
    c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
565
145
                                                   : AV_PICTURE_TYPE_P;
566
145
    if (frame_type == SKIP_FRAME) {
567
98
        *got_frame      = 1;
568
98
        if ((ret = av_frame_ref(data, c->pic)) < 0)
569
            return ret;
570
571
98
        return buf_size;
572
    }
573
574
47
    if (c->quality != quality) {
575
2
        c->quality = quality;
576
6
        for (i = 0; i < 2; i++)
577
4
            ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
578
    }
579
580
47
    if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
581
        return ret;
582
47
    dst[0] = c->pic->data[0];
583
47
    dst[1] = c->pic->data[1];
584
47
    dst[2] = c->pic->data[2];
585
586
47
    memset(c->prev_vec, 0, sizeof(c->prev_vec));
587
2519
    for (y = 0; y < mb_height; y++) {
588
2472
        memset(c->dc_cache, 0, sizeof(c->dc_cache));
589
191736
        for (x = 0; x < mb_width; x++) {
590
189264
            blk_type = decode012(&gb);
591

189264
            switch (blk_type) {
592
14214
            case DCT_BLOCK:
593
14214
                if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
594
                    av_log(avctx, AV_LOG_ERROR,
595
                           "Error decoding DCT block %d,%d\n",
596
                           x, y);
597
                    return AVERROR_INVALIDDATA;
598
                }
599
14214
                break;
600
11379
            case IMAGE_BLOCK:
601
11379
                if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
602
                    av_log(avctx, AV_LOG_ERROR,
603
                           "Error decoding VQ block %d,%d\n",
604
                           x, y);
605
                    return AVERROR_INVALIDDATA;
606
                }
607
11379
                break;
608
163671
            case SKIP_BLOCK:
609
163671
                if (frame_type == INTRA_FRAME) {
610
                    av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
611
                    return AVERROR_INVALIDDATA;
612
                }
613
163671
                break;
614
            }
615
189264
            if (blk_type != DCT_BLOCK)
616
175050
                mss4_update_dc_cache(c, x);
617
        }
618
2472
        dst[0] += c->pic->linesize[0] * 16;
619
2472
        dst[1] += c->pic->linesize[1] * 16;
620
2472
        dst[2] += c->pic->linesize[2] * 16;
621
    }
622
623
47
    if ((ret = av_frame_ref(data, c->pic)) < 0)
624
        return ret;
625
626
47
    *got_frame      = 1;
627
628
47
    return buf_size;
629
}
630
631
4
static av_cold int mss4_decode_end(AVCodecContext *avctx)
632
{
633
4
    MSS4Context * const c = avctx->priv_data;
634
    int i;
635
636
4
    av_frame_free(&c->pic);
637
16
    for (i = 0; i < 3; i++)
638
12
        av_freep(&c->prev_dc[i]);
639
4
    mss4_free_vlcs(c);
640
641
4
    return 0;
642
}
643
644
4
static av_cold int mss4_decode_init(AVCodecContext *avctx)
645
{
646
4
    MSS4Context * const c = avctx->priv_data;
647
    int i;
648
649
4
    if (mss4_init_vlcs(c)) {
650
        av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
651
        mss4_free_vlcs(c);
652
        return AVERROR(ENOMEM);
653
    }
654
16
    for (i = 0; i < 3; i++) {
655
12
        c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
656
12
        c->prev_dc[i]   = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
657
12
        if (!c->prev_dc[i]) {
658
            av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
659
            mss4_free_vlcs(c);
660
            return AVERROR(ENOMEM);
661
        }
662
    }
663
664
4
    c->pic = av_frame_alloc();
665
4
    if (!c->pic) {
666
        mss4_decode_end(avctx);
667
        return AVERROR(ENOMEM);
668
    }
669
670
4
    avctx->pix_fmt     = AV_PIX_FMT_YUV444P;
671
672
4
    return 0;
673
}
674
675
AVCodec ff_mts2_decoder = {
676
    .name           = "mts2",
677
    .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
678
    .type           = AVMEDIA_TYPE_VIDEO,
679
    .id             = AV_CODEC_ID_MTS2,
680
    .priv_data_size = sizeof(MSS4Context),
681
    .init           = mss4_decode_init,
682
    .close          = mss4_decode_end,
683
    .decode         = mss4_decode_frame,
684
    .capabilities   = AV_CODEC_CAP_DR1,
685
};