FFmpeg
 All Data Structures Namespaces 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 "get_bits.h"
31 #include "internal.h"
32 #include "mss34dsp.h"
33 #include "unary.h"
34 
35 #define HEADER_SIZE 8
36 
37 enum FrameType {
41 };
42 
43 enum BlockType {
47 };
48 
49 enum CachePos {
50  LEFT = 0,
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 {
129 
130  VLC dc_vlc[2], ac_vlc[2];
132  int block[64];
133  uint8_t imgbuf[3][16 * 16];
134 
135  int quality;
136  uint16_t quant_mat[2][64];
137 
138  int *prev_dc[3];
139  ptrdiff_t dc_stride[3];
140  int dc_cache[4][4];
141 
142  int prev_vec[3][4];
143 } MSS4Context;
144 
145 static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,
146  const uint8_t *syms, int num_syms)
147 {
148  uint8_t bits[MAX_ENTRIES];
149  uint16_t codes[MAX_ENTRIES];
150  int i, j;
151  int prefix = 0, max_bits = 0, idx = 0;
152 
153  for (i = 0; i < 16; i++) {
154  for (j = 0; j < lens[i]; j++) {
155  bits[idx] = i + 1;
156  codes[idx] = prefix++;
157  max_bits = i + 1;
158  idx++;
159  }
160  prefix <<= 1;
161  }
162 
163  return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
164  codes, 2, 2, syms, 1, 1, 0);
165 }
166 
168 {
169  int ret, i;
170 
171  for (i = 0; i < 2; i++) {
172  ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
173  if (ret)
174  return ret;
175  ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
176  mss4_ac_vlc_syms[i], 162);
177  if (ret)
178  return ret;
181  if (ret)
182  return ret;
183  }
184  return 0;
185 }
186 
188 {
189  int i;
190 
191  for (i = 0; i < 2; i++) {
192  ff_free_vlc(&ctx->dc_vlc[i]);
193  ff_free_vlc(&ctx->ac_vlc[i]);
194  ff_free_vlc(&ctx->vec_entry_vlc[i]);
195  }
196 }
197 
198 /* This function returns values in the range
199  * (-range + 1; -range/2] U [range/2; range - 1)
200  * i.e.
201  * nbits = 0 -> 0
202  * nbits = 1 -> -1, 1
203  * nbits = 2 -> -3, -2, 2, 3
204  */
206 {
207  int val;
208 
209  if (!nbits)
210  return 0;
211 
212  val = get_bits(gb, nbits);
213  if (val < (1 << (nbits - 1)))
214  val -= (1 << nbits) - 1;
215 
216  return val;
217 }
218 
219 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
220 {
221  int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
222 
223  return get_coeff_bits(gb, val);
224 }
225 
226 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
227  int *block, int *dc_cache,
228  int bx, int by, uint16_t *quant_mat)
229 {
230  int skip, val, pos = 1, zz_pos, dc;
231 
232  memset(block, 0, sizeof(*block) * 64);
233 
234  dc = get_coeff(gb, dc_vlc);
235  // DC prediction is the same as in MSS3
236  if (by) {
237  if (bx) {
238  int l, tl, t;
239 
240  l = dc_cache[LEFT];
241  tl = dc_cache[TOP_LEFT];
242  t = dc_cache[TOP];
243 
244  if (FFABS(t - tl) <= FFABS(l - tl))
245  dc += l;
246  else
247  dc += t;
248  } else {
249  dc += dc_cache[TOP];
250  }
251  } else if (bx) {
252  dc += dc_cache[LEFT];
253  }
254  dc_cache[LEFT] = dc;
255  block[0] = dc * quant_mat[0];
256 
257  while (pos < 64) {
258  val = get_vlc2(gb, ac_vlc->table, 9, 2);
259  if (!val)
260  return 0;
261  if (val == -1)
262  return -1;
263  if (val == 0xF0) {
264  pos += 16;
265  continue;
266  }
267  skip = val >> 4;
268  val = get_coeff_bits(gb, val & 0xF);
269  pos += skip;
270  if (pos >= 64)
271  return -1;
272 
273  zz_pos = ff_zigzag_direct[pos];
274  block[zz_pos] = val * quant_mat[zz_pos];
275  pos++;
276  }
277 
278  return pos == 64 ? 0 : -1;
279 }
280 
282  uint8_t *dst[3], int mb_x, int mb_y)
283 {
284  int i, j, k, ret;
285  uint8_t *out = dst[0];
286 
287  for (j = 0; j < 2; j++) {
288  for (i = 0; i < 2; i++) {
289  int xpos = mb_x * 2 + i;
290  c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
291  c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
292  ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
293  c->dc_cache[j],
294  xpos, mb_y * 2 + j, c->quant_mat[0]);
295  if (ret)
296  return ret;
297  c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
298 
299  ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
300  c->block);
301  }
302  out += 8 * c->pic->linesize[0];
303  }
304 
305  for (i = 1; i < 3; i++) {
306  c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
307  c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
308  ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
309  c->block, c->dc_cache[i + 1], mb_x, mb_y,
310  c->quant_mat[1]);
311  if (ret)
312  return ret;
313  c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
314 
315  ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
316  out = dst[i] + mb_x * 16;
317  // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
318  // we need to scale chroma.
319  for (j = 0; j < 16; j++) {
320  for (k = 0; k < 8; k++)
321  AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
322  out += c->pic->linesize[i];
323  }
324  }
325 
326  return 0;
327 }
328 
329 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
330  int *sel_len, int *prev)
331 {
332  int i, y_flag = 0;
333 
334  for (i = 2; i >= 0; i--) {
335  if (!sel_flag[i]) {
336  vec_pos[i] = 0;
337  continue;
338  }
339  if ((!i && !y_flag) || get_bits1(gb)) {
340  if (sel_len[i] > 0) {
341  int pval = prev[i];
342  vec_pos[i] = get_bits(gb, sel_len[i]);
343  if (vec_pos[i] >= pval)
344  vec_pos[i]++;
345  } else {
346  vec_pos[i] = !prev[i];
347  }
348  y_flag = 1;
349  } else {
350  vec_pos[i] = prev[i];
351  }
352  }
353 }
354 
355 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
356  int vec_size, int component, int shift, int *prev)
357 {
358  if (vec_pos < vec_size)
359  return vec[vec_pos];
360  if (!get_bits1(gb))
361  return prev[component];
362  prev[component] = get_bits(gb, 8 - shift) << shift;
363  return prev[component];
364 }
365 
366 #define MKVAL(vals) ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))
367 
368 /* Image mode - the hardest to comprehend MSS4 coding mode.
369  *
370  * In this mode all three 16x16 blocks are coded together with a method
371  * remotely similar to the methods employed in MSS1-MSS3.
372  * The idea is that every component has a vector of 1-4 most common symbols
373  * and an escape mode for reading new value from the bitstream. Decoding
374  * consists of retrieving pixel values from the vector or reading new ones
375  * from the bitstream; depending on flags read from the bitstream, these vector
376  * positions can be updated or reused from the state of the previous line
377  * or previous pixel.
378  */
380  uint8_t *picdst[3], int mb_x, int mb_y)
381 {
382  uint8_t vec[3][4];
383  int vec_len[3];
384  int sel_len[3], sel_flag[3];
385  int i, j, k, mode, split;
386  int prev_vec1 = 0, prev_split = 0;
387  int vals[3] = { 0 };
388  int prev_pix[3] = { 0 };
389  int prev_mode[16] = { 0 };
390  uint8_t *dst[3];
391 
392  const int val_shift = ctx->quality == 100 ? 0 : 2;
393 
394  for (i = 0; i < 3; i++)
395  dst[i] = ctx->imgbuf[i];
396 
397  for (i = 0; i < 3; i++) {
398  vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
399  for (j = 0; j < vec_len[i]; j++) {
400  vec[i][j] = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
401  vec[i][j] += ctx->prev_vec[i][j];
402  ctx->prev_vec[i][j] = vec[i][j];
403  }
404  sel_flag[i] = vec_len[i] > 1;
405  sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
406  }
407 
408  for (j = 0; j < 16; j++) {
409  if (get_bits1(gb)) {
410  split = 0;
411  if (get_bits1(gb)) {
412  prev_mode[0] = 0;
413  vals[0] = vals[1] = vals[2] = 0;
414  mode = 2;
415  } else {
416  mode = get_bits1(gb);
417  if (mode)
418  split = get_bits(gb, 4);
419  }
420  for (i = 0; i < 16; i++) {
421  if (mode <= 1) {
422  vals[0] = prev_mode[i] & 7;
423  vals[1] = (prev_mode[i] >> 3) & 7;
424  vals[2] = prev_mode[i] >> 6;
425  if (mode == 1 && i == split) {
426  read_vec_pos(gb, vals, sel_flag, sel_len, vals);
427  }
428  } else if (mode == 2) {
429  if (get_bits1(gb))
430  read_vec_pos(gb, vals, sel_flag, sel_len, vals);
431  }
432  for (k = 0; k < 3; k++)
433  *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
434  vec_len[k], k,
435  val_shift, prev_pix);
436  prev_mode[i] = MKVAL(vals);
437  }
438  } else {
439  if (get_bits1(gb)) {
440  split = get_bits(gb, 4);
441  if (split >= prev_split)
442  split++;
443  prev_split = split;
444  } else {
445  split = prev_split;
446  }
447  if (split) {
448  vals[0] = prev_mode[0] & 7;
449  vals[1] = (prev_mode[0] >> 3) & 7;
450  vals[2] = prev_mode[0] >> 6;
451  for (i = 0; i < 3; i++) {
452  for (k = 0; k < split; k++) {
453  *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
454  vec_len[i], i, val_shift,
455  prev_pix);
456  prev_mode[k] = MKVAL(vals);
457  }
458  }
459  }
460 
461  if (split != 16) {
462  vals[0] = prev_vec1 & 7;
463  vals[1] = (prev_vec1 >> 3) & 7;
464  vals[2] = prev_vec1 >> 6;
465  if (get_bits1(gb)) {
466  read_vec_pos(gb, vals, sel_flag, sel_len, vals);
467  prev_vec1 = MKVAL(vals);
468  }
469  for (i = 0; i < 3; i++) {
470  for (k = 0; k < 16 - split; k++) {
471  *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
472  vec_len[i], i, val_shift,
473  prev_pix);
474  prev_mode[split + k] = MKVAL(vals);
475  }
476  }
477  }
478  }
479  }
480 
481  for (i = 0; i < 3; i++)
482  for (j = 0; j < 16; j++)
483  memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
484  ctx->imgbuf[i] + j * 16, 16);
485 
486  return 0;
487 }
488 
489 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
490 {
491  int i;
492 
493  c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];
494  c->dc_cache[0][LEFT] = 0;
495  c->dc_cache[1][TOP] = 0;
496  c->dc_cache[1][LEFT] = 0;
497 
498  for (i = 0; i < 2; i++)
499  c->prev_dc[0][mb_x * 2 + i] = 0;
500 
501  for (i = 1; i < 3; i++) {
502  c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
503  c->dc_cache[i + 1][LEFT] = 0;
504  c->prev_dc[i][mb_x] = 0;
505  }
506 }
507 
508 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
509  AVPacket *avpkt)
510 {
511  const uint8_t *buf = avpkt->data;
512  int buf_size = avpkt->size;
513  MSS4Context *c = avctx->priv_data;
514  GetBitContext gb;
515  GetByteContext bc;
516  uint8_t *dst[3];
517  int width, height, quality, frame_type;
518  int x, y, i, mb_width, mb_height, blk_type;
519  int ret;
520 
521  if (buf_size < HEADER_SIZE) {
522  av_log(avctx, AV_LOG_ERROR,
523  "Frame should have at least %d bytes, got %d instead\n",
524  HEADER_SIZE, buf_size);
525  return AVERROR_INVALIDDATA;
526  }
527 
528  bytestream2_init(&bc, buf, buf_size);
529  width = bytestream2_get_be16(&bc);
530  height = bytestream2_get_be16(&bc);
531  bytestream2_skip(&bc, 2);
532  quality = bytestream2_get_byte(&bc);
533  frame_type = bytestream2_get_byte(&bc);
534 
535  if (width > avctx->width ||
536  height != avctx->height) {
537  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
538  width, height);
539  return AVERROR_INVALIDDATA;
540  }
541  if (quality < 1 || quality > 100) {
542  av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
543  return AVERROR_INVALIDDATA;
544  }
545  if ((frame_type & ~3) || frame_type == 3) {
546  av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
547  return AVERROR_INVALIDDATA;
548  }
549 
550  if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
551  av_log(avctx, AV_LOG_ERROR,
552  "Empty frame found but it is not a skip frame.\n");
553  return AVERROR_INVALIDDATA;
554  }
555 
556  if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
557  return ret;
558  c->pic->key_frame = (frame_type == INTRA_FRAME);
559  c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
561  if (frame_type == SKIP_FRAME) {
562  *got_frame = 1;
563  if ((ret = av_frame_ref(data, c->pic)) < 0)
564  return ret;
565 
566  return buf_size;
567  }
568 
569  if (c->quality != quality) {
570  c->quality = quality;
571  for (i = 0; i < 2; i++)
572  ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
573  }
574 
575  if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
576  return ret;
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 
630 {
631  MSS4Context * const c = avctx->priv_data;
632  int i;
633 
634  av_frame_free(&c->pic);
635  for (i = 0; i < 3; i++)
636  av_freep(&c->prev_dc[i]);
637  mss4_free_vlcs(c);
638 
639  return 0;
640 }
641 
643 {
644  MSS4Context * const c = avctx->priv_data;
645  int i;
646 
647  if (mss4_init_vlcs(c)) {
648  av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
649  mss4_free_vlcs(c);
650  return AVERROR(ENOMEM);
651  }
652  for (i = 0; i < 3; i++) {
653  c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
654  c->prev_dc[i] = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
655  if (!c->prev_dc[i]) {
656  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
657  mss4_free_vlcs(c);
658  return AVERROR(ENOMEM);
659  }
660  }
661 
662  c->pic = av_frame_alloc();
663  if (!c->pic) {
664  mss4_decode_end(avctx);
665  return AVERROR(ENOMEM);
666  }
667 
668  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
669 
670  return 0;
671 }
672 
674  .name = "mts2",
675  .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
676  .type = AVMEDIA_TYPE_VIDEO,
677  .id = AV_CODEC_ID_MTS2,
678  .priv_data_size = sizeof(MSS4Context),
680  .close = mss4_decode_end,
682  .capabilities = AV_CODEC_CAP_DR1,
683 };
static av_cold int mss4_decode_end(AVCodecContext *avctx)
Definition: mss4.c:629
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)
Generate quantisation matrix for given quality.
Definition: mss34dsp.c:48
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
uint16_t quant_mat[2][64]
Definition: mss4.c:136
static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb, uint8_t *dst[3], int mb_x, int mb_y)
Definition: mss4.c:281
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
VLC vec_entry_vlc[2]
Definition: mss4.c:131
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
Definition: mss4.c:51
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag, int *sel_len, int *prev)
Definition: mss4.c:329
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:268
int size
Definition: avcodec.h:1431
int * prev_dc[3]
Definition: mss4.c:138
Definition: mss4.c:50
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
Definition: mss4.c:52
int block[64]
Definition: mss4.c:132
AVCodec.
Definition: avcodec.h:3408
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:1938
AVFrame * pic
Definition: mss4.c:128
static int16_t block[64]
Definition: dct.c:115
int prev_vec[3][4]
Definition: mss4.c:142
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
#define MKVAL(vals)
Definition: mss4.c:366
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:441
VLC dc_vlc[2]
Definition: mss4.c:130
#define height
uint8_t * data
Definition: avcodec.h:1430
static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mss4.c:508
bitstream reader API header.
static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
Definition: mss4.c:205
#define FFALIGN(x, a)
Definition: macros.h:48
ptrdiff_t dc_stride[3]
Definition: mss4.c:139
#define av_log(a,...)
FrameType
G723.1 frame types.
Definition: g723_1.h:63
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
CachePos
Definition: mss4.c:49
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
static const uint8_t vec_len_syms[2][4]
Definition: mss4.c:110
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int dc_cache[4][4]
Definition: mss4.c:140
static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec, int vec_size, int component, int shift, int *prev)
Definition: mss4.c:355
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
uint16_t width
Definition: gdv.c:47
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
static const uint8_t mss4_ac_vlc_syms[2][162]
Definition: mss4.c:65
Definition: mss4.c:45
static int get_coeff(GetBitContext *gb, VLC *vlc)
Definition: mss4.c:219
Definition: vlc.h:26
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
void ff_mss34_dct_put(uint8_t *dst, ptrdiff_t stride, int *block)
Transform and output DCT block.
Definition: mss34dsp.c:90
static av_cold void mss4_free_vlcs(MSS4Context *ctx)
Definition: mss4.c:187
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
#define FFMIN(a, b)
Definition: common.h:96
static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens, const uint8_t *syms, int num_syms)
Definition: mss4.c:145
int width
picture width / height.
Definition: avcodec.h:1690
static const uint8_t mss4_dc_vlc_lens[2][16]
Definition: mss4.c:55
AVFormatContext * ctx
Definition: movenc.c:48
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:563
#define AV_WN16A(p, v)
Definition: intreadwrite.h:534
int bits
Definition: vlc.h:27
static av_cold int mss4_init_vlcs(MSS4Context *ctx)
Definition: mss4.c:167
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:464
main external API structure.
Definition: avcodec.h:1518
VLC ac_vlc[2]
Definition: mss4.c:130
void * buf
Definition: avisynth_c.h:690
static void mss4_update_dc_cache(MSS4Context *c, int mb_x)
Definition: mss4.c:489
static av_cold int mss4_decode_init(AVCodecContext *avctx)
Definition: mss4.c:642
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
int quality
Definition: mss4.c:135
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
static const uint8_t mss4_ac_vlc_lens[2][16]
Definition: mss4.c:60
BlockType
Definition: mss3.c:68
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
static const uint8_t mss4_vec_entry_vlc_lens[2][16]
Definition: mss4.c:115
static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb, uint8_t *picdst[3], int mb_x, int mb_y)
Definition: mss4.c:379
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
static double c[64]
void * priv_data
Definition: avcodec.h:1545
static int decode012(GetBitContext *gb)
Definition: get_bits.h:578
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
#define HEADER_SIZE
Definition: mss4.c:35
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc, int *block, int *dc_cache, int bx, int by, uint16_t *quant_mat)
Definition: mss4.c:226
#define av_malloc_array(a, b)
uint8_t imgbuf[3][16 *16]
Definition: mss4.c:133
AVCodec ff_mts2_decoder
Definition: mss4.c:673
This structure stores compressed data.
Definition: avcodec.h:1407
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:354
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
for(j=16;j >0;--j)
Predicted.
Definition: avutil.h:275
static const uint8_t mss4_vec_entry_vlc_syms[2][9]
Definition: mss4.c:120
#define MAX_ENTRIES
Definition: mss4.c:125