GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mss2.c Lines: 428 507 84.4 %
Date: 2019-11-22 03:34:36 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->bits = buf_size * 8;
416
417
79
    v->end_mb_x = (w + 15) >> 4;
418
79
    s->end_mb_y = (h + 15) >> 4;
419
79
    if (v->respic & 1)
420
53
        v->end_mb_x = v->end_mb_x + 1 >> 1;
421
79
    if (v->respic & 2)
422
53
        s->end_mb_y = s->end_mb_y + 1 >> 1;
423
424
79
    ff_vc1_decode_blocks(v);
425
426

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

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

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


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

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

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

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

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

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

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

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

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

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