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