rv34: export qp table
[ffmpeg.git] / libavcodec / mss4.c
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 "dsputil.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 #include "mss34dsp.h"
34 #include "unary.h"
35
36 #define HEADER_SIZE 8
37
38 enum FrameType {
39     INTRA_FRAME = 0,
40     INTER_FRAME,
41     SKIP_FRAME
42 };
43
44 enum BlockType {
45     SKIP_BLOCK = 0,
46     DCT_BLOCK,
47     IMAGE_BLOCK,
48 };
49
50 enum CachePos {
51     LEFT = 0,
52     TOP_LEFT,
53     TOP,
54 };
55
56 static const uint8_t mss4_dc_vlc_lens[2][16] = {
57     { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
58     { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
59 };
60
61 static const uint8_t mss4_ac_vlc_lens[2][16] = {
62     { 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125 },
63     { 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119 }
64 };
65
66 static const uint8_t mss4_ac_vlc_syms[2][162] = {
67   { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
68     0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
69     0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
70     0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
71     0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
72     0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
73     0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
74     0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
75     0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
76     0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
77     0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
78     0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
79     0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
80     0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
81     0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
82     0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
83     0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
84     0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
85     0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
86     0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
87     0xF9, 0xFA  },
88   { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
89     0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
90     0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
91     0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
92     0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
93     0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
94     0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
95     0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
96     0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
97     0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
98     0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
99     0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
100     0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
101     0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
102     0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
103     0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
104     0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
105     0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
106     0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
107     0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
108     0xF9, 0xFA  }
109 };
110
111 static const uint8_t vec_len_syms[2][4] = {
112     { 4, 2, 3, 1 },
113     { 4, 1, 2, 3 }
114 };
115
116 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
117     { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
118     { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
119 };
120
121 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
122     { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
123     { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
124 };
125
126 #define MAX_ENTRIES  162
127
128 typedef struct MSS4Context {
129     AVFrame    pic;
130
131     VLC        dc_vlc[2], ac_vlc[2];
132     VLC        vec_entry_vlc[2];
133     int        block[64];
134     uint8_t    imgbuf[3][16 * 16];
135
136     int        quality;
137     uint16_t   quant_mat[2][64];
138
139     int        *prev_dc[3];
140     int        dc_stride[3];
141     int        dc_cache[4][4];
142
143     int        prev_vec[3][4];
144 } MSS4Context;
145
146 static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,
147                                  const uint8_t *syms, int num_syms)
148 {
149     uint8_t  bits[MAX_ENTRIES];
150     uint16_t codes[MAX_ENTRIES];
151     int i, j;
152     int prefix = 0, max_bits = 0, idx = 0;
153
154     for (i = 0; i < 16; i++) {
155         for (j = 0; j < lens[i]; j++) {
156             bits[idx]  = i + 1;
157             codes[idx] = prefix++;
158             max_bits   = i + 1;
159             idx++;
160         }
161         prefix <<= 1;
162     }
163
164     return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
165                               codes, 2, 2, syms, 1, 1, 0);
166 }
167
168 static av_cold int mss4_init_vlcs(MSS4Context *ctx)
169 {
170     int ret, i;
171
172     for (i = 0; i < 2; i++) {
173         ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
174         if (ret)
175             return ret;
176         ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
177                             mss4_ac_vlc_syms[i], 162);
178         if (ret)
179             return ret;
180         ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
181                             mss4_vec_entry_vlc_syms[i], 9);
182         if (ret)
183             return ret;
184     }
185     return 0;
186 }
187
188 static av_cold void mss4_free_vlcs(MSS4Context *ctx)
189 {
190     int i;
191
192     for (i = 0; i < 2; i++) {
193         ff_free_vlc(&ctx->dc_vlc[i]);
194         ff_free_vlc(&ctx->ac_vlc[i]);
195         ff_free_vlc(&ctx->vec_entry_vlc[i]);
196     }
197 }
198
199 /* This function returns values in the range
200  * (-range + 1; -range/2] U [range/2; range - 1)
201  * i.e.
202  * nbits = 0 -> 0
203  * nbits = 1 -> -1, 1
204  * nbits = 2 -> -3, -2, 2, 3
205  */
206 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
207 {
208     int val;
209
210     if (!nbits)
211         return 0;
212
213     val = get_bits(gb, nbits);
214     if (val < (1 << (nbits - 1)))
215         val -= (1 << nbits) - 1;
216
217     return val;
218 }
219
220 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
221 {
222     int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
223
224     return get_coeff_bits(gb, val);
225 }
226
227 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
228                            int *block, int *dc_cache,
229                            int bx, int by, uint16_t *quant_mat)
230 {
231     int skip, val, pos = 1, zz_pos, dc;
232
233     memset(block, 0, sizeof(*block) * 64);
234
235     dc = get_coeff(gb, dc_vlc);
236     // DC prediction is the same as in MSS3
237     if (by) {
238         if (bx) {
239             int l, tl, t;
240
241             l  = dc_cache[LEFT];
242             tl = dc_cache[TOP_LEFT];
243             t  = dc_cache[TOP];
244
245             if (FFABS(t - tl) <= FFABS(l - tl))
246                 dc += l;
247             else
248                 dc += t;
249         } else {
250             dc += dc_cache[TOP];
251         }
252     } else if (bx) {
253         dc += dc_cache[LEFT];
254     }
255     dc_cache[LEFT] = dc;
256     block[0]       = dc * quant_mat[0];
257
258     while (pos < 64) {
259         val = get_vlc2(gb, ac_vlc->table, 9, 2);
260         if (!val)
261             return 0;
262         if (val == -1)
263             return -1;
264         if (val == 0xF0) {
265             pos += 16;
266             continue;
267         }
268         skip = val >> 4;
269         val  = get_coeff_bits(gb, val & 0xF);
270         pos += skip;
271         if (pos >= 64)
272             return -1;
273
274         zz_pos = ff_zigzag_direct[pos];
275         block[zz_pos] = val * quant_mat[zz_pos];
276         pos++;
277     }
278
279     return pos == 64 ? 0 : -1;
280 }
281
282 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
283                                  uint8_t *dst[3], int mb_x, int mb_y)
284 {
285     int i, j, k, ret;
286     uint8_t *out = dst[0];
287
288     for (j = 0; j < 2; j++) {
289         for (i = 0; i < 2; i++) {
290             int xpos = mb_x * 2 + i;
291             c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
292             c->dc_cache[j][TOP]      = c->prev_dc[0][mb_x * 2 + i];
293             ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
294                                   c->dc_cache[j],
295                                   xpos, mb_y * 2 + j, c->quant_mat[0]);
296             if (ret)
297                 return ret;
298             c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
299
300             ff_mss34_dct_put(out + xpos * 8, c->pic.linesize[0],
301                              c->block);
302         }
303         out += 8 * c->pic.linesize[0];
304     }
305
306     for (i = 1; i < 3; i++) {
307         c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
308         c->dc_cache[i + 1][TOP]      = c->prev_dc[i][mb_x];
309         ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
310                               c->block, c->dc_cache[i + 1], mb_x, mb_y,
311                               c->quant_mat[1]);
312         if (ret)
313             return ret;
314         c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
315
316         ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
317         out = dst[i] + mb_x * 16;
318         // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
319         // we need to scale chroma.
320         for (j = 0; j < 16; j++) {
321             for (k = 0; k < 8; k++)
322                 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
323             out += c->pic.linesize[i];
324         }
325     }
326
327     return 0;
328 }
329
330 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
331                          int *sel_len, int *prev)
332 {
333     int i, y_flag = 0;
334
335     for (i = 2; i >= 0; i--) {
336         if (!sel_flag[i]) {
337             vec_pos[i] = 0;
338             continue;
339         }
340         if ((!i && !y_flag) || get_bits1(gb)) {
341             if (sel_len[i] > 0) {
342                 int pval = prev[i];
343                 vec_pos[i] = get_bits(gb, sel_len[i]);
344                 if (vec_pos[i] >= pval)
345                     vec_pos[i]++;
346             } else {
347                 vec_pos[i] = !prev[i];
348             }
349             y_flag = 1;
350         } else {
351             vec_pos[i] = prev[i];
352         }
353     }
354 }
355
356 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
357                             int vec_size, int component, int shift, int *prev)
358 {
359     if (vec_pos < vec_size)
360         return vec[vec_pos];
361     if (!get_bits1(gb))
362         return prev[component];
363     prev[component] = get_bits(gb, 8 - shift) << shift;
364     return prev[component];
365 }
366
367 #define MKVAL(vals)  (vals[0] | (vals[1] << 3) | (vals[2] << 6))
368
369 /* Image mode - the hardest to comprehend MSS4 coding mode.
370  *
371  * In this mode all three 16x16 blocks are coded together with a method
372  * remotely similar to the methods employed in MSS1-MSS3.
373  * The idea is that every component has a vector of 1-4 most common symbols
374  * and an escape mode for reading new value from the bitstream. Decoding
375  * consists of retrieving pixel values from the vector or reading new ones
376  * from the bitstream; depending on flags read from the bitstream, these vector
377  * positions can be updated or reused from the state of the previous line
378  * or previous pixel.
379  */
380 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
381                                    uint8_t *picdst[3], int mb_x, int mb_y)
382 {
383     uint8_t vec[3][4];
384     int     vec_len[3];
385     int     sel_len[3], sel_flag[3];
386     int     i, j, k, mode, split;
387     int     prev_vec1 = 0, prev_split = 0;
388     int     vals[3] = { 0 };
389     int     prev_pix[3] = { 0 };
390     int     prev_mode[16] = { 0 };
391     uint8_t *dst[3];
392
393     const int val_shift = ctx->quality == 100 ? 0 : 2;
394
395     for (i = 0; i < 3; i++)
396         dst[i] = ctx->imgbuf[i];
397
398     for (i = 0; i < 3; i++) {
399         vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
400         for (j = 0; j < vec_len[i]; j++) {
401             vec[i][j]  = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
402             vec[i][j] += ctx->prev_vec[i][j];
403             ctx->prev_vec[i][j] = vec[i][j];
404         }
405         sel_flag[i] = vec_len[i] > 1;
406         sel_len[i]  = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
407     }
408
409     for (j = 0; j < 16; j++) {
410         if (get_bits1(gb)) {
411             split = 0;
412             if (get_bits1(gb)) {
413                 prev_mode[0] = 0;
414                 vals[0] = vals[1] = vals[2] = 0;
415                 mode = 2;
416             } else {
417                 mode = get_bits1(gb);
418                 if (mode)
419                     split = get_bits(gb, 4);
420             }
421             for (i = 0; i < 16; i++) {
422                 if (mode <= 1) {
423                     vals[0] =  prev_mode[i]       & 7;
424                     vals[1] = (prev_mode[i] >> 3) & 7;
425                     vals[2] =  prev_mode[i] >> 6;
426                     if (mode == 1 && i == split) {
427                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
428                     }
429                 } else if (mode == 2) {
430                     if (get_bits1(gb))
431                         read_vec_pos(gb, vals, sel_flag, sel_len, vals);
432                 }
433                 for (k = 0; k < 3; k++)
434                     *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
435                                                  vec_len[k], k,
436                                                  val_shift, prev_pix);
437                 prev_mode[i] = MKVAL(vals);
438             }
439         } else {
440             if (get_bits1(gb)) {
441                 split = get_bits(gb, 4);
442                 if (split >= prev_split)
443                     split++;
444                 prev_split = split;
445             } else {
446                 split = prev_split;
447             }
448             if (split) {
449                 vals[0] =  prev_mode[0]       & 7;
450                 vals[1] = (prev_mode[0] >> 3) & 7;
451                 vals[2] =  prev_mode[0] >> 6;
452                 for (i = 0; i < 3; i++) {
453                     for (k = 0; k < split; k++) {
454                         *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
455                                                      vec_len[i], i, val_shift,
456                                                      prev_pix);
457                         prev_mode[k] = MKVAL(vals);
458                     }
459                 }
460             }
461
462             if (split != 16) {
463                 vals[0] =  prev_vec1       & 7;
464                 vals[1] = (prev_vec1 >> 3) & 7;
465                 vals[2] =  prev_vec1 >> 6;
466                 if (get_bits1(gb)) {
467                     read_vec_pos(gb, vals, sel_flag, sel_len, vals);
468                     prev_vec1 = MKVAL(vals);
469                 }
470                 for (i = 0; i < 3; i++) {
471                     for (k = 0; k < 16 - split; k++) {
472                         *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
473                                                      vec_len[i], i, val_shift,
474                                                      prev_pix);
475                         prev_mode[split + k] = MKVAL(vals);
476                     }
477                 }
478             }
479         }
480     }
481
482     for (i = 0; i < 3; i++)
483         for (j = 0; j < 16; j++)
484             memcpy(picdst[i] + mb_x * 16 + j * ctx->pic.linesize[i],
485                    ctx->imgbuf[i] + j * 16, 16);
486
487     return 0;
488 }
489
490 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
491 {
492     int i;
493
494     c->dc_cache[0][TOP]  = c->prev_dc[0][mb_x * 2 + 1];
495     c->dc_cache[0][LEFT] = 0;
496     c->dc_cache[1][TOP]  = 0;
497     c->dc_cache[1][LEFT] = 0;
498
499     for (i = 0; i < 2; i++)
500         c->prev_dc[0][mb_x * 2 + i] = 0;
501
502     for (i = 1; i < 3; i++) {
503         c->dc_cache[i + 1][TOP]  = c->prev_dc[i][mb_x];
504         c->dc_cache[i + 1][LEFT] = 0;
505         c->prev_dc[i][mb_x]      = 0;
506     }
507 }
508
509 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
510                              AVPacket *avpkt)
511 {
512     const uint8_t *buf = avpkt->data;
513     int buf_size = avpkt->size;
514     MSS4Context *c = avctx->priv_data;
515     GetBitContext gb;
516     GetByteContext bc;
517     uint8_t *dst[3];
518     int width, height, quality, frame_type;
519     int x, y, i, mb_width, mb_height, blk_type;
520     int ret;
521
522     if (buf_size < HEADER_SIZE) {
523         av_log(avctx, AV_LOG_ERROR,
524                "Frame should have at least %d bytes, got %d instead\n",
525                HEADER_SIZE, buf_size);
526         return AVERROR_INVALIDDATA;
527     }
528
529     bytestream2_init(&bc, buf, buf_size);
530     width      = bytestream2_get_be16(&bc);
531     height     = bytestream2_get_be16(&bc);
532     bytestream2_skip(&bc, 2);
533     quality    = bytestream2_get_byte(&bc);
534     frame_type = bytestream2_get_byte(&bc);
535
536     if (width > avctx->width ||
537         height != avctx->height) {
538         av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
539                width, height);
540         return AVERROR_INVALIDDATA;
541     }
542     if (quality < 1 || quality > 100) {
543         av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
544         return AVERROR_INVALIDDATA;
545     }
546     if ((frame_type & ~3) || frame_type == 3) {
547         av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
548         return AVERROR_INVALIDDATA;
549     }
550
551     if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
552         av_log(avctx, AV_LOG_ERROR,
553                "Empty frame found but it is not a skip frame.\n");
554         return AVERROR_INVALIDDATA;
555     }
556
557     if ((ret = ff_reget_buffer(avctx, &c->pic)) < 0)
558         return ret;
559     c->pic.key_frame = (frame_type == INTRA_FRAME);
560     c->pic.pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
561                                                    : AV_PICTURE_TYPE_P;
562     if (frame_type == SKIP_FRAME) {
563         *got_frame      = 1;
564         if ((ret = av_frame_ref(data, &c->pic)) < 0)
565             return ret;
566
567         return buf_size;
568     }
569
570     if (c->quality != quality) {
571         c->quality = quality;
572         for (i = 0; i < 2; i++)
573             ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
574     }
575
576     init_get_bits(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
577
578     mb_width  = FFALIGN(width,  16) >> 4;
579     mb_height = FFALIGN(height, 16) >> 4;
580     dst[0] = c->pic.data[0];
581     dst[1] = c->pic.data[1];
582     dst[2] = c->pic.data[2];
583
584     memset(c->prev_vec, 0, sizeof(c->prev_vec));
585     for (y = 0; y < mb_height; y++) {
586         memset(c->dc_cache, 0, sizeof(c->dc_cache));
587         for (x = 0; x < mb_width; x++) {
588             blk_type = decode012(&gb);
589             switch (blk_type) {
590             case DCT_BLOCK:
591                 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
592                     av_log(avctx, AV_LOG_ERROR,
593                            "Error decoding DCT block %d,%d\n",
594                            x, y);
595                     return AVERROR_INVALIDDATA;
596                 }
597                 break;
598             case IMAGE_BLOCK:
599                 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
600                     av_log(avctx, AV_LOG_ERROR,
601                            "Error decoding VQ block %d,%d\n",
602                            x, y);
603                     return AVERROR_INVALIDDATA;
604                 }
605                 break;
606             case SKIP_BLOCK:
607                 if (frame_type == INTRA_FRAME) {
608                     av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
609                     return AVERROR_INVALIDDATA;
610                 }
611                 break;
612             }
613             if (blk_type != DCT_BLOCK)
614                 mss4_update_dc_cache(c, x);
615         }
616         dst[0] += c->pic.linesize[0] * 16;
617         dst[1] += c->pic.linesize[1] * 16;
618         dst[2] += c->pic.linesize[2] * 16;
619     }
620
621     if ((ret = av_frame_ref(data, &c->pic)) < 0)
622         return ret;
623
624     *got_frame      = 1;
625
626     return buf_size;
627 }
628
629 static av_cold int mss4_decode_init(AVCodecContext *avctx)
630 {
631     MSS4Context * const c = avctx->priv_data;
632     int i;
633
634     if (mss4_init_vlcs(c)) {
635         av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
636         mss4_free_vlcs(c);
637         return AVERROR(ENOMEM);
638     }
639     for (i = 0; i < 3; i++) {
640         c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
641         c->prev_dc[i]   = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
642         if (!c->prev_dc[i]) {
643             av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
644             mss4_free_vlcs(c);
645             return AVERROR(ENOMEM);
646         }
647     }
648
649     avctx->pix_fmt     = AV_PIX_FMT_YUV444P;
650
651     return 0;
652 }
653
654 static av_cold int mss4_decode_end(AVCodecContext *avctx)
655 {
656     MSS4Context * const c = avctx->priv_data;
657     int i;
658
659     av_frame_unref(&c->pic);
660     for (i = 0; i < 3; i++)
661         av_freep(&c->prev_dc[i]);
662     mss4_free_vlcs(c);
663
664     return 0;
665 }
666
667 AVCodec ff_mts2_decoder = {
668     .name           = "mts2",
669     .type           = AVMEDIA_TYPE_VIDEO,
670     .id             = AV_CODEC_ID_MTS2,
671     .priv_data_size = sizeof(MSS4Context),
672     .init           = mss4_decode_init,
673     .close          = mss4_decode_end,
674     .decode         = mss4_decode_frame,
675     .capabilities   = CODEC_CAP_DR1,
676     .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
677 };