GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/rv10.c Lines: 245 369 66.4 %
Date: 2020-09-25 23:16:12 Branches: 141 246 57.3 %

Line Branch Exec Source
1
/*
2
 * RV10/RV20 decoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
/**
24
 * @file
25
 * RV10/RV20 decoder
26
 */
27
28
#include <inttypes.h>
29
30
#include "libavutil/imgutils.h"
31
32
#include "avcodec.h"
33
#include "error_resilience.h"
34
#include "h263.h"
35
#include "h263data.h"
36
#include "internal.h"
37
#include "mpeg_er.h"
38
#include "mpegutils.h"
39
#include "mpegvideo.h"
40
#include "mpeg4video.h"
41
#include "mpegvideodata.h"
42
#include "rv10.h"
43
44
#define RV_GET_MAJOR_VER(x)  ((x) >> 28)
45
#define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
46
#define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
47
48
#define DC_VLC_BITS 14 // FIXME find a better solution
49
50
typedef struct RVDecContext {
51
    MpegEncContext m;
52
    int sub_id;
53
    int orig_width, orig_height;
54
} RVDecContext;
55
56
static const uint16_t rv_lum_code[256] = {
57
    0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
58
    0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
59
    0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
60
    0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
61
    0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
62
    0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
63
    0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
64
    0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
65
    0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
66
    0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
67
    0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
68
    0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
69
    0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
70
    0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
71
    0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
72
    0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
73
    0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
74
    0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
75
    0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
76
    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
77
    0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
78
    0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
79
    0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
80
    0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
81
    0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
82
    0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
83
    0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
84
    0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
85
    0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
86
    0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
87
    0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
88
    0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
89
};
90
91
static const uint8_t rv_lum_bits[256] = {
92
    14, 12, 12, 12, 12, 12, 12, 12,
93
    12, 12, 12, 12, 12, 12, 12, 12,
94
    12, 12, 12, 12, 12, 12, 12, 12,
95
    12, 12, 12, 12, 12, 12, 12, 12,
96
    12, 12, 12, 12, 12, 12, 12, 12,
97
    12, 12, 12, 12, 12, 12, 12, 12,
98
    12, 12, 12, 12, 12, 12, 12, 12,
99
    12, 12, 12, 12, 12, 12, 12, 12,
100
    12, 10, 10, 10, 10, 10, 10, 10,
101
    10, 10, 10, 10, 10, 10, 10, 10,
102
    10, 10, 10, 10, 10, 10, 10, 10,
103
    10, 10, 10, 10, 10, 10, 10, 10,
104
    10,  8,  8,  8,  8,  8,  8,  8,
105
     8,  8,  8,  8,  8,  8,  8,  8,
106
     8,  7,  7,  7,  7,  7,  7,  7,
107
     7,  6,  6,  6,  6,  5,  5,  4,
108
     2,  4,  5,  5,  6,  6,  6,  6,
109
     7,  7,  7,  7,  7,  7,  7,  7,
110
     8,  8,  8,  8,  8,  8,  8,  8,
111
     8,  8,  8,  8,  8,  8,  8,  8,
112
    10, 10, 10, 10, 10, 10, 10, 10,
113
    10, 10, 10, 10, 10, 10, 10, 10,
114
    10, 10, 10, 10, 10, 10, 10, 10,
115
    10, 10, 10, 10, 10, 10, 10, 10,
116
    12, 12, 12, 12, 12, 12, 12, 12,
117
    12, 12, 12, 12, 12, 12, 12, 12,
118
    12, 12, 12, 12, 12, 12, 12, 12,
119
    12, 12, 12, 12, 12, 12, 12, 12,
120
    12, 12, 12, 12, 12, 12, 12, 12,
121
    12, 12, 12, 12, 12, 12, 12, 12,
122
    12, 12, 12, 12, 12, 12, 12, 12,
123
    12, 12, 12, 12, 12, 12, 12, 12,
124
};
125
126
static const uint16_t rv_chrom_code[256] = {
127
    0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
128
    0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
129
    0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
130
    0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
131
    0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
132
    0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
133
    0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
134
    0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
135
    0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
136
    0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
137
    0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
138
    0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
139
    0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
140
    0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
141
    0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
142
    0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
143
    0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
144
    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
145
    0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
146
    0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
147
    0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
148
    0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
149
    0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
150
    0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
151
    0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
152
    0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
153
    0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
154
    0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
155
    0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
156
    0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
157
    0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
158
    0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
159
};
160
161
static const uint8_t rv_chrom_bits[256] = {
162
    16, 14, 14, 14, 14, 14, 14, 14,
163
    14, 14, 14, 14, 14, 14, 14, 14,
164
    14, 14, 14, 14, 14, 14, 14, 14,
165
    14, 14, 14, 14, 14, 14, 14, 14,
166
    14, 14, 14, 14, 14, 14, 14, 14,
167
    14, 14, 14, 14, 14, 14, 14, 14,
168
    14, 14, 14, 14, 14, 14, 14, 14,
169
    14, 14, 14, 14, 14, 14, 14, 14,
170
    14, 12, 12, 12, 12, 12, 12, 12,
171
    12, 12, 12, 12, 12, 12, 12, 12,
172
    12, 12, 12, 12, 12, 12, 12, 12,
173
    12, 12, 12, 12, 12, 12, 12, 12,
174
    12, 10, 10, 10, 10, 10, 10, 10,
175
    10, 10, 10, 10, 10, 10, 10, 10,
176
    10,  8,  8,  8,  8,  8,  8,  8,
177
     8,  6,  6,  6,  6,  4,  4,  3,
178
     2,  3,  4,  4,  6,  6,  6,  6,
179
     8,  8,  8,  8,  8,  8,  8,  8,
180
    10, 10, 10, 10, 10, 10, 10, 10,
181
    10, 10, 10, 10, 10, 10, 10, 10,
182
    12, 12, 12, 12, 12, 12, 12, 12,
183
    12, 12, 12, 12, 12, 12, 12, 12,
184
    12, 12, 12, 12, 12, 12, 12, 12,
185
    12, 12, 12, 12, 12, 12, 12, 12,
186
    14, 14, 14, 14, 14, 14, 14, 14,
187
    14, 14, 14, 14, 14, 14, 14, 14,
188
    14, 14, 14, 14, 14, 14, 14, 14,
189
    14, 14, 14, 14, 14, 14, 14, 14,
190
    14, 14, 14, 14, 14, 14, 14, 14,
191
    14, 14, 14, 14, 14, 14, 14, 14,
192
    14, 14, 14, 14, 14, 14, 14, 14,
193
    14, 14, 14, 14, 14, 14, 14, 14,
194
};
195
196
static VLC rv_dc_lum, rv_dc_chrom;
197
198
int ff_rv_decode_dc(MpegEncContext *s, int n)
199
{
200
    int code;
201
202
    if (n < 4) {
203
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
204
        if (code < 0) {
205
            /* XXX: I don't understand why they use LONGER codes than
206
             * necessary. The following code would be completely useless
207
             * if they had thought about it !!! */
208
            code = get_bits(&s->gb, 7);
209
            if (code == 0x7c) {
210
                code = (int8_t) (get_bits(&s->gb, 7) + 1);
211
            } else if (code == 0x7d) {
212
                code = -128 + get_bits(&s->gb, 7);
213
            } else if (code == 0x7e) {
214
                if (get_bits1(&s->gb) == 0)
215
                    code = (int8_t) (get_bits(&s->gb, 8) + 1);
216
                else
217
                    code = (int8_t) (get_bits(&s->gb, 8));
218
            } else if (code == 0x7f) {
219
                skip_bits(&s->gb, 11);
220
                code = 1;
221
            }
222
        } else {
223
            code -= 128;
224
        }
225
    } else {
226
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
227
        /* same remark */
228
        if (code < 0) {
229
            code = get_bits(&s->gb, 9);
230
            if (code == 0x1fc) {
231
                code = (int8_t) (get_bits(&s->gb, 7) + 1);
232
            } else if (code == 0x1fd) {
233
                code = -128 + get_bits(&s->gb, 7);
234
            } else if (code == 0x1fe) {
235
                skip_bits(&s->gb, 9);
236
                code = 1;
237
            } else {
238
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
239
                return 0xffff;
240
            }
241
        } else {
242
            code -= 128;
243
        }
244
    }
245
    return -code;
246
}
247
248
/* read RV 1.0 compatible frame header */
249
150
static int rv10_decode_picture_header(MpegEncContext *s)
250
{
251
    int mb_count, pb_frame, marker, mb_xy;
252
253
150
    marker = get_bits1(&s->gb);
254
255
150
    if (get_bits1(&s->gb))
256
135
        s->pict_type = AV_PICTURE_TYPE_P;
257
    else
258
15
        s->pict_type = AV_PICTURE_TYPE_I;
259
260
150
    if (!marker)
261
        av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
262
263
150
    pb_frame = get_bits1(&s->gb);
264
265
    ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
266
267
150
    if (pb_frame) {
268
        avpriv_request_sample(s->avctx, "PB-frame");
269
        return AVERROR_PATCHWELCOME;
270
    }
271
272
150
    s->qscale = get_bits(&s->gb, 5);
273
150
    if (s->qscale == 0) {
274
        av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
275
        return AVERROR_INVALIDDATA;
276
    }
277
278
150
    if (s->pict_type == AV_PICTURE_TYPE_I) {
279
15
        if (s->rv10_version == 3) {
280
            /* specific MPEG like DC coding not used */
281
            s->last_dc[0] = get_bits(&s->gb, 8);
282
            s->last_dc[1] = get_bits(&s->gb, 8);
283
            s->last_dc[2] = get_bits(&s->gb, 8);
284
            ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
285
                    s->last_dc[1], s->last_dc[2]);
286
        }
287
    }
288
    /* if multiple packets per frame are sent, the position at which
289
     * to display the macroblocks is coded here */
290
291
150
    mb_xy = s->mb_x + s->mb_y * s->mb_width;
292

150
    if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
293
150
        s->mb_x  = get_bits(&s->gb, 6); /* mb_x */
294
150
        s->mb_y  = get_bits(&s->gb, 6); /* mb_y */
295
150
        mb_count = get_bits(&s->gb, 12);
296
    } else {
297
        s->mb_x  = 0;
298
        s->mb_y  = 0;
299
        mb_count = s->mb_width * s->mb_height;
300
    }
301
150
    skip_bits(&s->gb, 3);   /* ignored */
302
150
    s->f_code          = 1;
303
150
    s->unrestricted_mv = 1;
304
305
150
    return mb_count;
306
}
307
308
742
static int rv20_decode_picture_header(RVDecContext *rv)
309
{
310
742
    MpegEncContext *s = &rv->m;
311
    int seq, mb_pos, i, ret;
312
    int rpr_max;
313
314
742
    i = get_bits(&s->gb, 2);
315

742
    switch (i) {
316
52
    case 0:
317
52
        s->pict_type = AV_PICTURE_TYPE_I;
318
52
        break;
319
15
    case 1:
320
15
        s->pict_type = AV_PICTURE_TYPE_I;
321
15
        break;                                  // hmm ...
322
494
    case 2:
323
494
        s->pict_type = AV_PICTURE_TYPE_P;
324
494
        break;
325
181
    case 3:
326
181
        s->pict_type = AV_PICTURE_TYPE_B;
327
181
        break;
328
    default:
329
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
330
        return AVERROR_INVALIDDATA;
331
    }
332
333

742
    if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
334
        av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
335
        return -1;
336
    }
337

742
    if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
338
        av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
339
        return AVERROR_INVALIDDATA;
340
    }
341
342
742
    if (get_bits1(&s->gb)) {
343
        av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
344
        return AVERROR_INVALIDDATA;
345
    }
346
347
742
    s->qscale = get_bits(&s->gb, 5);
348
742
    if (s->qscale == 0) {
349
        av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
350
        return AVERROR_INVALIDDATA;
351
    }
352
353
742
    if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
354

592
        s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
355
356
742
    if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
357
150
        seq = get_bits(&s->gb, 8) << 7;
358
    else
359
592
        seq = get_bits(&s->gb, 13) << 2;
360
361
742
    rpr_max = s->avctx->extradata[1] & 7;
362
742
    if (rpr_max) {
363
        int f, new_w, new_h;
364
592
        int rpr_bits = av_log2(rpr_max) + 1;
365
366
592
        f = get_bits(&s->gb, rpr_bits);
367
368
592
        if (f) {
369
            if (s->avctx->extradata_size < 8 + 2 * f) {
370
                av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
371
                return AVERROR_INVALIDDATA;
372
            }
373
374
            new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
375
            new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
376
        } else {
377
592
            new_w = rv->orig_width;
378
592
            new_h = rv->orig_height;
379
        }
380

592
        if (new_w != s->width || new_h != s->height) {
381
            AVRational old_aspect = s->avctx->sample_aspect_ratio;
382
            av_log(s->avctx, AV_LOG_DEBUG,
383
                   "attempting to change resolution to %dx%d\n", new_w, new_h);
384
            if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
385
                return AVERROR_INVALIDDATA;
386
            ff_mpv_common_end(s);
387
388
            // attempt to keep aspect during typical resolution switches
389
            if (!old_aspect.num)
390
                old_aspect = (AVRational){1, 1};
391
            if (2 * (int64_t)new_w * s->height == (int64_t)new_h * s->width)
392
                s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
393
            if ((int64_t)new_w * s->height == 2 * (int64_t)new_h * s->width)
394
                s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
395
396
            ret = ff_set_dimensions(s->avctx, new_w, new_h);
397
            if (ret < 0)
398
                return ret;
399
400
            s->width  = new_w;
401
            s->height = new_h;
402
            if ((ret = ff_mpv_common_init(s)) < 0)
403
                return ret;
404
        }
405
406
592
        if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
407
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
408
        }
409
    }
410
742
    if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
411
        return AVERROR_INVALIDDATA;
412
413
742
    mb_pos = ff_h263_decode_mba(s);
414
415
742
    seq |= s->time & ~0x7FFF;
416
742
    if (seq - s->time >  0x4000)
417
        seq -= 0x8000;
418
742
    if (seq - s->time < -0x4000)
419
        seq += 0x8000;
420
421
742
    if (seq != s->time) {
422
292
        if (s->pict_type != AV_PICTURE_TYPE_B) {
423
220
            s->time            = seq;
424
220
            s->pp_time         = s->time - s->last_non_b_time;
425
220
            s->last_non_b_time = s->time;
426
        } else {
427
72
            s->time    = seq;
428
72
            s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
429
        }
430
    }
431
742
    if (s->pict_type == AV_PICTURE_TYPE_B) {
432

181
        if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
433
            av_log(s->avctx, AV_LOG_DEBUG,
434
                   "messed up order, possible from seeking? skipping current B-frame\n");
435
#define ERROR_SKIP_FRAME -123
436
            return ERROR_SKIP_FRAME;
437
        }
438
181
        ff_mpeg4_init_direct_mv(s);
439
    }
440
441
742
    s->no_rounding = get_bits1(&s->gb);
442
443

742
    if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
444
        // binary decoder reads 3+2 bits here but they don't seem to be used
445
        skip_bits(&s->gb, 5);
446
447
742
    s->f_code          = 1;
448
742
    s->unrestricted_mv = 1;
449
742
    s->h263_aic        = s->pict_type == AV_PICTURE_TYPE_I;
450
742
    s->modified_quant  = 1;
451
742
    if (!s->avctx->lowres)
452
150
        s->loop_filter = 1;
453
454
742
    if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
455
        av_log(s->avctx, AV_LOG_INFO,
456
               "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
457
               seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
458
               s->no_rounding);
459
    }
460
461

742
    av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
462
463
742
    return s->mb_width * s->mb_height - mb_pos;
464
}
465
466
20
static av_cold int rv10_decode_init(AVCodecContext *avctx)
467
{
468
20
    RVDecContext *rv = avctx->priv_data;
469
20
    MpegEncContext *s = &rv->m;
470
    static int done = 0;
471
    int major_ver, minor_ver, micro_ver, ret;
472
473
20
    if (avctx->extradata_size < 8) {
474
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
475
        return AVERROR_INVALIDDATA;
476
    }
477
20
    if ((ret = av_image_check_size(avctx->coded_width,
478
20
                                   avctx->coded_height, 0, avctx)) < 0)
479
        return ret;
480
481
20
    ff_mpv_decode_defaults(s);
482
20
    ff_mpv_decode_init(s, avctx);
483
484
20
    s->out_format  = FMT_H263;
485
486
20
    rv->orig_width  =
487
20
    s->width        = avctx->coded_width;
488
20
    rv->orig_height =
489
20
    s->height       = avctx->coded_height;
490
491
20
    s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
492
20
    rv->sub_id           = AV_RB32((uint8_t *) avctx->extradata + 4);
493
494
20
    major_ver = RV_GET_MAJOR_VER(rv->sub_id);
495
20
    minor_ver = RV_GET_MINOR_VER(rv->sub_id);
496
20
    micro_ver = RV_GET_MICRO_VER(rv->sub_id);
497
498
20
    s->low_delay = 1;
499
20
    switch (major_ver) {
500
9
    case 1:
501
9
        s->rv10_version = micro_ver ? 3 : 1;
502
9
        s->obmc         = micro_ver == 2;
503
9
        break;
504
11
    case 2:
505
11
        if (minor_ver >= 2) {
506
3
            s->low_delay           = 0;
507
3
            s->avctx->has_b_frames = 1;
508
        }
509
11
        break;
510
    default:
511
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
512
        avpriv_request_sample(avctx, "RV1/2 version");
513
        return AVERROR_PATCHWELCOME;
514
    }
515
516
20
    if (avctx->debug & FF_DEBUG_PICT_INFO) {
517
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,
518
               ((uint32_t *) avctx->extradata)[0]);
519
    }
520
521
20
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
522
523
20
    ff_mpv_idct_init(s);
524
20
    if ((ret = ff_mpv_common_init(s)) < 0)
525
        return ret;
526
527
20
    ff_h263dsp_init(&s->h263dsp);
528
20
    ff_h263_decode_init_vlc();
529
530
    /* init rv vlc */
531
20
    if (!done) {
532
13
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
533
                        rv_lum_bits, 1, 1,
534
                        rv_lum_code, 2, 2, 16384);
535
13
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
536
                        rv_chrom_bits, 1, 1,
537
                        rv_chrom_code, 2, 2, 16388);
538
13
        done = 1;
539
    }
540
541
20
    return 0;
542
}
543
544
20
static av_cold int rv10_decode_end(AVCodecContext *avctx)
545
{
546
20
    MpegEncContext *s = avctx->priv_data;
547
548
20
    ff_mpv_common_end(s);
549
20
    return 0;
550
}
551
552
892
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
553
                              int buf_size, int buf_size2, int whole_size)
554
{
555
892
    RVDecContext *rv = avctx->priv_data;
556
892
    MpegEncContext *s = &rv->m;
557
    int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
558
559
892
    active_bits_size = buf_size * 8;
560
892
    init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
561
892
    if (s->codec_id == AV_CODEC_ID_RV10)
562
150
        mb_count = rv10_decode_picture_header(s);
563
    else
564
742
        mb_count = rv20_decode_picture_header(rv);
565
892
    if (mb_count < 0) {
566
        if (mb_count != ERROR_SKIP_FRAME)
567
            av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
568
        return AVERROR_INVALIDDATA;
569
    }
570
571
892
    if (s->mb_x >= s->mb_width ||
572
892
        s->mb_y >= s->mb_height) {
573
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
574
        return AVERROR_INVALIDDATA;
575
    }
576
892
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
577
892
    left   = s->mb_width * s->mb_height - mb_pos;
578
892
    if (mb_count > left) {
579
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
580
        return AVERROR_INVALIDDATA;
581
    }
582
583
892
    if (whole_size < s->mb_width * s->mb_height / 8)
584
        return AVERROR_INVALIDDATA;
585
586

892
    if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
587
        // FIXME write parser so we always have complete frames?
588
445
        if (s->current_picture_ptr) {
589
            ff_er_frame_end(&s->er);
590
            ff_mpv_frame_end(s);
591
            s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
592
        }
593
445
        if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
594
            return ret;
595
445
        ff_mpeg_er_frame_start(s);
596
    } else {
597
447
        if (s->current_picture_ptr->f->pict_type != s->pict_type) {
598
            av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
599
            return AVERROR_INVALIDDATA;
600
        }
601
    }
602
603
604
    ff_dlog(avctx, "qscale=%d\n", s->qscale);
605
606
    /* default quantization values */
607
892
    if (s->codec_id == AV_CODEC_ID_RV10) {
608
150
        if (s->mb_y == 0)
609
150
            s->first_slice_line = 1;
610
    } else {
611
742
        s->first_slice_line = 1;
612
742
        s->resync_mb_x      = s->mb_x;
613
    }
614
892
    start_mb_x     = s->mb_x;
615
892
    s->resync_mb_y = s->mb_y;
616
892
    if (s->h263_aic) {
617
67
        s->y_dc_scale_table =
618
67
        s->c_dc_scale_table = ff_aic_dc_scale_table;
619
    } else {
620
825
        s->y_dc_scale_table =
621
825
        s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
622
    }
623
624
892
    if (s->modified_quant)
625
742
        s->chroma_qscale_table = ff_h263_chroma_qscale_table;
626
627
892
    ff_set_qscale(s, s->qscale);
628
629
892
    s->rv10_first_dc_coded[0] = 0;
630
892
    s->rv10_first_dc_coded[1] = 0;
631
892
    s->rv10_first_dc_coded[2] = 0;
632
892
    s->block_wrap[0] =
633
892
    s->block_wrap[1] =
634
892
    s->block_wrap[2] =
635
892
    s->block_wrap[3] = s->b8_stride;
636
892
    s->block_wrap[4] =
637
892
    s->block_wrap[5] = s->mb_stride;
638
892
    ff_init_block_index(s);
639
640
    /* decode each macroblock */
641
162300
    for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
642
        int ret;
643
162300
        ff_update_block_index(s);
644
        ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
645
646
162300
        s->mv_dir  = MV_DIR_FORWARD;
647
162300
        s->mv_type = MV_TYPE_16X16;
648
162300
        ret = ff_h263_decode_mb(s, s->block);
649
650
        // Repeat the slice end check from ff_h263_decode_mb with our active
651
        // bitstream size
652

162300
        if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&s->gb)) {
653
162300
            int v = show_bits(&s->gb, 16);
654
655
162300
            if (get_bits_count(&s->gb) + 16 > active_bits_size)
656
1341
                v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
657
658
162300
            if (!v)
659
892
                ret = SLICE_END;
660
        }
661

162300
        if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
662
            8 * buf_size2 >= get_bits_count(&s->gb)) {
663
            active_bits_size = buf_size2 * 8;
664
            av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
665
                   8 * buf_size, active_bits_size);
666
            ret = SLICE_OK;
667
        }
668
669

162300
        if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
670
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
671
                   s->mb_y);
672
            return AVERROR_INVALIDDATA;
673
        }
674
162300
        if (s->pict_type != AV_PICTURE_TYPE_B)
675
140700
            ff_h263_update_motion_val(s);
676
162300
        ff_mpv_reconstruct_mb(s, s->block);
677
162300
        if (s->loop_filter)
678
59400
            ff_h263_loop_filter(s);
679
680
162300
        if (++s->mb_x == s->mb_width) {
681
7575
            s->mb_x = 0;
682
7575
            s->mb_y++;
683
7575
            ff_init_block_index(s);
684
        }
685
162300
        if (s->mb_x == s->resync_mb_x)
686
7297
            s->first_slice_line = 0;
687
162300
        if (ret == SLICE_END)
688
892
            break;
689
    }
690
691
892
    ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
692
                    ER_MB_END);
693
694
892
    return active_bits_size;
695
}
696
697
1667
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
698
{
699
1667
    if (avctx->slice_count)
700
        return avctx->slice_offset[n];
701
    else
702
1667
        return AV_RL32(buf + n * 8);
703
}
704
705
449
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
706
                             AVPacket *avpkt)
707
{
708
449
    const uint8_t *buf = avpkt->data;
709
449
    int buf_size       = avpkt->size;
710
449
    MpegEncContext *s = avctx->priv_data;
711
449
    AVFrame *pict = data;
712
    int i, ret;
713
    int slice_count;
714
449
    const uint8_t *slices_hdr = NULL;
715
716
    ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
717
718
    /* no supplementary picture */
719
449
    if (buf_size == 0) {
720
4
        return 0;
721
    }
722
723
445
    if (!avctx->slice_count) {
724
445
        slice_count = (*buf++) + 1;
725
445
        buf_size--;
726
727

445
        if (!slice_count || buf_size <= 8 * slice_count) {
728
            av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
729
                   slice_count);
730
            return AVERROR_INVALIDDATA;
731
        }
732
733
445
        slices_hdr = buf + 4;
734
445
        buf       += 8 * slice_count;
735
445
        buf_size  -= 8 * slice_count;
736
    } else
737
        slice_count = avctx->slice_count;
738
739
1337
    for (i = 0; i < slice_count; i++) {
740
892
        unsigned offset = get_slice_offset(avctx, slices_hdr, i);
741
        int size, size2;
742
743
892
        if (offset >= buf_size)
744
            return AVERROR_INVALIDDATA;
745
746
892
        if (i + 1 == slice_count)
747
445
            size = buf_size - offset;
748
        else
749
447
            size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
750
751
892
        if (i + 2 >= slice_count)
752
564
            size2 = buf_size - offset;
753
        else
754
328
            size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
755
756

892
        if (size <= 0 || size2 <= 0 ||
757
892
            offset + FFMAX(size, size2) > buf_size)
758
            return AVERROR_INVALIDDATA;
759
760
892
        if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2, buf_size)) < 0)
761
            return ret;
762
763
892
        if (ret > 8 * size)
764
            i++;
765
    }
766
767

445
    if (s->current_picture_ptr && s->mb_y >= s->mb_height) {
768
445
        ff_er_frame_end(&s->er);
769
445
        ff_mpv_frame_end(s);
770
771

445
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
772
372
            if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
773
                return ret;
774
372
            ff_print_debug_info(s, s->current_picture_ptr, pict);
775
372
            ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
776
73
        } else if (s->last_picture_ptr) {
777
72
            if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
778
                return ret;
779
72
            ff_print_debug_info(s, s->last_picture_ptr, pict);
780
72
            ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
781
        }
782
783

445
        if (s->last_picture_ptr || s->low_delay) {
784
444
            *got_frame = 1;
785
        }
786
787
        // so we can detect if frame_end was not called (find some nicer solution...)
788
445
        s->current_picture_ptr = NULL;
789
    }
790
791
445
    return avpkt->size;
792
}
793
794
AVCodec ff_rv10_decoder = {
795
    .name           = "rv10",
796
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
797
    .type           = AVMEDIA_TYPE_VIDEO,
798
    .id             = AV_CODEC_ID_RV10,
799
    .priv_data_size = sizeof(RVDecContext),
800
    .init           = rv10_decode_init,
801
    .close          = rv10_decode_end,
802
    .decode         = rv10_decode_frame,
803
    .capabilities   = AV_CODEC_CAP_DR1,
804
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
805
    .max_lowres     = 3,
806
    .pix_fmts       = (const enum AVPixelFormat[]) {
807
        AV_PIX_FMT_YUV420P,
808
        AV_PIX_FMT_NONE
809
    },
810
};
811
812
AVCodec ff_rv20_decoder = {
813
    .name           = "rv20",
814
    .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
815
    .type           = AVMEDIA_TYPE_VIDEO,
816
    .id             = AV_CODEC_ID_RV20,
817
    .priv_data_size = sizeof(RVDecContext),
818
    .init           = rv10_decode_init,
819
    .close          = rv10_decode_end,
820
    .decode         = rv10_decode_frame,
821
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
822
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
823
    .flush          = ff_mpeg_flush,
824
    .max_lowres     = 3,
825
    .pix_fmts       = (const enum AVPixelFormat[]) {
826
        AV_PIX_FMT_YUV420P,
827
        AV_PIX_FMT_NONE
828
    },
829
};