FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups 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->range >= RAC_BOTTOM)
302  return;
303  }
304 }
305 
307 {
308  int bit;
309 
310  c->range >>= 1;
311 
312  bit = (c->range <= c->low);
313  if (bit)
314  c->low -= c->range;
315 
316  if (c->range < RAC_BOTTOM)
317  rac_normalise(c);
318 
319  return bit;
320 }
321 
322 static int rac_get_bits(RangeCoder *c, int nbits)
323 {
324  int val;
325 
326  c->range >>= nbits;
327  val = c->low / c->range;
328  c->low -= c->range * val;
329 
330  if (c->range < RAC_BOTTOM)
331  rac_normalise(c);
332 
333  return val;
334 }
335 
337 {
338  int bit, helper;
339 
340  helper = m->zero_freq * (c->range >> MODEL2_SCALE);
341  bit = (c->low >= helper);
342  if (bit) {
343  c->low -= helper;
344  c->range -= helper;
345  } else {
346  c->range = helper;
347  }
348 
349  if (c->range < RAC_BOTTOM)
350  rac_normalise(c);
351 
352  model2_update(m, bit);
353 
354  return bit;
355 }
356 
358 {
359  int prob, prob2, helper, val;
360  int end, end2;
361 
362  prob = 0;
363  prob2 = c->range;
364  c->range >>= MODEL_SCALE;
365  val = 0;
366  end = m->num_syms >> 1;
367  end2 = m->num_syms;
368  do {
369  helper = m->freqs[end] * c->range;
370  if (helper <= c->low) {
371  val = end;
372  prob = helper;
373  } else {
374  end2 = end;
375  prob2 = helper;
376  }
377  end = (end2 + val) >> 1;
378  } while (end != val);
379  c->low -= prob;
380  c->range = prob2 - prob;
381  if (c->range < RAC_BOTTOM)
382  rac_normalise(c);
383 
384  model_update(m, val);
385 
386  return val;
387 }
388 
390 {
391  int prob, prob2, helper, val;
392  int start, end;
393  int ssym;
394 
395  prob2 = c->range;
396  c->range >>= MODEL_SCALE;
397 
398  helper = c->low / c->range;
399  ssym = helper >> MODEL256_SEC_SCALE;
400  val = m->secondary[ssym];
401 
402  end = start = m->secondary[ssym + 1] + 1;
403  while (end > val + 1) {
404  ssym = (end + val) >> 1;
405  if (m->freqs[ssym] <= helper) {
406  end = start;
407  val = ssym;
408  } else {
409  end = (end + val) >> 1;
410  start = ssym;
411  }
412  }
413  prob = m->freqs[val] * c->range;
414  if (val != 255)
415  prob2 = m->freqs[val + 1] * c->range;
416 
417  c->low -= prob;
418  c->range = prob2 - prob;
419  if (c->range < RAC_BOTTOM)
420  rac_normalise(c);
421 
422  model256_update(m, val);
423 
424  return val;
425 }
426 
428 {
429  bt->last_type = rac_get_model_sym(c, &bt->bt_model[bt->last_type]);
430 
431  return bt->last_type;
432 }
433 
435 {
436  int val, sign;
437 
438  val = rac_get_model_sym(c, m);
439  if (val) {
440  sign = rac_get_bit(c);
441  if (val > 1) {
442  val--;
443  val = (1 << val) + rac_get_bits(c, val);
444  }
445  if (!sign)
446  val = -val;
447  }
448 
449  return val;
450 }
451 
453  uint8_t *dst, int stride, int block_size)
454 {
455  int i;
456 
457  fc->fill_val += decode_coeff(c, &fc->coef_model);
458 
459  for (i = 0; i < block_size; i++, dst += stride)
460  memset(dst, fc->fill_val, block_size);
461 }
462 
464  uint8_t *dst, int stride, int block_size)
465 {
466  int i, j;
467  int vec_size;
468  int vec[4];
469  int prev_line[16];
470  int A, B, C;
471 
472  vec_size = rac_get_model_sym(c, &ic->vec_size_model) + 2;
473  for (i = 0; i < vec_size; i++)
474  vec[i] = rac_get_model256_sym(c, &ic->vec_entry_model);
475  for (; i < 4; i++)
476  vec[i] = 0;
477  memset(prev_line, 0, sizeof(prev_line));
478 
479  for (j = 0; j < block_size; j++) {
480  A = 0;
481  B = 0;
482  for (i = 0; i < block_size; i++) {
483  C = B;
484  B = prev_line[i];
485  A = rac_get_model_sym(c, &ic->vq_model[A + B * 5 + C * 25]);
486 
487  prev_line[i] = A;
488  if (A < 4)
489  dst[i] = vec[A];
490  else
491  dst[i] = rac_get_model256_sym(c, &ic->esc_model);
492  }
493  dst += stride;
494  }
495 }
496 
497 static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,
498  int bx, int by)
499 {
500  int skip, val, sign, pos = 1, zz_pos, dc;
501  int blk_pos = bx + by * bc->prev_dc_stride;
502 
503  memset(block, 0, sizeof(*block) * 64);
504 
505  dc = decode_coeff(c, &bc->dc_model);
506  if (by) {
507  if (bx) {
508  int l, tl, t;
509 
510  l = bc->prev_dc[blk_pos - 1];
511  tl = bc->prev_dc[blk_pos - 1 - bc->prev_dc_stride];
512  t = bc->prev_dc[blk_pos - bc->prev_dc_stride];
513 
514  if (FFABS(t - tl) <= FFABS(l - tl))
515  dc += l;
516  else
517  dc += t;
518  } else {
519  dc += bc->prev_dc[blk_pos - bc->prev_dc_stride];
520  }
521  } else if (bx) {
522  dc += bc->prev_dc[bx - 1];
523  }
524  bc->prev_dc[blk_pos] = dc;
525  block[0] = dc * bc->qmat[0];
526 
527  while (pos < 64) {
528  val = rac_get_model256_sym(c, &bc->ac_model);
529  if (!val)
530  return 0;
531  if (val == 0xF0) {
532  pos += 16;
533  continue;
534  }
535  skip = val >> 4;
536  val = val & 0xF;
537  if (!val)
538  return -1;
539  pos += skip;
540  if (pos >= 64)
541  return -1;
542 
543  sign = rac_get_model2_sym(c, &bc->sign_model);
544  if (val > 1) {
545  val--;
546  val = (1 << val) + rac_get_bits(c, val);
547  }
548  if (!sign)
549  val = -val;
550 
551  zz_pos = ff_zigzag_direct[pos];
552  block[zz_pos] = val * bc->qmat[zz_pos];
553  pos++;
554  }
555 
556  return pos == 64 ? 0 : -1;
557 }
558 
560  uint8_t *dst, int stride, int block_size,
561  int *block, int mb_x, int mb_y)
562 {
563  int i, j;
564  int bx, by;
565  int nblocks = block_size >> 3;
566 
567  bx = mb_x * nblocks;
568  by = mb_y * nblocks;
569 
570  for (j = 0; j < nblocks; j++) {
571  for (i = 0; i < nblocks; i++) {
572  if (decode_dct(c, bc, block, bx + i, by + j)) {
573  c->got_error = 1;
574  return;
575  }
576  ff_mss34_dct_put(dst + i * 8, stride, block);
577  }
578  dst += 8 * stride;
579  }
580 }
581 
583  uint8_t *dst, int stride, int block_size,
584  int *block)
585 {
586  const int hsize = block_size >> 1;
587  int A, B, C, D, t1, t2, t3, t4;
588  int i, j;
589 
590  for (j = 0; j < block_size; j++) {
591  for (i = 0; i < block_size; i++) {
592  if (i < hsize && j < hsize)
593  block[i] = rac_get_model256_sym(c, &hc->coef_model);
594  else
595  block[i] = decode_coeff(c, &hc->coef_hi_model);
596  block[i] *= hc->scale;
597  }
598  block += block_size;
599  }
600  block -= block_size * block_size;
601 
602  for (j = 0; j < hsize; j++) {
603  for (i = 0; i < hsize; i++) {
604  A = block[i];
605  B = block[i + hsize];
606  C = block[i + hsize * block_size];
607  D = block[i + hsize * block_size + hsize];
608 
609  t1 = A - B;
610  t2 = C - D;
611  t3 = A + B;
612  t4 = C + D;
613  dst[i * 2] = av_clip_uint8(t1 - t2);
614  dst[i * 2 + stride] = av_clip_uint8(t1 + t2);
615  dst[i * 2 + 1] = av_clip_uint8(t3 - t4);
616  dst[i * 2 + 1 + stride] = av_clip_uint8(t3 + t4);
617  }
618  block += block_size;
619  dst += stride * 2;
620  }
621 }
622 
623 static void reset_coders(MSS3Context *ctx, int quality)
624 {
625  int i, j;
626 
627  for (i = 0; i < 3; i++) {
628  ctx->btype[i].last_type = SKIP_BLOCK;
629  for (j = 0; j < 5; j++)
630  model_reset(&ctx->btype[i].bt_model[j]);
631  ctx->fill_coder[i].fill_val = 0;
636  for (j = 0; j < 125; j++)
637  model_reset(&ctx->image_coder[i].vq_model[j]);
638  if (ctx->dct_coder[i].quality != quality) {
639  ctx->dct_coder[i].quality = quality;
640  ff_mss34_gen_quant_mat(ctx->dct_coder[i].qmat, quality, !i);
641  }
642  memset(ctx->dct_coder[i].prev_dc, 0,
643  sizeof(*ctx->dct_coder[i].prev_dc) *
644  ctx->dct_coder[i].prev_dc_stride *
645  ctx->dct_coder[i].prev_dc_height);
646  model_reset(&ctx->dct_coder[i].dc_model);
649  if (ctx->haar_coder[i].quality != quality) {
650  ctx->haar_coder[i].quality = quality;
651  ctx->haar_coder[i].scale = 17 - 7 * quality / 50;
652  }
655  }
656 }
657 
659 {
660  int i, j;
661 
662  for (i = 0; i < 3; i++) {
663  for (j = 0; j < 5; j++)
664  model_init(&ctx->btype[i].bt_model[j], 5);
665  model_init(&ctx->fill_coder[i].coef_model, 12);
669  for (j = 0; j < 125; j++)
670  model_init(&ctx->image_coder[i].vq_model[j], 5);
671  model_init(&ctx->dct_coder[i].dc_model, 12);
672  model256_init(&ctx->dct_coder[i].ac_model);
673  model_init(&ctx->haar_coder[i].coef_hi_model, 12);
675  }
676 }
677 
678 static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
679  AVPacket *avpkt)
680 {
681  const uint8_t *buf = avpkt->data;
682  int buf_size = avpkt->size;
683  MSS3Context *c = avctx->priv_data;
684  RangeCoder *acoder = &c->coder;
685  GetByteContext gb;
686  uint8_t *dst[3];
687  int dec_width, dec_height, dec_x, dec_y, quality, keyframe;
688  int x, y, i, mb_width, mb_height, blk_size, btype;
689  int ret;
690 
691  if (buf_size < HEADER_SIZE) {
692  av_log(avctx, AV_LOG_ERROR,
693  "Frame should have at least %d bytes, got %d instead\n",
694  HEADER_SIZE, buf_size);
695  return AVERROR_INVALIDDATA;
696  }
697 
698  bytestream2_init(&gb, buf, buf_size);
699  keyframe = bytestream2_get_be32(&gb);
700  if (keyframe & ~0x301) {
701  av_log(avctx, AV_LOG_ERROR, "Invalid frame type %X\n", keyframe);
702  return AVERROR_INVALIDDATA;
703  }
704  keyframe = !(keyframe & 1);
705  bytestream2_skip(&gb, 6);
706  dec_x = bytestream2_get_be16(&gb);
707  dec_y = bytestream2_get_be16(&gb);
708  dec_width = bytestream2_get_be16(&gb);
709  dec_height = bytestream2_get_be16(&gb);
710 
711  if (dec_x + dec_width > avctx->width ||
712  dec_y + dec_height > avctx->height ||
713  (dec_width | dec_height) & 0xF) {
714  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d +%d,%d\n",
715  dec_width, dec_height, dec_x, dec_y);
716  return AVERROR_INVALIDDATA;
717  }
718  bytestream2_skip(&gb, 4);
719  quality = bytestream2_get_byte(&gb);
720  if (quality < 1 || quality > 100) {
721  av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
722  return AVERROR_INVALIDDATA;
723  }
724  bytestream2_skip(&gb, 4);
725 
726  if (keyframe && !bytestream2_get_bytes_left(&gb)) {
727  av_log(avctx, AV_LOG_ERROR, "Keyframe without data found\n");
728  return AVERROR_INVALIDDATA;
729  }
730  if (!keyframe && c->got_error)
731  return buf_size;
732  c->got_error = 0;
733 
734  if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
735  return ret;
736  c->pic->key_frame = keyframe;
738  if (!bytestream2_get_bytes_left(&gb)) {
739  if ((ret = av_frame_ref(data, c->pic)) < 0)
740  return ret;
741  *got_frame = 1;
742 
743  return buf_size;
744  }
745 
746  reset_coders(c, quality);
747 
748  rac_init(acoder, buf + HEADER_SIZE, buf_size - HEADER_SIZE);
749 
750  mb_width = dec_width >> 4;
751  mb_height = dec_height >> 4;
752  dst[0] = c->pic->data[0] + dec_x + dec_y * c->pic->linesize[0];
753  dst[1] = c->pic->data[1] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[1];
754  dst[2] = c->pic->data[2] + dec_x / 2 + (dec_y / 2) * c->pic->linesize[2];
755  for (y = 0; y < mb_height; y++) {
756  for (x = 0; x < mb_width; x++) {
757  for (i = 0; i < 3; i++) {
758  blk_size = 8 << !i;
759 
760  btype = decode_block_type(acoder, c->btype + i);
761  switch (btype) {
762  case FILL_BLOCK:
763  decode_fill_block(acoder, c->fill_coder + i,
764  dst[i] + x * blk_size,
765  c->pic->linesize[i], blk_size);
766  break;
767  case IMAGE_BLOCK:
768  decode_image_block(acoder, c->image_coder + i,
769  dst[i] + x * blk_size,
770  c->pic->linesize[i], blk_size);
771  break;
772  case DCT_BLOCK:
773  decode_dct_block(acoder, c->dct_coder + i,
774  dst[i] + x * blk_size,
775  c->pic->linesize[i], blk_size,
776  c->dctblock, x, y);
777  break;
778  case HAAR_BLOCK:
779  decode_haar_block(acoder, c->haar_coder + i,
780  dst[i] + x * blk_size,
781  c->pic->linesize[i], blk_size,
782  c->hblock);
783  break;
784  }
785  if (c->got_error || acoder->got_error) {
786  av_log(avctx, AV_LOG_ERROR, "Error decoding block %d,%d\n",
787  x, y);
788  c->got_error = 1;
789  return AVERROR_INVALIDDATA;
790  }
791  }
792  }
793  dst[0] += c->pic->linesize[0] * 16;
794  dst[1] += c->pic->linesize[1] * 8;
795  dst[2] += c->pic->linesize[2] * 8;
796  }
797 
798  if ((ret = av_frame_ref(data, c->pic)) < 0)
799  return ret;
800 
801  *got_frame = 1;
802 
803  return buf_size;
804 }
805 
807 {
808  MSS3Context * const c = avctx->priv_data;
809  int i;
810 
811  av_frame_free(&c->pic);
812  for (i = 0; i < 3; i++)
813  av_freep(&c->dct_coder[i].prev_dc);
814 
815  return 0;
816 }
817 
819 {
820  MSS3Context * const c = avctx->priv_data;
821  int i;
822 
823  c->avctx = avctx;
824 
825  if ((avctx->width & 0xF) || (avctx->height & 0xF)) {
826  av_log(avctx, AV_LOG_ERROR,
827  "Image dimensions should be a multiple of 16.\n");
828  return AVERROR_INVALIDDATA;
829  }
830 
831  c->got_error = 0;
832  for (i = 0; i < 3; i++) {
833  int b_width = avctx->width >> (2 + !!i);
834  int b_height = avctx->height >> (2 + !!i);
835  c->dct_coder[i].prev_dc_stride = b_width;
836  c->dct_coder[i].prev_dc_height = b_height;
837  c->dct_coder[i].prev_dc = av_malloc(sizeof(*c->dct_coder[i].prev_dc) *
838  b_width * b_height);
839  if (!c->dct_coder[i].prev_dc) {
840  av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
841  av_frame_free(&c->pic);
842  while (i >= 0) {
843  av_freep(&c->dct_coder[i].prev_dc);
844  i--;
845  }
846  return AVERROR(ENOMEM);
847  }
848  }
849 
850  c->pic = av_frame_alloc();
851  if (!c->pic) {
852  mss3_decode_end(avctx);
853  return AVERROR(ENOMEM);
854  }
855 
856  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
857 
858  init_coders(c);
859 
860  return 0;
861 }
862 
864  .name = "msa1",
865  .long_name = NULL_IF_CONFIG_SMALL("MS ATC Screen"),
866  .type = AVMEDIA_TYPE_VIDEO,
867  .id = AV_CODEC_ID_MSA1,
868  .priv_data_size = sizeof(MSS3Context),
870  .close = mss3_decode_end,
872  .capabilities = AV_CODEC_CAP_DR1,
873 };
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:427
uint32_t low
Definition: mss3.c:64
This structure describes decoded (raw) audio or video data.
Definition: frame.h:180
#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:582
#define C
static void model2_reset(Model2 *m)
Definition: mss3.c:126
AVFormatContext * ctx
Definition: movenc-test.c:48
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:1578
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1870
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:678
AVCodec.
Definition: avcodec.h:3535
#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:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc, uint8_t *dst, int stride, int block_size)
Definition: mss3.c:452
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:374
static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block, int bx, int by)
Definition: mss3.c:497
Model256 esc_model
Definition: mss3.c:87
int quality
Definition: mss3.c:104
static void reset_coders(MSS3Context *ctx, int quality)
Definition: mss3.c:623
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:1577
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:153
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:176
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:3542
#define t3
Definition: regdef.h:31
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:977
unsigned zero_weight
Definition: mss3.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:254
unsigned total_weight
Definition: mss3.c:42
#define FFMIN(a, b)
Definition: common.h:96
static av_cold int mss3_decode_init(AVCodecContext *avctx)
Definition: mss3.c:818
const uint8_t * src_end
Definition: mss3.c:62
int width
picture width / height.
Definition: avcodec.h:1829
int upd_val
Definition: mss3.c:57
static int rac_get_bits(RangeCoder *c, int nbits)
Definition: mss3.c:322
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int prev_dc_height
Definition: mss3.c:95
unsigned zero_freq
Definition: mss3.c:41
#define src
Definition: vp9dsp.c:530
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:389
Definition: mss3.c:52
Libavcodec external API header.
static int rac_get_model_sym(RangeCoder *c, Model *m)
Definition: mss3.c:357
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:211
main external API structure.
Definition: avcodec.h:1642
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:658
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:306
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:463
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
#define u(width,...)
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:806
#define RAC_BOTTOM
Definition: mss3.c:60
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:194
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:722
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:62
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:434
static double c[64]
int max_upd_val
Definition: mss3.c:49
AVCodec ff_msa1_decoder
Definition: mss3.c:863
Definition: vf_geq.c:46
void * priv_data
Definition: avcodec.h:1684
#define t4
Definition: regdef.h:32
int fill_val
Definition: mss3.c:82
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:249
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:336
This structure stores compressed data.
Definition: avcodec.h:1554
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:953
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:559
#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:112