eamad: remove use of MpegEncContext
[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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 "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     DSPContext dsp;
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 *data_size,
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     c->pic.reference    = 3;
558     c->pic.buffer_hints = FF_BUFFER_HINTS_VALID    |
559                           FF_BUFFER_HINTS_PRESERVE |
560                           FF_BUFFER_HINTS_REUSABLE;
561     if ((ret = avctx->reget_buffer(avctx, &c->pic)) < 0) {
562         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
563         return ret;
564     }
565     c->pic.key_frame = (frame_type == INTRA_FRAME);
566     c->pic.pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
567                                                    : AV_PICTURE_TYPE_P;
568     if (frame_type == SKIP_FRAME) {
569         *data_size = sizeof(AVFrame);
570         *(AVFrame*)data = c->pic;
571
572         return buf_size;
573     }
574
575     if (c->quality != quality) {
576         c->quality = quality;
577         for (i = 0; i < 2; i++)
578             ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
579     }
580
581     init_get_bits(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
582
583     mb_width  = FFALIGN(width,  16) >> 4;
584     mb_height = FFALIGN(height, 16) >> 4;
585     dst[0] = c->pic.data[0];
586     dst[1] = c->pic.data[1];
587     dst[2] = c->pic.data[2];
588
589     memset(c->prev_vec, 0, sizeof(c->prev_vec));
590     for (y = 0; y < mb_height; y++) {
591         memset(c->dc_cache, 0, sizeof(c->dc_cache));
592         for (x = 0; x < mb_width; x++) {
593             blk_type = decode012(&gb);
594             switch (blk_type) {
595             case DCT_BLOCK:
596                 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
597                     av_log(avctx, AV_LOG_ERROR,
598                            "Error decoding DCT block %d,%d\n",
599                            x, y);
600                     return AVERROR_INVALIDDATA;
601                 }
602                 break;
603             case IMAGE_BLOCK:
604                 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
605                     av_log(avctx, AV_LOG_ERROR,
606                            "Error decoding VQ block %d,%d\n",
607                            x, y);
608                     return AVERROR_INVALIDDATA;
609                 }
610                 break;
611             case SKIP_BLOCK:
612                 if (frame_type == INTRA_FRAME) {
613                     av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
614                     return AVERROR_INVALIDDATA;
615                 }
616                 break;
617             }
618             if (blk_type != DCT_BLOCK)
619                 mss4_update_dc_cache(c, x);
620         }
621         dst[0] += c->pic.linesize[0] * 16;
622         dst[1] += c->pic.linesize[1] * 16;
623         dst[2] += c->pic.linesize[2] * 16;
624     }
625
626     *data_size = sizeof(AVFrame);
627     *(AVFrame*)data = c->pic;
628
629     return buf_size;
630 }
631
632 static av_cold int mss4_decode_init(AVCodecContext *avctx)
633 {
634     MSS4Context * const c = avctx->priv_data;
635     int i;
636
637     if (mss4_init_vlcs(c)) {
638         av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
639         mss4_free_vlcs(c);
640         return AVERROR(ENOMEM);
641     }
642     for (i = 0; i < 3; i++) {
643         c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
644         c->prev_dc[i]   = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
645         if (!c->prev_dc[i]) {
646             av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
647             mss4_free_vlcs(c);
648             return AVERROR(ENOMEM);
649         }
650     }
651
652     avctx->pix_fmt     = PIX_FMT_YUV444P;
653     avctx->coded_frame = &c->pic;
654
655     return 0;
656 }
657
658 static av_cold int mss4_decode_end(AVCodecContext *avctx)
659 {
660     MSS4Context * const c = avctx->priv_data;
661     int i;
662
663     if (c->pic.data[0])
664         avctx->release_buffer(avctx, &c->pic);
665     for (i = 0; i < 3; i++)
666         av_freep(&c->prev_dc[i]);
667     mss4_free_vlcs(c);
668
669     return 0;
670 }
671
672 AVCodec ff_mts2_decoder = {
673     .name           = "mts2",
674     .type           = AVMEDIA_TYPE_VIDEO,
675     .id             = CODEC_ID_MTS2,
676     .priv_data_size = sizeof(MSS4Context),
677     .init           = mss4_decode_init,
678     .close          = mss4_decode_end,
679     .decode         = mss4_decode_frame,
680     .capabilities   = CODEC_CAP_DR1,
681     .long_name      = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
682 };