1c850bc1c36a9d1a911d2cd9c1b1f71825de5502
[libav.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 = AV_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 = AV_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 };