2
* Microsoft Screen 3 (aka Microsoft ATC Screen) decoder
3
* Copyright (c) 2012 Konstantin Shishkov
5
* This file is part of Libav.
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.
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.
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
24
* Microsoft Screen 3 (aka Microsoft ATC Screen) decoder
28
#include "bytestream.h"
32
#define HEADER_SIZE 27
34
#define MODEL2_SCALE 13
35
#define MODEL_SCALE 15
36
#define MODEL256_SEC_SCALE 9
38
typedef struct Model2 {
39
int upd_val, till_rescale;
40
unsigned zero_freq, zero_weight;
41
unsigned total_freq, total_weight;
44
typedef struct Model {
45
int weights[16], freqs[16];
48
int upd_val, max_upd_val, till_rescale;
51
typedef struct Model256 {
52
int weights[256], freqs[256];
56
int upd_val, max_upd_val, till_rescale;
59
#define RAC_BOTTOM 0x01000000
60
typedef struct RangeCoder {
61
const uint8_t *src, *src_end;
75
typedef struct BlockTypeContext {
80
typedef struct FillBlockCoder {
85
typedef struct ImageBlockCoder {
86
Model256 esc_model, vec_entry_model;
91
typedef struct DCTBlockCoder {
102
typedef struct HaarBlockCoder {
108
typedef struct MSS3Context {
109
AVCodecContext *avctx;
114
BlockTypeContext btype[3];
115
FillBlockCoder fill_coder[3];
116
ImageBlockCoder image_coder[3];
117
DCTBlockCoder dct_coder[3];
118
HaarBlockCoder haar_coder[3];
125
static void model2_reset(Model2 *m)
129
m->zero_freq = 0x1000;
130
m->total_freq = 0x2000;
135
static void model2_update(Model2 *m, int bit)
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;
152
m->upd_val = m->upd_val * 5 >> 2;
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;
161
static void model_update(Model *m, int val)
170
m->tot_weight += m->upd_val;
172
if (m->tot_weight > 0x8000) {
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];
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];
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;
191
static void model_reset(Model *m)
196
for (i = 0; i < m->num_syms - 1; i++)
198
m->weights[m->num_syms - 1] = 0;
200
m->upd_val = m->num_syms;
202
model_update(m, m->num_syms - 1);
204
m->upd_val = (m->num_syms + 6) >> 1;
207
static av_cold void model_init(Model *m, int num_syms)
209
m->num_syms = num_syms;
210
m->max_upd_val = 8 * num_syms + 48;
215
static void model256_update(Model256 *m, int val)
225
m->tot_weight += m->upd_val;
227
if (m->tot_weight > 0x8000) {
229
for (i = 0; i < 256; i++) {
230
m->weights[i] = (m->weights[i] + 1) >> 1;
231
m->tot_weight += m->weights[i];
234
scale = 0x80000000u / m->tot_weight;
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;
241
m->secondary[sidx++] = i - 1;
243
while (sidx < m->sec_size)
244
m->secondary[sidx++] = 255;
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;
252
static void model256_reset(Model256 *m)
256
for (i = 0; i < 255; i++)
263
model256_update(m, 255);
265
m->upd_val = (256 + 6) >> 1;
268
static av_cold void model256_init(Model256 *m)
270
m->max_upd_val = 8 * 256 + 48;
271
m->sec_size = (1 << 6) + 2;
276
static void rac_init(RangeCoder *c, const uint8_t *src, int size)
281
c->src_end = src + size;
283
for (i = 0; i < FFMIN(size, 4); i++)
284
c->low = (c->low << 8) | *c->src++;
285
c->range = 0xFFFFFFFF;
289
static void rac_normalise(RangeCoder *c)
294
if (c->src < c->src_end) {
296
} else if (!c->low) {
300
if (c->range >= RAC_BOTTOM)
305
static int rac_get_bit(RangeCoder *c)
311
bit = (c->range <= c->low);
315
if (c->range < RAC_BOTTOM)
321
static int rac_get_bits(RangeCoder *c, int nbits)
326
val = c->low / c->range;
327
c->low -= c->range * val;
329
if (c->range < RAC_BOTTOM)
335
static int rac_get_model2_sym(RangeCoder *c, Model2 *m)
339
helper = m->zero_freq * (c->range >> MODEL2_SCALE);
340
bit = (c->low >= helper);
348
if (c->range < RAC_BOTTOM)
351
model2_update(m, bit);
356
static int rac_get_model_sym(RangeCoder *c, Model *m)
358
int prob, prob2, helper, val;
363
c->range >>= MODEL_SCALE;
365
end = m->num_syms >> 1;
368
helper = m->freqs[end] * c->range;
369
if (helper <= c->low) {
376
end = (end2 + val) >> 1;
377
} while (end != val);
379
c->range = prob2 - prob;
380
if (c->range < RAC_BOTTOM)
383
model_update(m, val);
388
static int rac_get_model256_sym(RangeCoder *c, Model256 *m)
390
int prob, prob2, helper, val;
395
c->range >>= MODEL_SCALE;
397
helper = c->low / c->range;
398
ssym = helper >> MODEL256_SEC_SCALE;
399
val = m->secondary[ssym];
401
end = start = m->secondary[ssym + 1] + 1;
402
while (end > val + 1) {
403
ssym = (end + val) >> 1;
404
if (m->freqs[ssym] <= helper) {
408
end = (end + val) >> 1;
412
prob = m->freqs[val] * c->range;
414
prob2 = m->freqs[val + 1] * c->range;
417
c->range = prob2 - prob;
418
if (c->range < RAC_BOTTOM)
421
model256_update(m, val);
426
static int decode_block_type(RangeCoder *c, BlockTypeContext *bt)
428
bt->last_type = rac_get_model_sym(c, &bt->bt_model[bt->last_type]);
430
return bt->last_type;
433
static int decode_coeff(RangeCoder *c, Model *m)
437
val = rac_get_model_sym(c, m);
439
sign = rac_get_bit(c);
442
val = (1 << val) + rac_get_bits(c, val);
451
static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc,
452
uint8_t *dst, int stride, int block_size)
456
fc->fill_val += decode_coeff(c, &fc->coef_model);
458
for (i = 0; i < block_size; i++, dst += stride)
459
memset(dst, fc->fill_val, block_size);
462
static void decode_image_block(RangeCoder *c, ImageBlockCoder *ic,
463
uint8_t *dst, int stride, int block_size)
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);
476
memset(prev_line, 0, sizeof(prev_line));
478
for (j = 0; j < block_size; j++) {
481
for (i = 0; i < block_size; i++) {
484
A = rac_get_model_sym(c, &ic->vq_model[A + B * 5 + C * 25]);
490
dst[i] = rac_get_model256_sym(c, &ic->esc_model);
496
static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,
499
int skip, val, sign, pos = 1, zz_pos, dc;
500
int blk_pos = bx + by * bc->prev_dc_stride;
502
memset(block, 0, sizeof(*block) * 64);
504
dc = decode_coeff(c, &bc->dc_model);
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];
513
if (FFABS(t - tl) <= FFABS(l - tl))
518
dc += bc->prev_dc[blk_pos - bc->prev_dc_stride];
521
dc += bc->prev_dc[bx - 1];
523
bc->prev_dc[blk_pos] = dc;
524
block[0] = dc * bc->qmat[0];
527
val = rac_get_model256_sym(c, &bc->ac_model);
542
sign = rac_get_model2_sym(c, &bc->sign_model);
545
val = (1 << val) + rac_get_bits(c, val);
550
zz_pos = ff_zigzag_direct[pos];
551
block[zz_pos] = val * bc->qmat[zz_pos];
555
return pos == 64 ? 0 : -1;
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)
564
int nblocks = block_size >> 3;
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)) {
575
ff_mss34_dct_put(dst + i * 8, stride, block);
581
static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc,
582
uint8_t *dst, int stride, int block_size,
585
const int hsize = block_size >> 1;
586
int A, B, C, D, t1, t2, t3, t4;
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);
594
block[i] = decode_coeff(c, &hc->coef_hi_model);
595
block[i] *= hc->scale;
599
block -= block_size * block_size;
601
for (j = 0; j < hsize; j++) {
602
for (i = 0; i < hsize; i++) {
604
B = block[i + hsize];
605
C = block[i + hsize * block_size];
606
D = block[i + hsize * block_size + hsize];
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);
622
static void reset_coders(MSS3Context *ctx, int quality)
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);
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;
652
model_reset(&ctx->haar_coder[i].coef_hi_model);
653
model256_reset(&ctx->haar_coder[i].coef_model);
657
static av_cold void init_coders(MSS3Context *ctx)
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);
677
static int mss3_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
680
const uint8_t *buf = avpkt->data;
681
int buf_size = avpkt->size;
682
MSS3Context *c = avctx->priv_data;
683
RangeCoder *acoder = &c->coder;
686
int dec_width, dec_height, dec_x, dec_y, quality, keyframe;
687
int x, y, i, mb_width, mb_height, blk_size, btype;
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;
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;
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);
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;
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;
723
bytestream2_skip(&gb, 4);
725
if (keyframe && !bytestream2_get_bytes_left(&gb)) {
726
av_log(avctx, AV_LOG_ERROR, "Keyframe without data found\n");
727
return AVERROR_INVALIDDATA;
729
if (!keyframe && c->got_error)
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");
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)) {
744
*(AVFrame*)data = c->pic;
749
reset_coders(c, quality);
751
rac_init(acoder, buf + HEADER_SIZE, buf_size - HEADER_SIZE);
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++) {
763
btype = decode_block_type(acoder, c->btype + i);
766
decode_fill_block(acoder, c->fill_coder + i,
767
dst[i] + x * blk_size,
768
c->pic.linesize[i], blk_size);
771
decode_image_block(acoder, c->image_coder + i,
772
dst[i] + x * blk_size,
773
c->pic.linesize[i], blk_size);
776
decode_dct_block(acoder, c->dct_coder + i,
777
dst[i] + x * blk_size,
778
c->pic.linesize[i], blk_size,
782
decode_haar_block(acoder, c->haar_coder + i,
783
dst[i] + x * blk_size,
784
c->pic.linesize[i], blk_size,
788
if (c->got_error || acoder->got_error) {
789
av_log(avctx, AV_LOG_ERROR, "Error decoding block %d,%d\n",
792
return AVERROR_INVALIDDATA;
796
dst[0] += c->pic.linesize[0] * 16;
797
dst[1] += c->pic.linesize[1] * 8;
798
dst[2] += c->pic.linesize[2] * 8;
802
*(AVFrame*)data = c->pic;
807
static av_cold int mss3_decode_init(AVCodecContext *avctx)
809
MSS3Context * const c = avctx->priv_data;
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;
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) *
828
if (!c->dct_coder[i].prev_dc) {
829
av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
831
av_freep(&c->dct_coder[i].prev_dc);
834
return AVERROR(ENOMEM);
838
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
839
avctx->coded_frame = &c->pic;
846
static av_cold int mss3_decode_end(AVCodecContext *avctx)
848
MSS3Context * const c = avctx->priv_data;
852
avctx->release_buffer(avctx, &c->pic);
853
for (i = 0; i < 3; i++)
854
av_freep(&c->dct_coder[i].prev_dc);
859
AVCodec ff_msa1_decoder = {
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"),