git.sesse.net Git - ffmpeg/blob - 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 };