FFmpeg
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 "libavutil/thread.h"
29 
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "get_bits.h"
33 #include "internal.h"
34 #include "jpegtables.h"
35 #include "mss34dsp.h"
36 #include "unary.h"
37 
38 #define HEADER_SIZE 8
39 
40 enum FrameType {
44 };
45 
46 enum BlockType {
50 };
51 
52 enum CachePos {
53  LEFT = 0,
55  TOP,
56 };
57 
58 static const uint8_t mss4_dc_vlc_lens[2][16] = {
59  { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
60  { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
61 };
62 
63 static const uint8_t vec_len_syms[2][4] = {
64  { 4, 2, 3, 1 },
65  { 4, 1, 2, 3 }
66 };
67 
68 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
69  { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
70  { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
71 };
72 
73 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
74  { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
75  { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
76 };
77 
78 #define MAX_ENTRIES 162
79 
80 typedef struct MSS4Context {
82 
83  int block[64];
84  uint8_t imgbuf[3][16 * 16];
85 
86  int quality;
87  uint16_t quant_mat[2][64];
88 
89  int *prev_dc[3];
90  ptrdiff_t dc_stride[3];
91  int dc_cache[4][4];
92 
93  int prev_vec[3][4];
94 } MSS4Context;
95 
96 static VLC dc_vlc[2], ac_vlc[2];
97 static VLC vec_entry_vlc[2];
98 
99 static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset,
100  const uint8_t *lens, const uint8_t *syms)
101 {
102  static VLC_TYPE vlc_buf[2146][2];
103  uint8_t bits[MAX_ENTRIES];
104  int i, j;
105  int idx = 0;
106 
107  for (i = 0; i < 16; i++) {
108  for (j = 0; j < lens[i]; j++) {
109  bits[idx] = i + 1;
110  idx++;
111  }
112  }
113 
114  vlc->table = &vlc_buf[*offset];
116  ff_init_vlc_from_lengths(vlc, FFMIN(bits[idx - 1], 9), idx,
117  bits, 1, syms, 1, 1,
119  *offset += vlc->table_size;
120 }
121 
122 static av_cold void mss4_init_vlcs(void)
123 {
124  for (unsigned i = 0, offset = 0; i < 2; i++) {
133  }
134 }
135 
136 /* This function returns values in the range
137  * (-range + 1; -range/2] U [range/2; range - 1)
138  * i.e.
139  * nbits = 0 -> 0
140  * nbits = 1 -> -1, 1
141  * nbits = 2 -> -3, -2, 2, 3
142  */
144 {
145  int val;
146 
147  if (!nbits)
148  return 0;
149 
150  val = get_bits(gb, nbits);
151  if (val < (1 << (nbits - 1)))
152  val -= (1 << nbits) - 1;
153 
154  return val;
155 }
156 
157 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
158 {
159  int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
160 
161  return get_coeff_bits(gb, val);
162 }
163 
165  int *block, int *dc_cache,
166  int bx, int by, uint16_t *quant_mat)
167 {
168  int skip, val, pos = 1, zz_pos, dc;
169 
170  memset(block, 0, sizeof(*block) * 64);
171 
172  dc = get_coeff(gb, dc_vlc);
173  // DC prediction is the same as in MSS3
174  if (by) {
175  if (bx) {
176  int l, tl, t;
177 
178  l = dc_cache[LEFT];
179  tl = dc_cache[TOP_LEFT];
180  t = dc_cache[TOP];
181 
182  if (FFABS(t - tl) <= FFABS(l - tl))
183  dc += l;
184  else
185  dc += t;
186  } else {
187  dc += dc_cache[TOP];
188  }
189  } else if (bx) {
190  dc += dc_cache[LEFT];
191  }
192  dc_cache[LEFT] = dc;
193  block[0] = dc * quant_mat[0];
194 
195  while (pos < 64) {
196  val = get_vlc2(gb, ac_vlc->table, 9, 2);
197  if (!val)
198  return 0;
199  if (val == -1)
200  return -1;
201  if (val == 0xF0) {
202  pos += 16;
203  continue;
204  }
205  skip = val >> 4;
206  val = get_coeff_bits(gb, val & 0xF);
207  pos += skip;
208  if (pos >= 64)
209  return -1;
210 
211  zz_pos = ff_zigzag_direct[pos];
212  block[zz_pos] = val * quant_mat[zz_pos];
213  pos++;
214  }
215 
216  return pos == 64 ? 0 : -1;
217 }
218 
220  uint8_t *dst[3], int mb_x, int mb_y)
221 {
222  int i, j, k, ret;
223  uint8_t *out = dst[0];
224 
225  for (j = 0; j < 2; j++) {
226  for (i = 0; i < 2; i++) {
227  int xpos = mb_x * 2 + i;
228  c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
229  c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
230  ret = mss4_decode_dct(gb, &dc_vlc[0], &ac_vlc[0], c->block,
231  c->dc_cache[j],
232  xpos, mb_y * 2 + j, c->quant_mat[0]);
233  if (ret)
234  return ret;
235  c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
236 
237  ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
238  c->block);
239  }
240  out += 8 * c->pic->linesize[0];
241  }
242 
243  for (i = 1; i < 3; i++) {
244  c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
245  c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
246  ret = mss4_decode_dct(gb, &dc_vlc[1], &ac_vlc[1],
247  c->block, c->dc_cache[i + 1], mb_x, mb_y,
248  c->quant_mat[1]);
249  if (ret)
250  return ret;
251  c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
252 
253  ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
254  out = dst[i] + mb_x * 16;
255  // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
256  // we need to scale chroma.
257  for (j = 0; j < 16; j++) {
258  for (k = 0; k < 8; k++)
259  AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
260  out += c->pic->linesize[i];
261  }
262  }
263 
264  return 0;
265 }
266 
267 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
268  int *sel_len, int *prev)
269 {
270  int i, y_flag = 0;
271 
272  for (i = 2; i >= 0; i--) {
273  if (!sel_flag[i]) {
274  vec_pos[i] = 0;
275  continue;
276  }
277  if ((!i && !y_flag) || get_bits1(gb)) {
278  if (sel_len[i] > 0) {
279  int pval = prev[i];
280  vec_pos[i] = get_bits(gb, sel_len[i]);
281  if (vec_pos[i] >= pval)
282  vec_pos[i]++;
283  } else {
284  vec_pos[i] = !prev[i];
285  }
286  y_flag = 1;
287  } else {
288  vec_pos[i] = prev[i];
289  }
290  }
291 }
292 
293 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
294  int vec_size, int component, int shift, int *prev)
295 {
296  if (vec_pos < vec_size)
297  return vec[vec_pos];
298  if (!get_bits1(gb))
299  return prev[component];
300  prev[component] = get_bits(gb, 8 - shift) << shift;
301  return prev[component];
302 }
303 
304 #define MKVAL(vals) ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))
305 
306 /* Image mode - the hardest to comprehend MSS4 coding mode.
307  *
308  * In this mode all three 16x16 blocks are coded together with a method
309  * remotely similar to the methods employed in MSS1-MSS3.
310  * The idea is that every component has a vector of 1-4 most common symbols
311  * and an escape mode for reading new value from the bitstream. Decoding
312  * consists of retrieving pixel values from the vector or reading new ones
313  * from the bitstream; depending on flags read from the bitstream, these vector
314  * positions can be updated or reused from the state of the previous line
315  * or previous pixel.
316  */
318  uint8_t *picdst[3], int mb_x, int mb_y)
319 {
320  uint8_t vec[3][4];
321  int vec_len[3];
322  int sel_len[3], sel_flag[3];
323  int i, j, k, mode, split;
324  int prev_vec1 = 0, prev_split = 0;
325  int vals[3] = { 0 };
326  int prev_pix[3] = { 0 };
327  int prev_mode[16] = { 0 };
328  uint8_t *dst[3];
329 
330  const int val_shift = ctx->quality == 100 ? 0 : 2;
331 
332  for (i = 0; i < 3; i++)
333  dst[i] = ctx->imgbuf[i];
334 
335  for (i = 0; i < 3; i++) {
336  vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
337  for (j = 0; j < vec_len[i]; j++) {
338  vec[i][j] = get_coeff(gb, &vec_entry_vlc[!!i]);
339  vec[i][j] += ctx->prev_vec[i][j];
340  ctx->prev_vec[i][j] = vec[i][j];
341  }
342  sel_flag[i] = vec_len[i] > 1;
343  sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
344  }
345 
346  for (j = 0; j < 16; j++) {
347  if (get_bits1(gb)) {
348  split = 0;
349  if (get_bits1(gb)) {
350  prev_mode[0] = 0;
351  vals[0] = vals[1] = vals[2] = 0;
352  mode = 2;
353  } else {
354  mode = get_bits1(gb);
355  if (mode)
356  split = get_bits(gb, 4);
357  }
358  for (i = 0; i < 16; i++) {
359  if (mode <= 1) {
360  vals[0] = prev_mode[i] & 7;
361  vals[1] = (prev_mode[i] >> 3) & 7;
362  vals[2] = prev_mode[i] >> 6;
363  if (mode == 1 && i == split) {
364  read_vec_pos(gb, vals, sel_flag, sel_len, vals);
365  }
366  } else if (mode == 2) {
367  if (get_bits1(gb))
368  read_vec_pos(gb, vals, sel_flag, sel_len, vals);
369  }
370  for (k = 0; k < 3; k++)
371  *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
372  vec_len[k], k,
373  val_shift, prev_pix);
374  prev_mode[i] = MKVAL(vals);
375  }
376  } else {
377  if (get_bits1(gb)) {
378  split = get_bits(gb, 4);
379  if (split >= prev_split)
380  split++;
381  prev_split = split;
382  } else {
383  split = prev_split;
384  }
385  if (split) {
386  vals[0] = prev_mode[0] & 7;
387  vals[1] = (prev_mode[0] >> 3) & 7;
388  vals[2] = prev_mode[0] >> 6;
389  for (i = 0; i < 3; i++) {
390  for (k = 0; k < split; k++) {
391  *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
392  vec_len[i], i, val_shift,
393  prev_pix);
394  prev_mode[k] = MKVAL(vals);
395  }
396  }
397  }
398 
399  if (split != 16) {
400  vals[0] = prev_vec1 & 7;
401  vals[1] = (prev_vec1 >> 3) & 7;
402  vals[2] = prev_vec1 >> 6;
403  if (get_bits1(gb)) {
404  read_vec_pos(gb, vals, sel_flag, sel_len, vals);
405  prev_vec1 = MKVAL(vals);
406  }
407  for (i = 0; i < 3; i++) {
408  for (k = 0; k < 16 - split; k++) {
409  *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
410  vec_len[i], i, val_shift,
411  prev_pix);
412  prev_mode[split + k] = MKVAL(vals);
413  }
414  }
415  }
416  }
417  }
418 
419  for (i = 0; i < 3; i++)
420  for (j = 0; j < 16; j++)
421  memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
422  ctx->imgbuf[i] + j * 16, 16);
423 
424  return 0;
425 }
426 
427 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
428 {
429  int i;
430 
431  c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];
432  c->dc_cache[0][LEFT] = 0;
433  c->dc_cache[1][TOP] = 0;
434  c->dc_cache[1][LEFT] = 0;
435 
436  for (i = 0; i < 2; i++)
437  c->prev_dc[0][mb_x * 2 + i] = 0;
438 
439  for (i = 1; i < 3; i++) {
440  c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
441  c->dc_cache[i + 1][LEFT] = 0;
442  c->prev_dc[i][mb_x] = 0;
443  }
444 }
445 
446 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
447  AVPacket *avpkt)
448 {
449  const uint8_t *buf = avpkt->data;
450  int buf_size = avpkt->size;
451  MSS4Context *c = avctx->priv_data;
452  GetBitContext gb;
453  GetByteContext bc;
454  uint8_t *dst[3];
456  int x, y, i, mb_width, mb_height, blk_type;
457  int ret;
458 
459  if (buf_size < HEADER_SIZE) {
460  av_log(avctx, AV_LOG_ERROR,
461  "Frame should have at least %d bytes, got %d instead\n",
462  HEADER_SIZE, buf_size);
463  return AVERROR_INVALIDDATA;
464  }
465 
466  bytestream2_init(&bc, buf, buf_size);
467  width = bytestream2_get_be16(&bc);
468  height = bytestream2_get_be16(&bc);
469  bytestream2_skip(&bc, 2);
470  quality = bytestream2_get_byte(&bc);
471  frame_type = bytestream2_get_byte(&bc);
472 
473  if (width > avctx->width ||
474  height != avctx->height) {
475  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
476  width, height);
477  return AVERROR_INVALIDDATA;
478  }
479  if (quality < 1 || quality > 100) {
480  av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
481  return AVERROR_INVALIDDATA;
482  }
483  if ((frame_type & ~3) || frame_type == 3) {
484  av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
485  return AVERROR_INVALIDDATA;
486  }
487 
489  av_log(avctx, AV_LOG_ERROR,
490  "Empty frame found but it is not a skip frame.\n");
491  return AVERROR_INVALIDDATA;
492  }
493  mb_width = FFALIGN(width, 16) >> 4;
494  mb_height = FFALIGN(height, 16) >> 4;
495 
496  if (frame_type != SKIP_FRAME && 8*buf_size < 8*HEADER_SIZE + mb_width*mb_height)
497  return AVERROR_INVALIDDATA;
498 
499  if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
500  return ret;
501  c->pic->key_frame = (frame_type == INTRA_FRAME);
502  c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
504  if (frame_type == SKIP_FRAME) {
505  *got_frame = 1;
506  if ((ret = av_frame_ref(data, c->pic)) < 0)
507  return ret;
508 
509  return buf_size;
510  }
511 
512  if (c->quality != quality) {
513  c->quality = quality;
514  for (i = 0; i < 2; i++)
515  ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
516  }
517 
518  if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
519  return ret;
520  dst[0] = c->pic->data[0];
521  dst[1] = c->pic->data[1];
522  dst[2] = c->pic->data[2];
523 
524  memset(c->prev_vec, 0, sizeof(c->prev_vec));
525  for (y = 0; y < mb_height; y++) {
526  memset(c->dc_cache, 0, sizeof(c->dc_cache));
527  for (x = 0; x < mb_width; x++) {
528  blk_type = decode012(&gb);
529  switch (blk_type) {
530  case DCT_BLOCK:
531  if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
532  av_log(avctx, AV_LOG_ERROR,
533  "Error decoding DCT block %d,%d\n",
534  x, y);
535  return AVERROR_INVALIDDATA;
536  }
537  break;
538  case IMAGE_BLOCK:
539  if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
540  av_log(avctx, AV_LOG_ERROR,
541  "Error decoding VQ block %d,%d\n",
542  x, y);
543  return AVERROR_INVALIDDATA;
544  }
545  break;
546  case SKIP_BLOCK:
547  if (frame_type == INTRA_FRAME) {
548  av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
549  return AVERROR_INVALIDDATA;
550  }
551  break;
552  }
553  if (blk_type != DCT_BLOCK)
555  }
556  dst[0] += c->pic->linesize[0] * 16;
557  dst[1] += c->pic->linesize[1] * 16;
558  dst[2] += c->pic->linesize[2] * 16;
559  }
560 
561  if ((ret = av_frame_ref(data, c->pic)) < 0)
562  return ret;
563 
564  *got_frame = 1;
565 
566  return buf_size;
567 }
568 
570 {
571  MSS4Context * const c = avctx->priv_data;
572  int i;
573 
574  av_frame_free(&c->pic);
575  for (i = 0; i < 3; i++)
576  av_freep(&c->prev_dc[i]);
577 
578  return 0;
579 }
580 
582 {
583  static AVOnce init_static_once = AV_ONCE_INIT;
584  MSS4Context * const c = avctx->priv_data;
585  int i;
586 
587  for (i = 0; i < 3; i++) {
588  c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
589  c->prev_dc[i] = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
590  if (!c->prev_dc[i]) {
591  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
592  return AVERROR(ENOMEM);
593  }
594  }
595 
596  c->pic = av_frame_alloc();
597  if (!c->pic)
598  return AVERROR(ENOMEM);
599 
600  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
601 
602  ff_thread_once(&init_static_once, mss4_init_vlcs);
603 
604  return 0;
605 }
606 
608  .name = "mts2",
609  .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
610  .type = AVMEDIA_TYPE_VIDEO,
611  .id = AV_CODEC_ID_MTS2,
612  .priv_data_size = sizeof(MSS4Context),
614  .close = mss4_decode_end,
616  .capabilities = AV_CODEC_CAP_DR1,
618 };
AVCodec
AVCodec.
Definition: codec.h:202
ff_mss34_gen_quant_mat
void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)
Generate quantisation matrix for given quality.
Definition: mss34dsp.c:48
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
jpegtables.h
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
ac_vlc
static VLC ac_vlc[2]
Definition: mss4.c:96
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame 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. Frame references ownership and permissions
MSS4Context
Definition: mss4.c:80
MSS4Context::prev_dc
int * prev_dc[3]
Definition: mss4.c:89
out
FILE * out
Definition: movenc.c:54
GetByteContext
Definition: bytestream.h:33
thread.h
avpriv_mjpeg_bits_ac_luminance
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
Definition: jpegtables.c:73
MKVAL
#define MKVAL(vals)
Definition: mss4.c:304
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
avpriv_mjpeg_val_ac_luminance
const uint8_t avpriv_mjpeg_val_ac_luminance[]
Definition: jpegtables.c:75
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
mss4_dc_vlc_lens
static const uint8_t mss4_dc_vlc_lens[2][16]
Definition: mss4.c:58
data
const char data[16]
Definition: mxf.c:143
BlockType
BlockType
Definition: mss3.c:68
get_vlc2
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:798
get_coeff_bits
static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
Definition: mss4.c:143
DCT_BLOCK
@ DCT_BLOCK
Definition: mss4.c:48
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
SKIP_FRAME
@ SKIP_FRAME
Definition: mss4.c:43
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
GetBitContext
Definition: get_bits.h:62
mss4_decode_end
static av_cold int mss4_decode_end(AVCodecContext *avctx)
Definition: mss4.c:569
val
static double val(void *priv, double ch)
Definition: aeval.c:76
mss4_decode_dct_block
static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb, uint8_t *dst[3], int mb_x, int mb_y)
Definition: mss4.c:219
INTRA_FRAME
@ INTRA_FRAME
Definition: mss4.c:41
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:381
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
mss4_decode_dct
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:164
mss4_init_vlcs
static av_cold void mss4_init_vlcs(void)
Definition: mss4.c:122
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
read_vec_pos
static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag, int *sel_len, int *prev)
Definition: mss4.c:267
SKIP_BLOCK
@ SKIP_BLOCK
Definition: mss4.c:47
bits
uint8_t bits
Definition: vp3data.h:141
LEFT
@ LEFT
Definition: mss4.c:53
mss4_vec_entry_vlc_syms
static const uint8_t mss4_vec_entry_vlc_syms[2][9]
Definition: mss4.c:73
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
AV_WN16A
#define AV_WN16A(p, v)
Definition: intreadwrite.h:534
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:832
mss4_decode_image_block
static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb, uint8_t *picdst[3], int mb_x, int mb_y)
Definition: mss4.c:317
FrameType
FrameType
G723.1 frame types.
Definition: g723_1.h:63
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
IMAGE_BLOCK
@ IMAGE_BLOCK
Definition: mss4.c:49
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
NULL
#define NULL
Definition: coverity.c:32
MSS4Context::pic
AVFrame * pic
Definition: mss4.c:81
INTER_FRAME
@ INTER_FRAME
Definition: mss4.c:42
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
vec_entry_vlc
static VLC vec_entry_vlc[2]
Definition: mss4.c:97
mss4_vec_entry_vlc_lens
static const uint8_t mss4_vec_entry_vlc_lens[2][16]
Definition: mss4.c:68
AVOnce
#define AVOnce
Definition: thread.h:172
avpriv_mjpeg_val_ac_chrominance
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
mss34dsp.h
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled 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 Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
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:327
MSS4Context::prev_vec
int prev_vec[3][4]
Definition: mss4.c:93
get_value_cached
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:293
mss4_decode_frame
static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mss4.c:446
MAX_ENTRIES
#define MAX_ENTRIES
Definition: mss4.c:78
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
height
#define height
mss4_init_vlc
static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset, const uint8_t *lens, const uint8_t *syms)
Definition: mss4.c:99
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
MSS4Context::quality
int quality
Definition: mss4.c:86
unary.h
HEADER_SIZE
#define HEADER_SIZE
Definition: mss4.c:38
MSS4Context::dc_cache
int dc_cache[4][4]
Definition: mss4.c:91
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
frame_type
frame_type
Definition: jpeg2000_parser.c:31
AV_CODEC_ID_MTS2
@ AV_CODEC_ID_MTS2
Definition: codec_id.h:215
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
get_coeff
static int get_coeff(GetBitContext *gb, VLC *vlc)
Definition: mss4.c:157
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
MSS4Context::dc_stride
ptrdiff_t dc_stride[3]
Definition: mss4.c:90
dc_vlc
static VLC dc_vlc[2]
Definition: mss4.c:96
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
MSS4Context::quant_mat
uint16_t quant_mat[2][64]
Definition: mss4.c:87
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
VLC::bits
int bits
Definition: vlc.h:27
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1759
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
pos
unsigned int pos
Definition: spdifenc.c:412
vec_len_syms
static const uint8_t vec_len_syms[2][4]
Definition: mss4.c:63
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
AVCodecContext
main external API structure.
Definition: avcodec.h:383
mode
mode
Definition: ebur128.h:83
TOP_LEFT
@ TOP_LEFT
Definition: mss4.c:54
VLC
Definition: vlc.h:26
MSS4Context::imgbuf
uint8_t imgbuf[3][16 *16]
Definition: mss4.c:84
mss4_update_dc_cache
static void mss4_update_dc_cache(MSS4Context *c, int mb_x)
Definition: mss4.c:427
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
shift
static int shift(int a, int b)
Definition: sonic.c:83
VLC::table_size
int table_size
Definition: vlc.h:29
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
TOP
@ TOP
Definition: mss4.c:55
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
ff_mts2_decoder
const AVCodec ff_mts2_decoder
Definition: mss4.c:607
MSS4Context::block
int block[64]
Definition: mss4.c:83
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
avpriv_mjpeg_bits_ac_chrominance
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
ff_mss34_dct_put
void ff_mss34_dct_put(uint8_t *dst, ptrdiff_t stride, int *block)
Transform and output DCT block.
Definition: mss34dsp.c:90
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
mss4_decode_init
static av_cold int mss4_decode_init(AVCodecContext *avctx)
Definition: mss4.c:581
CachePos
CachePos
Definition: mss4.c:52