2 * Microsoft Screen 3 (aka Microsoft ATC Screen) decoder
3 * Copyright (c) 2012 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
24 * Microsoft Screen 3 (aka Microsoft ATC Screen) decoder
28 #include "bytestream.h"
33 #define HEADER_SIZE 27
35 #define MODEL2_SCALE 13
36 #define MODEL_SCALE 15
37 #define MODEL256_SEC_SCALE 9
39 typedef struct Model2
{
40 int upd_val
, till_rescale
;
41 unsigned zero_freq
, zero_weight
;
42 unsigned total_freq
, total_weight
;
45 typedef struct Model
{
46 int weights
[16], freqs
[16];
49 int upd_val
, max_upd_val
, till_rescale
;
52 typedef struct Model256
{
53 int weights
[256], freqs
[256];
57 int upd_val
, max_upd_val
, till_rescale
;
60 #define RAC_BOTTOM 0x01000000
61 typedef struct RangeCoder
{
62 const uint8_t *src
, *src_end
;
76 typedef struct BlockTypeContext
{
81 typedef struct FillBlockCoder
{
86 typedef struct ImageBlockCoder
{
87 Model256 esc_model
, vec_entry_model
;
92 typedef struct DCTBlockCoder
{
103 typedef struct HaarBlockCoder
{
109 typedef struct MSS3Context
{
110 AVCodecContext
*avctx
;
115 BlockTypeContext btype
[3];
116 FillBlockCoder fill_coder
[3];
117 ImageBlockCoder image_coder
[3];
118 DCTBlockCoder dct_coder
[3];
119 HaarBlockCoder haar_coder
[3];
126 static void model2_reset(Model2
*m
)
130 m
->zero_freq
= 0x1000;
131 m
->total_freq
= 0x2000;
136 static void model2_update(Model2
*m
, int bit
)
146 m
->total_weight
+= m
->upd_val
;
147 if (m
->total_weight
> 0x2000) {
148 m
->total_weight
= (m
->total_weight
+ 1) >> 1;
149 m
->zero_weight
= (m
->zero_weight
+ 1) >> 1;
150 if (m
->total_weight
== m
->zero_weight
)
151 m
->total_weight
= m
->zero_weight
+ 1;
153 m
->upd_val
= m
->upd_val
* 5 >> 2;
156 scale
= 0x80000000u
/ m
->total_weight
;
157 m
->zero_freq
= m
->zero_weight
* scale
>> 18;
158 m
->total_freq
= m
->total_weight
* scale
>> 18;
159 m
->till_rescale
= m
->upd_val
;
162 static void model_update(Model
*m
, int val
)
171 m
->tot_weight
+= m
->upd_val
;
173 if (m
->tot_weight
> 0x8000) {
175 for (i
= 0; i
< m
->num_syms
; i
++) {
176 m
->weights
[i
] = (m
->weights
[i
] + 1) >> 1;
177 m
->tot_weight
+= m
->weights
[i
];
180 scale
= 0x80000000u
/ m
->tot_weight
;
181 for (i
= 0; i
< m
->num_syms
; i
++) {
182 m
->freqs
[i
] = sum
* scale
>> 16;
183 sum
+= m
->weights
[i
];
186 m
->upd_val
= m
->upd_val
* 5 >> 2;
187 if (m
->upd_val
> m
->max_upd_val
)
188 m
->upd_val
= m
->max_upd_val
;
189 m
->till_rescale
= m
->upd_val
;
192 static void model_reset(Model
*m
)
197 for (i
= 0; i
< m
->num_syms
- 1; i
++)
199 m
->weights
[m
->num_syms
- 1] = 0;
201 m
->upd_val
= m
->num_syms
;
203 model_update(m
, m
->num_syms
- 1);
205 m
->upd_val
= (m
->num_syms
+ 6) >> 1;
208 static av_cold
void model_init(Model
*m
, int num_syms
)
210 m
->num_syms
= num_syms
;
211 m
->max_upd_val
= 8 * num_syms
+ 48;
216 static void model256_update(Model256
*m
, int val
)
226 m
->tot_weight
+= m
->upd_val
;
228 if (m
->tot_weight
> 0x8000) {
230 for (i
= 0; i
< 256; i
++) {
231 m
->weights
[i
] = (m
->weights
[i
] + 1) >> 1;
232 m
->tot_weight
+= m
->weights
[i
];
235 scale
= 0x80000000u
/ m
->tot_weight
;
237 for (i
= 0; i
< 256; i
++) {
238 m
->freqs
[i
] = sum
* scale
>> 16;
239 sum
+= m
->weights
[i
];
240 send
= m
->freqs
[i
] >> MODEL256_SEC_SCALE
;
242 m
->secondary
[sidx
++] = i
- 1;
244 while (sidx
< m
->sec_size
)
245 m
->secondary
[sidx
++] = 255;
247 m
->upd_val
= m
->upd_val
* 5 >> 2;
248 if (m
->upd_val
> m
->max_upd_val
)
249 m
->upd_val
= m
->max_upd_val
;
250 m
->till_rescale
= m
->upd_val
;
253 static void model256_reset(Model256
*m
)
257 for (i
= 0; i
< 255; i
++)
264 model256_update(m
, 255);
266 m
->upd_val
= (256 + 6) >> 1;
269 static av_cold
void model256_init(Model256
*m
)
271 m
->max_upd_val
= 8 * 256 + 48;
272 m
->sec_size
= (1 << 6) + 2;
277 static void rac_init(RangeCoder
*c
, const uint8_t *src
, int size
)
282 c
->src_end
= src
+ size
;
284 for (i
= 0; i
< FFMIN(size
, 4); i
++)
285 c
->low
= (c
->low
<< 8) | *c
->src
++;
286 c
->range
= 0xFFFFFFFF;
290 static void rac_normalise(RangeCoder
*c
)
295 if (c
->src
< c
->src_end
) {
297 } else if (!c
->low
) {
301 if (c
->range
>= RAC_BOTTOM
)
306 static int rac_get_bit(RangeCoder
*c
)
312 bit
= (c
->range
<= c
->low
);
316 if (c
->range
< RAC_BOTTOM
)
322 static int rac_get_bits(RangeCoder
*c
, int nbits
)
327 val
= c
->low
/ c
->range
;
328 c
->low
-= c
->range
* val
;
330 if (c
->range
< RAC_BOTTOM
)
336 static int rac_get_model2_sym(RangeCoder
*c
, Model2
*m
)
340 helper
= m
->zero_freq
* (c
->range
>> MODEL2_SCALE
);
341 bit
= (c
->low
>= helper
);
349 if (c
->range
< RAC_BOTTOM
)
352 model2_update(m
, bit
);
357 static int rac_get_model_sym(RangeCoder
*c
, Model
*m
)
359 int prob
, prob2
, helper
, val
;
364 c
->range
>>= MODEL_SCALE
;
366 end
= m
->num_syms
>> 1;
369 helper
= m
->freqs
[end
] * c
->range
;
370 if (helper
<= c
->low
) {
377 end
= (end2
+ val
) >> 1;
378 } while (end
!= val
);
380 c
->range
= prob2
- prob
;
381 if (c
->range
< RAC_BOTTOM
)
384 model_update(m
, val
);
389 static int rac_get_model256_sym(RangeCoder
*c
, Model256
*m
)
391 int prob
, prob2
, helper
, val
;
396 c
->range
>>= MODEL_SCALE
;
398 helper
= c
->low
/ c
->range
;
399 ssym
= helper
>> MODEL256_SEC_SCALE
;
400 val
= m
->secondary
[ssym
];
402 end
= start
= m
->secondary
[ssym
+ 1] + 1;
403 while (end
> val
+ 1) {
404 ssym
= (end
+ val
) >> 1;
405 if (m
->freqs
[ssym
] <= helper
) {
409 end
= (end
+ val
) >> 1;
413 prob
= m
->freqs
[val
] * c
->range
;
415 prob2
= m
->freqs
[val
+ 1] * c
->range
;
418 c
->range
= prob2
- prob
;
419 if (c
->range
< RAC_BOTTOM
)
422 model256_update(m
, val
);
427 static int decode_block_type(RangeCoder
*c
, BlockTypeContext
*bt
)
429 bt
->last_type
= rac_get_model_sym(c
, &bt
->bt_model
[bt
->last_type
]);
431 return bt
->last_type
;
434 static int decode_coeff(RangeCoder
*c
, Model
*m
)
438 val
= rac_get_model_sym(c
, m
);
440 sign
= rac_get_bit(c
);
443 val
= (1 << val
) + rac_get_bits(c
, val
);
452 static void decode_fill_block(RangeCoder
*c
, FillBlockCoder
*fc
,
453 uint8_t *dst
, int stride
, int block_size
)
457 fc
->fill_val
+= decode_coeff(c
, &fc
->coef_model
);
459 for (i
= 0; i
< block_size
; i
++, dst
+= stride
)
460 memset(dst
, fc
->fill_val
, block_size
);
463 static void decode_image_block(RangeCoder
*c
, ImageBlockCoder
*ic
,
464 uint8_t *dst
, int stride
, int block_size
)
472 vec_size
= rac_get_model_sym(c
, &ic
->vec_size_model
) + 2;
473 for (i
= 0; i
< vec_size
; i
++)
474 vec
[i
] = rac_get_model256_sym(c
, &ic
->vec_entry_model
);
477 memset(prev_line
, 0, sizeof(prev_line
));
479 for (j
= 0; j
< block_size
; j
++) {
482 for (i
= 0; i
< block_size
; i
++) {
485 A
= rac_get_model_sym(c
, &ic
->vq_model
[A
+ B
* 5 + C
* 25]);
491 dst
[i
] = rac_get_model256_sym(c
, &ic
->esc_model
);
497 static int decode_dct(RangeCoder
*c
, DCTBlockCoder
*bc
, int *block
,
500 int skip
, val
, sign
, pos
= 1, zz_pos
, dc
;
501 int blk_pos
= bx
+ by
* bc
->prev_dc_stride
;
503 memset(block
, 0, sizeof(*block
) * 64);
505 dc
= decode_coeff(c
, &bc
->dc_model
);
510 l
= bc
->prev_dc
[blk_pos
- 1];
511 tl
= bc
->prev_dc
[blk_pos
- 1 - bc
->prev_dc_stride
];
512 t
= bc
->prev_dc
[blk_pos
- bc
->prev_dc_stride
];
514 if (FFABS(t
- tl
) <= FFABS(l
- tl
))
519 dc
+= bc
->prev_dc
[blk_pos
- bc
->prev_dc_stride
];
522 dc
+= bc
->prev_dc
[bx
- 1];
524 bc
->prev_dc
[blk_pos
] = dc
;
525 block
[0] = dc
* bc
->qmat
[0];
528 val
= rac_get_model256_sym(c
, &bc
->ac_model
);
543 sign
= rac_get_model2_sym(c
, &bc
->sign_model
);
546 val
= (1 << val
) + rac_get_bits(c
, val
);
551 zz_pos
= ff_zigzag_direct
[pos
];
552 block
[zz_pos
] = val
* bc
->qmat
[zz_pos
];
556 return pos
== 64 ? 0 : -1;
559 static void decode_dct_block(RangeCoder
*c
, DCTBlockCoder
*bc
,
560 uint8_t *dst
, int stride
, int block_size
,
561 int *block
, int mb_x
, int mb_y
)
565 int nblocks
= block_size
>> 3;
570 for (j
= 0; j
< nblocks
; j
++) {
571 for (i
= 0; i
< nblocks
; i
++) {
572 if (decode_dct(c
, bc
, block
, bx
+ i
, by
+ j
)) {
576 ff_mss34_dct_put(dst
+ i
* 8, stride
, block
);
582 static void decode_haar_block(RangeCoder
*c
, HaarBlockCoder
*hc
,
583 uint8_t *dst
, int stride
, int block_size
,
586 const int hsize
= block_size
>> 1;
587 int A
, B
, C
, D
, t1
, t2
, t3
, t4
;
590 for (j
= 0; j
< block_size
; j
++) {
591 for (i
= 0; i
< block_size
; i
++) {
592 if (i
< hsize
&& j
< hsize
)
593 block
[i
] = rac_get_model256_sym(c
, &hc
->coef_model
);
595 block
[i
] = decode_coeff(c
, &hc
->coef_hi_model
);
596 block
[i
] *= hc
->scale
;
600 block
-= block_size
* block_size
;
602 for (j
= 0; j
< hsize
; j
++) {
603 for (i
= 0; i
< hsize
; i
++) {
605 B
= block
[i
+ hsize
];
606 C
= block
[i
+ hsize
* block_size
];
607 D
= block
[i
+ hsize
* block_size
+ hsize
];
613 dst
[i
* 2] = av_clip_uint8(t1
- t2
);
614 dst
[i
* 2 + stride
] = av_clip_uint8(t1
+ t2
);
615 dst
[i
* 2 + 1] = av_clip_uint8(t3
- t4
);
616 dst
[i
* 2 + 1 + stride
] = av_clip_uint8(t3
+ t4
);
623 static void reset_coders(MSS3Context
*ctx
, int quality
)
627 for (i
= 0; i
< 3; i
++) {
628 ctx
->btype
[i
].last_type
= SKIP_BLOCK
;
629 for (j
= 0; j
< 5; j
++)
630 model_reset(&ctx
->btype
[i
].bt_model
[j
]);
631 ctx
->fill_coder
[i
].fill_val
= 0;
632 model_reset(&ctx
->fill_coder
[i
].coef_model
);
633 model256_reset(&ctx
->image_coder
[i
].esc_model
);
634 model256_reset(&ctx
->image_coder
[i
].vec_entry_model
);
635 model_reset(&ctx
->image_coder
[i
].vec_size_model
);
636 for (j
= 0; j
< 125; j
++)
637 model_reset(&ctx
->image_coder
[i
].vq_model
[j
]);
638 if (ctx
->dct_coder
[i
].quality
!= quality
) {
639 ctx
->dct_coder
[i
].quality
= quality
;
640 ff_mss34_gen_quant_mat(ctx
->dct_coder
[i
].qmat
, quality
, !i
);
642 memset(ctx
->dct_coder
[i
].prev_dc
, 0,
643 sizeof(*ctx
->dct_coder
[i
].prev_dc
) *
644 ctx
->dct_coder
[i
].prev_dc_stride
*
645 ctx
->dct_coder
[i
].prev_dc_height
);
646 model_reset(&ctx
->dct_coder
[i
].dc_model
);
647 model2_reset(&ctx
->dct_coder
[i
].sign_model
);
648 model256_reset(&ctx
->dct_coder
[i
].ac_model
);
649 if (ctx
->haar_coder
[i
].quality
!= quality
) {
650 ctx
->haar_coder
[i
].quality
= quality
;
651 ctx
->haar_coder
[i
].scale
= 17 - 7 * quality
/ 50;
653 model_reset(&ctx
->haar_coder
[i
].coef_hi_model
);
654 model256_reset(&ctx
->haar_coder
[i
].coef_model
);
658 static av_cold
void init_coders(MSS3Context
*ctx
)
662 for (i
= 0; i
< 3; i
++) {
663 for (j
= 0; j
< 5; j
++)
664 model_init(&ctx
->btype
[i
].bt_model
[j
], 5);
665 model_init(&ctx
->fill_coder
[i
].coef_model
, 12);
666 model256_init(&ctx
->image_coder
[i
].esc_model
);
667 model256_init(&ctx
->image_coder
[i
].vec_entry_model
);
668 model_init(&ctx
->image_coder
[i
].vec_size_model
, 3);
669 for (j
= 0; j
< 125; j
++)
670 model_init(&ctx
->image_coder
[i
].vq_model
[j
], 5);
671 model_init(&ctx
->dct_coder
[i
].dc_model
, 12);
672 model256_init(&ctx
->dct_coder
[i
].ac_model
);
673 model_init(&ctx
->haar_coder
[i
].coef_hi_model
, 12);
674 model256_init(&ctx
->haar_coder
[i
].coef_model
);
678 static int mss3_decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
681 const uint8_t *buf
= avpkt
->data
;
682 int buf_size
= avpkt
->size
;
683 MSS3Context
*c
= avctx
->priv_data
;
684 RangeCoder
*acoder
= &c
->coder
;
687 int dec_width
, dec_height
, dec_x
, dec_y
, quality
, keyframe
;
688 int x
, y
, i
, mb_width
, mb_height
, blk_size
, btype
;
691 if (buf_size
< HEADER_SIZE
) {
692 av_log(avctx
, AV_LOG_ERROR
,
693 "Frame should have at least %d bytes, got %d instead\n",
694 HEADER_SIZE
, buf_size
);
695 return AVERROR_INVALIDDATA
;
698 bytestream2_init(&gb
, buf
, buf_size
);
699 keyframe
= bytestream2_get_be32(&gb
);
700 if (keyframe
& ~0x301) {
701 av_log(avctx
, AV_LOG_ERROR
, "Invalid frame type %X\n", keyframe
);
702 return AVERROR_INVALIDDATA
;
704 keyframe
= !(keyframe
& 1);
705 bytestream2_skip(&gb
, 6);
706 dec_x
= bytestream2_get_be16(&gb
);
707 dec_y
= bytestream2_get_be16(&gb
);
708 dec_width
= bytestream2_get_be16(&gb
);
709 dec_height
= bytestream2_get_be16(&gb
);
711 if (dec_x
+ dec_width
> avctx
->width
||
712 dec_y
+ dec_height
> avctx
->height
||
713 (dec_width
| dec_height
) & 0xF) {
714 av_log(avctx
, AV_LOG_ERROR
, "Invalid frame dimensions %dx%d +%d,%d\n",
715 dec_width
, dec_height
, dec_x
, dec_y
);
716 return AVERROR_INVALIDDATA
;
718 bytestream2_skip(&gb
, 4);
719 quality
= bytestream2_get_byte(&gb
);
720 if (quality
< 1 || quality
> 100) {
721 av_log(avctx
, AV_LOG_ERROR
, "Invalid quality setting %d\n", quality
);
722 return AVERROR_INVALIDDATA
;
724 bytestream2_skip(&gb
, 4);
726 if (keyframe
&& !bytestream2_get_bytes_left(&gb
)) {
727 av_log(avctx
, AV_LOG_ERROR
, "Keyframe without data found\n");
728 return AVERROR_INVALIDDATA
;
730 if (!keyframe
&& c
->got_error
)
734 if ((ret
= ff_reget_buffer(avctx
, c
->pic
)) < 0)
736 c
->pic
->key_frame
= keyframe
;
737 c
->pic
->pict_type
= keyframe
? AV_PICTURE_TYPE_I
: AV_PICTURE_TYPE_P
;
738 if (!bytestream2_get_bytes_left(&gb
)) {
739 if ((ret
= av_frame_ref(data
, c
->pic
)) < 0)
746 reset_coders(c
, quality
);
748 rac_init(acoder
, buf
+ HEADER_SIZE
, buf_size
- HEADER_SIZE
);
750 mb_width
= dec_width
>> 4;
751 mb_height
= dec_height
>> 4;
752 dst
[0] = c
->pic
->data
[0] + dec_x
+ dec_y
* c
->pic
->linesize
[0];
753 dst
[1] = c
->pic
->data
[1] + dec_x
/ 2 + (dec_y
/ 2) * c
->pic
->linesize
[1];
754 dst
[2] = c
->pic
->data
[2] + dec_x
/ 2 + (dec_y
/ 2) * c
->pic
->linesize
[2];
755 for (y
= 0; y
< mb_height
; y
++) {
756 for (x
= 0; x
< mb_width
; x
++) {
757 for (i
= 0; i
< 3; i
++) {
760 btype
= decode_block_type(acoder
, c
->btype
+ i
);
763 decode_fill_block(acoder
, c
->fill_coder
+ i
,
764 dst
[i
] + x
* blk_size
,
765 c
->pic
->linesize
[i
], blk_size
);
768 decode_image_block(acoder
, c
->image_coder
+ i
,
769 dst
[i
] + x
* blk_size
,
770 c
->pic
->linesize
[i
], blk_size
);
773 decode_dct_block(acoder
, c
->dct_coder
+ i
,
774 dst
[i
] + x
* blk_size
,
775 c
->pic
->linesize
[i
], blk_size
,
779 decode_haar_block(acoder
, c
->haar_coder
+ i
,
780 dst
[i
] + x
* blk_size
,
781 c
->pic
->linesize
[i
], blk_size
,
785 if (c
->got_error
|| acoder
->got_error
) {
786 av_log(avctx
, AV_LOG_ERROR
, "Error decoding block %d,%d\n",
789 return AVERROR_INVALIDDATA
;
793 dst
[0] += c
->pic
->linesize
[0] * 16;
794 dst
[1] += c
->pic
->linesize
[1] * 8;
795 dst
[2] += c
->pic
->linesize
[2] * 8;
798 if ((ret
= av_frame_ref(data
, c
->pic
)) < 0)
806 static av_cold
int mss3_decode_end(AVCodecContext
*avctx
)
808 MSS3Context
* const c
= avctx
->priv_data
;
811 av_frame_free(&c
->pic
);
812 for (i
= 0; i
< 3; i
++)
813 av_freep(&c
->dct_coder
[i
].prev_dc
);
818 static av_cold
int mss3_decode_init(AVCodecContext
*avctx
)
820 MSS3Context
* const c
= avctx
->priv_data
;
825 if ((avctx
->width
& 0xF) || (avctx
->height
& 0xF)) {
826 av_log(avctx
, AV_LOG_ERROR
,
827 "Image dimensions should be a multiple of 16.\n");
828 return AVERROR_INVALIDDATA
;
832 for (i
= 0; i
< 3; i
++) {
833 int b_width
= avctx
->width
>> (2 + !!i
);
834 int b_height
= avctx
->height
>> (2 + !!i
);
835 c
->dct_coder
[i
].prev_dc_stride
= b_width
;
836 c
->dct_coder
[i
].prev_dc_height
= b_height
;
837 c
->dct_coder
[i
].prev_dc
= av_malloc(sizeof(*c
->dct_coder
[i
].prev_dc
) *
839 if (!c
->dct_coder
[i
].prev_dc
) {
840 av_log(avctx
, AV_LOG_ERROR
, "Cannot allocate buffer\n");
841 av_frame_free(&c
->pic
);
843 av_freep(&c
->dct_coder
[i
].prev_dc
);
846 return AVERROR(ENOMEM
);
850 c
->pic
= av_frame_alloc();
852 mss3_decode_end(avctx
);
853 return AVERROR(ENOMEM
);
856 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
863 AVCodec ff_msa1_decoder
= {
865 .long_name
= NULL_IF_CONFIG_SMALL("MS ATC Screen"),
866 .type
= AVMEDIA_TYPE_VIDEO
,
867 .id
= AV_CODEC_ID_MSA1
,
868 .priv_data_size
= sizeof(MSS3Context
),
869 .init
= mss3_decode_init
,
870 .close
= mss3_decode_end
,
871 .decode
= mss3_decode_frame
,
872 .capabilities
= CODEC_CAP_DR1
,