FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mss4.c
Go to the documentation of this file.
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 "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 *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  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  *got_frame = 1;
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  *got_frame = 1;
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 };
Generated on Sat May 25 2013 03:58:38 for FFmpeg by   doxygen 1.8.2