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