← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libav/oneiric-security

« back to all changes in this revision

Viewing changes to .pc/post-0.7.1/0032-rv10-20-tell-decoder-to-use-edge-emulation.patch/libavcodec/rv10.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2011-10-01 00:22:07 UTC
  • mfrom: (1.3.8 sid)
  • Revision ID: package-import@ubuntu.com-20111001002207-tnxz39i0rwr5ufy9
Tags: 4:0.7.2-1ubuntu1
* Merge from debian, remaining changes:
  - don't build against libfaad, libdirac, librtmp and libopenjpeg,
    lame, xvid, x264  (all in universe)
  - not installing into multiarch directories
* This new upstream release has basically merged in all 70 patches that
  are present in 4:0.7.1-7ubuntu2, plus some additional, similarily
  focused ones.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/post-0.7.1/0032-rv10-20-tell-decoder-to-use-edge-emulation.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
 
 
442
 
    s->orig_width = s->width  = avctx->coded_width;
443
 
    s->orig_height= s->height = avctx->coded_height;
444
 
 
445
 
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
446
 
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
447
 
 
448
 
    if (avctx->sub_id == 0x10000000) {
449
 
        s->rv10_version= 0;
450
 
        s->low_delay=1;
451
 
    } else if (avctx->sub_id == 0x10001000) {
452
 
        s->rv10_version= 3;
453
 
        s->low_delay=1;
454
 
    } else if (avctx->sub_id == 0x10002000) {
455
 
        s->rv10_version= 3;
456
 
        s->low_delay=1;
457
 
        s->obmc=1;
458
 
    } else if (avctx->sub_id == 0x10003000) {
459
 
        s->rv10_version= 3;
460
 
        s->low_delay=1;
461
 
    } else if (avctx->sub_id == 0x10003001) {
462
 
        s->rv10_version= 3;
463
 
        s->low_delay=1;
464
 
    } else if (    avctx->sub_id == 0x20001000
465
 
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
466
 
        s->low_delay=1;
467
 
    } else if (    avctx->sub_id == 0x30202002
468
 
               ||  avctx->sub_id == 0x30203002
469
 
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
470
 
        s->low_delay=0;
471
 
        s->avctx->has_b_frames=1;
472
 
    } else
473
 
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
474
 
 
475
 
    if(avctx->debug & FF_DEBUG_PICT_INFO){
476
 
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
477
 
    }
478
 
 
479
 
    avctx->pix_fmt = PIX_FMT_YUV420P;
480
 
 
481
 
    if (MPV_common_init(s) < 0)
482
 
        return -1;
483
 
 
484
 
    h263_decode_init_vlc(s);
485
 
 
486
 
    /* init rv vlc */
487
 
    if (!done) {
488
 
        INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
489
 
                 rv_lum_bits, 1, 1,
490
 
                 rv_lum_code, 2, 2, 16384);
491
 
        INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
492
 
                 rv_chrom_bits, 1, 1,
493
 
                 rv_chrom_code, 2, 2, 16388);
494
 
        done = 1;
495
 
    }
496
 
 
497
 
    return 0;
498
 
}
499
 
 
500
 
static av_cold int rv10_decode_end(AVCodecContext *avctx)
501
 
{
502
 
    MpegEncContext *s = avctx->priv_data;
503
 
 
504
 
    MPV_common_end(s);
505
 
    return 0;
506
 
}
507
 
 
508
 
static int rv10_decode_packet(AVCodecContext *avctx,
509
 
                             const uint8_t *buf, int buf_size, int buf_size2)
510
 
{
511
 
    MpegEncContext *s = avctx->priv_data;
512
 
    int mb_count, mb_pos, left, start_mb_x;
513
 
 
514
 
    init_get_bits(&s->gb, buf, buf_size*8);
515
 
    if(s->codec_id ==CODEC_ID_RV10)
516
 
        mb_count = rv10_decode_picture_header(s);
517
 
    else
518
 
        mb_count = rv20_decode_picture_header(s);
519
 
    if (mb_count < 0) {
520
 
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
521
 
        return -1;
522
 
    }
523
 
 
524
 
    if (s->mb_x >= s->mb_width ||
525
 
        s->mb_y >= s->mb_height) {
526
 
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
527
 
        return -1;
528
 
    }
529
 
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
530
 
    left = s->mb_width * s->mb_height - mb_pos;
531
 
    if (mb_count > left) {
532
 
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
533
 
        return -1;
534
 
    }
535
 
 
536
 
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
537
 
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
538
 
            ff_er_frame_end(s);
539
 
            MPV_frame_end(s);
540
 
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
541
 
        }
542
 
        if(MPV_frame_start(s, avctx) < 0)
543
 
            return -1;
544
 
        ff_er_frame_start(s);
545
 
    }
546
 
 
547
 
    av_dlog(avctx, "qscale=%d\n", s->qscale);
548
 
 
549
 
    /* default quantization values */
550
 
    if(s->codec_id== CODEC_ID_RV10){
551
 
        if(s->mb_y==0) s->first_slice_line=1;
552
 
    }else{
553
 
        s->first_slice_line=1;
554
 
        s->resync_mb_x= s->mb_x;
555
 
    }
556
 
    start_mb_x= s->mb_x;
557
 
    s->resync_mb_y= s->mb_y;
558
 
    if(s->h263_aic){
559
 
        s->y_dc_scale_table=
560
 
        s->c_dc_scale_table= ff_aic_dc_scale_table;
561
 
    }else{
562
 
        s->y_dc_scale_table=
563
 
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
564
 
    }
565
 
 
566
 
    if(s->modified_quant)
567
 
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
568
 
 
569
 
    ff_set_qscale(s, s->qscale);
570
 
 
571
 
    s->rv10_first_dc_coded[0] = 0;
572
 
    s->rv10_first_dc_coded[1] = 0;
573
 
    s->rv10_first_dc_coded[2] = 0;
574
 
    s->block_wrap[0]=
575
 
    s->block_wrap[1]=
576
 
    s->block_wrap[2]=
577
 
    s->block_wrap[3]= s->b8_stride;
578
 
    s->block_wrap[4]=
579
 
    s->block_wrap[5]= s->mb_stride;
580
 
    ff_init_block_index(s);
581
 
    /* decode each macroblock */
582
 
 
583
 
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
584
 
        int ret;
585
 
        ff_update_block_index(s);
586
 
        av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
587
 
 
588
 
        s->mv_dir = MV_DIR_FORWARD;
589
 
        s->mv_type = MV_TYPE_16X16;
590
 
        ret=ff_h263_decode_mb(s, s->block);
591
 
 
592
 
        if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
593
 
            av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
594
 
            s->gb.size_in_bits= 8*buf_size2;
595
 
            ret= SLICE_OK;
596
 
        }
597
 
 
598
 
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
599
 
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
600
 
            return -1;
601
 
        }
602
 
        if(s->pict_type != AV_PICTURE_TYPE_B)
603
 
            ff_h263_update_motion_val(s);
604
 
        MPV_decode_mb(s, s->block);
605
 
        if(s->loop_filter)
606
 
            ff_h263_loop_filter(s);
607
 
 
608
 
        if (++s->mb_x == s->mb_width) {
609
 
            s->mb_x = 0;
610
 
            s->mb_y++;
611
 
            ff_init_block_index(s);
612
 
        }
613
 
        if(s->mb_x == s->resync_mb_x)
614
 
            s->first_slice_line=0;
615
 
        if(ret == SLICE_END) break;
616
 
    }
617
 
 
618
 
    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);
619
 
 
620
 
    return s->gb.size_in_bits;
621
 
}
622
 
 
623
 
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
624
 
{
625
 
    if(avctx->slice_count) return avctx->slice_offset[n];
626
 
    else                   return AV_RL32(buf + n*8);
627
 
}
628
 
 
629
 
static int rv10_decode_frame(AVCodecContext *avctx,
630
 
                             void *data, int *data_size,
631
 
                             AVPacket *avpkt)
632
 
{
633
 
    const uint8_t *buf = avpkt->data;
634
 
    int buf_size = avpkt->size;
635
 
    MpegEncContext *s = avctx->priv_data;
636
 
    int i;
637
 
    AVFrame *pict = data;
638
 
    int slice_count;
639
 
    const uint8_t *slices_hdr = NULL;
640
 
 
641
 
    av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
642
 
 
643
 
    /* no supplementary picture */
644
 
    if (buf_size == 0) {
645
 
        return 0;
646
 
    }
647
 
 
648
 
    if(!avctx->slice_count){
649
 
        slice_count = (*buf++) + 1;
650
 
        slices_hdr = buf + 4;
651
 
        buf += 8 * slice_count;
652
 
    }else
653
 
        slice_count = avctx->slice_count;
654
 
 
655
 
    for(i=0; i<slice_count; i++){
656
 
        int offset= get_slice_offset(avctx, slices_hdr, i);
657
 
        int size, size2;
658
 
 
659
 
        if(i+1 == slice_count)
660
 
            size= buf_size - offset;
661
 
        else
662
 
            size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
663
 
 
664
 
        if(i+2 >= slice_count)
665
 
            size2= buf_size - offset;
666
 
        else
667
 
            size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
668
 
 
669
 
        if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
670
 
            i++;
671
 
    }
672
 
 
673
 
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
674
 
        ff_er_frame_end(s);
675
 
        MPV_frame_end(s);
676
 
 
677
 
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
678
 
            *pict= *(AVFrame*)s->current_picture_ptr;
679
 
        } else if (s->last_picture_ptr != NULL) {
680
 
            *pict= *(AVFrame*)s->last_picture_ptr;
681
 
        }
682
 
 
683
 
        if(s->last_picture_ptr || s->low_delay){
684
 
            *data_size = sizeof(AVFrame);
685
 
            ff_print_debug_info(s, pict);
686
 
        }
687
 
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
688
 
    }
689
 
 
690
 
    return buf_size;
691
 
}
692
 
 
693
 
AVCodec ff_rv10_decoder = {
694
 
    "rv10",
695
 
    AVMEDIA_TYPE_VIDEO,
696
 
    CODEC_ID_RV10,
697
 
    sizeof(MpegEncContext),
698
 
    rv10_decode_init,
699
 
    NULL,
700
 
    rv10_decode_end,
701
 
    rv10_decode_frame,
702
 
    CODEC_CAP_DR1,
703
 
    .max_lowres = 3,
704
 
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
705
 
    .pix_fmts= ff_pixfmt_list_420,
706
 
};
707
 
 
708
 
AVCodec ff_rv20_decoder = {
709
 
    "rv20",
710
 
    AVMEDIA_TYPE_VIDEO,
711
 
    CODEC_ID_RV20,
712
 
    sizeof(MpegEncContext),
713
 
    rv10_decode_init,
714
 
    NULL,
715
 
    rv10_decode_end,
716
 
    rv10_decode_frame,
717
 
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
718
 
    .flush= ff_mpeg_flush,
719
 
    .max_lowres = 3,
720
 
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
721
 
    .pix_fmts= ff_pixfmt_list_420,
722
 
};