FFmpeg
mss3.c
Go to the documentation of this file.
1 /*
2  * Microsoft Screen 3 (aka Microsoft ATC 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 3 (aka Microsoft ATC Screen) decoder
25  */
26 
27 #include "avcodec.h"
28 #include "bytestream.h"
29 #include "internal.h"
30 #include "mathops.h"
31 #include "mss34dsp.h"
32 
33 #define HEADER_SIZE 27
34 
35 #define MODEL2_SCALE 13
36 #define MODEL_SCALE 15
37 #define MODEL256_SEC_SCALE 9
38 
39 typedef struct Model2 {
43 } Model2;
44 
45 typedef struct Model {
46  int weights[16], freqs[16];
47  int num_syms;
50 } Model;
51 
52 typedef struct Model256 {
53  int weights[256], freqs[256];
55  int secondary[68];
56  int sec_size;
58 } Model256;
59 
60 #define RAC_BOTTOM 0x01000000
61 typedef struct RangeCoder {
62  const uint8_t *src, *src_end;
63 
64  uint32_t range, low;
65  int got_error;
66 } RangeCoder;
67 
68 enum BlockType {
74 };
75 
76 typedef struct BlockTypeContext {
77  int last_type;
80 
81 typedef struct FillBlockCoder {
82  int fill_val;
85 
86 typedef struct ImageBlockCoder {
91 
92 typedef struct DCTBlockCoder {
93  int *prev_dc;
94  ptrdiff_t prev_dc_stride;
96  int quality;
97  uint16_t qmat[64];
101 } DCTBlockCoder;
102 
103 typedef struct HaarBlockCoder {
108 
109 typedef struct MSS3Context {
112 
120 
121  int dctblock[64];
122  int hblock[16 * 16];
123 } MSS3Context;
124 
125 
126 static void model2_reset(Model2 *m)
127 {
128  m->zero_weight = 1;
129  m->total_weight = 2;
130  m->zero_freq = 0x1000;
131  m->total_freq = 0x2000;
132  m->upd_val = 4;
133  m->till_rescale = 4;
134 }
135 
136 static void model2_update(Model2 *m, int bit)
137 {
138  unsigned scale;
139 
140  if (!bit)
141  m->zero_weight++;
142  m->till_rescale--;
143  if (m->till_rescale)
144  return;
145 
146  m->total_weight += m->upd_val;
147  if (m->total_weight > 0x2000) {
148  m->total_weight = (m->total_weight + 1) >> 1;
149  m->zero_weight = (m->zero_weight + 1) >> 1;
150  if (m->total_weight == m->zero_weight)
151  m->total_weight = m->zero_weight + 1;
152  }
153  m->upd_val = m->upd_val * 5 >> 2;
154  if (m->upd_val > 64)
155  m->upd_val = 64;
156  scale = 0x80000000u / m->total_weight;
157  m->zero_freq = m->zero_weight * scale >> 18;
158  m->total_freq = m->total_weight * scale >> 18;
159  m->till_rescale = m->upd_val;
160 }
161 
162 static void model_update(Model *m, int val)
163 {
164  int i, sum = 0;
165  unsigned scale;
166 
167  m->weights[val]++;
168  m->till_rescale--;
169  if (m->till_rescale)
170  return;
171  m->tot_weight += m->upd_val;
172 
173  if (m->tot_weight > 0x8000) {
174  m->tot_weight = 0;
175  for (i = 0; i < m->num_syms; i++) {
176  m->weights[i] = (m->weights[i] + 1) >> 1;
177  m->tot_weight += m->weights[i];
178  }
179  }
180  scale = 0x80000000u / m->tot_weight;
181  for (i = 0; i < m->num_syms; i++) {
182  m->freqs[i] = sum * scale >> 16;
183  sum += m->weights[i];
184  }
185 
186  m->upd_val = m->upd_val * 5 >> 2;
187  if (m->upd_val > m->max_upd_val)
188  m->upd_val = m->max_upd_val;
189  m->till_rescale = m->upd_val;
190 }
191 
192 static void model_reset(Model *m)
193 {
194  int i;
195 
196  m->tot_weight = 0;
197  for (i = 0; i < m->num_syms - 1; i++)
198  m->weights[i] = 1;
199  m->weights[m->num_syms - 1] = 0;
200 
201  m->upd_val = m->num_syms;
202  m->till_rescale = 1;
203  model_update(m, m->num_syms - 1);
204  m->till_rescale =
205  m->upd_val = (m->num_syms + 6) >> 1;
206 }
207 
208 static av_cold void model_init(Model *m, int num_syms)
209 {
210  m->num_syms = num_syms;
211  m->max_upd_val = 8 * num_syms + 48;
212 
213  model_reset(m);
214 }
215 
216 static void model256_update(Model256 *m, int val)
217 {
218  int i, sum = 0;
219  unsigned scale;
220  int send, sidx = 1;
221 
222  m->weights[val]++;
223  m->till_rescale--;
224  if (m->till_rescale)
225  return;
226  m->tot_weight += m->upd_val;
227 
228  if (m->tot_weight > 0x8000) {
229  m->tot_weight = 0;
230  for (i = 0; i < 256; i++) {
231  m->weights[i] = (m->weights[i] + 1) >> 1;
232  m->tot_weight += m->weights[i];
233  }
234  }
235  scale = 0x80000000u / m->tot_weight;
236  m->secondary[0] = 0;
237  for (i = 0; i < 256; i++) {
238  m->freqs[i] = sum * scale >> 16;
239  sum += m->weights[i];
240  send = m->freqs[i] >> MODEL256_SEC_SCALE;
241  while (sidx <= send)
242  m->secondary[sidx++] = i - 1;
243  }
244  while (sidx < m->sec_size)
245  m->secondary[sidx++] = 255;
246 
247  m->upd_val = m->upd_val * 5 >> 2;
248  if (m->upd_val > m->max_upd_val)
249  m->upd_val = m->max_upd_val;
250  m->till_rescale = m->upd_val;
251 }
252 
253 static void model256_reset(Model256 *m)
254 {
255  int i;
256 
257  for (i = 0; i < 255; i++)
258  m->weights[i] = 1;
259  m->weights[255] = 0;
260 
261  m->tot_weight = 0;
262  m->upd_val = 256;
263  m->till_rescale = 1;
264  model256_update(m, 255);
265  m->till_rescale =
266  m->upd_val = (256 + 6) >> 1;
267 }
268 
270 {
271  m->max_upd_val = 8 * 256 + 48;
272  m->sec_size = (1 << 6) + 2;
273 
274  model256_reset(m);
275 }
276 
277 static void rac_init(RangeCoder *c, const uint8_t *src, int size)
278 {
279  int i;
280 
281  c->src = src;
282  c->src_end = src + size;
283  c->low = 0;
284  for (i = 0; i < FFMIN(size, 4); i++)
285  c->low = (c->low << 8) | *c->src++;
286  c->range = 0xFFFFFFFF;
287  c->got_error = 0;
288 }
289 
291 {
292  for (;;) {
293  c->range <<= 8;
294  c->low <<= 8;
295  if (c->src < c->src_end) {
296  c->low |= *c->src++;
297  } else if (!c->low) {
298  c->got_error = 1;
299  c->low = 1;
300  }
301  if (c->low > c->range) {
302  c->got_error = 1;
303  c->low = 1;
304  }
305  if (c->range >= RAC_BOTTOM)
306  return;
307  }
308 }
309 
311 {
312  int bit;
313 
314  c->range >>= 1;
315 
316  bit = (c->range <= c->low);
317  if (bit)
318  c->low -= c->range;
319 
320  if (c->range < RAC_BOTTOM)
321  rac_normalise(c);
322 
323  return bit;
324 }
325 
326 static int rac_get_bits(RangeCoder *c, int nbits)
327 {
328  int val;
329 
330  c->range >>= nbits;
331  val = c->low / c->range;
332  c->low -= c->range * val;
333 
334  if (c->range < RAC_BOTTOM)
335  rac_normalise(c);
336 
337  return val;
338 }
339 
341 {
342  int bit, helper;
343 
344  helper = m->zero_freq * (c->range >> MODEL2_SCALE);
345  bit = (c->low >= helper);
346  if (bit) {
347  c->low -= helper;
348  c->range -= helper;
349  } else {
350  c->range = helper;
351  }
352 
353  if (c->range < RAC_BOTTOM)
354  rac_normalise(c);
355 
356  model2_update(m, bit);
357 
358  return bit;
359 }
360 
362 {
363  int val;
364  int end, end2;
365  unsigned prob, prob2, helper;
366 
367  prob = 0;
368  prob2 = c->range;
369  c->range >>= MODEL_SCALE;
370  val = 0;
371  end = m->num_syms >> 1;
372  end2 = m->num_syms;
373  do {
374  helper = m->freqs[end] * c->range;
375  if (helper <= c->low) {
376  val = end;
377  prob = helper;
378  } else {
379  end2 = end;
380  prob2 = helper;
381  }
382  end = (end2 + val) >> 1;
383  } while (end != val);
384  c->low -= prob;
385  c->range = prob2 - prob;
386  if (c->range < RAC_BOTTOM)
387  rac_normalise(c);
388 
389  model_update(m, val);
390 
391  return val;
392 }
393 
395 {
396  int val;
397  int start, end;
398  int ssym;
399  unsigned prob, prob2, helper;
400 
401  prob2 = c->range;
402  c->range >>= MODEL_SCALE;
403 
404  helper = c->low / c->range;
405  ssym = helper >> MODEL256_SEC_SCALE;
406  val = m->secondary[ssym];
407 
408  end = start = m->secondary[ssym + 1] + 1;
409  while (end > val + 1) {
410  ssym = (end + val) >> 1;
411  if (m->freqs[ssym] <= helper) {
412  end = start;
413  val = ssym;
414  } else {
415  end = (end + val) >> 1;
416  start = ssym;
417  }
418  }
419  prob = m->freqs[val] * c->range;
420  if (val != 255)
421  prob2 = m->freqs[val + 1] * c->range;
422 
423  c->low -= prob;
424  c->range = prob2 - prob;
425  if (c->range < RAC_BOTTOM)
426  rac_normalise(c);
427 
428  model256_update(m, val);
429 
430  return val;
431 }
432 
434 {
435  bt->last_type = rac_get_model_sym(c, &bt->bt_model[bt->last_type]);
436 
437  return bt->last_type;
438 }
439 
440 static int decode_coeff(RangeCoder *c, Model *m)
441 {
442  int val, sign;
443 
444  val = rac_get_model_sym(c, m);
445  if (val) {
446  sign = rac_get_bit(c);
447  if (val > 1) {
448  val--;
449  val = (1 << val) + rac_get_bits(c, val);
450  }
451  if (!sign)
452  val = -val;
453  }
454 
455  return val;
456 }
457 
459  uint8_t *dst, ptrdiff_t stride, int block_size)
460 {
461  int i;
462 
463  fc->fill_val += decode_coeff(c, &fc->coef_model);
464 
465  for (i = 0; i < block_size; i++, dst += stride)
466  memset(dst, fc->fill_val, block_size);
467 }
468 
470  uint8_t *dst, ptrdiff_t stride, int block_size)
471 {
472  int i, j;
473  int vec_size;
474  int vec[4];
475  int prev_line[16];
476  int A, B, C;
477 
478  vec_size = rac_get_model_sym(c, &ic->vec_size_model) + 2;
479  for (i = 0; i < vec_size; i++)
480  vec[i] = rac_get_model256_sym(c, &ic->vec_entry_model);
481  for (; i < 4; i++)
482  vec[i] = 0;
483  memset(prev_line, 0, sizeof(prev_line));
484 
485  for (j = 0; j < block_size; j++) {
486  A = 0;
487  B = 0;
488  for (i = 0; i < block_size; i++) {
489  C = B;
490  B = prev_line[i];
491  A = rac_get_model_sym(c, &ic->vq_model[A + B * 5 + C * 25]);
492 
493  prev_line[i] = A;
494  if (A < 4)
495  dst[i] = vec[A];
496  else
497  dst[i] = rac_get_model256_sym(c, &ic->esc_model);
498  }
499  dst += stride;
500  }
501 }
502 
503 static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,
504  int bx, int by)
505 {
506  int skip, val, sign, pos = 1, zz_pos, dc;
507  int blk_pos = bx + by * bc->prev_dc_stride;
508 
509  memset(block, 0, sizeof(*block) * 64);
510 
511  dc = decode_coeff(c, &bc->dc_model);
512  if (by) {
513  if (bx) {
514  int l, tl, t;
515 
516  l = bc->prev_dc[blk_pos - 1];
517  tl = bc->prev_dc[blk_pos - 1 - bc->prev_dc_stride];
518  t = bc->prev_dc[blk_pos - bc->prev_dc_stride];
519 
520  if (FFABS(t - tl) <= FFABS(l - tl))
521  dc += l;
522  else
523  dc += t;
524  } else {
525  dc += bc->prev_dc[blk_pos - bc->prev_dc_stride];
526  }
527  } else if (bx) {
528  dc += bc->prev_dc[bx - 1];
529  }
530  bc->prev_dc[blk_pos] = dc;
531  block[0] = dc * bc->qmat[0];
532 
533  while (pos < 64) {
535  if (!val)
536  return 0;
537  if (val == 0xF0) {
538  pos += 16;
539  continue;
540  }
541  skip = val >> 4;
542  val = val & 0xF;
543  if (!val)
544  return -1;
545  pos += skip;
546  if (pos >= 64)
547  return -1;
548 
549  sign = rac_get_model2_sym(c, &bc->sign_model);
550  if (val > 1) {
551  val--;
552  val = (1 << val) + rac_get_bits(c, val);
553  }
554  if (!sign)
555  val = -val;
556 
557  zz_pos = ff_zigzag_direct[pos];
558  block[zz_pos] = val * bc->qmat[zz_pos];
559  pos++;
560  }
561 
562  return pos == 64 ? 0 : -1;
563 }
564 
566  uint8_t *dst, ptrdiff_t stride, int block_size,
567  int *block, int mb_x, int mb_y)
568 {
569  int i, j;
570  int bx, by;
571  int nblocks = block_size >> 3;
572 
573  bx = mb_x * nblocks;
574  by = mb_y * nblocks;
575 
576  for (j = 0; j < nblocks; j++) {
577  for (i = 0; i < nblocks; i++) {
578  if (decode_dct(c, bc, block, bx + i, by + j)) {
579  c->got_error = 1;
580  return;
581  }
582  ff_mss34_dct_put(dst + i * 8, stride, block);
583  }
584  dst += 8 * stride;
585  }
586 }
587 
589  uint8_t *dst, ptrdiff_t stride,
590  int block_size, int *block)
591 {
592  const int hsize = block_size >> 1;
593  int A, B, C, D, t1, t2, t3, t4;
594  int i, j;
595 
596  for (j = 0; j < block_size; j++) {
597  for (i = 0; i < block_size; i++) {
598  if (i < hsize && j < hsize)
600  else
601  block[i] = decode_coeff(c, &hc->coef_hi_model);
602  block[i] *= hc->scale;
603  }
604  block += block_size;
605  }
606  block -= block_size * block_size;
607 
608  for (j = 0; j < hsize; j++) {
609  for (i = 0; i < hsize; i++) {
610  A = block[i];
611  B = block[i + hsize];
612  C = block[i + hsize * block_size];
613  D = block[i + hsize * block_size + hsize];
614 
615  t1 = A - B;
616  t2 = C - D;
617  t3 = A + B;
618  t4 = C + D;
619  dst[i * 2] = av_clip_uint8(t1 - t2);
620  dst[i * 2 + stride] = av_clip_uint8(t1 + t2);
621  dst[i * 2 + 1] = av_clip_uint8(t3 - t4);
622  dst[i * 2 + 1 + stride] = av_clip_uint8(t3 + t4);
623  }
624  block += block_size;
625  dst += stride * 2;
626  }
627 }
628 
630 {
631  int i, j;
632 
633  for (i = 0; i < 3; i++) {
634  ctx->btype[i].last_type = SKIP_BLOCK;
635  for (j = 0; j < 5; j++)
636  model_reset(&ctx->btype[i].bt_model[j]);
637  ctx->fill_coder[i].fill_val = 0;
638  model_reset(&ctx->fill_coder[i].coef_model);
639  model256_reset(&ctx->image_coder[i].esc_model);
640  model256_reset(&ctx->image_coder[i].vec_entry_model);
641  model_reset(&ctx->image_coder[i].vec_size_model);
642  for (j = 0; j < 125; j++)
643  model_reset(&ctx->image_coder[i].vq_model[j]);
644  if (ctx->dct_coder[i].quality != quality) {
645  ctx->dct_coder[i].quality = quality;
646  ff_mss34_gen_quant_mat(ctx->dct_coder[i].qmat, quality, !i);
647  }
648  memset(ctx->dct_coder[i].prev_dc, 0,
649  sizeof(*ctx->dct_coder[i].prev_dc) *
650  ctx->dct_coder[i].prev_dc_stride *
651  ctx->dct_coder[i].prev_dc_height);
652  model_reset(&ctx->dct_coder[i].dc_model);
653  model2_reset(&ctx->dct_coder[i].sign_model);
654  model256_reset(&ctx->dct_coder[i].ac_model);
655  if (ctx->haar_coder[i].quality != quality) {
656  ctx->haar_coder[i].quality = quality;
657  ctx->haar_coder[i].scale = 17 - 7 * quality / 50;
658  }
659  model_reset(&ctx->haar_coder[i].coef_hi_model);
660  model256_reset(&ctx->haar_coder[i].coef_model);
661  }
662 }
663 
665 {
666  int i, j;
667 
668  for (i = 0; i < 3; i++) {
669  for (j = 0; j < 5; j++)
670  model_init(&ctx->btype[i].bt_model[j], 5);
671  model_init(&ctx->fill_coder[i].coef_model, 12);
672  model256_init(&ctx->image_coder[i].esc_model);
673  model256_init(&ctx->image_coder[i].vec_entry_model);
674  model_init(&ctx->image_coder[i].vec_size_model, 3);
675  for (j = 0; j < 125; j++)
676  model_init(&ctx->image_coder[i].vq_model[j], 5);
677  model_init(&ctx->dct_coder[i].dc_model, 12);
678  model256_init(&ctx->dct_coder[i].ac_model);
679  model_init(&ctx->haar_coder[i].coef_hi_model, 12);
680  model256_init(&ctx->haar_coder[i].coef_model);
681  }
682 }
683 
684 static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
685  AVPacket *avpkt)
686 {
687  const uint8_t *buf = avpkt->data;
688  int buf_size = avpkt->size;
689  MSS3Context *c = avctx->priv_data;
690  RangeCoder *acoder = &c->coder;
691  GetByteContext gb;
692  uint8_t *dst[3];
693  int dec_width, dec_height, dec_x, dec_y, quality, keyframe;
694  int x, y, i, mb_width, mb_height, blk_size, btype;
695  int ret;
696 
697  if (buf_size < HEADER_SIZE) {
698  av_log(avctx, AV_LOG_ERROR,
699  "Frame should have at least %d bytes, got %d instead\n",
700  HEADER_SIZE, buf_size);
701  return AVERROR_INVALIDDATA;
702  }
703 
704  bytestream2_init(&gb, buf, buf_size);
705  keyframe = bytestream2_get_be32(&gb);
706  if (keyframe & ~0x301) {
707  av_log(avctx, AV_LOG_ERROR, "Invalid frame type %X\n", keyframe);
708  return AVERROR_INVALIDDATA;
709  }
710  keyframe = !(keyframe & 1);
711  bytestream2_skip(&gb, 6);
712  dec_x = bytestream2_get_be16(&gb);
713  dec_y = bytestream2_get_be16(&gb);
714  dec_width = bytestream2_get_be16(&gb);
715  dec_height = bytestream2_get_be16(&gb);
716 
717  if (dec_x + dec_width > avctx->width ||
718  dec_y + dec_height > avctx->height ||
719  (dec_width | dec_height) & 0xF) {
720  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d +%d,%d\n",
721  dec_width, dec_height, dec_x, dec_y);
722  return AVERROR_INVALIDDATA;
723  }
724  bytestream2_skip(&gb, 4);
725  quality = bytestream2_get_byte(&gb);
726  if (quality < 1 || quality > 100) {
727  av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
728  return AVERROR_INVALIDDATA;
729  }
730  bytestream2_skip(&gb, 4);
731 
732  if (keyframe && !bytestream2_get_bytes_left(&gb)) {
733  av_log(avctx, AV_LOG_ERROR, "Keyframe without data found\n");
734  return AVERROR_INVALIDDATA;
735  }
736  if (!keyframe && c->got_error)
737  return buf_size;
738  c->got_error = 0;
739 
740  if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
741  return ret;
742  c->pic->key_frame = keyframe;
743  c->pic->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
744  if (!bytestream2_get_bytes_left(&gb)) {
745  if ((ret = av_frame_ref(data, c->pic)) < 0)
746  return ret;
747  *got_frame = 1;
748 
749  return buf_size;
750  }
751 
753 
754  rac_init(acoder, buf + HEADER_SIZE, buf_size - HEADER_SIZE);
755 
756  mb_width = dec_width >> 4;
757  mb_height = dec_height >> 4;
758  dst[0] = c->pic->data[0] + dec_x + dec_y * c->pic->linesize[0];
759  dst[1] = c->pic->data[1] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[1];
760  dst[2] = c->pic->data[2] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[2];
761  for (y = 0; y < mb_height; y++) {
762  for (x = 0; x < mb_width; x++) {
763  for (i = 0; i < 3; i++) {
764  blk_size = 8 << !i;
765 
766  btype = decode_block_type(acoder, c->btype + i);
767  switch (btype) {
768  case FILL_BLOCK:
769  decode_fill_block(acoder, c->fill_coder + i,
770  dst[i] + x * blk_size,
771  c->pic->linesize[i], blk_size);
772  break;
773  case IMAGE_BLOCK:
774  decode_image_block(acoder, c->image_coder + i,
775  dst[i] + x * blk_size,
776  c->pic->linesize[i], blk_size);
777  break;
778  case DCT_BLOCK:
779  decode_dct_block(acoder, c->dct_coder + i,
780  dst[i] + x * blk_size,
781  c->pic->linesize[i], blk_size,
782  c->dctblock, x, y);
783  break;
784  case HAAR_BLOCK:
785  decode_haar_block(acoder, c->haar_coder + i,
786  dst[i] + x * blk_size,
787  c->pic->linesize[i], blk_size,
788  c->hblock);
789  break;
790  }
791  if (c->got_error || acoder->got_error) {
792  av_log(avctx, AV_LOG_ERROR, "Error decoding block %d,%d\n",
793  x, y);
794  c->got_error = 1;
795  return AVERROR_INVALIDDATA;
796  }
797  }
798  }
799  dst[0] += c->pic->linesize[0] * 16;
800  dst[1] += c->pic->linesize[1] * 8;
801  dst[2] += c->pic->linesize[2] * 8;
802  }
803 
804  if ((ret = av_frame_ref(data, c->pic)) < 0)
805  return ret;
806 
807  *got_frame = 1;
808 
809  return buf_size;
810 }
811 
813 {
814  MSS3Context * const c = avctx->priv_data;
815  int i;
816 
817  av_frame_free(&c->pic);
818  for (i = 0; i < 3; i++)
819  av_freep(&c->dct_coder[i].prev_dc);
820 
821  return 0;
822 }
823 
825 {
826  MSS3Context * const c = avctx->priv_data;
827  int i;
828 
829  c->avctx = avctx;
830 
831  if ((avctx->width & 0xF) || (avctx->height & 0xF)) {
832  av_log(avctx, AV_LOG_ERROR,
833  "Image dimensions should be a multiple of 16.\n");
834  return AVERROR_INVALIDDATA;
835  }
836 
837  c->got_error = 0;
838  for (i = 0; i < 3; i++) {
839  int b_width = avctx->width >> (2 + !!i);
840  int b_height = avctx->height >> (2 + !!i);
841  c->dct_coder[i].prev_dc_stride = b_width;
842  c->dct_coder[i].prev_dc_height = b_height;
843  c->dct_coder[i].prev_dc = av_malloc(sizeof(*c->dct_coder[i].prev_dc) *
844  b_width * b_height);
845  if (!c->dct_coder[i].prev_dc) {
846  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
847  return AVERROR(ENOMEM);
848  }
849  }
850 
851  c->pic = av_frame_alloc();
852  if (!c->pic)
853  return AVERROR(ENOMEM);
854 
855  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
856 
857  init_coders(c);
858 
859  return 0;
860 }
861 
863  .name = "msa1",
864  .long_name = NULL_IF_CONFIG_SMALL("MS ATC Screen"),
865  .type = AVMEDIA_TYPE_VIDEO,
866  .id = AV_CODEC_ID_MSA1,
867  .priv_data_size = sizeof(MSS3Context),
869  .close = mss3_decode_end,
871  .capabilities = AV_CODEC_CAP_DR1,
873 };
RangeCoder::range
uint32_t range
Definition: mss3.c:64
AVCodec
AVCodec.
Definition: codec.h:197
HEADER_SIZE
#define HEADER_SIZE
Definition: mss3.c:33
stride
int stride
Definition: mace.c:144
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
Model256::upd_val
int upd_val
Definition: mss3.c:57
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
Model2
Definition: mss3.c:39
ImageBlockCoder::esc_model
Model256 esc_model
Definition: mss3.c:87
ImageBlockCoder::vq_model
Model vq_model[125]
Definition: mss3.c:89
DCTBlockCoder::prev_dc_stride
ptrdiff_t prev_dc_stride
Definition: mss3.c:94
Model256::secondary
int secondary[68]
Definition: mss3.c:55
GetByteContext
Definition: bytestream.h:33
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
HaarBlockCoder::coef_hi_model
Model coef_hi_model
Definition: mss3.c:106
DCTBlockCoder::dc_model
Model dc_model
Definition: mss3.c:98
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
DCTBlockCoder::ac_model
Model256 ac_model
Definition: mss3.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
MSS3Context
Definition: mss3.c:109
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
ImageBlockCoder::vec_entry_model
Model256 vec_entry_model
Definition: mss3.c:87
FillBlockCoder
Definition: mss3.c:81
data
const char data[16]
Definition: mxf.c:143
MSS3Context::got_error
int got_error
Definition: mss3.c:113
BlockType
BlockType
Definition: mss3.c:68
DCTBlockCoder::qmat
uint16_t qmat[64]
Definition: mss3.c:97
DCTBlockCoder::quality
int quality
Definition: mss3.c:96
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
t1
#define t1
Definition: regdef.h:29
Model::weights
int16_t weights[MODEL_MAX_SYMS+1]
Definition: mss12.h:42
Model256::till_rescale
int till_rescale
Definition: mss3.c:57
MSS3Context::haar_coder
HaarBlockCoder haar_coder[3]
Definition: mss3.c:119
model2_update
static void model2_update(Model2 *m, int bit)
Definition: mss3.c:136
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
MSS3Context::avctx
AVCodecContext * avctx
Definition: mss3.c:110
D
D(D(float, sse)
Definition: rematrix_init.c:29
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
MODEL256_SEC_SCALE
#define MODEL256_SEC_SCALE
Definition: mss3.c:37
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
HaarBlockCoder::quality
int quality
Definition: mss3.c:104
A
#define A(x)
Definition: vp56_arith.h:28
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
MSS3Context::dct_coder
DCTBlockCoder dct_coder[3]
Definition: mss3.c:118
val
static double val(void *priv, double ch)
Definition: aeval.c:75
Model256::max_upd_val
int max_upd_val
Definition: mss3.c:57
DCTBlockCoder::prev_dc
int * prev_dc
Definition: mss3.c:93
init_coders
static av_cold void init_coders(MSS3Context *ctx)
Definition: mss3.c:664
decode_image_block
static void decode_image_block(RangeCoder *c, ImageBlockCoder *ic, uint8_t *dst, ptrdiff_t stride, int block_size)
Definition: mss3.c:469
MSS3Context::btype
BlockTypeContext btype[3]
Definition: mss3.c:115
decode_block_type
static int decode_block_type(RangeCoder *c, BlockTypeContext *bt)
Definition: mss3.c:433
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
model2_reset
static void model2_reset(Model2 *m)
Definition: mss3.c:126
av_cold
#define av_cold
Definition: attributes.h:90
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
HaarBlockCoder::scale
int scale
Definition: mss3.c:104
rac_get_model2_sym
static int rac_get_model2_sym(RangeCoder *c, Model2 *m)
Definition: mss3.c:340
rac_get_model_sym
static int rac_get_model_sym(RangeCoder *c, Model *m)
Definition: mss3.c:361
mss3_decode_init
static av_cold int mss3_decode_init(AVCodecContext *avctx)
Definition: mss3.c:824
RangeCoder::got_error
int got_error
Definition: mss3.c:65
RangeCoder::src_end
const uint8_t * src_end
Definition: mss3.c:62
MODEL_SCALE
#define MODEL_SCALE
Definition: mss3.c:36
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FillBlockCoder::fill_val
int fill_val
Definition: mss3.c:82
rac_get_bit
static int rac_get_bit(RangeCoder *c)
Definition: mss3.c:310
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
SKIP_BLOCK
@ SKIP_BLOCK
Definition: mss3.c:73
HAAR_BLOCK
@ HAAR_BLOCK
Definition: mss3.c:72
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
decode_haar_block
static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc, uint8_t *dst, ptrdiff_t stride, int block_size, int *block)
Definition: mss3.c:588
mss3_decode_frame
static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mss3.c:684
Model2::upd_val
int upd_val
Definition: mss3.c:40
rac_get_model256_sym
static int rac_get_model256_sym(RangeCoder *c, Model256 *m)
Definition: mss3.c:394
MODEL2_SCALE
#define MODEL2_SCALE
Definition: mss3.c:35
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
mathops.h
Model256
Definition: mss3.c:52
mss3_decode_end
static av_cold int mss3_decode_end(AVCodecContext *avctx)
Definition: mss3.c:812
MSS3Context::hblock
int hblock[16 *16]
Definition: mss3.c:122
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
decode_coeff
static int decode_coeff(RangeCoder *c, Model *m)
Definition: mss3.c:440
Model::upd_val
int upd_val
Definition: mss3.c:49
decode_dct
static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block, int bx, int by)
Definition: mss3.c:503
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
FILL_BLOCK
@ FILL_BLOCK
Definition: mss3.c:69
mss34dsp.h
BlockTypeContext::last_type
int last_type
Definition: mss3.c:77
MSS3Context::fill_coder
FillBlockCoder fill_coder[3]
Definition: mss3.c:116
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:116
RangeCoder::src
const uint8_t * src
Definition: mss3.c:62
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
size
int size
Definition: twinvq_data.h:10344
RAC_BOTTOM
#define RAC_BOTTOM
Definition: mss3.c:60
model256_init
static av_cold void model256_init(Model256 *m)
Definition: mss3.c:269
BlockTypeContext
Definition: mss3.c:76
MSS3Context::coder
RangeCoder coder
Definition: mss3.c:114
IMAGE_BLOCK
@ IMAGE_BLOCK
Definition: mss3.c:70
HaarBlockCoder::coef_model
Model256 coef_model
Definition: mss3.c:105
rac_normalise
static void rac_normalise(RangeCoder *c)
Definition: mss3.c:290
i
int i
Definition: input.c:406
DCTBlockCoder::prev_dc_height
int prev_dc_height
Definition: mss3.c:95
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
t4
#define t4
Definition: regdef.h:32
t3
#define t3
Definition: regdef.h:31
FillBlockCoder::coef_model
Model coef_model
Definition: mss3.c:83
Model::tot_weight
int tot_weight
Definition: mss3.c:48
Model2::total_freq
unsigned total_freq
Definition: mss3.c:42
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
Model256::freqs
int freqs[256]
Definition: mss3.c:53
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
MSS3Context::pic
AVFrame * pic
Definition: mss3.c:111
Model::num_syms
int num_syms
Definition: mss12.h:44
AVCodecContext::height
int height
Definition: avcodec.h:552
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
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:1755
ret
ret
Definition: filter_design.txt:187
model_reset
static void model_reset(Model *m)
Definition: mss3.c:192
prob
#define prob(name, subs,...)
Definition: cbs_vp9.c:373
pos
unsigned int pos
Definition: spdifenc.c:412
B
#define B
Definition: huffyuvdsp.h:32
AVCodecContext
main external API structure.
Definition: avcodec.h:379
t2
#define t2
Definition: regdef.h:30
ff_msa1_decoder
const AVCodec ff_msa1_decoder
Definition: mss3.c:862
decode_dct_block
static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc, uint8_t *dst, ptrdiff_t stride, int block_size, int *block, int mb_x, int mb_y)
Definition: mss3.c:565
Model256::tot_weight
int tot_weight
Definition: mss3.c:54
DCTBlockCoder::sign_model
Model2 sign_model
Definition: mss3.c:99
DCTBlockCoder
Definition: mss3.c:92
MSS3Context::dctblock
int dctblock[64]
Definition: mss3.c:121
AV_CODEC_ID_MSA1
@ AV_CODEC_ID_MSA1
Definition: codec_id.h:213
Model::max_upd_val
int max_upd_val
Definition: mss3.c:49
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
model256_reset
static void model256_reset(Model256 *m)
Definition: mss3.c:253
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
Model::till_rescale
int till_rescale
Definition: mss3.c:49
RangeCoder::low
uint32_t low
Definition: mss3.c:64
Model2::total_weight
unsigned total_weight
Definition: mss3.c:42
reset_coders
static void reset_coders(MSS3Context *ctx, int quality)
Definition: mss3.c:629
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
Model2::zero_freq
unsigned zero_freq
Definition: mss3.c:41
Model
Definition: mss12.h:40
Model256::sec_size
int sec_size
Definition: mss3.c:56
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
HaarBlockCoder
Definition: mss3.c:103
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
Model2::zero_weight
unsigned zero_weight
Definition: mss3.c:41
bytestream.h
model256_update
static void model256_update(Model256 *m, int val)
Definition: mss3.c:216
Model2::till_rescale
int till_rescale
Definition: mss3.c:40
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
Model::freqs
int freqs[16]
Definition: mss3.c:46
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
decode_fill_block
static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc, uint8_t *dst, ptrdiff_t stride, int block_size)
Definition: mss3.c:458
ImageBlockCoder::vec_size_model
Model vec_size_model
Definition: mss3.c:88
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
rac_get_bits
static int rac_get_bits(RangeCoder *c, int nbits)
Definition: mss3.c:326
RangeCoder
Definition: mss3.c:61
ImageBlockCoder
Definition: mss3.c:86
DCT_BLOCK
@ DCT_BLOCK
Definition: mss3.c:71
Model256::weights
int weights[256]
Definition: mss3.c:53
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
MSS3Context::image_coder
ImageBlockCoder image_coder[3]
Definition: mss3.c:117
model_update
static void model_update(Model *m, int val)
Definition: mss3.c:162
model_init
static av_cold void model_init(Model *m, int num_syms)
Definition: mss3.c:208
BlockTypeContext::bt_model
Model bt_model[5]
Definition: mss3.c:78
rac_init
static void rac_init(RangeCoder *c, const uint8_t *src, int size)
Definition: mss3.c:277