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