GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mss2.c Lines: 427 506 84.4 %
Date: 2020-09-28 00:47:38 Branches: 233 314 74.2 %

Line Branch Exec Source
1
/*
2
 * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
/**
22
 * @file
23
 * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
24
 */
25
26
#include "libavutil/avassert.h"
27
#include "error_resilience.h"
28
#include "internal.h"
29
#include "mpeg_er.h"
30
#include "msmpeg4.h"
31
#include "qpeldsp.h"
32
#include "vc1.h"
33
#include "wmv2data.h"
34
#include "mss12.h"
35
#include "mss2dsp.h"
36
37
typedef struct MSS2Context {
38
    VC1Context     v;
39
    int            split_position;
40
    AVFrame       *last_pic;
41
    MSS12Context   c;
42
    MSS2DSPContext dsp;
43
    QpelDSPContext qdsp;
44
    SliceContext   sc[2];
45
} MSS2Context;
46
47
3080857
static void arith2_normalise(ArithCoder *c)
48
{
49
3120139
    while ((c->high >> 15) - (c->low >> 15) < 2) {
50
39282
        if ((c->low ^ c->high) & 0x10000) {
51
8424
            c->high  ^= 0x8000;
52
8424
            c->value ^= 0x8000;
53
8424
            c->low   ^= 0x8000;
54
        }
55
39282
        c->high  = (uint16_t)c->high  << 8  | 0xFF;
56
39282
        c->value = (uint16_t)c->value << 8  | bytestream2_get_byte(c->gbc.gB);
57
39282
        c->low   = (uint16_t)c->low   << 8;
58
    }
59
3080857
}
60
61
243
ARITH_GET_BIT(arith2)
62
63
/* L. Stuiver and A. Moffat: "Piecewise Integer Mapping for Arithmetic Coding."
64
 * In Proc. 8th Data Compression Conference (DCC '98), pp. 3-12, Mar. 1998 */
65
66
3080614
static int arith2_get_scaled_value(int value, int n, int range)
67
{
68
3080614
    int split = (n << 1) - range;
69
70
3080614
    if (value > split)
71
1706480
        return split + (value - split >> 1);
72
    else
73
1374134
        return value;
74
}
75
76
3080614
static void arith2_rescale_interval(ArithCoder *c, int range,
77
                                    int low, int high, int n)
78
{
79
3080614
    int split = (n << 1) - range;
80
81
3080614
    if (high > split)
82
3008013
        c->high = split + (high - split << 1);
83
    else
84
72601
        c->high = high;
85
86
3080614
    c->high += c->low - 1;
87
88
3080614
    if (low > split)
89
28986
        c->low += split + (low - split << 1);
90
    else
91
3051628
        c->low += low;
92
3080614
}
93
94
806
static int arith2_get_number(ArithCoder *c, int n)
95
{
96
806
    int range = c->high - c->low + 1;
97
806
    int scale = av_log2(range) - av_log2(n);
98
    int val;
99
100
806
    if (n << scale > range)
101
368
        scale--;
102
103
806
    n <<= scale;
104
105
806
    val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
106
107
806
    arith2_rescale_interval(c, range, val << scale, (val + 1) << scale, n);
108
109
806
    arith2_normalise(c);
110
111
806
    return val;
112
}
113
114
3079808
static int arith2_get_prob(ArithCoder *c, int16_t *probs)
115
{
116
3079808
    int range = c->high - c->low + 1, n = *probs;
117
3079808
    int scale = av_log2(range) - av_log2(n);
118
3079808
    int i     = 0, val;
119
120
3079808
    if (n << scale > range)
121
1611522
        scale--;
122
123
3079808
    n <<= scale;
124
125
3079808
    val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
126
3164916
    while (probs[++i] > val) ;
127
128
3079808
    arith2_rescale_interval(c, range,
129
3079808
                            probs[i] << scale, probs[i - 1] << scale, n);
130
131
3079808
    return i;
132
}
133
134
3079808
ARITH_GET_MODEL_SYM(arith2)
135
136
358
static int arith2_get_consumed_bytes(ArithCoder *c)
137
{
138
358
    int diff = (c->high >> 16) - (c->low >> 16);
139
358
    int bp   = bytestream2_tell(c->gbc.gB) - 3 << 3;
140
358
    int bits = 1;
141
142
1798
    while (!(diff & 0x80)) {
143
1440
        bits++;
144
1440
        diff <<= 1;
145
    }
146
147
358
    return (bits + bp + 7 >> 3) + ((c->low >> 16) + 1 == c->high >> 16);
148
}
149
150
179
static void arith2_init(ArithCoder *c, GetByteContext *gB)
151
{
152
179
    c->low           = 0;
153
179
    c->high          = 0xFFFFFF;
154
179
    c->value         = bytestream2_get_be24(gB);
155
179
    c->overread      = 0;
156
179
    c->gbc.gB        = gB;
157
179
    c->get_model_sym = arith2_get_model_sym;
158
179
    c->get_number    = arith2_get_number;
159
179
}
160
161
4
static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)
162
{
163
    int i, ncol;
164
4
    uint32_t *pal = ctx->pal + 256 - ctx->free_colours;
165
166
4
    if (!ctx->free_colours)
167
        return 0;
168
169
4
    ncol = *buf++;
170

4
    if (ncol > ctx->free_colours || buf_size < 2 + ncol * 3)
171
        return AVERROR_INVALIDDATA;
172
21
    for (i = 0; i < ncol; i++)
173
17
        *pal++ = AV_RB24(buf + 3 * i);
174
175
4
    return 1 + ncol * 3;
176
}
177
178
4
static int decode_555(AVCodecContext *avctx, GetByteContext *gB, uint16_t *dst, ptrdiff_t stride,
179
                      int keyframe, int w, int h)
180
{
181
4
    int last_symbol = 0, repeat = 0, prev_avail = 0;
182
183
4
    if (!keyframe) {
184
        int x, y, endx, endy, t;
185
186
#define READ_PAIR(a, b)                 \
187
    a  = bytestream2_get_byte(gB) << 4; \
188
    t  = bytestream2_get_byte(gB);      \
189
    a |= t >> 4;                        \
190
    b  = (t & 0xF) << 8;                \
191
    b |= bytestream2_get_byte(gB);      \
192
193
2
        READ_PAIR(x, endx)
194
2
        READ_PAIR(y, endy)
195
196


2
        if (endx >= w || endy >= h || x > endx || y > endy)
197
            return AVERROR_INVALIDDATA;
198
2
        dst += x + stride * y;
199
2
        w    = endx - x + 1;
200
2
        h    = endy - y + 1;
201
2
        if (y)
202
2
            prev_avail = 1;
203
    }
204
205
    do {
206
146
        uint16_t *p = dst;
207
        do {
208
9200
            if (repeat-- < 1) {
209
5320
                int b = bytestream2_get_byte(gB);
210
5320
                if (b < 128)
211
2920
                    last_symbol = b << 8 | bytestream2_get_byte(gB);
212
2400
                else if (b > 129) {
213
1440
                    repeat = 0;
214
1838
                    while (b-- > 130) {
215
398
                        if (repeat >= (INT_MAX >> 8) - 1) {
216
                            av_log(avctx, AV_LOG_ERROR, "repeat overflow\n");
217
                            return AVERROR_INVALIDDATA;
218
                        }
219
398
                        repeat = (repeat << 8) + bytestream2_get_byte(gB) + 1;
220
                    }
221
1440
                    if (last_symbol == -2) {
222
10
                        int skip = FFMIN((unsigned)repeat, dst + w - p);
223
10
                        repeat -= skip;
224
10
                        p      += skip;
225
                    }
226
                } else
227
960
                    last_symbol = 127 - b;
228
            }
229
9200
            if (last_symbol >= 0)
230
4414
                *p = last_symbol;
231

4786
            else if (last_symbol == -1 && prev_avail)
232
4764
                *p = *(p - stride);
233
9200
        } while (++p < dst + w);
234
146
        dst       += stride;
235
146
        prev_avail = 1;
236
146
    } while (--h);
237
238
4
    return 0;
239
}
240
241
6
static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, ptrdiff_t pal_stride,
242
                      uint8_t *rgb_dst, ptrdiff_t rgb_stride, uint32_t *pal,
243
                      int keyframe, int kf_slipt, int slice, int w, int h)
244
{
245
6
    uint8_t bits[270] = { 0 };
246
    uint32_t codes[270];
247
    VLC vlc;
248
249
6
    int current_length = 0, read_codes = 0, next_code = 0, current_codes = 0;
250
    int remaining_codes, surplus_codes, i;
251
252
6
    const int alphabet_size = 270 - keyframe;
253
254
6
    int last_symbol = 0, repeat = 0, prev_avail = 0;
255
256
6
    if (!keyframe) {
257
        int x, y, clipw, cliph;
258
259
3
        x     = get_bits(gb, 12);
260
3
        y     = get_bits(gb, 12);
261
3
        clipw = get_bits(gb, 12) + 1;
262
3
        cliph = get_bits(gb, 12) + 1;
263
264

3
        if (x + clipw > w || y + cliph > h)
265
            return AVERROR_INVALIDDATA;
266
3
        pal_dst += pal_stride * y + x;
267
3
        rgb_dst += rgb_stride * y + x * 3;
268
3
        w        = clipw;
269
3
        h        = cliph;
270
3
        if (y)
271
3
            prev_avail = 1;
272
    } else {
273
3
        if (slice > 0) {
274
1
            pal_dst   += pal_stride * kf_slipt;
275
1
            rgb_dst   += rgb_stride * kf_slipt;
276
1
            prev_avail = 1;
277
1
            h         -= kf_slipt;
278
        } else
279
2
            h = kf_slipt;
280
    }
281
282
    /* read explicit codes */
283
    do {
284
231
        while (current_codes--) {
285
153
            int symbol = get_bits(gb, 8);
286
153
            if (symbol >= 204 - keyframe)
287
52
                symbol += 14 - keyframe;
288
101
            else if (symbol > 189)
289
11
                symbol = get_bits1(gb) + (symbol << 1) - 190;
290
153
            if (bits[symbol])
291
                return AVERROR_INVALIDDATA;
292
153
            bits[symbol]  = current_length;
293
153
            codes[symbol] = next_code++;
294
153
            read_codes++;
295
        }
296
78
        current_length++;
297
78
        next_code     <<= 1;
298
78
        remaining_codes = (1 << current_length) - next_code;
299
78
        current_codes   = get_bits(gb, av_ceil_log2(remaining_codes + 1));
300

78
        if (current_length > 22 || current_codes > remaining_codes)
301
            return AVERROR_INVALIDDATA;
302
78
    } while (current_codes != remaining_codes);
303
304
6
    remaining_codes = alphabet_size - read_codes;
305
306
    /* determine the minimum length to fit the rest of the alphabet */
307
6
    while ((surplus_codes = (2 << current_length) -
308
19
                            (next_code << 1) - remaining_codes) < 0) {
309
13
        current_length++;
310
13
        next_code <<= 1;
311
    }
312
313
    /* add the rest of the symbols lexicographically */
314
1623
    for (i = 0; i < alphabet_size; i++)
315
1617
        if (!bits[i]) {
316
1464
            if (surplus_codes-- == 0) {
317
6
                current_length++;
318
6
                next_code <<= 1;
319
            }
320
1464
            bits[i]  = current_length;
321
1464
            codes[i] = next_code++;
322
        }
323
324
6
    if (next_code != 1 << current_length)
325
        return AVERROR_INVALIDDATA;
326
327
6
    if ((i = init_vlc(&vlc, 9, alphabet_size, bits, 1, 1, codes, 4, 4, 0)) < 0)
328
        return i;
329
330
    /* frame decode */
331
    do {
332
146
        uint8_t *pp = pal_dst;
333
146
        uint8_t *rp = rgb_dst;
334
        do {
335
9148
            if (repeat-- < 1) {
336
1908
                int b = get_vlc2(gb, vlc.table, 9, 3);
337
1908
                if (b < 256)
338
686
                    last_symbol = b;
339
1222
                else if (b < 268) {
340
828
                    b -= 256;
341
828
                    if (b == 11)
342
                        b = get_bits(gb, 4) + 10;
343
344
828
                    if (!b)
345
84
                        repeat = 0;
346
                    else
347
744
                        repeat = get_bits(gb, b);
348
349
828
                    repeat += (1 << b) - 1;
350
351
828
                    if (last_symbol == -2) {
352
32
                        int skip = FFMIN(repeat, pal_dst + w - pp);
353
32
                        repeat -= skip;
354
32
                        pp     += skip;
355
32
                        rp     += skip * 3;
356
                    }
357
                } else
358
394
                    last_symbol = 267 - b;
359
            }
360
9148
            if (last_symbol >= 0) {
361
3616
                *pp = last_symbol;
362
3616
                AV_WB24(rp, pal[last_symbol]);
363

5532
            } else if (last_symbol == -1 && prev_avail) {
364
5466
                *pp = *(pp - pal_stride);
365
5466
                memcpy(rp, rp - rgb_stride, 3);
366
            }
367
9148
            rp += 3;
368
9148
        } while (++pp < pal_dst + w);
369
146
        pal_dst   += pal_stride;
370
146
        rgb_dst   += rgb_stride;
371
146
        prev_avail = 1;
372
146
    } while (--h);
373
374
6
    ff_free_vlc(&vlc);
375
6
    return 0;
376
}
377
378
79
static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
379
                       int x, int y, int w, int h, int wmv9_mask)
380
{
381
79
    MSS2Context *ctx  = avctx->priv_data;
382
79
    MSS12Context *c   = &ctx->c;
383
79
    VC1Context *v     = avctx->priv_data;
384
79
    MpegEncContext *s = &v->s;
385
    AVFrame *f;
386
    int ret;
387
388
79
    ff_mpeg_flush(avctx);
389
390
79
    if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
391
        return ret;
392
393
79
    s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
394
395
79
    if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
396
        av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
397
        return AVERROR_INVALIDDATA;
398
    }
399
400
79
    if (s->pict_type != AV_PICTURE_TYPE_I) {
401
        av_log(v->s.avctx, AV_LOG_ERROR, "expected I-frame\n");
402
        return AVERROR_INVALIDDATA;
403
    }
404
405
79
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
406
407
79
    if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
408
        av_log(v->s.avctx, AV_LOG_ERROR, "ff_mpv_frame_start error\n");
409
        avctx->pix_fmt = AV_PIX_FMT_RGB24;
410
        return ret;
411
    }
412
413
79
    ff_mpeg_er_frame_start(s);
414
415
79
    v->end_mb_x = (w + 15) >> 4;
416
79
    s->end_mb_y = (h + 15) >> 4;
417
79
    if (v->respic & 1)
418
53
        v->end_mb_x = v->end_mb_x + 1 >> 1;
419
79
    if (v->respic & 2)
420
53
        s->end_mb_y = s->end_mb_y + 1 >> 1;
421
422
79
    ff_vc1_decode_blocks(v);
423
424

79
    if (v->end_mb_x == s->mb_width && s->end_mb_y == s->mb_height) {
425
26
        ff_er_frame_end(&s->er);
426
    } else {
427
53
        av_log(v->s.avctx, AV_LOG_WARNING,
428
               "disabling error correction due to block count mismatch %dx%d != %dx%d\n",
429
               v->end_mb_x, s->end_mb_y, s->mb_width, s->mb_height);
430
    }
431
432
79
    ff_mpv_frame_end(s);
433
434
79
    f = s->current_picture.f;
435
436
79
    if (v->respic == 3) {
437
53
        ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w,      h);
438
53
        ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w+1 >> 1, h+1 >> 1);
439
53
        ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w+1 >> 1, h+1 >> 1);
440
26
    } else if (v->respic)
441
        avpriv_request_sample(v->s.avctx,
442
                              "Asymmetric WMV9 rectangle subsampling");
443
444
79
    av_assert0(f->linesize[1] == f->linesize[2]);
445
446
79
    if (wmv9_mask != -1)
447
79
        ctx->dsp.mss2_blit_wmv9_masked(c->rgb_pic + y * c->rgb_stride + x * 3,
448
                                       c->rgb_stride, wmv9_mask,
449
79
                                       c->pal_pic + y * c->pal_stride + x,
450
                                       c->pal_stride,
451
79
                                       f->data[0], f->linesize[0],
452
79
                                       f->data[1], f->data[2], f->linesize[1],
453
                                       w, h);
454
    else
455
        ctx->dsp.mss2_blit_wmv9(c->rgb_pic + y * c->rgb_stride + x * 3,
456
                                c->rgb_stride,
457
                                f->data[0], f->linesize[0],
458
                                f->data[1], f->data[2], f->linesize[1],
459
                                w, h);
460
461
79
    avctx->pix_fmt = AV_PIX_FMT_RGB24;
462
463
79
    return 0;
464
}
465
466
struct Rectangle {
467
    int coded, x, y, w, h;
468
};
469
470
#define MAX_WMV9_RECTANGLES 20
471
#define ARITH2_PADDING 2
472
473
108
static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
474
                             AVPacket *avpkt)
475
{
476
108
    const uint8_t *buf = avpkt->data;
477
108
    int buf_size       = avpkt->size;
478
108
    MSS2Context *ctx = avctx->priv_data;
479
108
    MSS12Context *c  = &ctx->c;
480
108
    AVFrame *frame   = data;
481
    GetBitContext gb;
482
    GetByteContext gB;
483
    ArithCoder acoder;
484
485
    int keyframe, has_wmv9, has_mv, is_rle, is_555, ret;
486
487
    struct Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;
488
108
    int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask);
489
490
108
    if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
491
        return ret;
492
493
108
    if (keyframe = get_bits1(&gb))
494
6
        skip_bits(&gb, 7);
495
108
    has_wmv9 = get_bits1(&gb);
496
108
    has_mv   = keyframe ? 0 : get_bits1(&gb);
497
108
    is_rle   = get_bits1(&gb);
498

108
    is_555   = is_rle && get_bits1(&gb);
499
108
    if (c->slice_split > 0)
500
        ctx->split_position = c->slice_split;
501
108
    else if (c->slice_split < 0) {
502
4
        if (get_bits1(&gb)) {
503
2
            if (get_bits1(&gb)) {
504
1
                if (get_bits1(&gb))
505
                    ctx->split_position = get_bits(&gb, 16);
506
                else
507
1
                    ctx->split_position = get_bits(&gb, 12);
508
            } else
509
1
                ctx->split_position = get_bits(&gb, 8) << 4;
510
        } else {
511
2
            if (keyframe)
512
1
                ctx->split_position = avctx->height / 2;
513
        }
514
    } else
515
104
        ctx->split_position = avctx->height;
516
517

108
    if (c->slice_split && (ctx->split_position < 1 - is_555 ||
518
4
                           ctx->split_position > avctx->height - 1))
519
        return AVERROR_INVALIDDATA;
520
521
108
    align_get_bits(&gb);
522
108
    buf      += get_bits_count(&gb) >> 3;
523
108
    buf_size -= get_bits_count(&gb) >> 3;
524
525
108
    if (buf_size < 1)
526
        return AVERROR_INVALIDDATA;
527
528


108
    if (is_555 && (has_wmv9 || has_mv || c->slice_split && ctx->split_position))
529
        return AVERROR_INVALIDDATA;
530
531
108
    avctx->pix_fmt = is_555 ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_RGB24;
532
108
    if (ctx->last_pic->format != avctx->pix_fmt)
533
5
        av_frame_unref(ctx->last_pic);
534
535
108
    if (has_wmv9) {
536
79
        bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
537
79
        arith2_init(&acoder, &gB);
538
539
79
        implicit_rect = !arith2_get_bit(&acoder);
540
541
82
        while (arith2_get_bit(&acoder)) {
542
3
            if (used_rects == MAX_WMV9_RECTANGLES)
543
                return AVERROR_INVALIDDATA;
544
3
            r = &wmv9rects[used_rects];
545
3
            if (!used_rects)
546
3
                r->x = arith2_get_number(&acoder, avctx->width);
547
            else
548
                r->x = arith2_get_number(&acoder, avctx->width -
549
                                         wmv9rects[used_rects - 1].x) +
550
                       wmv9rects[used_rects - 1].x;
551
3
            r->y = arith2_get_number(&acoder, avctx->height);
552
3
            r->w = arith2_get_number(&acoder, avctx->width  - r->x) + 1;
553
3
            r->h = arith2_get_number(&acoder, avctx->height - r->y) + 1;
554
3
            used_rects++;
555
        }
556
557

79
        if (implicit_rect && used_rects) {
558
            av_log(avctx, AV_LOG_ERROR, "implicit_rect && used_rects > 0\n");
559
            return AVERROR_INVALIDDATA;
560
        }
561
562
79
        if (implicit_rect) {
563
76
            wmv9rects[0].x = 0;
564
76
            wmv9rects[0].y = 0;
565
76
            wmv9rects[0].w = avctx->width;
566
76
            wmv9rects[0].h = avctx->height;
567
568
76
            used_rects = 1;
569
        }
570
158
        for (i = 0; i < used_rects; i++) {
571

79
            if (!implicit_rect && arith2_get_bit(&acoder)) {
572
                av_log(avctx, AV_LOG_ERROR, "Unexpected grandchildren\n");
573
                return AVERROR_INVALIDDATA;
574
            }
575
79
            if (!i) {
576
79
                wmv9_mask = arith2_get_bit(&acoder) - 1;
577
79
                if (!wmv9_mask)
578
79
                    wmv9_mask = arith2_get_number(&acoder, 256);
579
            }
580
79
            wmv9rects[i].coded = arith2_get_number(&acoder, 2);
581
        }
582
583
79
        buf      += arith2_get_consumed_bytes(&acoder);
584
79
        buf_size -= arith2_get_consumed_bytes(&acoder);
585
79
        if (buf_size < 1)
586
            return AVERROR_INVALIDDATA;
587
    }
588
589
108
    c->mvX = c->mvY = 0;
590

108
    if (keyframe && !is_555) {
591
4
        if ((i = decode_pal_v2(c, buf, buf_size)) < 0)
592
            return AVERROR_INVALIDDATA;
593
4
        buf      += i;
594
4
        buf_size -= i;
595
104
    } else if (has_mv) {
596
78
        buf      += 4;
597
78
        buf_size -= 4;
598
78
        if (buf_size < 1)
599
            return AVERROR_INVALIDDATA;
600
78
        c->mvX = AV_RB16(buf - 4) - avctx->width;
601
78
        c->mvY = AV_RB16(buf - 2) - avctx->height;
602
    }
603
604

108
    if (c->mvX < 0 || c->mvY < 0) {
605
42
        FFSWAP(uint8_t *, c->pal_pic, c->last_pal_pic);
606
607
42
        if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
608
            return ret;
609
610
42
        if (ctx->last_pic->data[0]) {
611
42
            av_assert0(frame->linesize[0] == ctx->last_pic->linesize[0]);
612
42
            c->last_rgb_pic = ctx->last_pic->data[0] +
613
42
                              ctx->last_pic->linesize[0] * (avctx->height - 1);
614
        } else {
615
            av_log(avctx, AV_LOG_ERROR, "Missing keyframe\n");
616
            return AVERROR_INVALIDDATA;
617
        }
618
    } else {
619
66
        if ((ret = ff_reget_buffer(avctx, ctx->last_pic, 0)) < 0)
620
            return ret;
621
66
        if ((ret = av_frame_ref(frame, ctx->last_pic)) < 0)
622
            return ret;
623
624
66
        c->last_rgb_pic = NULL;
625
    }
626
108
    c->rgb_pic    = frame->data[0] +
627
108
                    frame->linesize[0] * (avctx->height - 1);
628
108
    c->rgb_stride = -frame->linesize[0];
629
630
108
    frame->key_frame = keyframe;
631
108
    frame->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
632
633
108
    if (is_555) {
634
4
        bytestream2_init(&gB, buf, buf_size);
635
636
4
        if (decode_555(avctx, &gB, (uint16_t *)c->rgb_pic, c->rgb_stride >> 1,
637
                       keyframe, avctx->width, avctx->height))
638
            return AVERROR_INVALIDDATA;
639
640
4
        buf_size -= bytestream2_tell(&gB);
641
    } else {
642
104
        if (keyframe) {
643
4
            c->corrupted = 0;
644
4
            ff_mss12_slicecontext_reset(&ctx->sc[0]);
645
4
            if (c->slice_split)
646
1
                ff_mss12_slicecontext_reset(&ctx->sc[1]);
647
        }
648
104
        if (is_rle) {
649
4
            if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
650
                return ret;
651
4
            if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
652
4
                                 c->rgb_pic, c->rgb_stride, c->pal, keyframe,
653
                                 ctx->split_position, 0,
654
                                 avctx->width, avctx->height))
655
                return ret;
656
4
            align_get_bits(&gb);
657
658
4
            if (c->slice_split)
659
2
                if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
660
2
                                     c->rgb_pic, c->rgb_stride, c->pal, keyframe,
661
                                     ctx->split_position, 1,
662
                                     avctx->width, avctx->height))
663
                    return ret;
664
665
4
            align_get_bits(&gb);
666
4
            buf      += get_bits_count(&gb) >> 3;
667
4
            buf_size -= get_bits_count(&gb) >> 3;
668

100
        } else if (!implicit_rect || wmv9_mask != -1) {
669
100
            if (c->corrupted)
670
                return AVERROR_INVALIDDATA;
671
100
            bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
672
100
            arith2_init(&acoder, &gB);
673
100
            c->keyframe = keyframe;
674
100
            if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0,
675
                                                    avctx->width,
676
                                                    ctx->split_position))
677
                return AVERROR_INVALIDDATA;
678
679
100
            buf      += arith2_get_consumed_bytes(&acoder);
680
100
            buf_size -= arith2_get_consumed_bytes(&acoder);
681
100
            if (c->slice_split) {
682
                if (buf_size < 1)
683
                    return AVERROR_INVALIDDATA;
684
                bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
685
                arith2_init(&acoder, &gB);
686
                if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0,
687
                                                        ctx->split_position,
688
                                                        avctx->width,
689
                                                        avctx->height - ctx->split_position))
690
                    return AVERROR_INVALIDDATA;
691
692
                buf      += arith2_get_consumed_bytes(&acoder);
693
                buf_size -= arith2_get_consumed_bytes(&acoder);
694
            }
695
        } else
696
            memset(c->pal_pic, 0, c->pal_stride * avctx->height);
697
    }
698
699
108
    if (has_wmv9) {
700
158
        for (i = 0; i < used_rects; i++) {
701
79
            int x = wmv9rects[i].x;
702
79
            int y = wmv9rects[i].y;
703
79
            int w = wmv9rects[i].w;
704
79
            int h = wmv9rects[i].h;
705
79
            if (wmv9rects[i].coded) {
706
                int WMV9codedFrameSize;
707

79
                if (buf_size < 4 || !(WMV9codedFrameSize = AV_RL24(buf)))
708
                    return AVERROR_INVALIDDATA;
709
79
                if (ret = decode_wmv9(avctx, buf + 3, buf_size - 3,
710
                                      x, y, w, h, wmv9_mask))
711
                    return ret;
712
79
                buf      += WMV9codedFrameSize + 3;
713
79
                buf_size -= WMV9codedFrameSize + 3;
714
            } else {
715
                uint8_t *dst = c->rgb_pic + y * c->rgb_stride + x * 3;
716
                if (wmv9_mask != -1) {
717
                    ctx->dsp.mss2_gray_fill_masked(dst, c->rgb_stride,
718
                                                   wmv9_mask,
719
                                                   c->pal_pic + y * c->pal_stride + x,
720
                                                   c->pal_stride,
721
                                                   w, h);
722
                } else {
723
                    do {
724
                        memset(dst, 0x80, w * 3);
725
                        dst += c->rgb_stride;
726
                    } while (--h);
727
                }
728
            }
729
        }
730
    }
731
732
108
    if (buf_size)
733
        av_log(avctx, AV_LOG_WARNING, "buffer not fully consumed\n");
734
735

108
    if (c->mvX < 0 || c->mvY < 0) {
736
42
        av_frame_unref(ctx->last_pic);
737
42
        ret = av_frame_ref(ctx->last_pic, frame);
738
42
        if (ret < 0)
739
            return ret;
740
    }
741
742
108
    *got_frame       = 1;
743
744
108
    return avpkt->size;
745
}
746
747
10
static av_cold int wmv9_init(AVCodecContext *avctx)
748
{
749
10
    VC1Context *v = avctx->priv_data;
750
    int ret;
751
752
10
    v->s.avctx    = avctx;
753
754
10
    if ((ret = ff_vc1_init_common(v)) < 0)
755
        return ret;
756
10
    ff_vc1dsp_init(&v->vc1dsp);
757
758
10
    v->profile = PROFILE_MAIN;
759
760
10
    v->zz_8x4     = ff_wmv2_scantableA;
761
10
    v->zz_4x8     = ff_wmv2_scantableB;
762
10
    v->res_y411   = 0;
763
10
    v->res_sprite = 0;
764
765
10
    v->frmrtq_postproc = 7;
766
10
    v->bitrtq_postproc = 31;
767
768
10
    v->res_x8          = 0;
769
10
    v->multires        = 0;
770
10
    v->res_fasttx      = 1;
771
772
10
    v->fastuvmc        = 0;
773
774
10
    v->extended_mv     = 0;
775
776
10
    v->dquant          = 1;
777
10
    v->vstransform     = 1;
778
779
10
    v->res_transtab    = 0;
780
781
10
    v->overlap         = 0;
782
783
10
    v->resync_marker   = 0;
784
10
    v->rangered        = 0;
785
786
10
    v->s.max_b_frames = avctx->max_b_frames = 0;
787
10
    v->quantizer_mode = 0;
788
789
10
    v->finterpflag = 0;
790
791
10
    v->res_rtm_flag = 1;
792
793
10
    ff_vc1_init_transposed_scantables(v);
794
795

20
    if ((ret = ff_msmpeg4_decode_init(avctx)) < 0 ||
796
10
        (ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
797
        return ret;
798
799
    /* error concealment */
800
10
    v->s.me.qpel_put = v->s.qdsp.put_qpel_pixels_tab;
801
10
    v->s.me.qpel_avg = v->s.qdsp.avg_qpel_pixels_tab;
802
803
10
    return 0;
804
}
805
806
10
static av_cold int mss2_decode_end(AVCodecContext *avctx)
807
{
808
10
    MSS2Context *const ctx = avctx->priv_data;
809
810
10
    av_frame_free(&ctx->last_pic);
811
812
10
    ff_mss12_decode_end(&ctx->c);
813
10
    av_freep(&ctx->c.pal_pic);
814
10
    av_freep(&ctx->c.last_pal_pic);
815
10
    ff_vc1_decode_end(avctx);
816
817
10
    return 0;
818
}
819
820
10
static av_cold int mss2_decode_init(AVCodecContext *avctx)
821
{
822
10
    MSS2Context * const ctx = avctx->priv_data;
823
10
    MSS12Context *c = &ctx->c;
824
    int ret;
825
10
    c->avctx = avctx;
826
10
    if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))
827
        return ret;
828
10
    ctx->last_pic   = av_frame_alloc();
829
10
    c->pal_stride   = c->mask_stride;
830
10
    c->pal_pic      = av_mallocz(c->pal_stride * avctx->height);
831
10
    c->last_pal_pic = av_mallocz(c->pal_stride * avctx->height);
832

10
    if (!c->pal_pic || !c->last_pal_pic || !ctx->last_pic) {
833
        mss2_decode_end(avctx);
834
        return AVERROR(ENOMEM);
835
    }
836
10
    if (ret = wmv9_init(avctx)) {
837
        mss2_decode_end(avctx);
838
        return ret;
839
    }
840
10
    ff_mss2dsp_init(&ctx->dsp);
841
10
    ff_qpeldsp_init(&ctx->qdsp);
842
843
20
    avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555
844
10
                                            : AV_PIX_FMT_RGB24;
845
846
847
10
    return 0;
848
}
849
850
AVCodec ff_mss2_decoder = {
851
    .name           = "mss2",
852
    .long_name      = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),
853
    .type           = AVMEDIA_TYPE_VIDEO,
854
    .id             = AV_CODEC_ID_MSS2,
855
    .priv_data_size = sizeof(MSS2Context),
856
    .init           = mss2_decode_init,
857
    .close          = mss2_decode_end,
858
    .decode         = mss2_decode_frame,
859
    .capabilities   = AV_CODEC_CAP_DR1,
860
};