← Back to branch summary

~siretart/libav/trusty-security

« back to all changes in this revision

Viewing changes to libavcodec/mss2.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/mss2.c
 
1
/*
 
2
 * Microsoft Screen 2 (aka Windows Media Video V9 Screen) decoder
 
3
 *
 
4
 * This file is part of Libav.
 
5
 *
 
6
 * Libav 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
 * Libav 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 Libav; 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 "internal.h"
 
28
#include "msmpeg4data.h"
 
29
#include "vc1.h"
 
30
#include "mss12.h"
 
31
#include "mss2dsp.h"
 
32
 
 
33
typedef struct MSS2Context {
 
34
    VC1Context     v;
 
35
    int            split_position;
 
36
    AVFrame        pic;
 
37
    AVFrame        last_pic;
 
38
    MSS12Context   c;
 
39
    MSS2DSPContext dsp;
 
40
    SliceContext   sc[2];
 
41
} MSS2Context;
 
42
 
 
43
static void arith2_normalise(ArithCoder *c)
 
44
{
 
45
    while ((c->high >> 15) - (c->low >> 15) < 2) {
 
46
        if ((c->low ^ c->high) & 0x10000) {
 
47
            c->high  ^= 0x8000;
 
48
            c->value ^= 0x8000;
 
49
            c->low   ^= 0x8000;
 
50
        }
 
51
        c->high  = c->high  << 8 & 0xFFFFFF | 0xFF;
 
52
        c->value = c->value << 8 & 0xFFFFFF | bytestream2_get_byte(c->gbc.gB);
 
53
        c->low   = c->low   << 8 & 0xFFFFFF;
 
54
    }
 
55
}
 
56
 
 
57
ARITH_GET_BIT(2)
 
58
 
 
59
/* L. Stuiver and A. Moffat: "Piecewise Integer Mapping for Arithmetic Coding."
 
60
 * In Proc. 8th Data Compression Conference (DCC '98), pp. 3-12, Mar. 1998 */
 
61
 
 
62
static int arith2_get_scaled_value(int value, int n, int range)
 
63
{
 
64
    int split = (n << 1) - range;
 
65
 
 
66
    if (value > split)
 
67
        return split + (value - split >> 1);
 
68
    else
 
69
        return value;
 
70
}
 
71
 
 
72
static void arith2_rescale_interval(ArithCoder *c, int range,
 
73
                                    int low, int high, int n)
 
74
{
 
75
    int split = (n << 1) - range;
 
76
 
 
77
    if (high > split)
 
78
        c->high = split + (high - split << 1);
 
79
    else
 
80
        c->high = high;
 
81
 
 
82
    c->high += c->low - 1;
 
83
 
 
84
    if (low > split)
 
85
        c->low += split + (low - split << 1);
 
86
    else
 
87
        c->low += low;
 
88
}
 
89
 
 
90
static int arith2_get_number(ArithCoder *c, int n)
 
91
{
 
92
    int range = c->high - c->low + 1;
 
93
    int scale = av_log2(range) - av_log2(n);
 
94
    int val;
 
95
 
 
96
    if (n << scale > range)
 
97
        scale--;
 
98
 
 
99
    n <<= scale;
 
100
 
 
101
    val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
 
102
 
 
103
    arith2_rescale_interval(c, range, val << scale, (val + 1) << scale, n);
 
104
 
 
105
    arith2_normalise(c);
 
106
 
 
107
    return val;
 
108
}
 
109
 
 
110
static int arith2_get_prob(ArithCoder *c, int16_t *probs)
 
111
{
 
112
    int range = c->high - c->low + 1, n = *probs;
 
113
    int scale = av_log2(range) - av_log2(n);
 
114
    int i     = 0, val;
 
115
 
 
116
    if (n << scale > range)
 
117
        scale--;
 
118
 
 
119
    n <<= scale;
 
120
 
 
121
    val = arith2_get_scaled_value(c->value - c->low, n, range) >> scale;
 
122
    while (probs[++i] > val) ;
 
123
 
 
124
    arith2_rescale_interval(c, range,
 
125
                            probs[i] << scale, probs[i - 1] << scale, n);
 
126
 
 
127
    return i;
 
128
}
 
129
 
 
130
ARITH_GET_MODEL_SYM(2)
 
131
 
 
132
static int arith2_get_consumed_bytes(ArithCoder *c)
 
133
{
 
134
    int diff = (c->high >> 16) - (c->low >> 16);
 
135
    int bp   = bytestream2_tell(c->gbc.gB) - 3 << 3;
 
136
    int bits = 1;
 
137
 
 
138
    while (!(diff & 0x80)) {
 
139
        bits++;
 
140
        diff <<= 1;
 
141
    }
 
142
 
 
143
    return (bits + bp + 7 >> 3) + ((c->low >> 16) + 1 == c->high >> 16);
 
144
}
 
145
 
 
146
static void arith2_init(ArithCoder *c, GetByteContext *gB)
 
147
{
 
148
    c->low           = 0;
 
149
    c->high          = 0xFFFFFF;
 
150
    c->value         = bytestream2_get_be24(gB);
 
151
    c->gbc.gB        = gB;
 
152
    c->get_model_sym = arith2_get_model_sym;
 
153
    c->get_number    = arith2_get_number;
 
154
}
 
155
 
 
156
static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)
 
157
{
 
158
    int i, ncol;
 
159
    uint32_t *pal = ctx->pal + 256 - ctx->free_colours;
 
160
 
 
161
    if (!ctx->free_colours)
 
162
        return 0;
 
163
 
 
164
    ncol = *buf++;
 
165
    if (ncol > ctx->free_colours || buf_size < 2 + ncol * 3)
 
166
        return -1;
 
167
    for (i = 0; i < ncol; i++)
 
168
        *pal++ = AV_RB24(buf + 3 * i);
 
169
 
 
170
    return 1 + ncol * 3;
 
171
}
 
172
 
 
173
static int decode_555(GetByteContext *gB, uint16_t *dst, int stride,
 
174
                      int keyframe, int w, int h)
 
175
{
 
176
    int last_symbol = 0, repeat = 0, prev_avail = 0;
 
177
 
 
178
    if (!keyframe) {
 
179
        int x, y, endx, endy, t;
 
180
 
 
181
#define READ_PAIR(a, b)                 \
 
182
    a  = bytestream2_get_byte(gB) << 4; \
 
183
    t  = bytestream2_get_byte(gB);      \
 
184
    a |= t >> 4;                        \
 
185
    b  = (t & 0xF) << 8;                \
 
186
    b |= bytestream2_get_byte(gB);      \
 
187
 
 
188
        READ_PAIR(x, endx)
 
189
        READ_PAIR(y, endy)
 
190
 
 
191
        if (endx >= w || endy >= h || x > endx || y > endy)
 
192
            return -1;
 
193
        dst += x + stride * y;
 
194
        w    = endx - x + 1;
 
195
        h    = endy - y + 1;
 
196
        if (y)
 
197
            prev_avail = 1;
 
198
    }
 
199
 
 
200
    do {
 
201
        uint16_t *p = dst;
 
202
        do {
 
203
            if (repeat-- < 1) {
 
204
                int b = bytestream2_get_byte(gB);
 
205
                if (b < 128)
 
206
                    last_symbol = b << 8 | bytestream2_get_byte(gB);
 
207
                else if (b > 129) {
 
208
                    repeat = 0;
 
209
                    while (b-- > 130)
 
210
                        repeat = (repeat << 8) + bytestream2_get_byte(gB) + 1;
 
211
                    if (last_symbol == -2) {
 
212
                        int skip = FFMIN((unsigned)repeat, dst + w - p);
 
213
                        repeat -= skip;
 
214
                        p      += skip;
 
215
                    }
 
216
                } else
 
217
                    last_symbol = 127 - b;
 
218
            }
 
219
            if (last_symbol >= 0)
 
220
                *p = last_symbol;
 
221
            else if (last_symbol == -1 && prev_avail)
 
222
                *p = *(p - stride);
 
223
        } while (++p < dst + w);
 
224
        dst       += stride;
 
225
        prev_avail = 1;
 
226
    } while (--h);
 
227
 
 
228
    return 0;
 
229
}
 
230
 
 
231
static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, int pal_stride,
 
232
                      uint8_t *rgb_dst, int rgb_stride, uint32_t *pal,
 
233
                      int keyframe, int kf_slipt, int slice, int w, int h)
 
234
{
 
235
    uint8_t bits[270] = { 0 };
 
236
    uint32_t codes[270];
 
237
    VLC vlc;
 
238
 
 
239
    int current_length = 0, read_codes = 0, next_code = 0, current_codes = 0;
 
240
    int remaining_codes, surplus_codes, i;
 
241
 
 
242
    const int alphabet_size = 270 - keyframe;
 
243
 
 
244
    int last_symbol = 0, repeat = 0, prev_avail = 0;
 
245
 
 
246
    if (!keyframe) {
 
247
        int x, y, clipw, cliph;
 
248
 
 
249
        x     = get_bits(gb, 12);
 
250
        y     = get_bits(gb, 12);
 
251
        clipw = get_bits(gb, 12) + 1;
 
252
        cliph = get_bits(gb, 12) + 1;
 
253
 
 
254
        if (x + clipw > w || y + cliph > h)
 
255
            return AVERROR_INVALIDDATA;
 
256
        pal_dst += pal_stride * y + x;
 
257
        rgb_dst += rgb_stride * y + x * 3;
 
258
        w        = clipw;
 
259
        h        = cliph;
 
260
        if (y)
 
261
            prev_avail = 1;
 
262
    } else {
 
263
        if (slice > 0) {
 
264
            pal_dst   += pal_stride * kf_slipt;
 
265
            rgb_dst   += rgb_stride * kf_slipt;
 
266
            prev_avail = 1;
 
267
            h         -= kf_slipt;
 
268
        } else
 
269
            h = kf_slipt;
 
270
    }
 
271
 
 
272
    /* read explicit codes */
 
273
    do {
 
274
        while (current_codes--) {
 
275
            int symbol = get_bits(gb, 8);
 
276
            if (symbol >= 204 - keyframe)
 
277
                symbol += 14 - keyframe;
 
278
            else if (symbol > 189)
 
279
                symbol = get_bits1(gb) + (symbol << 1) - 190;
 
280
            if (bits[symbol])
 
281
                return AVERROR_INVALIDDATA;
 
282
            bits[symbol]  = current_length;
 
283
            codes[symbol] = next_code++;
 
284
            read_codes++;
 
285
        }
 
286
        current_length++;
 
287
        next_code     <<= 1;
 
288
        remaining_codes = (1 << current_length) - next_code;
 
289
        current_codes   = get_bits(gb, av_ceil_log2(remaining_codes + 1));
 
290
        if (current_length > 22 || current_codes > remaining_codes)
 
291
            return AVERROR_INVALIDDATA;
 
292
    } while (current_codes != remaining_codes);
 
293
 
 
294
    remaining_codes = alphabet_size - read_codes;
 
295
 
 
296
    /* determine the minimum length to fit the rest of the alphabet */
 
297
    while ((surplus_codes = (2 << current_length) -
 
298
                            (next_code << 1) - remaining_codes) < 0) {
 
299
        current_length++;
 
300
        next_code <<= 1;
 
301
    }
 
302
 
 
303
    /* add the rest of the symbols lexicographically */
 
304
    for (i = 0; i < alphabet_size; i++)
 
305
        if (!bits[i]) {
 
306
            if (surplus_codes-- == 0) {
 
307
                current_length++;
 
308
                next_code <<= 1;
 
309
            }
 
310
            bits[i]  = current_length;
 
311
            codes[i] = next_code++;
 
312
        }
 
313
 
 
314
    if (next_code != 1 << current_length)
 
315
        return AVERROR_INVALIDDATA;
 
316
 
 
317
    if (i = init_vlc(&vlc, 9, alphabet_size, bits, 1, 1, codes, 4, 4, 0))
 
318
        return i;
 
319
 
 
320
    /* frame decode */
 
321
    do {
 
322
        uint8_t *pp = pal_dst;
 
323
        uint8_t *rp = rgb_dst;
 
324
        do {
 
325
            if (repeat-- < 1) {
 
326
                int b = get_vlc2(gb, vlc.table, 9, 3);
 
327
                if (b < 256)
 
328
                    last_symbol = b;
 
329
                else if (b < 268) {
 
330
                    b -= 256;
 
331
                    if (b == 11)
 
332
                        b = get_bits(gb, 4) + 10;
 
333
 
 
334
                    if (!b)
 
335
                        repeat = 0;
 
336
                    else
 
337
                        repeat = get_bits(gb, b);
 
338
 
 
339
                    repeat += (1 << b) - 1;
 
340
 
 
341
                    if (last_symbol == -2) {
 
342
                        int skip = FFMIN(repeat, pal_dst + w - pp);
 
343
                        repeat -= skip;
 
344
                        pp     += skip;
 
345
                        rp     += skip * 3;
 
346
                    }
 
347
                } else
 
348
                    last_symbol = 267 - b;
 
349
            }
 
350
            if (last_symbol >= 0) {
 
351
                *pp = last_symbol;
 
352
                AV_WB24(rp, pal[last_symbol]);
 
353
            } else if (last_symbol == -1 && prev_avail) {
 
354
                *pp = *(pp - pal_stride);
 
355
                memcpy(rp, rp - rgb_stride, 3);
 
356
            }
 
357
            rp += 3;
 
358
        } while (++pp < pal_dst + w);
 
359
        pal_dst   += pal_stride;
 
360
        rgb_dst   += rgb_stride;
 
361
        prev_avail = 1;
 
362
    } while (--h);
 
363
 
 
364
    ff_free_vlc(&vlc);
 
365
    return 0;
 
366
}
 
367
 
 
368
static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
 
369
                       int x, int y, int w, int h, int wmv9_mask)
 
370
{
 
371
    MSS2Context *ctx  = avctx->priv_data;
 
372
    MSS12Context *c   = &ctx->c;
 
373
    VC1Context *v     = avctx->priv_data;
 
374
    MpegEncContext *s = &v->s;
 
375
    AVFrame *f;
 
376
 
 
377
    ff_mpeg_flush(avctx);
 
378
 
 
379
    if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
 
380
        int i = ff_find_unused_picture(s, 0);
 
381
        if (i < 0)
 
382
            return -1;
 
383
        s->current_picture_ptr = &s->picture[i];
 
384
    }
 
385
 
 
386
    init_get_bits(&s->gb, buf, buf_size * 8);
 
387
 
 
388
    s->loop_filter = avctx->skip_loop_filter < AVDISCARD_ALL;
 
389
 
 
390
    if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
 
391
        av_log(v->s.avctx, AV_LOG_ERROR, "header error\n");
 
392
        return AVERROR_INVALIDDATA;
 
393
    }
 
394
 
 
395
    if (s->pict_type != AV_PICTURE_TYPE_I) {
 
396
        av_log(v->s.avctx, AV_LOG_ERROR, "expected I-frame\n");
 
397
        return AVERROR_INVALIDDATA;
 
398
    }
 
399
 
 
400
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 
401
 
 
402
    if (ff_MPV_frame_start(s, avctx) < 0) {
 
403
        av_log(v->s.avctx, AV_LOG_ERROR, "ff_MPV_frame_start error\n");
 
404
        avctx->pix_fmt = AV_PIX_FMT_RGB24;
 
405
        return -1;
 
406
    }
 
407
 
 
408
    ff_er_frame_start(s);
 
409
 
 
410
    v->bits = buf_size * 8;
 
411
 
 
412
    v->end_mb_x = (w + 15) >> 4;
 
413
    s->end_mb_y = (h + 15) >> 4;
 
414
    if (v->respic & 1)
 
415
        v->end_mb_x = v->end_mb_x + 1 >> 1;
 
416
    if (v->respic & 2)
 
417
        s->end_mb_y = s->end_mb_y + 1 >> 1;
 
418
 
 
419
    ff_vc1_decode_blocks(v);
 
420
 
 
421
    ff_er_frame_end(s);
 
422
 
 
423
    ff_MPV_frame_end(s);
 
424
 
 
425
    f = &s->current_picture.f;
 
426
 
 
427
    if (v->respic == 3) {
 
428
        ctx->dsp.upsample_plane(f->data[0], f->linesize[0], w,      h);
 
429
        ctx->dsp.upsample_plane(f->data[1], f->linesize[1], w >> 1, h >> 1);
 
430
        ctx->dsp.upsample_plane(f->data[2], f->linesize[2], w >> 1, h >> 1);
 
431
    } else if (v->respic)
 
432
        av_log_ask_for_sample(v->s.avctx,
 
433
                              "Asymmetric WMV9 rectangle subsampling\n");
 
434
 
 
435
    av_assert0(f->linesize[1] == f->linesize[2]);
 
436
 
 
437
    if (wmv9_mask != -1)
 
438
        ctx->dsp.mss2_blit_wmv9_masked(c->rgb_pic + y * c->rgb_stride + x * 3,
 
439
                                       c->rgb_stride, wmv9_mask,
 
440
                                       c->pal_pic + y * c->pal_stride + x,
 
441
                                       c->pal_stride,
 
442
                                       f->data[0], f->linesize[0],
 
443
                                       f->data[1], f->data[2], f->linesize[1],
 
444
                                       w, h);
 
445
    else
 
446
        ctx->dsp.mss2_blit_wmv9(c->rgb_pic + y * c->rgb_stride + x * 3,
 
447
                                c->rgb_stride,
 
448
                                f->data[0], f->linesize[0],
 
449
                                f->data[1], f->data[2], f->linesize[1],
 
450
                                w, h);
 
451
 
 
452
    avctx->pix_fmt = AV_PIX_FMT_RGB24;
 
453
 
 
454
    return 0;
 
455
}
 
456
 
 
457
typedef struct Rectangle {
 
458
    int coded, x, y, w, h;
 
459
} Rectangle;
 
460
 
 
461
#define MAX_WMV9_RECTANGLES 20
 
462
#define ARITH2_PADDING 2
 
463
 
 
464
static int mss2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
465
                             AVPacket *avpkt)
 
466
{
 
467
    const uint8_t *buf = avpkt->data;
 
468
    int buf_size       = avpkt->size;
 
469
    MSS2Context *ctx = avctx->priv_data;
 
470
    MSS12Context *c  = &ctx->c;
 
471
    GetBitContext gb;
 
472
    GetByteContext gB;
 
473
    ArithCoder acoder;
 
474
 
 
475
    int keyframe, has_wmv9, has_mv, is_rle, is_555, ret;
 
476
 
 
477
    Rectangle wmv9rects[MAX_WMV9_RECTANGLES], *r;
 
478
    int used_rects = 0, i, implicit_rect = 0, av_uninit(wmv9_mask);
 
479
 
 
480
    av_assert0(FF_INPUT_BUFFER_PADDING_SIZE >=
 
481
               ARITH2_PADDING + (MIN_CACHE_BITS + 7) / 8);
 
482
 
 
483
    init_get_bits(&gb, buf, buf_size * 8);
 
484
 
 
485
    if (keyframe = get_bits1(&gb))
 
486
        skip_bits(&gb, 7);
 
487
    has_wmv9 = get_bits1(&gb);
 
488
    has_mv   = keyframe ? 0 : get_bits1(&gb);
 
489
    is_rle   = get_bits1(&gb);
 
490
    is_555   = is_rle && get_bits1(&gb);
 
491
    if (c->slice_split > 0)
 
492
        ctx->split_position = c->slice_split;
 
493
    else if (c->slice_split < 0) {
 
494
        if (get_bits1(&gb)) {
 
495
            if (get_bits1(&gb)) {
 
496
                if (get_bits1(&gb))
 
497
                    ctx->split_position = get_bits(&gb, 16);
 
498
                else
 
499
                    ctx->split_position = get_bits(&gb, 12);
 
500
            } else
 
501
                ctx->split_position = get_bits(&gb, 8) << 4;
 
502
        } else {
 
503
            if (keyframe)
 
504
                ctx->split_position = avctx->height / 2;
 
505
        }
 
506
    } else
 
507
        ctx->split_position = avctx->height;
 
508
 
 
509
    if (c->slice_split && (ctx->split_position < 1 - is_555 ||
 
510
                           ctx->split_position > avctx->height - 1))
 
511
        return AVERROR_INVALIDDATA;
 
512
 
 
513
    align_get_bits(&gb);
 
514
    buf      += get_bits_count(&gb) >> 3;
 
515
    buf_size -= get_bits_count(&gb) >> 3;
 
516
 
 
517
    if (buf_size < 1)
 
518
        return AVERROR_INVALIDDATA;
 
519
 
 
520
    if (is_555 && (has_wmv9 || has_mv || c->slice_split && ctx->split_position))
 
521
        return AVERROR_INVALIDDATA;
 
522
 
 
523
    avctx->pix_fmt = is_555 ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_RGB24;
 
524
    if (ctx->pic.data[0] && ctx->pic.format != avctx->pix_fmt)
 
525
        avctx->release_buffer(avctx, &ctx->pic);
 
526
 
 
527
    if (has_wmv9) {
 
528
        bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
 
529
        arith2_init(&acoder, &gB);
 
530
 
 
531
        implicit_rect = !arith2_get_bit(&acoder);
 
532
 
 
533
        while (arith2_get_bit(&acoder)) {
 
534
            if (used_rects == MAX_WMV9_RECTANGLES)
 
535
                return AVERROR_INVALIDDATA;
 
536
            r = &wmv9rects[used_rects];
 
537
            if (!used_rects)
 
538
                r->x = arith2_get_number(&acoder, avctx->width);
 
539
            else
 
540
                r->x = arith2_get_number(&acoder, avctx->width -
 
541
                                         wmv9rects[used_rects - 1].x) +
 
542
                       wmv9rects[used_rects - 1].x;
 
543
            r->y = arith2_get_number(&acoder, avctx->height);
 
544
            r->w = arith2_get_number(&acoder, avctx->width  - r->x) + 1;
 
545
            r->h = arith2_get_number(&acoder, avctx->height - r->y) + 1;
 
546
            used_rects++;
 
547
        }
 
548
 
 
549
        if (implicit_rect && used_rects) {
 
550
            av_log(avctx, AV_LOG_ERROR, "implicit_rect && used_rects > 0\n");
 
551
            return AVERROR_INVALIDDATA;
 
552
        }
 
553
 
 
554
        if (implicit_rect) {
 
555
            wmv9rects[0].x = 0;
 
556
            wmv9rects[0].y = 0;
 
557
            wmv9rects[0].w = avctx->width;
 
558
            wmv9rects[0].h = avctx->height;
 
559
 
 
560
            used_rects = 1;
 
561
        }
 
562
        for (i = 0; i < used_rects; i++) {
 
563
            if (!implicit_rect && arith2_get_bit(&acoder)) {
 
564
                av_log(avctx, AV_LOG_ERROR, "Unexpected grandchildren\n");
 
565
                return AVERROR_INVALIDDATA;
 
566
            }
 
567
            if (!i) {
 
568
                wmv9_mask = arith2_get_bit(&acoder) - 1;
 
569
                if (!wmv9_mask)
 
570
                    wmv9_mask = arith2_get_number(&acoder, 256);
 
571
            }
 
572
            wmv9rects[i].coded = arith2_get_number(&acoder, 2);
 
573
        }
 
574
 
 
575
        buf      += arith2_get_consumed_bytes(&acoder);
 
576
        buf_size -= arith2_get_consumed_bytes(&acoder);
 
577
        if (buf_size < 1)
 
578
            return AVERROR_INVALIDDATA;
 
579
    }
 
580
 
 
581
    c->mvX = c->mvY = 0;
 
582
    if (keyframe && !is_555) {
 
583
        if ((i = decode_pal_v2(c, buf, buf_size)) < 0)
 
584
            return AVERROR_INVALIDDATA;
 
585
        buf      += i;
 
586
        buf_size -= i;
 
587
    } else if (has_mv) {
 
588
        buf      += 4;
 
589
        buf_size -= 4;
 
590
        if (buf_size < 1)
 
591
            return AVERROR_INVALIDDATA;
 
592
        c->mvX = AV_RB16(buf - 4) - avctx->width;
 
593
        c->mvY = AV_RB16(buf - 2) - avctx->height;
 
594
    }
 
595
 
 
596
    if (c->mvX < 0 || c->mvY < 0) {
 
597
        FFSWAP(AVFrame, ctx->pic, ctx->last_pic);
 
598
        FFSWAP(uint8_t *, c->pal_pic, c->last_pal_pic);
 
599
 
 
600
        if (ctx->pic.data[0])
 
601
            avctx->release_buffer(avctx, &ctx->pic);
 
602
 
 
603
        ctx->pic.reference    = 3;
 
604
        ctx->pic.buffer_hints = FF_BUFFER_HINTS_VALID    |
 
605
                                FF_BUFFER_HINTS_READABLE |
 
606
                                FF_BUFFER_HINTS_PRESERVE |
 
607
                                FF_BUFFER_HINTS_REUSABLE;
 
608
 
 
609
        if ((ret = ff_get_buffer(avctx, &ctx->pic)) < 0) {
 
610
            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 
611
            return ret;
 
612
        }
 
613
 
 
614
        if (ctx->last_pic.data[0]) {
 
615
            av_assert0(ctx->pic.linesize[0] == ctx->last_pic.linesize[0]);
 
616
            c->last_rgb_pic = ctx->last_pic.data[0] +
 
617
                              ctx->last_pic.linesize[0] * (avctx->height - 1);
 
618
        } else {
 
619
            av_log(avctx, AV_LOG_ERROR, "Missing keyframe\n");
 
620
            return -1;
 
621
        }
 
622
    } else {
 
623
        if (ctx->last_pic.data[0])
 
624
            avctx->release_buffer(avctx, &ctx->last_pic);
 
625
 
 
626
        ctx->pic.reference    = 3;
 
627
        ctx->pic.buffer_hints = FF_BUFFER_HINTS_VALID    |
 
628
                                FF_BUFFER_HINTS_READABLE |
 
629
                                FF_BUFFER_HINTS_PRESERVE |
 
630
                                FF_BUFFER_HINTS_REUSABLE;
 
631
 
 
632
        if ((ret = avctx->reget_buffer(avctx, &ctx->pic)) < 0) {
 
633
            av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 
634
            return ret;
 
635
        }
 
636
 
 
637
        c->last_rgb_pic = NULL;
 
638
    }
 
639
    c->rgb_pic    = ctx->pic.data[0] +
 
640
                    ctx->pic.linesize[0] * (avctx->height - 1);
 
641
    c->rgb_stride = -ctx->pic.linesize[0];
 
642
 
 
643
    ctx->pic.key_frame = keyframe;
 
644
    ctx->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 
645
 
 
646
    if (is_555) {
 
647
        bytestream2_init(&gB, buf, buf_size);
 
648
 
 
649
        if (decode_555(&gB, (uint16_t *)c->rgb_pic, c->rgb_stride >> 1,
 
650
                       keyframe, avctx->width, avctx->height))
 
651
            return AVERROR_INVALIDDATA;
 
652
 
 
653
        buf_size -= bytestream2_tell(&gB);
 
654
    } else {
 
655
        if (keyframe) {
 
656
            c->corrupted = 0;
 
657
            ff_mss12_slicecontext_reset(&ctx->sc[0]);
 
658
            if (c->slice_split)
 
659
                ff_mss12_slicecontext_reset(&ctx->sc[1]);
 
660
        }
 
661
        if (is_rle) {
 
662
            init_get_bits(&gb, buf, buf_size * 8);
 
663
            if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
 
664
                                 c->rgb_pic, c->rgb_stride, c->pal, keyframe,
 
665
                                 ctx->split_position, 0,
 
666
                                 avctx->width, avctx->height))
 
667
                return ret;
 
668
            align_get_bits(&gb);
 
669
 
 
670
            if (c->slice_split)
 
671
                if (ret = decode_rle(&gb, c->pal_pic, c->pal_stride,
 
672
                                     c->rgb_pic, c->rgb_stride, c->pal, keyframe,
 
673
                                     ctx->split_position, 1,
 
674
                                     avctx->width, avctx->height))
 
675
                    return ret;
 
676
 
 
677
            align_get_bits(&gb);
 
678
            buf      += get_bits_count(&gb) >> 3;
 
679
            buf_size -= get_bits_count(&gb) >> 3;
 
680
        } else if (!implicit_rect || wmv9_mask != -1) {
 
681
            if (c->corrupted)
 
682
                return AVERROR_INVALIDDATA;
 
683
            bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
 
684
            arith2_init(&acoder, &gB);
 
685
            c->keyframe = keyframe;
 
686
            if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[0], &acoder, 0, 0,
 
687
                                                    avctx->width,
 
688
                                                    ctx->split_position))
 
689
                return AVERROR_INVALIDDATA;
 
690
 
 
691
            buf      += arith2_get_consumed_bytes(&acoder);
 
692
            buf_size -= arith2_get_consumed_bytes(&acoder);
 
693
            if (c->slice_split) {
 
694
                if (buf_size < 1)
 
695
                    return AVERROR_INVALIDDATA;
 
696
                bytestream2_init(&gB, buf, buf_size + ARITH2_PADDING);
 
697
                arith2_init(&acoder, &gB);
 
698
                if (c->corrupted = ff_mss12_decode_rect(&ctx->sc[1], &acoder, 0,
 
699
                                                        ctx->split_position,
 
700
                                                        avctx->width,
 
701
                                                        avctx->height - ctx->split_position))
 
702
                    return AVERROR_INVALIDDATA;
 
703
 
 
704
                buf      += arith2_get_consumed_bytes(&acoder);
 
705
                buf_size -= arith2_get_consumed_bytes(&acoder);
 
706
            }
 
707
        } else
 
708
            memset(c->pal_pic, 0, c->pal_stride * avctx->height);
 
709
    }
 
710
 
 
711
    if (has_wmv9) {
 
712
        for (i = 0; i < used_rects; i++) {
 
713
            int x = wmv9rects[i].x;
 
714
            int y = wmv9rects[i].y;
 
715
            int w = wmv9rects[i].w;
 
716
            int h = wmv9rects[i].h;
 
717
            if (wmv9rects[i].coded) {
 
718
                int WMV9codedFrameSize;
 
719
                if (buf_size < 4 || !(WMV9codedFrameSize = AV_RL24(buf)))
 
720
                    return AVERROR_INVALIDDATA;
 
721
                if (ret = decode_wmv9(avctx, buf + 3, buf_size - 3,
 
722
                                      x, y, w, h, wmv9_mask))
 
723
                    return ret;
 
724
                buf      += WMV9codedFrameSize + 3;
 
725
                buf_size -= WMV9codedFrameSize + 3;
 
726
            } else {
 
727
                uint8_t *dst = c->rgb_pic + y * c->rgb_stride + x * 3;
 
728
                if (wmv9_mask != -1) {
 
729
                    ctx->dsp.mss2_gray_fill_masked(dst, c->rgb_stride,
 
730
                                                   wmv9_mask,
 
731
                                                   c->pal_pic + y * c->pal_stride + x,
 
732
                                                   c->pal_stride,
 
733
                                                   w, h);
 
734
                } else {
 
735
                    do {
 
736
                        memset(dst, 0x80, w * 3);
 
737
                        dst += c->rgb_stride;
 
738
                    } while (--h);
 
739
                }
 
740
            }
 
741
        }
 
742
    }
 
743
 
 
744
    if (buf_size)
 
745
        av_log(avctx, AV_LOG_WARNING, "buffer not fully consumed\n");
 
746
 
 
747
    *got_frame       = 1;
 
748
    *(AVFrame *)data = ctx->pic;
 
749
 
 
750
    return avpkt->size;
 
751
}
 
752
 
 
753
static av_cold int wmv9_init(AVCodecContext *avctx)
 
754
{
 
755
    VC1Context *v = avctx->priv_data;
 
756
 
 
757
    v->s.avctx    = avctx;
 
758
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
 
759
    v->s.flags   |= CODEC_FLAG_EMU_EDGE;
 
760
 
 
761
    if (avctx->idct_algo == FF_IDCT_AUTO)
 
762
        avctx->idct_algo = FF_IDCT_WMV2;
 
763
 
 
764
    if (ff_vc1_init_common(v) < 0)
 
765
        return -1;
 
766
    ff_vc1dsp_init(&v->vc1dsp);
 
767
 
 
768
    v->profile = PROFILE_MAIN;
 
769
 
 
770
    v->zz_8x4     = ff_wmv2_scantableA;
 
771
    v->zz_4x8     = ff_wmv2_scantableB;
 
772
    v->res_y411   = 0;
 
773
    v->res_sprite = 0;
 
774
 
 
775
    v->frmrtq_postproc = 7;
 
776
    v->bitrtq_postproc = 31;
 
777
 
 
778
    v->res_x8          = 0;
 
779
    v->multires        = 0;
 
780
    v->res_fasttx      = 1;
 
781
 
 
782
    v->fastuvmc        = 0;
 
783
 
 
784
    v->extended_mv     = 0;
 
785
 
 
786
    v->dquant          = 1;
 
787
    v->vstransform     = 1;
 
788
 
 
789
    v->res_transtab    = 0;
 
790
 
 
791
    v->overlap         = 0;
 
792
 
 
793
    v->s.resync_marker = 0;
 
794
    v->rangered        = 0;
 
795
 
 
796
    v->s.max_b_frames = avctx->max_b_frames = 0;
 
797
    v->quantizer_mode = 0;
 
798
 
 
799
    v->finterpflag = 0;
 
800
 
 
801
    v->res_rtm_flag = 1;
 
802
 
 
803
    ff_vc1_init_transposed_scantables(v);
 
804
 
 
805
    if (ff_msmpeg4_decode_init(avctx) < 0 ||
 
806
        ff_vc1_decode_init_alloc_tables(v) < 0)
 
807
        return -1;
 
808
 
 
809
    /* error concealment */
 
810
    v->s.me.qpel_put = v->s.dsp.put_qpel_pixels_tab;
 
811
    v->s.me.qpel_avg = v->s.dsp.avg_qpel_pixels_tab;
 
812
 
 
813
    return 0;
 
814
}
 
815
 
 
816
static av_cold int mss2_decode_end(AVCodecContext *avctx)
 
817
{
 
818
    MSS2Context *const ctx = avctx->priv_data;
 
819
 
 
820
    if (ctx->pic.data[0])
 
821
        avctx->release_buffer(avctx, &ctx->pic);
 
822
    if (ctx->last_pic.data[0])
 
823
        avctx->release_buffer(avctx, &ctx->last_pic);
 
824
 
 
825
    ff_mss12_decode_end(&ctx->c);
 
826
    av_freep(&ctx->c.pal_pic);
 
827
    av_freep(&ctx->c.last_pal_pic);
 
828
    ff_vc1_decode_end(avctx);
 
829
 
 
830
    return 0;
 
831
}
 
832
 
 
833
static av_cold int mss2_decode_init(AVCodecContext *avctx)
 
834
{
 
835
    MSS2Context * const ctx = avctx->priv_data;
 
836
    MSS12Context *c = &ctx->c;
 
837
    int ret;
 
838
    c->avctx = avctx;
 
839
    avctx->coded_frame = &ctx->pic;
 
840
    if (ret = ff_mss12_decode_init(c, 1, &ctx->sc[0], &ctx->sc[1]))
 
841
        return ret;
 
842
    c->pal_stride   = c->mask_stride;
 
843
    c->pal_pic      = av_mallocz(c->pal_stride * avctx->height);
 
844
    c->last_pal_pic = av_mallocz(c->pal_stride * avctx->height);
 
845
    if (!c->pal_pic || !c->last_pal_pic) {
 
846
        mss2_decode_end(avctx);
 
847
        return AVERROR(ENOMEM);
 
848
    }
 
849
    if (ret = wmv9_init(avctx)) {
 
850
        mss2_decode_end(avctx);
 
851
        return ret;
 
852
    }
 
853
    ff_mss2dsp_init(&ctx->dsp);
 
854
 
 
855
    avctx->pix_fmt = c->free_colours == 127 ? AV_PIX_FMT_RGB555
 
856
                                            : AV_PIX_FMT_RGB24;
 
857
 
 
858
    return 0;
 
859
}
 
860
 
 
861
AVCodec ff_mss2_decoder = {
 
862
    .name           = "mss2",
 
863
    .type           = AVMEDIA_TYPE_VIDEO,
 
864
    .id             = AV_CODEC_ID_MSS2,
 
865
    .priv_data_size = sizeof(MSS2Context),
 
866
    .init           = mss2_decode_init,
 
867
    .close          = mss2_decode_end,
 
868
    .decode         = mss2_decode_frame,
 
869
    .capabilities   = CODEC_CAP_DR1,
 
870
    .long_name      = NULL_IF_CONFIG_SMALL("MS Windows Media Video V9 Screen"),
 
871
};