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 "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 
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  return ret;
559  c->pic->key_frame = (frame_type == INTRA_FRAME);
560  c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
562  if (frame_type == SKIP_FRAME) {
563  *got_frame = 1;
564  if ((ret = av_frame_ref(data, c->pic)) < 0)
565  return ret;
566 
567  return buf_size;
568  }
569 
570  if (c->quality != quality) {
571  c->quality = quality;
572  for (i = 0; i < 2; i++)
573  ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
574  }
575 
576  init_get_bits8(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE));
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  c->pic = av_frame_alloc();
635  if (!c->pic)
636  return AVERROR(ENOMEM);
637 
638  if (mss4_init_vlcs(c)) {
639  av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
640  mss4_free_vlcs(c);
641  return AVERROR(ENOMEM);
642  }
643  for (i = 0; i < 3; i++) {
644  c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
645  c->prev_dc[i] = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);
646  if (!c->prev_dc[i]) {
647  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
648  mss4_free_vlcs(c);
649  return AVERROR(ENOMEM);
650  }
651  }
652 
653  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
654 
655  return 0;
656 }
657 
659 {
660  MSS4Context * const c = avctx->priv_data;
661  int i;
662 
663  av_frame_free(&c->pic);
664 
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 
673  .name = "mts2",
674  .type = AVMEDIA_TYPE_VIDEO,
675  .id = AV_CODEC_ID_MTS2,
676  .priv_data_size = sizeof(MSS4Context),
680  .capabilities = CODEC_CAP_DR1,
681  .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
682 };
static av_cold int mss4_decode_end(AVCodecContext *avctx)
Definition: mss4.c:658
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:86
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:76
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:73
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
Definition: mss4.c:52
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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 * prev_dc[3]
Definition: mss4.c:139
Definition: mss4.c:51
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
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
#define FFALIGN(x, a)
Definition: common.h:63
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
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:262
uint8_t bits
Definition: crc.c:216
uint8_t
#define av_cold
Definition: attributes.h:78
mode
Definition: f_perms.c:27
#define MKVAL(vals)
Definition: mss4.c:367
VLC dc_vlc[2]
Definition: mss4.c:131
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
uint8_t * data
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
Discrete Time axis x
CachePos
Definition: mss4.c:50
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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Spectrum Plot time data
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
FrameType
G723.1 frame types.
Definition: g723_1_data.h:52
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
const char * name
Name of the codec implementation.
static const uint8_t mss4_ac_vlc_syms[2][162]
Definition: mss4.c:66
Definition: mss4.c:46
external API header
static int get_coeff(GetBitContext *gb, VLC *vlc)
Definition: mss4.c:220
Definition: get_bits.h:63
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...
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
#define FFMIN(a, b)
Definition: common.h:58
static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens, const uint8_t *syms, int num_syms)
Definition: mss4.c:146
ret
Definition: avfilter.c:821
int width
picture width / height.
static const uint8_t mss4_dc_vlc_lens[2][16]
Definition: mss4.c:56
t
Definition: genspecsines3.m:6
#define FFABS(a)
Definition: common.h:53
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:524
#define AV_WN16A(p, v)
Definition: intreadwrite.h:526
struct MSS4Context MSS4Context
Note except for filters that can have queued request_frame does not push and as a the filter_frame method will be called and do the work Legacy the filter_frame method was split
int bits
Definition: get_bits.h:64
static av_cold int mss4_init_vlcs(MSS4Context *ctx)
Definition: mss4.c:168
for k
NULL
Definition: eval.c:55
static int width
Definition: tests/utils.c:158
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:410
main external API structure.
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
FIXME Range Coding of cr are mx and my are Motion Vector top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Predicton block[y][x] dc[1]
Definition: snow.txt:392
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
VLC ac_vlc[2]
Definition: mss4.c:131
void * buf
Definition: avisynth_c.h:594
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:629
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:273
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
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:73
int quality
Definition: mss4.c:136
synthesis window for stochastic i
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Buffer references ownership and permissions
static const uint8_t mss4_ac_vlc_lens[2][16]
Definition: mss4.c:61
BlockType
Definition: mss3.c:68
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:95
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by an given frame.
Definition: frame.c:228
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
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:115
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:108
static double c[64]
function y
Definition: D.m:1
DSP utils.
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
static int decode012(GetBitContext *gb)
Definition: get_bits.h:539
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
#define HEADER_SIZE
Definition: mss4.c:36
#define av_always_inline
Definition: attributes.h:41
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;}return ac;}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;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->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);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> out
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
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 imgbuf[3][16 *16]
Definition: mss4.c:134
AVCodec ff_mts2_decoder
Definition: mss4.c:672
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:344
for(j=16;j >0;--j)
Predicted.
Definition: avutil.h:217
static const uint8_t mss4_vec_entry_vlc_syms[2][9]
Definition: mss4.c:121
#define MAX_ENTRIES
Definition: mss4.c:126