Libav
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 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 
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 {
42 };
43 
44 enum BlockType {
48 };
49 
50 enum CachePos {
51  LEFT = 0,
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 {
130 
131  VLC dc_vlc[2], ac_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 {
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 
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;
182  if (ret)
183  return ret;
184  }
185  return 0;
186 }
187 
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  */
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 
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  */
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
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 
632 {
633  MSS4Context * const c = avctx->priv_data;
634  int i;
635 
636  av_frame_free(&c->pic);
637  for (i = 0; i < 3; i++)
638  av_freep(&c->prev_dc[i]);
639  mss4_free_vlcs(c);
640 
641  return 0;
642 }
643 
645 {
646  MSS4Context * const c = avctx->priv_data;
647  int i;
648 
649  if (mss4_init_vlcs(c)) {
650  av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
651  mss4_free_vlcs(c);
652  return AVERROR(ENOMEM);
653  }
654  for (i = 0; i < 3; i++) {
655  c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
656  c->prev_dc[i] = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
657  if (!c->prev_dc[i]) {
658  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
659  mss4_free_vlcs(c);
660  return AVERROR(ENOMEM);
661  }
662  }
663 
664  c->pic = av_frame_alloc();
665  if (!c->pic) {
666  mss4_decode_end(avctx);
667  return AVERROR(ENOMEM);
668  }
669 
670  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
671 
672  return 0;
673 }
674 
676  .name = "mts2",
677  .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
678  .type = AVMEDIA_TYPE_VIDEO,
679  .id = AV_CODEC_ID_MTS2,
680  .priv_data_size = sizeof(MSS4Context),
684  .capabilities = CODEC_CAP_DR1,
685 };
static av_cold int mss4_decode_end(AVCodecContext *avctx)
Definition: mss4.c:631
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
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:54
uint16_t quant_mat[2][64]
Definition: mss4.c:137
static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb, uint8_t *dst[3], int mb_x, int mb_y)
Definition: mss4.c:282
This structure describes decoded (raw) audio or video data.
Definition: frame.h:107
FrameType
G723.1 frame types.
Definition: g723_1.c:44
VLC vec_entry_vlc[2]
Definition: mss4.c:132
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:70
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
Definition: mss4.c:52
void ff_mss34_dct_put(uint8_t *dst, int stride, int *block)
Transform and output DCT block.
Definition: mss34dsp.c:90
static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag, int *sel_len, int *prev)
Definition: mss4.c:330
int size
Definition: avcodec.h:974
int * prev_dc[3]
Definition: mss4.c:139
Definition: mss4.c:51
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1247
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
Definition: mss4.c:53
int block[64]
Definition: mss4.c:133
AVCodec.
Definition: avcodec.h:2755
#define FFALIGN(x, a)
Definition: common.h:62
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
AVFrame * pic
Definition: mss4.c:129
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:269
int prev_vec[3][4]
Definition: mss4.c:143
int ff_init_vlc_sparse(VLC *vlc, 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:266
uint8_t bits
Definition: crc.c:216
uint8_t
#define av_cold
Definition: attributes.h:66
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:43
#define MKVAL(vals)
Definition: mss4.c:367
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:174
VLC dc_vlc[2]
Definition: mss4.c:131
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=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);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_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_dlog(ac->avr,"%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-> out
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:711
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:973
static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mss4.c:509
bitstream reader API header.
static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
Definition: mss4.c:206
static float t
Definition: output.c:52
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
CachePos
Definition: mss4.c:50
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:159
static const uint8_t vec_len_syms[2][4]
Definition: mss4.c:111
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:55
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
int dc_cache[4][4]
Definition: mss4.c:141
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:356
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:149
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
static const uint8_t mss4_ac_vlc_syms[2][162]
Definition: mss4.c:66
Definition: mss4.c:46
static int get_coeff(GetBitContext *gb, VLC *vlc)
Definition: mss4.c:220
Definition: get_bits.h:64
static char * split(char *message, char delim)
Definition: af_channelmap.c:86
int dc_stride[3]
Definition: mss4.c:140
static av_cold void mss4_free_vlcs(MSS4Context *ctx)
Definition: mss4.c:188
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: utils.c:755
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:168
#define FFMIN(a, b)
Definition: common.h:57
static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens, const uint8_t *syms, int num_syms)
Definition: mss4.c:146
int width
picture width / height.
Definition: avcodec.h:1217
static const uint8_t mss4_dc_vlc_lens[2][16]
Definition: mss4.c:56
#define FFABS(a)
Definition: common.h:52
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:522
#define AV_WN16A(p, v)
Definition: intreadwrite.h:454
int bits
Definition: get_bits.h:65
static av_cold int mss4_init_vlcs(MSS4Context *ctx)
Definition: mss4.c:168
NULL
Definition: eval.c:55
static int width
Definition: utils.c:156
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:125
main external API structure.
Definition: avcodec.h:1054
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:489
VLC ac_vlc[2]
Definition: mss4.c:131
static void mss4_update_dc_cache(MSS4Context *c, int mb_x)
Definition: mss4.c:490
static av_cold int mss4_decode_init(AVCodecContext *avctx)
Definition: mss4.c:644
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
int quality
Definition: mss4.c:136
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
static const uint8_t mss4_ac_vlc_lens[2][16]
Definition: mss4.c:61
BlockType
Definition: mss3.c:68
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:113
int height
Definition: gxfenc.c:72
static const uint8_t mss4_vec_entry_vlc_lens[2][16]
Definition: mss4.c:116
static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb, uint8_t *picdst[3], int mb_x, int mb_y)
Definition: mss4.c:380
common internal api header.
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:113
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:498
DSP utils.
void * priv_data
Definition: avcodec.h:1090
static int decode012(GetBitContext *gb)
Definition: get_bits.h:537
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:163
#define HEADER_SIZE
Definition: mss4.c:36
#define av_always_inline
Definition: attributes.h:40
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:227
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=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);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_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_dlog(ac->avr,"%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
uint8_t imgbuf[3][16 *16]
Definition: mss4.c:134
AVCodec ff_mts2_decoder
Definition: mss4.c:675
This structure stores compressed data.
Definition: avcodec.h:950
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:333
for(j=16;j >0;--j)
Predicted.
Definition: avutil.h:254
static const uint8_t mss4_vec_entry_vlc_syms[2][9]
Definition: mss4.c:121
#define MAX_ENTRIES
Definition: mss4.c:126
static int16_t block[64]
Definition: dct-test.c:170