FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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;
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 prob, prob2, helper, val;
397  int start, end;
398  int ssym;
399 
400  prob2 = c->range;
401  c->range >>= MODEL_SCALE;
402 
403  helper = c->low / c->range;
404  ssym = helper >> MODEL256_SEC_SCALE;
405  val = m->secondary[ssym];
406 
407  end = start = m->secondary[ssym + 1] + 1;
408  while (end > val + 1) {
409  ssym = (end + val) >> 1;
410  if (m->freqs[ssym] <= helper) {
411  end = start;
412  val = ssym;
413  } else {
414  end = (end + val) >> 1;
415  start = ssym;
416  }
417  }
418  prob = m->freqs[val] * c->range;
419  if (val != 255)
420  prob2 = m->freqs[val + 1] * c->range;
421 
422  c->low -= prob;
423  c->range = prob2 - prob;
424  if (c->range < RAC_BOTTOM)
425  rac_normalise(c);
426 
427  model256_update(m, val);
428 
429  return val;
430 }
431 
433 {
434  bt->last_type = rac_get_model_sym(c, &bt->bt_model[bt->last_type]);
435 
436  return bt->last_type;
437 }
438 
440 {
441  int val, sign;
442 
443  val = rac_get_model_sym(c, m);
444  if (val) {
445  sign = rac_get_bit(c);
446  if (val > 1) {
447  val--;
448  val = (1 << val) + rac_get_bits(c, val);
449  }
450  if (!sign)
451  val = -val;
452  }
453 
454  return val;
455 }
456 
458  uint8_t *dst, int stride, int block_size)
459 {
460  int i;
461 
462  fc->fill_val += decode_coeff(c, &fc->coef_model);
463 
464  for (i = 0; i < block_size; i++, dst += stride)
465  memset(dst, fc->fill_val, block_size);
466 }
467 
469  uint8_t *dst, int stride, int block_size)
470 {
471  int i, j;
472  int vec_size;
473  int vec[4];
474  int prev_line[16];
475  int A, B, C;
476 
477  vec_size = rac_get_model_sym(c, &ic->vec_size_model) + 2;
478  for (i = 0; i < vec_size; i++)
479  vec[i] = rac_get_model256_sym(c, &ic->vec_entry_model);
480  for (; i < 4; i++)
481  vec[i] = 0;
482  memset(prev_line, 0, sizeof(prev_line));
483 
484  for (j = 0; j < block_size; j++) {
485  A = 0;
486  B = 0;
487  for (i = 0; i < block_size; i++) {
488  C = B;
489  B = prev_line[i];
490  A = rac_get_model_sym(c, &ic->vq_model[A + B * 5 + C * 25]);
491 
492  prev_line[i] = A;
493  if (A < 4)
494  dst[i] = vec[A];
495  else
496  dst[i] = rac_get_model256_sym(c, &ic->esc_model);
497  }
498  dst += stride;
499  }
500 }
501 
502 static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,
503  int bx, int by)
504 {
505  int skip, val, sign, pos = 1, zz_pos, dc;
506  int blk_pos = bx + by * bc->prev_dc_stride;
507 
508  memset(block, 0, sizeof(*block) * 64);
509 
510  dc = decode_coeff(c, &bc->dc_model);
511  if (by) {
512  if (bx) {
513  int l, tl, t;
514 
515  l = bc->prev_dc[blk_pos - 1];
516  tl = bc->prev_dc[blk_pos - 1 - bc->prev_dc_stride];
517  t = bc->prev_dc[blk_pos - bc->prev_dc_stride];
518 
519  if (FFABS(t - tl) <= FFABS(l - tl))
520  dc += l;
521  else
522  dc += t;
523  } else {
524  dc += bc->prev_dc[blk_pos - bc->prev_dc_stride];
525  }
526  } else if (bx) {
527  dc += bc->prev_dc[bx - 1];
528  }
529  bc->prev_dc[blk_pos] = dc;
530  block[0] = dc * bc->qmat[0];
531 
532  while (pos < 64) {
533  val = rac_get_model256_sym(c, &bc->ac_model);
534  if (!val)
535  return 0;
536  if (val == 0xF0) {
537  pos += 16;
538  continue;
539  }
540  skip = val >> 4;
541  val = val & 0xF;
542  if (!val)
543  return -1;
544  pos += skip;
545  if (pos >= 64)
546  return -1;
547 
548  sign = rac_get_model2_sym(c, &bc->sign_model);
549  if (val > 1) {
550  val--;
551  val = (1 << val) + rac_get_bits(c, val);
552  }
553  if (!sign)
554  val = -val;
555 
556  zz_pos = ff_zigzag_direct[pos];
557  block[zz_pos] = val * bc->qmat[zz_pos];
558  pos++;
559  }
560 
561  return pos == 64 ? 0 : -1;
562 }
563 
565  uint8_t *dst, int stride, int block_size,
566  int *block, int mb_x, int mb_y)
567 {
568  int i, j;
569  int bx, by;
570  int nblocks = block_size >> 3;
571 
572  bx = mb_x * nblocks;
573  by = mb_y * nblocks;
574 
575  for (j = 0; j < nblocks; j++) {
576  for (i = 0; i < nblocks; i++) {
577  if (decode_dct(c, bc, block, bx + i, by + j)) {
578  c->got_error = 1;
579  return;
580  }
581  ff_mss34_dct_put(dst + i * 8, stride, block);
582  }
583  dst += 8 * stride;
584  }
585 }
586 
588  uint8_t *dst, int stride, int block_size,
589  int *block)
590 {
591  const int hsize = block_size >> 1;
592  int A, B, C, D, t1, t2, t3, t4;
593  int i, j;
594 
595  for (j = 0; j < block_size; j++) {
596  for (i = 0; i < block_size; i++) {
597  if (i < hsize && j < hsize)
598  block[i] = rac_get_model256_sym(c, &hc->coef_model);
599  else
600  block[i] = decode_coeff(c, &hc->coef_hi_model);
601  block[i] *= hc->scale;
602  }
603  block += block_size;
604  }
605  block -= block_size * block_size;
606 
607  for (j = 0; j < hsize; j++) {
608  for (i = 0; i < hsize; i++) {
609  A = block[i];
610  B = block[i + hsize];
611  C = block[i + hsize * block_size];
612  D = block[i + hsize * block_size + hsize];
613 
614  t1 = A - B;
615  t2 = C - D;
616  t3 = A + B;
617  t4 = C + D;
618  dst[i * 2] = av_clip_uint8(t1 - t2);
619  dst[i * 2 + stride] = av_clip_uint8(t1 + t2);
620  dst[i * 2 + 1] = av_clip_uint8(t3 - t4);
621  dst[i * 2 + 1 + stride] = av_clip_uint8(t3 + t4);
622  }
623  block += block_size;
624  dst += stride * 2;
625  }
626 }
627 
628 static void reset_coders(MSS3Context *ctx, int quality)
629 {
630  int i, j;
631 
632  for (i = 0; i < 3; i++) {
633  ctx->btype[i].last_type = SKIP_BLOCK;
634  for (j = 0; j < 5; j++)
635  model_reset(&ctx->btype[i].bt_model[j]);
636  ctx->fill_coder[i].fill_val = 0;
641  for (j = 0; j < 125; j++)
642  model_reset(&ctx->image_coder[i].vq_model[j]);
643  if (ctx->dct_coder[i].quality != quality) {
644  ctx->dct_coder[i].quality = quality;
645  ff_mss34_gen_quant_mat(ctx->dct_coder[i].qmat, quality, !i);
646  }
647  memset(ctx->dct_coder[i].prev_dc, 0,
648  sizeof(*ctx->dct_coder[i].prev_dc) *
649  ctx->dct_coder[i].prev_dc_stride *
650  ctx->dct_coder[i].prev_dc_height);
651  model_reset(&ctx->dct_coder[i].dc_model);
654  if (ctx->haar_coder[i].quality != quality) {
655  ctx->haar_coder[i].quality = quality;
656  ctx->haar_coder[i].scale = 17 - 7 * quality / 50;
657  }
660  }
661 }
662 
663 static av_cold void init_coders(MSS3Context *ctx)
664 {
665  int i, j;
666 
667  for (i = 0; i < 3; i++) {
668  for (j = 0; j < 5; j++)
669  model_init(&ctx->btype[i].bt_model[j], 5);
670  model_init(&ctx->fill_coder[i].coef_model, 12);
674  for (j = 0; j < 125; j++)
675  model_init(&ctx->image_coder[i].vq_model[j], 5);
676  model_init(&ctx->dct_coder[i].dc_model, 12);
677  model256_init(&ctx->dct_coder[i].ac_model);
678  model_init(&ctx->haar_coder[i].coef_hi_model, 12);
680  }
681 }
682 
683 static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
684  AVPacket *avpkt)
685 {
686  const uint8_t *buf = avpkt->data;
687  int buf_size = avpkt->size;
688  MSS3Context *c = avctx->priv_data;
689  RangeCoder *acoder = &c->coder;
690  GetByteContext gb;
691  uint8_t *dst[3];
692  int dec_width, dec_height, dec_x, dec_y, quality, keyframe;
693  int x, y, i, mb_width, mb_height, blk_size, btype;
694  int ret;
695 
696  if (buf_size < HEADER_SIZE) {
697  av_log(avctx, AV_LOG_ERROR,
698  "Frame should have at least %d bytes, got %d instead\n",
699  HEADER_SIZE, buf_size);
700  return AVERROR_INVALIDDATA;
701  }
702 
703  bytestream2_init(&gb, buf, buf_size);
704  keyframe = bytestream2_get_be32(&gb);
705  if (keyframe & ~0x301) {
706  av_log(avctx, AV_LOG_ERROR, "Invalid frame type %X\n", keyframe);
707  return AVERROR_INVALIDDATA;
708  }
709  keyframe = !(keyframe & 1);
710  bytestream2_skip(&gb, 6);
711  dec_x = bytestream2_get_be16(&gb);
712  dec_y = bytestream2_get_be16(&gb);
713  dec_width = bytestream2_get_be16(&gb);
714  dec_height = bytestream2_get_be16(&gb);
715 
716  if (dec_x + dec_width > avctx->width ||
717  dec_y + dec_height > avctx->height ||
718  (dec_width | dec_height) & 0xF) {
719  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d +%d,%d\n",
720  dec_width, dec_height, dec_x, dec_y);
721  return AVERROR_INVALIDDATA;
722  }
723  bytestream2_skip(&gb, 4);
724  quality = bytestream2_get_byte(&gb);
725  if (quality < 1 || quality > 100) {
726  av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
727  return AVERROR_INVALIDDATA;
728  }
729  bytestream2_skip(&gb, 4);
730 
731  if (keyframe && !bytestream2_get_bytes_left(&gb)) {
732  av_log(avctx, AV_LOG_ERROR, "Keyframe without data found\n");
733  return AVERROR_INVALIDDATA;
734  }
735  if (!keyframe && c->got_error)
736  return buf_size;
737  c->got_error = 0;
738 
739  if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
740  return ret;
741  c->pic->key_frame = keyframe;
743  if (!bytestream2_get_bytes_left(&gb)) {
744  if ((ret = av_frame_ref(data, c->pic)) < 0)
745  return ret;
746  *got_frame = 1;
747 
748  return buf_size;
749  }
750 
751  reset_coders(c, quality);
752 
753  rac_init(acoder, buf + HEADER_SIZE, buf_size - HEADER_SIZE);
754 
755  mb_width = dec_width >> 4;
756  mb_height = dec_height >> 4;
757  dst[0] = c->pic->data[0] + dec_x + dec_y * c->pic->linesize[0];
758  dst[1] = c->pic->data[1] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[1];
759  dst[2] = c->pic->data[2] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[2];
760  for (y = 0; y < mb_height; y++) {
761  for (x = 0; x < mb_width; x++) {
762  for (i = 0; i < 3; i++) {
763  blk_size = 8 << !i;
764 
765  btype = decode_block_type(acoder, c->btype + i);
766  switch (btype) {
767  case FILL_BLOCK:
768  decode_fill_block(acoder, c->fill_coder + i,
769  dst[i] + x * blk_size,
770  c->pic->linesize[i], blk_size);
771  break;
772  case IMAGE_BLOCK:
773  decode_image_block(acoder, c->image_coder + i,
774  dst[i] + x * blk_size,
775  c->pic->linesize[i], blk_size);
776  break;
777  case DCT_BLOCK:
778  decode_dct_block(acoder, c->dct_coder + i,
779  dst[i] + x * blk_size,
780  c->pic->linesize[i], blk_size,
781  c->dctblock, x, y);
782  break;
783  case HAAR_BLOCK:
784  decode_haar_block(acoder, c->haar_coder + i,
785  dst[i] + x * blk_size,
786  c->pic->linesize[i], blk_size,
787  c->hblock);
788  break;
789  }
790  if (c->got_error || acoder->got_error) {
791  av_log(avctx, AV_LOG_ERROR, "Error decoding block %d,%d\n",
792  x, y);
793  c->got_error = 1;
794  return AVERROR_INVALIDDATA;
795  }
796  }
797  }
798  dst[0] += c->pic->linesize[0] * 16;
799  dst[1] += c->pic->linesize[1] * 8;
800  dst[2] += c->pic->linesize[2] * 8;
801  }
802 
803  if ((ret = av_frame_ref(data, c->pic)) < 0)
804  return ret;
805 
806  *got_frame = 1;
807 
808  return buf_size;
809 }
810 
812 {
813  MSS3Context * const c = avctx->priv_data;
814  int i;
815 
816  av_frame_free(&c->pic);
817  for (i = 0; i < 3; i++)
818  av_freep(&c->dct_coder[i].prev_dc);
819 
820  return 0;
821 }
822 
824 {
825  MSS3Context * const c = avctx->priv_data;
826  int i;
827 
828  c->avctx = avctx;
829 
830  if ((avctx->width & 0xF) || (avctx->height & 0xF)) {
831  av_log(avctx, AV_LOG_ERROR,
832  "Image dimensions should be a multiple of 16.\n");
833  return AVERROR_INVALIDDATA;
834  }
835 
836  c->got_error = 0;
837  for (i = 0; i < 3; i++) {
838  int b_width = avctx->width >> (2 + !!i);
839  int b_height = avctx->height >> (2 + !!i);
840  c->dct_coder[i].prev_dc_stride = b_width;
841  c->dct_coder[i].prev_dc_height = b_height;
842  c->dct_coder[i].prev_dc = av_malloc(sizeof(*c->dct_coder[i].prev_dc) *
843  b_width * b_height);
844  if (!c->dct_coder[i].prev_dc) {
845  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
846  av_frame_free(&c->pic);
847  while (i >= 0) {
848  av_freep(&c->dct_coder[i].prev_dc);
849  i--;
850  }
851  return AVERROR(ENOMEM);
852  }
853  }
854 
855  c->pic = av_frame_alloc();
856  if (!c->pic) {
857  mss3_decode_end(avctx);
858  return AVERROR(ENOMEM);
859  }
860 
861  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
862 
863  init_coders(c);
864 
865  return 0;
866 }
867 
869  .name = "msa1",
870  .long_name = NULL_IF_CONFIG_SMALL("MS ATC Screen"),
871  .type = AVMEDIA_TYPE_VIDEO,
872  .id = AV_CODEC_ID_MSA1,
873  .priv_data_size = sizeof(MSS3Context),
875  .close = mss3_decode_end,
877  .capabilities = AV_CODEC_CAP_DR1,
878 };
const char const char void * val
Definition: avisynth_c.h:634
void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)
Generate quantisation matrix for given quality.
Definition: mss34dsp.c:48
int * prev_dc
Definition: mss3.c:93
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int scale
Definition: mss3.c:104
int sec_size
Definition: mss3.c:56
unsigned total_freq
Definition: mss3.c:42
static int decode_block_type(RangeCoder *c, BlockTypeContext *bt)
Definition: mss3.c:432
uint32_t low
Definition: mss3.c:64
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
#define MODEL256_SEC_SCALE
Definition: mss3.c:37
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc, uint8_t *dst, int stride, int block_size, int *block)
Definition: mss3.c:587
#define C
static void model2_reset(Model2 *m)
Definition: mss3.c:126
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
Model256 ac_model
Definition: mss3.c:100
void ff_mss34_dct_put(uint8_t *dst, int stride, int *block)
Transform and output DCT block.
Definition: mss34dsp.c:90
Definition: mss12.h:40
ImageBlockCoder image_coder[3]
Definition: mss3.c:117
int size
Definition: avcodec.h:1434
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1732
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int16_t weights[MODEL_MAX_SYMS+1]
Definition: mss12.h:42
int till_rescale
Definition: mss3.c:57
uint32_t range
Definition: mss3.c:64
static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mss3.c:683
AVCodec.
Definition: avcodec.h:3482
#define MODEL2_SCALE
Definition: mss3.c:35
Definition: mss3.c:71
AVFrame * pic
Definition: mss3.c:111
AVCodecContext * avctx
Definition: mss3.c:110
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc, uint8_t *dst, int stride, int block_size)
Definition: mss3.c:457
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
static void rac_normalise(RangeCoder *c)
Definition: mss3.c:290
#define HEADER_SIZE
Definition: mss3.c:33
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:366
static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block, int bx, int by)
Definition: mss3.c:502
Model256 esc_model
Definition: mss3.c:87
int quality
Definition: mss3.c:104
static void reset_coders(MSS3Context *ctx, int quality)
Definition: mss3.c:628
int weights[256]
Definition: mss3.c:53
static void rac_init(RangeCoder *c, const uint8_t *src, int size)
Definition: mss3.c:277
uint8_t * data
Definition: avcodec.h:1433
static void model256_update(Model256 *m, int val)
Definition: mss3.c:216
uint16_t qmat[64]
Definition: mss3.c:97
int got_error
Definition: mss3.c:65
ptrdiff_t size
Definition: opengl_enc.c:101
#define A(x)
Definition: vp56_arith.h:28
#define av_log(a,...)
Model coef_model
Definition: mss3.c:83
unsigned m
Definition: audioconvert.c:187
static av_cold void model_init(Model *m, int num_syms)
Definition: mss3.c:208
Definition: mss3.c:39
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
int freqs[256]
Definition: mss3.c:53
int till_rescale
Definition: mss3.c:40
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
Model vq_model[125]
Definition: mss3.c:89
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
int tot_weight
Definition: mss3.c:54
int quality
Definition: mss3.c:96
DCTBlockCoder dct_coder[3]
Definition: mss3.c:118
#define t1
Definition: regdef.h:29
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3489
#define t3
Definition: regdef.h:31
Libavcodec external API header.
static av_cold void model256_init(Model256 *m)
Definition: mss3.c:269
HaarBlockCoder haar_coder[3]
Definition: mss3.c:119
int upd_val
Definition: mss3.c:40
int secondary[68]
Definition: mss3.c:55
static const uint16_t fc[]
Definition: dcaenc.h:41
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: utils.c:1097
unsigned zero_weight
Definition: mss3.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
unsigned total_weight
Definition: mss3.c:42
#define FFMIN(a, b)
Definition: common.h:92
float y
static av_cold int mss3_decode_init(AVCodecContext *avctx)
Definition: mss3.c:823
const uint8_t * src_end
Definition: mss3.c:62
int width
picture width / height.
Definition: avcodec.h:1691
int upd_val
Definition: mss3.c:57
static int rac_get_bits(RangeCoder *c, int nbits)
Definition: mss3.c:326
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:68
float u
int prev_dc_height
Definition: mss3.c:95
unsigned zero_freq
Definition: mss3.c:41
int hblock[16 *16]
Definition: mss3.c:122
int upd_val
Definition: mss3.c:49
const uint8_t * src
Definition: mss3.c:62
static void model_reset(Model *m)
Definition: mss3.c:192
static int rac_get_model256_sym(RangeCoder *c, Model256 *m)
Definition: mss3.c:394
Definition: mss3.c:52
AVS_Value src
Definition: avisynth_c.h:482
static int rac_get_model_sym(RangeCoder *c, Model *m)
Definition: mss3.c:361
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
main external API structure.
Definition: avcodec.h:1512
int num_syms
Definition: mss12.h:44
static void model_update(Model *m, int val)
Definition: mss3.c:162
static av_cold void init_coders(MSS3Context *ctx)
Definition: mss3.c:663
void * buf
Definition: avisynth_c.h:553
#define MODEL_SCALE
Definition: mss3.c:36
int tot_weight
Definition: mss3.c:48
static int rac_get_bit(RangeCoder *c)
Definition: mss3.c:310
int dctblock[64]
Definition: mss3.c:121
static void model256_reset(Model256 *m)
Definition: mss3.c:253
static void decode_image_block(RangeCoder *c, ImageBlockCoder *ic, uint8_t *dst, int stride, int block_size)
Definition: mss3.c:468
Model2 sign_model
Definition: mss3.c:99
int got_error
Definition: mss3.c:113
int freqs[16]
Definition: mss3.c:46
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
Model256 coef_model
Definition: mss3.c:105
FillBlockCoder fill_coder[3]
Definition: mss3.c:116
BlockType
Definition: mss3.c:68
static av_cold int mss3_decode_end(AVCodecContext *avctx)
Definition: mss3.c:811
#define RAC_BOTTOM
Definition: mss3.c:60
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
Model256 vec_entry_model
Definition: mss3.c:87
RangeCoder coder
Definition: mss3.c:114
int max_upd_val
Definition: mss3.c:57
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:521
static void model2_update(Model2 *m, int bit)
Definition: mss3.c:136
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:67
int till_rescale
Definition: mss3.c:49
common internal api header.
D(D(float, sse)
Definition: rematrix_init.c:28
static int decode_coeff(RangeCoder *c, Model *m)
Definition: mss3.c:439
static double c[64]
int max_upd_val
Definition: mss3.c:49
AVCodec ff_msa1_decoder
Definition: mss3.c:868
void * priv_data
Definition: avcodec.h:1554
#define t4
Definition: regdef.h:32
Definition: vf_geq.c:46
int fill_val
Definition: mss3.c:82
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
Model bt_model[5]
Definition: mss3.c:78
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:553
BlockTypeContext btype[3]
Definition: mss3.c:115
int last_type
Definition: mss3.c:77
#define stride
int prev_dc_stride
Definition: mss3.c:94
static int rac_get_model2_sym(RangeCoder *c, Model2 *m)
Definition: mss3.c:340
This structure stores compressed data.
Definition: avcodec.h:1410
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:857
static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc, uint8_t *dst, int stride, int block_size, int *block, int mb_x, int mb_y)
Definition: mss3.c:564
#define t2
Definition: regdef.h:30
Model dc_model
Definition: mss3.c:98
Predicted.
Definition: avutil.h:267
Model vec_size_model
Definition: mss3.c:88
Model coef_hi_model
Definition: mss3.c:106
static int16_t block[64]
Definition: dct-test.c:110