← Back to branch summary

~ubuntu-branches/ubuntu/raring/libav/raring-security

« back to all changes in this revision

Viewing changes to .pc/post-0.7.1/0064-rv10-Reject-slices-that-does-not-have-the-same-type-.patch/libavcodec/rv10.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2011-09-28 09:18:34 UTC
  • mfrom: (1.3.7 sid)
  • Revision ID: package-import@ubuntu.com-20110928091834-w415mnuh06h4zpvc
Tags: 4:0.7.1-7ubuntu2
Revert "Convert package to include multiarch support."

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/post-0.7.1/0064-rv10-Reject-slices-that-does-not-have-the-same-type-.patch/libavcodec/rv10.c
 
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 Libav.
 
7
 *
 
8
 * Libav 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
 * Libav 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 Libav; 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 "libavutil/imgutils.h"
 
29
#include "avcodec.h"
 
30
#include "dsputil.h"
 
31
#include "mpegvideo.h"
 
32
#include "mpeg4video.h"
 
33
#include "h263.h"
 
34
 
 
35
//#define DEBUG
 
36
 
 
37
#define DC_VLC_BITS 14 //FIXME find a better solution
 
38
 
 
39
static const uint16_t rv_lum_code[256] =
 
40
{
 
41
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
 
42
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
 
43
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
 
44
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
 
45
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
 
46
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
 
47
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
 
48
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
 
49
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
 
50
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
 
51
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
 
52
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
 
53
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
 
54
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
 
55
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
 
56
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
 
57
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
 
58
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
 
59
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
 
60
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
 
61
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
 
62
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
 
63
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
 
64
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
 
65
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
 
66
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
 
67
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
 
68
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
 
69
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
 
70
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
 
71
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
 
72
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
 
73
};
 
74
 
 
75
static const uint8_t rv_lum_bits[256] =
 
76
{
 
77
 14, 12, 12, 12, 12, 12, 12, 12,
 
78
 12, 12, 12, 12, 12, 12, 12, 12,
 
79
 12, 12, 12, 12, 12, 12, 12, 12,
 
80
 12, 12, 12, 12, 12, 12, 12, 12,
 
81
 12, 12, 12, 12, 12, 12, 12, 12,
 
82
 12, 12, 12, 12, 12, 12, 12, 12,
 
83
 12, 12, 12, 12, 12, 12, 12, 12,
 
84
 12, 12, 12, 12, 12, 12, 12, 12,
 
85
 12, 10, 10, 10, 10, 10, 10, 10,
 
86
 10, 10, 10, 10, 10, 10, 10, 10,
 
87
 10, 10, 10, 10, 10, 10, 10, 10,
 
88
 10, 10, 10, 10, 10, 10, 10, 10,
 
89
 10,  8,  8,  8,  8,  8,  8,  8,
 
90
  8,  8,  8,  8,  8,  8,  8,  8,
 
91
  8,  7,  7,  7,  7,  7,  7,  7,
 
92
  7,  6,  6,  6,  6,  5,  5,  4,
 
93
  2,  4,  5,  5,  6,  6,  6,  6,
 
94
  7,  7,  7,  7,  7,  7,  7,  7,
 
95
  8,  8,  8,  8,  8,  8,  8,  8,
 
96
  8,  8,  8,  8,  8,  8,  8,  8,
 
97
 10, 10, 10, 10, 10, 10, 10, 10,
 
98
 10, 10, 10, 10, 10, 10, 10, 10,
 
99
 10, 10, 10, 10, 10, 10, 10, 10,
 
100
 10, 10, 10, 10, 10, 10, 10, 10,
 
101
 12, 12, 12, 12, 12, 12, 12, 12,
 
102
 12, 12, 12, 12, 12, 12, 12, 12,
 
103
 12, 12, 12, 12, 12, 12, 12, 12,
 
104
 12, 12, 12, 12, 12, 12, 12, 12,
 
105
 12, 12, 12, 12, 12, 12, 12, 12,
 
106
 12, 12, 12, 12, 12, 12, 12, 12,
 
107
 12, 12, 12, 12, 12, 12, 12, 12,
 
108
 12, 12, 12, 12, 12, 12, 12, 12,
 
109
};
 
110
 
 
111
static const uint16_t rv_chrom_code[256] =
 
112
{
 
113
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
 
114
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
 
115
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
 
116
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
 
117
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
 
118
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
 
119
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
 
120
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
 
121
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
 
122
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
 
123
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
 
124
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
 
125
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
 
126
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
 
127
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
 
128
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
 
129
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
 
130
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
 
131
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
 
132
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
 
133
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
 
134
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
 
135
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
 
136
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
 
137
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
 
138
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
 
139
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
 
140
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
 
141
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
 
142
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
 
143
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
 
144
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
 
145
};
 
146
 
 
147
static const uint8_t rv_chrom_bits[256] =
 
148
{
 
149
 16, 14, 14, 14, 14, 14, 14, 14,
 
150
 14, 14, 14, 14, 14, 14, 14, 14,
 
151
 14, 14, 14, 14, 14, 14, 14, 14,
 
152
 14, 14, 14, 14, 14, 14, 14, 14,
 
153
 14, 14, 14, 14, 14, 14, 14, 14,
 
154
 14, 14, 14, 14, 14, 14, 14, 14,
 
155
 14, 14, 14, 14, 14, 14, 14, 14,
 
156
 14, 14, 14, 14, 14, 14, 14, 14,
 
157
 14, 12, 12, 12, 12, 12, 12, 12,
 
158
 12, 12, 12, 12, 12, 12, 12, 12,
 
159
 12, 12, 12, 12, 12, 12, 12, 12,
 
160
 12, 12, 12, 12, 12, 12, 12, 12,
 
161
 12, 10, 10, 10, 10, 10, 10, 10,
 
162
 10, 10, 10, 10, 10, 10, 10, 10,
 
163
 10,  8,  8,  8,  8,  8,  8,  8,
 
164
  8,  6,  6,  6,  6,  4,  4,  3,
 
165
  2,  3,  4,  4,  6,  6,  6,  6,
 
166
  8,  8,  8,  8,  8,  8,  8,  8,
 
167
 10, 10, 10, 10, 10, 10, 10, 10,
 
168
 10, 10, 10, 10, 10, 10, 10, 10,
 
169
 12, 12, 12, 12, 12, 12, 12, 12,
 
170
 12, 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
 14, 14, 14, 14, 14, 14, 14, 14,
 
174
 14, 14, 14, 14, 14, 14, 14, 14,
 
175
 14, 14, 14, 14, 14, 14, 14, 14,
 
176
 14, 14, 14, 14, 14, 14, 14, 14,
 
177
 14, 14, 14, 14, 14, 14, 14, 14,
 
178
 14, 14, 14, 14, 14, 14, 14, 14,
 
179
 14, 14, 14, 14, 14, 14, 14, 14,
 
180
 14, 14, 14, 14, 14, 14, 14, 14,
 
181
};
 
182
 
 
183
static VLC rv_dc_lum, rv_dc_chrom;
 
184
 
 
185
int rv_decode_dc(MpegEncContext *s, int n)
 
186
{
 
187
    int code;
 
188
 
 
189
    if (n < 4) {
 
190
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
 
191
        if (code < 0) {
 
192
            /* XXX: I don't understand why they use LONGER codes than
 
193
               necessary. The following code would be completely useless
 
194
               if they had thought about it !!! */
 
195
            code = get_bits(&s->gb, 7);
 
196
            if (code == 0x7c) {
 
197
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
 
198
            } else if (code == 0x7d) {
 
199
                code = -128 + get_bits(&s->gb, 7);
 
200
            } else if (code == 0x7e) {
 
201
                if (get_bits1(&s->gb) == 0)
 
202
                    code = (int8_t)(get_bits(&s->gb, 8) + 1);
 
203
                else
 
204
                    code = (int8_t)(get_bits(&s->gb, 8));
 
205
            } else if (code == 0x7f) {
 
206
                skip_bits(&s->gb, 11);
 
207
                code = 1;
 
208
            }
 
209
        } else {
 
210
            code -= 128;
 
211
        }
 
212
    } else {
 
213
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
 
214
        /* same remark */
 
215
        if (code < 0) {
 
216
            code = get_bits(&s->gb, 9);
 
217
            if (code == 0x1fc) {
 
218
                code = (int8_t)(get_bits(&s->gb, 7) + 1);
 
219
            } else if (code == 0x1fd) {
 
220
                code = -128 + get_bits(&s->gb, 7);
 
221
            } else if (code == 0x1fe) {
 
222
                skip_bits(&s->gb, 9);
 
223
                code = 1;
 
224
            } else {
 
225
                av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
 
226
                return 0xffff;
 
227
            }
 
228
        } else {
 
229
            code -= 128;
 
230
        }
 
231
    }
 
232
    return -code;
 
233
}
 
234
 
 
235
/* read RV 1.0 compatible frame header */
 
236
static int rv10_decode_picture_header(MpegEncContext *s)
 
237
{
 
238
    int mb_count, pb_frame, marker, mb_xy;
 
239
 
 
240
    marker = get_bits1(&s->gb);
 
241
 
 
242
    if (get_bits1(&s->gb))
 
243
        s->pict_type = AV_PICTURE_TYPE_P;
 
244
    else
 
245
        s->pict_type = AV_PICTURE_TYPE_I;
 
246
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
 
247
    pb_frame = get_bits1(&s->gb);
 
248
 
 
249
    av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
 
250
 
 
251
    if (pb_frame){
 
252
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
 
253
        return -1;
 
254
    }
 
255
 
 
256
    s->qscale = get_bits(&s->gb, 5);
 
257
    if(s->qscale==0){
 
258
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 
259
        return -1;
 
260
    }
 
261
 
 
262
    if (s->pict_type == AV_PICTURE_TYPE_I) {
 
263
        if (s->rv10_version == 3) {
 
264
            /* specific MPEG like DC coding not used */
 
265
            s->last_dc[0] = get_bits(&s->gb, 8);
 
266
            s->last_dc[1] = get_bits(&s->gb, 8);
 
267
            s->last_dc[2] = get_bits(&s->gb, 8);
 
268
            av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
 
269
                    s->last_dc[1], s->last_dc[2]);
 
270
        }
 
271
    }
 
272
    /* if multiple packets per frame are sent, the position at which
 
273
       to display the macroblocks is coded here */
 
274
 
 
275
    mb_xy= s->mb_x + s->mb_y*s->mb_width;
 
276
    if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
 
277
        s->mb_x = get_bits(&s->gb, 6); /* mb_x */
 
278
        s->mb_y = get_bits(&s->gb, 6); /* mb_y */
 
279
        mb_count = get_bits(&s->gb, 12);
 
280
    } else {
 
281
        s->mb_x = 0;
 
282
        s->mb_y = 0;
 
283
        mb_count = s->mb_width * s->mb_height;
 
284
    }
 
285
    skip_bits(&s->gb, 3);   /* ignored */
 
286
    s->f_code = 1;
 
287
    s->unrestricted_mv = 1;
 
288
 
 
289
    return mb_count;
 
290
}
 
291
 
 
292
static int rv20_decode_picture_header(MpegEncContext *s)
 
293
{
 
294
    int seq, mb_pos, i;
 
295
 
 
296
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
 
297
        if (get_bits(&s->gb, 3)){
 
298
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
 
299
            return -1;
 
300
        }
 
301
    }
 
302
 
 
303
    i= get_bits(&s->gb, 2);
 
304
    switch(i){
 
305
    case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
 
306
    case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
 
307
    case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
 
308
    case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
 
309
    default:
 
310
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
 
311
        return -1;
 
312
    }
 
313
 
 
314
    if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
 
315
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
 
316
        return -1;
 
317
    }
 
318
 
 
319
    if (get_bits1(&s->gb)){
 
320
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
 
321
        return -1;
 
322
    }
 
323
 
 
324
    s->qscale = get_bits(&s->gb, 5);
 
325
    if(s->qscale==0){
 
326
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
 
327
        return -1;
 
328
    }
 
329
    if(s->avctx->sub_id == 0x30203002){
 
330
        if (get_bits1(&s->gb)){
 
331
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
 
332
            return -1;
 
333
        }
 
334
    }
 
335
 
 
336
    if(s->avctx->has_b_frames){
 
337
        int f, new_w, new_h;
 
338
        int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
 
339
 
 
340
        if (get_bits1(&s->gb)){
 
341
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
 
342
        }
 
343
        seq= get_bits(&s->gb, 13)<<2;
 
344
 
 
345
        f= get_bits(&s->gb, av_log2(v)+1);
 
346
 
 
347
        if(f){
 
348
            new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
 
349
            new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
 
350
        }else{
 
351
            new_w= s->orig_width ;
 
352
            new_h= s->orig_height;
 
353
        }
 
354
        if(new_w != s->width || new_h != s->height){
 
355
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
 
356
            if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 
357
                return -1;
 
358
            MPV_common_end(s);
 
359
            avcodec_set_dimensions(s->avctx, new_w, new_h);
 
360
            s->width  = new_w;
 
361
            s->height = new_h;
 
362
            if (MPV_common_init(s) < 0)
 
363
                return -1;
 
364
        }
 
365
 
 
366
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 
367
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
 
368
        }
 
369
    }else{
 
370
        seq= get_bits(&s->gb, 8)*128;
 
371
    }
 
372
 
 
373
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
 
374
    mb_pos= ff_h263_decode_mba(s);
 
375
/*    }else{
 
376
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
 
377
        s->mb_x= mb_pos % s->mb_width;
 
378
        s->mb_y= mb_pos / s->mb_width;
 
379
    }*/
 
380
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
 
381
    seq |= s->time &~0x7FFF;
 
382
    if(seq - s->time >  0x4000) seq -= 0x8000;
 
383
    if(seq - s->time < -0x4000) seq += 0x8000;
 
384
    if(seq != s->time){
 
385
        if(s->pict_type!=AV_PICTURE_TYPE_B){
 
386
            s->time= seq;
 
387
            s->pp_time= s->time - s->last_non_b_time;
 
388
            s->last_non_b_time= s->time;
 
389
        }else{
 
390
            s->time= seq;
 
391
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
 
392
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
 
393
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
 
394
                return FRAME_SKIPPED;
 
395
            }
 
396
            ff_mpeg4_init_direct_mv(s);
 
397
        }
 
398
    }
 
399
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
 
400
/*for(i=0; i<32; i++){
 
401
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
 
402
}
 
403
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
 
404
    s->no_rounding= get_bits1(&s->gb);
 
405
 
 
406
    s->f_code = 1;
 
407
    s->unrestricted_mv = 1;
 
408
    s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
 
409
//    s->alt_inter_vlc=1;
 
410
//    s->obmc=1;
 
411
//    s->umvplus=1;
 
412
    s->modified_quant=1;
 
413
    if(!s->avctx->lowres)
 
414
        s->loop_filter=1;
 
415
 
 
416
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
 
417
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
 
418
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
 
419
    }
 
420
 
 
421
    assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
 
422
 
 
423
    return s->mb_width*s->mb_height - mb_pos;
 
424
}
 
425
 
 
426
static av_cold int rv10_decode_init(AVCodecContext *avctx)
 
427
{
 
428
    MpegEncContext *s = avctx->priv_data;
 
429
    static int done=0;
 
430
 
 
431
    if (avctx->extradata_size < 8) {
 
432
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
 
433
        return -1;
 
434
    }
 
435
 
 
436
    MPV_decode_defaults(s);
 
437
 
 
438
    s->avctx= avctx;
 
439
    s->out_format = FMT_H263;
 
440
    s->codec_id= avctx->codec_id;
 
441
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
 
442
 
 
443
    s->orig_width = s->width  = avctx->coded_width;
 
444
    s->orig_height= s->height = avctx->coded_height;
 
445
 
 
446
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
 
447
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
 
448
 
 
449
    if (avctx->sub_id == 0x10000000) {
 
450
        s->rv10_version= 0;
 
451
        s->low_delay=1;
 
452
    } else if (avctx->sub_id == 0x10001000) {
 
453
        s->rv10_version= 3;
 
454
        s->low_delay=1;
 
455
    } else if (avctx->sub_id == 0x10002000) {
 
456
        s->rv10_version= 3;
 
457
        s->low_delay=1;
 
458
        s->obmc=1;
 
459
    } else if (avctx->sub_id == 0x10003000) {
 
460
        s->rv10_version= 3;
 
461
        s->low_delay=1;
 
462
    } else if (avctx->sub_id == 0x10003001) {
 
463
        s->rv10_version= 3;
 
464
        s->low_delay=1;
 
465
    } else if (    avctx->sub_id == 0x20001000
 
466
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
 
467
        s->low_delay=1;
 
468
    } else if (    avctx->sub_id == 0x30202002
 
469
               ||  avctx->sub_id == 0x30203002
 
470
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
 
471
        s->low_delay=0;
 
472
        s->avctx->has_b_frames=1;
 
473
    } else
 
474
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
 
475
 
 
476
    if(avctx->debug & FF_DEBUG_PICT_INFO){
 
477
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
 
478
    }
 
479
 
 
480
    avctx->pix_fmt = PIX_FMT_YUV420P;
 
481
 
 
482
    if (MPV_common_init(s) < 0)
 
483
        return -1;
 
484
 
 
485
    h263_decode_init_vlc(s);
 
486
 
 
487
    /* init rv vlc */
 
488
    if (!done) {
 
489
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
 
490
                 rv_lum_bits, 1, 1,
 
491
                 rv_lum_code, 2, 2, 16384);
 
492
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
 
493
                 rv_chrom_bits, 1, 1,
 
494
                 rv_chrom_code, 2, 2, 16388);
 
495
        done = 1;
 
496
    }
 
497
 
 
498
    return 0;
 
499
}
 
500
 
 
501
static av_cold int rv10_decode_end(AVCodecContext *avctx)
 
502
{
 
503
    MpegEncContext *s = avctx->priv_data;
 
504
 
 
505
    MPV_common_end(s);
 
506
    return 0;
 
507
}
 
508
 
 
509
static int rv10_decode_packet(AVCodecContext *avctx,
 
510
                             const uint8_t *buf, int buf_size, int buf_size2)
 
511
{
 
512
    MpegEncContext *s = avctx->priv_data;
 
513
    int mb_count, mb_pos, left, start_mb_x;
 
514
 
 
515
    init_get_bits(&s->gb, buf, buf_size*8);
 
516
    if(s->codec_id ==CODEC_ID_RV10)
 
517
        mb_count = rv10_decode_picture_header(s);
 
518
    else
 
519
        mb_count = rv20_decode_picture_header(s);
 
520
    if (mb_count < 0) {
 
521
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
 
522
        return -1;
 
523
    }
 
524
 
 
525
    if (s->mb_x >= s->mb_width ||
 
526
        s->mb_y >= s->mb_height) {
 
527
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
 
528
        return -1;
 
529
    }
 
530
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
 
531
    left = s->mb_width * s->mb_height - mb_pos;
 
532
    if (mb_count > left) {
 
533
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
 
534
        return -1;
 
535
    }
 
536
 
 
537
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
 
538
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
 
539
            ff_er_frame_end(s);
 
540
            MPV_frame_end(s);
 
541
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
 
542
        }
 
543
        if(MPV_frame_start(s, avctx) < 0)
 
544
            return -1;
 
545
        ff_er_frame_start(s);
 
546
    }
 
547
 
 
548
    av_dlog(avctx, "qscale=%d\n", s->qscale);
 
549
 
 
550
    /* default quantization values */
 
551
    if(s->codec_id== CODEC_ID_RV10){
 
552
        if(s->mb_y==0) s->first_slice_line=1;
 
553
    }else{
 
554
        s->first_slice_line=1;
 
555
        s->resync_mb_x= s->mb_x;
 
556
    }
 
557
    start_mb_x= s->mb_x;
 
558
    s->resync_mb_y= s->mb_y;
 
559
    if(s->h263_aic){
 
560
        s->y_dc_scale_table=
 
561
        s->c_dc_scale_table= ff_aic_dc_scale_table;
 
562
    }else{
 
563
        s->y_dc_scale_table=
 
564
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 
565
    }
 
566
 
 
567
    if(s->modified_quant)
 
568
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
 
569
 
 
570
    ff_set_qscale(s, s->qscale);
 
571
 
 
572
    s->rv10_first_dc_coded[0] = 0;
 
573
    s->rv10_first_dc_coded[1] = 0;
 
574
    s->rv10_first_dc_coded[2] = 0;
 
575
    s->block_wrap[0]=
 
576
    s->block_wrap[1]=
 
577
    s->block_wrap[2]=
 
578
    s->block_wrap[3]= s->b8_stride;
 
579
    s->block_wrap[4]=
 
580
    s->block_wrap[5]= s->mb_stride;
 
581
    ff_init_block_index(s);
 
582
    /* decode each macroblock */
 
583
 
 
584
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
 
585
        int ret;
 
586
        ff_update_block_index(s);
 
587
        av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
 
588
 
 
589
        s->mv_dir = MV_DIR_FORWARD;
 
590
        s->mv_type = MV_TYPE_16X16;
 
591
        ret=ff_h263_decode_mb(s, s->block);
 
592
 
 
593
        if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
 
594
            av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
 
595
            s->gb.size_in_bits= 8*buf_size2;
 
596
            ret= SLICE_OK;
 
597
        }
 
598
 
 
599
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
 
600
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
 
601
            return -1;
 
602
        }
 
603
        if(s->pict_type != AV_PICTURE_TYPE_B)
 
604
            ff_h263_update_motion_val(s);
 
605
        MPV_decode_mb(s, s->block);
 
606
        if(s->loop_filter)
 
607
            ff_h263_loop_filter(s);
 
608
 
 
609
        if (++s->mb_x == s->mb_width) {
 
610
            s->mb_x = 0;
 
611
            s->mb_y++;
 
612
            ff_init_block_index(s);
 
613
        }
 
614
        if(s->mb_x == s->resync_mb_x)
 
615
            s->first_slice_line=0;
 
616
        if(ret == SLICE_END) break;
 
617
    }
 
618
 
 
619
    ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
 
620
 
 
621
    return s->gb.size_in_bits;
 
622
}
 
623
 
 
624
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
 
625
{
 
626
    if(avctx->slice_count) return avctx->slice_offset[n];
 
627
    else                   return AV_RL32(buf + n*8);
 
628
}
 
629
 
 
630
static int rv10_decode_frame(AVCodecContext *avctx,
 
631
                             void *data, int *data_size,
 
632
                             AVPacket *avpkt)
 
633
{
 
634
    const uint8_t *buf = avpkt->data;
 
635
    int buf_size = avpkt->size;
 
636
    MpegEncContext *s = avctx->priv_data;
 
637
    int i;
 
638
    AVFrame *pict = data;
 
639
    int slice_count;
 
640
    const uint8_t *slices_hdr = NULL;
 
641
 
 
642
    av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
 
643
 
 
644
    /* no supplementary picture */
 
645
    if (buf_size == 0) {
 
646
        return 0;
 
647
    }
 
648
 
 
649
    if(!avctx->slice_count){
 
650
        slice_count = (*buf++) + 1;
 
651
        slices_hdr = buf + 4;
 
652
        buf += 8 * slice_count;
 
653
    }else
 
654
        slice_count = avctx->slice_count;
 
655
 
 
656
    for(i=0; i<slice_count; i++){
 
657
        int offset= get_slice_offset(avctx, slices_hdr, i);
 
658
        int size, size2;
 
659
 
 
660
        if(i+1 == slice_count)
 
661
            size= buf_size - offset;
 
662
        else
 
663
            size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
 
664
 
 
665
        if(i+2 >= slice_count)
 
666
            size2= buf_size - offset;
 
667
        else
 
668
            size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
 
669
 
 
670
        if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
 
671
            i++;
 
672
    }
 
673
 
 
674
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
 
675
        ff_er_frame_end(s);
 
676
        MPV_frame_end(s);
 
677
 
 
678
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
 
679
            *pict= *(AVFrame*)s->current_picture_ptr;
 
680
        } else if (s->last_picture_ptr != NULL) {
 
681
            *pict= *(AVFrame*)s->last_picture_ptr;
 
682
        }
 
683
 
 
684
        if(s->last_picture_ptr || s->low_delay){
 
685
            *data_size = sizeof(AVFrame);
 
686
            ff_print_debug_info(s, pict);
 
687
        }
 
688
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
 
689
    }
 
690
 
 
691
    return buf_size;
 
692
}
 
693
 
 
694
AVCodec ff_rv10_decoder = {
 
695
    "rv10",
 
696
    AVMEDIA_TYPE_VIDEO,
 
697
    CODEC_ID_RV10,
 
698
    sizeof(MpegEncContext),
 
699
    rv10_decode_init,
 
700
    NULL,
 
701
    rv10_decode_end,
 
702
    rv10_decode_frame,
 
703
    CODEC_CAP_DR1,
 
704
    .max_lowres = 3,
 
705
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 
706
    .pix_fmts= ff_pixfmt_list_420,
 
707
};
 
708
 
 
709
AVCodec ff_rv20_decoder = {
 
710
    "rv20",
 
711
    AVMEDIA_TYPE_VIDEO,
 
712
    CODEC_ID_RV20,
 
713
    sizeof(MpegEncContext),
 
714
    rv10_decode_init,
 
715
    NULL,
 
716
    rv10_decode_end,
 
717
    rv10_decode_frame,
 
718
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 
719
    .flush= ff_mpeg_flush,
 
720
    .max_lowres = 3,
 
721
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
 
722
    .pix_fmts= ff_pixfmt_list_420,
 
723
};