Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ 284ad8a4

History | View | Annotate | Download (25 KB)

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

297
    n = get_bits(gb, 16);
298
    if (n >= 0x4000) {
299
        return n - 0x4000;
300
    } else {
301
        n1 = get_bits(gb, 16);
302
        return (n << 16) | n1;
303
    }
304
}
305 88730be6 Måns Rullgård
#endif
306 de6d9b64 Fabrice Bellard
307 7604246d Wolfgang Hesseler
#endif //CONFIG_ENCODERS
308
309 de6d9b64 Fabrice Bellard
/* read RV 1.0 compatible frame header */
310
static int rv10_decode_picture_header(MpegEncContext *s)
311
{
312 18ade954 Michael Niedermayer
    int mb_count, pb_frame, marker, unk, mb_xy;
313 115329f1 Diego Biurrun
314 144f0625 Michael Niedermayer
//printf("ff:%d\n", full_frame);
315 de6d9b64 Fabrice Bellard
    marker = get_bits(&s->gb, 1);
316
317
    if (get_bits(&s->gb, 1))
318
        s->pict_type = P_TYPE;
319
    else
320
        s->pict_type = I_TYPE;
321 144f0625 Michael Niedermayer
//printf("h:%X ver:%d\n",h,s->rv10_version);
322 9b879566 Michel Bardiaux
    if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
323 de6d9b64 Fabrice Bellard
    pb_frame = get_bits(&s->gb, 1);
324
325
#ifdef DEBUG
326 267f7edc Steve L'Homme
    av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
327 de6d9b64 Fabrice Bellard
#endif
328 115329f1 Diego Biurrun
329 68bd11f5 Michael Niedermayer
    if (pb_frame){
330 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
331 de6d9b64 Fabrice Bellard
        return -1;
332 68bd11f5 Michael Niedermayer
    }
333 de6d9b64 Fabrice Bellard
334
    s->qscale = get_bits(&s->gb, 5);
335 ee3b2be6 Michael Niedermayer
    if(s->qscale==0){
336 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
337 ee3b2be6 Michael Niedermayer
        return -1;
338
    }
339 de6d9b64 Fabrice Bellard
340
    if (s->pict_type == I_TYPE) {
341
        if (s->rv10_version == 3) {
342
            /* specific MPEG like DC coding not used */
343
            s->last_dc[0] = get_bits(&s->gb, 8);
344
            s->last_dc[1] = get_bits(&s->gb, 8);
345
            s->last_dc[2] = get_bits(&s->gb, 8);
346
#ifdef DEBUG
347 267f7edc Steve L'Homme
            av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n",
348 de6d9b64 Fabrice Bellard
                   s->last_dc[0],
349
                   s->last_dc[1],
350
                   s->last_dc[2]);
351
#endif
352
        }
353
    }
354
    /* if multiple packets per frame are sent, the position at which
355
       to display the macro blocks is coded here */
356 18ade954 Michael Niedermayer
357
    mb_xy= s->mb_x + s->mb_y*s->mb_width;
358
    if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
359 bb270c08 Diego Biurrun
        s->mb_x = get_bits(&s->gb, 6); /* mb_x */
360
        s->mb_y = get_bits(&s->gb, 6); /* mb_y */
361 de6d9b64 Fabrice Bellard
        mb_count = get_bits(&s->gb, 12);
362
    } else {
363
        s->mb_x = 0;
364
        s->mb_y = 0;
365
        mb_count = s->mb_width * s->mb_height;
366
    }
367 bb270c08 Diego Biurrun
    unk= get_bits(&s->gb, 3);   /* ignored */
368 68bd11f5 Michael Niedermayer
//printf("%d\n", unk);
369 de6d9b64 Fabrice Bellard
    s->f_code = 1;
370
    s->unrestricted_mv = 1;
371 255b3ac2 Michael Niedermayer
372 de6d9b64 Fabrice Bellard
    return mb_count;
373
}
374
375 68b94c35 Michael Niedermayer
static int rv20_decode_picture_header(MpegEncContext *s)
376
{
377 473c7582 Michael Niedermayer
    int seq, mb_pos, i;
378 115329f1 Diego Biurrun
379 35ef76b5 Michael Niedermayer
#if 0
380
    GetBitContext gb= s->gb;
381
    for(i=0; i<64; i++){
382
        av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
383
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
384
    }
385
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
386
#endif
387 423962dc Michael Niedermayer
#if 0
388 113533a5 Michael Niedermayer
    av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
389 423962dc Michael Niedermayer
    for(i=0; i<s->avctx->extradata_size; i++){
390 113533a5 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
391 423962dc Michael Niedermayer
        if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
392
    }
393
    av_log(s->avctx, AV_LOG_DEBUG, "\n");
394
#endif
395 115329f1 Diego Biurrun
396 b40cd4e0 Michael Niedermayer
    if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
397
        if (get_bits(&s->gb, 3)){
398
            av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
399
            return -1;
400 115329f1 Diego Biurrun
        }
401
    }
402 473c7582 Michael Niedermayer
403
    i= get_bits(&s->gb, 2);
404
    switch(i){
405
    case 0: s->pict_type= I_TYPE; break;
406 248a1aa5 Michael Niedermayer
    case 1: s->pict_type= I_TYPE; break; //hmm ...
407 473c7582 Michael Niedermayer
    case 2: s->pict_type= P_TYPE; break;
408
    case 3: s->pict_type= B_TYPE; break;
409 115329f1 Diego Biurrun
    default:
410 473c7582 Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
411
        return -1;
412
    }
413 115329f1 Diego Biurrun
414 fddae1c3 Michael Niedermayer
    if(s->last_picture_ptr==NULL && s->pict_type==B_TYPE){
415
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
416
        return -1;
417
    }
418 115329f1 Diego Biurrun
419 473c7582 Michael Niedermayer
    if (get_bits(&s->gb, 1)){
420
        av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
421 68b94c35 Michael Niedermayer
        return -1;
422
    }
423
424
    s->qscale = get_bits(&s->gb, 5);
425
    if(s->qscale==0){
426
        av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
427
        return -1;
428
    }
429 b40cd4e0 Michael Niedermayer
    if(s->avctx->sub_id == 0x30203002){
430
        if (get_bits(&s->gb, 1)){
431
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
432
            return -1;
433
        }
434
    }
435 115329f1 Diego Biurrun
436 ac49f3ef Michael Niedermayer
    if(s->avctx->has_b_frames){
437 113533a5 Michael Niedermayer
        int f, new_w, new_h;
438 0d415b2d Michael Niedermayer
        int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
439 bc17df09 Michael Niedermayer
440 b40cd4e0 Michael Niedermayer
        if (get_bits(&s->gb, 1)){
441 bc17df09 Michael Niedermayer
            av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
442 bed1707c Michael Niedermayer
//            return -1;
443 b40cd4e0 Michael Niedermayer
        }
444 113533a5 Michael Niedermayer
        seq= get_bits(&s->gb, 13)<<2;
445 74679f5c Michael Niedermayer
446 113533a5 Michael Niedermayer
        f= get_bits(&s->gb, av_log2(v)+1);
447
448
        if(f){
449
            new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
450
            new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
451
        }else{
452
            new_w= s->width; //FIXME wrong we of course must save the original in the context
453
            new_h= s->height;
454
        }
455
        if(new_w != s->width || new_h != s->height){
456
            av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
457 284ad8a4 Reimar Döffinger
            if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0)
458
                return -1;
459 113533a5 Michael Niedermayer
            MPV_common_end(s);
460
            s->width  = s->avctx->width = new_w;
461
            s->height = s->avctx->height= new_h;
462
            if (MPV_common_init(s) < 0)
463
                return -1;
464
        }
465 9786bd4d Michael Niedermayer
466 bc17df09 Michael Niedermayer
        if(s->avctx->debug & FF_DEBUG_PICT_INFO){
467 f6d51123 Michael Niedermayer
            av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
468 9993064e Michael Niedermayer
        }
469 9786bd4d Michael Niedermayer
    }else{
470
        seq= get_bits(&s->gb, 8)*128;
471
    }
472 423962dc Michael Niedermayer
473 115329f1 Diego Biurrun
//     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
474 9786bd4d Michael Niedermayer
    mb_pos= ff_h263_decode_mba(s);
475
/*    }else{
476 423962dc Michael Niedermayer
        mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
477
        s->mb_x= mb_pos % s->mb_width;
478
        s->mb_y= mb_pos / s->mb_width;
479 9786bd4d Michael Niedermayer
    }*/
480 a3c22fbc Michael Niedermayer
//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
481 b40cd4e0 Michael Niedermayer
    seq |= s->time &~0x7FFF;
482
    if(seq - s->time >  0x4000) seq -= 0x8000;
483
    if(seq - s->time < -0x4000) seq += 0x8000;
484 115329f1 Diego Biurrun
    if(seq != s->time){
485 b40cd4e0 Michael Niedermayer
        if(s->pict_type!=B_TYPE){
486
            s->time= seq;
487
            s->pp_time= s->time - s->last_non_b_time;
488
            s->last_non_b_time= s->time;
489
        }else{
490
            s->time= seq;
491
            s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
492
            if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
493 160d679c Mike Melanson
                av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
494
                return FRAME_SKIPPED;
495 b40cd4e0 Michael Niedermayer
            }
496 6d312496 Michael Niedermayer
            ff_mpeg4_init_direct_mv(s);
497 b40cd4e0 Michael Niedermayer
        }
498
    }
499
//    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
500 a3c22fbc Michael Niedermayer
/*for(i=0; i<32; i++){
501
    av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
502
}
503
av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
504 68b94c35 Michael Niedermayer
    s->no_rounding= get_bits1(&s->gb);
505 115329f1 Diego Biurrun
506 68b94c35 Michael Niedermayer
    s->f_code = 1;
507
    s->unrestricted_mv = 1;
508
    s->h263_aic= s->pict_type == I_TYPE;
509
//    s->alt_inter_vlc=1;
510
//    s->obmc=1;
511
//    s->umvplus=1;
512 332f9ac4 Michael Niedermayer
    s->modified_quant=1;
513
    s->loop_filter=1;
514 115329f1 Diego Biurrun
515 68b94c35 Michael Niedermayer
    if(s->avctx->debug & FF_DEBUG_PICT_INFO){
516 115329f1 Diego Biurrun
            av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
517 68b94c35 Michael Niedermayer
                   seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
518
    }
519
520 b40cd4e0 Michael Niedermayer
    assert(s->pict_type != B_TYPE || !s->low_delay);
521 473c7582 Michael Niedermayer
522 68b94c35 Michael Niedermayer
    return s->mb_width*s->mb_height - mb_pos;
523
}
524
525 de6d9b64 Fabrice Bellard
static int rv10_decode_init(AVCodecContext *avctx)
526
{
527
    MpegEncContext *s = avctx->priv_data;
528 7604246d Wolfgang Hesseler
    static int done=0;
529 de6d9b64 Fabrice Bellard
530 3edcacde Michael Niedermayer
    MPV_decode_defaults(s);
531 115329f1 Diego Biurrun
532 9db99069 Michael Niedermayer
    s->avctx= avctx;
533 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
534 40a12840 Michael Niedermayer
    s->codec_id= avctx->codec_id;
535 de6d9b64 Fabrice Bellard
536
    s->width = avctx->width;
537
    s->height = avctx->height;
538
539 fb3d155c Michael Niedermayer
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
540 fead30d4 Alex Beregszaszi
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
541 78a5ec27 Michael Niedermayer
542 144f0625 Michael Niedermayer
    switch(avctx->sub_id){
543
    case 0x10000000:
544
        s->rv10_version= 0;
545 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
546 144f0625 Michael Niedermayer
        break;
547 8a36717a Michael Niedermayer
    case 0x10002000:
548
        s->rv10_version= 3;
549
        s->low_delay=1;
550
        s->obmc=1;
551
        break;
552 144f0625 Michael Niedermayer
    case 0x10003000:
553
        s->rv10_version= 3;
554 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
555 144f0625 Michael Niedermayer
        break;
556
    case 0x10003001:
557
        s->rv10_version= 3;
558 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
559 144f0625 Michael Niedermayer
        break;
560 f9e0f2a2 Matthieu Castet
    case 0x20001000: /* real rv20 decoder fail on this id */
561
    /*case 0x20100001:
562 ac49f3ef Michael Niedermayer
    case 0x20101001:
563 f9e0f2a2 Matthieu Castet
    case 0x20103001:*/
564
    case 0x20100000 ... 0x2019ffff:
565 ac49f3ef Michael Niedermayer
        s->low_delay=1;
566
        break;
567 f9e0f2a2 Matthieu Castet
    /*case 0x20200002:
568 a3c22fbc Michael Niedermayer
    case 0x20201002:
569 f9e0f2a2 Matthieu Castet
    case 0x20203002:*/
570
    case 0x20200002 ... 0x202fffff:
571 ac49f3ef Michael Niedermayer
    case 0x30202002:
572
    case 0x30203002:
573
        s->low_delay=0;
574
        s->avctx->has_b_frames=1;
575
        break;
576 144f0625 Michael Niedermayer
    default:
577 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
578 255b3ac2 Michael Niedermayer
    }
579 115329f1 Diego Biurrun
580 423962dc Michael Niedermayer
    if(avctx->debug & FF_DEBUG_PICT_INFO){
581
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
582
    }
583 644a9262 Michael Niedermayer
584
    avctx->pix_fmt = PIX_FMT_YUV420P;
585
586 de6d9b64 Fabrice Bellard
    if (MPV_common_init(s) < 0)
587
        return -1;
588
589
    h263_decode_init_vlc(s);
590
591
    /* init rv vlc */
592
    if (!done) {
593 115329f1 Diego Biurrun
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
594 de6d9b64 Fabrice Bellard
                 rv_lum_bits, 1, 1,
595 073c2593 Burkhard Plaum
                 rv_lum_code, 2, 2, 1);
596 115329f1 Diego Biurrun
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
597 de6d9b64 Fabrice Bellard
                 rv_chrom_bits, 1, 1,
598 073c2593 Burkhard Plaum
                 rv_chrom_code, 2, 2, 1);
599 de6d9b64 Fabrice Bellard
        done = 1;
600
    }
601
602
    return 0;
603
}
604
605
static int rv10_decode_end(AVCodecContext *avctx)
606
{
607
    MpegEncContext *s = avctx->priv_data;
608
609
    MPV_common_end(s);
610
    return 0;
611
}
612
613 115329f1 Diego Biurrun
static int rv10_decode_packet(AVCodecContext *avctx,
614 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
615 de6d9b64 Fabrice Bellard
{
616
    MpegEncContext *s = avctx->priv_data;
617 e2887363 Michael Niedermayer
    int mb_count, mb_pos, left, start_mb_x;
618 de6d9b64 Fabrice Bellard
619 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
620 68b94c35 Michael Niedermayer
    if(s->codec_id ==CODEC_ID_RV10)
621
        mb_count = rv10_decode_picture_header(s);
622
    else
623
        mb_count = rv20_decode_picture_header(s);
624 de6d9b64 Fabrice Bellard
    if (mb_count < 0) {
625 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
626 de6d9b64 Fabrice Bellard
        return -1;
627
    }
628 115329f1 Diego Biurrun
629 de6d9b64 Fabrice Bellard
    if (s->mb_x >= s->mb_width ||
630
        s->mb_y >= s->mb_height) {
631 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
632 de6d9b64 Fabrice Bellard
        return -1;
633
    }
634
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
635
    left = s->mb_width * s->mb_height - mb_pos;
636
    if (mb_count > left) {
637 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
638 de6d9b64 Fabrice Bellard
        return -1;
639
    }
640 68b94c35 Michael Niedermayer
//if(s->pict_type == P_TYPE) return 0;
641 de6d9b64 Fabrice Bellard
642 bed1707c Michael Niedermayer
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
643 473a200d Michael Niedermayer
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
644
            ff_er_frame_end(s);
645
            MPV_frame_end(s);
646
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
647
        }
648 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
649
            return -1;
650 473a200d Michael Niedermayer
        ff_er_frame_start(s);
651 de6d9b64 Fabrice Bellard
    }
652
653
#ifdef DEBUG
654 267f7edc Steve L'Homme
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
655 de6d9b64 Fabrice Bellard
#endif
656
657
    /* default quantization values */
658 68b94c35 Michael Niedermayer
    if(s->codec_id== CODEC_ID_RV10){
659
        if(s->mb_y==0) s->first_slice_line=1;
660
    }else{
661 115329f1 Diego Biurrun
        s->first_slice_line=1;
662 e2887363 Michael Niedermayer
        s->resync_mb_x= s->mb_x;
663 68b94c35 Michael Niedermayer
    }
664 e2887363 Michael Niedermayer
    start_mb_x= s->mb_x;
665 37921ffd Michael Niedermayer
    s->resync_mb_y= s->mb_y;
666 68b94c35 Michael Niedermayer
    if(s->h263_aic){
667 115329f1 Diego Biurrun
        s->y_dc_scale_table=
668 68b94c35 Michael Niedermayer
        s->c_dc_scale_table= ff_aic_dc_scale_table;
669
    }else{
670
        s->y_dc_scale_table=
671
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
672
    }
673 332f9ac4 Michael Niedermayer
674
    if(s->modified_quant)
675
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
676 115329f1 Diego Biurrun
677 554daa24 Michael Niedermayer
    ff_set_qscale(s, s->qscale);
678 332f9ac4 Michael Niedermayer
679 de6d9b64 Fabrice Bellard
    s->rv10_first_dc_coded[0] = 0;
680
    s->rv10_first_dc_coded[1] = 0;
681
    s->rv10_first_dc_coded[2] = 0;
682 8e784825 Michael Niedermayer
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
683 ab00685a Michael Niedermayer
    s->block_wrap[0]=
684
    s->block_wrap[1]=
685
    s->block_wrap[2]=
686 137c8468 Michael Niedermayer
    s->block_wrap[3]= s->b8_stride;
687 ab00685a Michael Niedermayer
    s->block_wrap[4]=
688 137c8468 Michael Niedermayer
    s->block_wrap[5]= s->mb_stride;
689 4d2858de Michael Niedermayer
    ff_init_block_index(s);
690 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
691 8a36717a Michael Niedermayer
692
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
693 68b94c35 Michael Niedermayer
        int ret;
694 4d2858de Michael Niedermayer
        ff_update_block_index(s);
695 de6d9b64 Fabrice Bellard
#ifdef DEBUG
696 267f7edc Steve L'Homme
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
697 de6d9b64 Fabrice Bellard
#endif
698 8a36717a Michael Niedermayer
699 de6d9b64 Fabrice Bellard
        s->mv_dir = MV_DIR_FORWARD;
700 115329f1 Diego Biurrun
        s->mv_type = MV_TYPE_16X16;
701 68b94c35 Michael Niedermayer
        ret=ff_h263_decode_mb(s, s->block);
702
703 473a200d Michael Niedermayer
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
704 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
705 de6d9b64 Fabrice Bellard
            return -1;
706
        }
707 8e784825 Michael Niedermayer
        if(s->pict_type != B_TYPE)
708
            ff_h263_update_motion_val(s);
709 4d2858de Michael Niedermayer
        MPV_decode_mb(s, s->block);
710 332f9ac4 Michael Niedermayer
        if(s->loop_filter)
711
            ff_h263_loop_filter(s);
712
713 de6d9b64 Fabrice Bellard
        if (++s->mb_x == s->mb_width) {
714
            s->mb_x = 0;
715
            s->mb_y++;
716 4d2858de Michael Niedermayer
            ff_init_block_index(s);
717 de6d9b64 Fabrice Bellard
        }
718 68b94c35 Michael Niedermayer
        if(s->mb_x == s->resync_mb_x)
719
            s->first_slice_line=0;
720
        if(ret == SLICE_END) break;
721 de6d9b64 Fabrice Bellard
    }
722
723 e2887363 Michael Niedermayer
    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);
724 473a200d Michael Niedermayer
725 144f0625 Michael Niedermayer
    return buf_size;
726
}
727
728 115329f1 Diego Biurrun
static int rv10_decode_frame(AVCodecContext *avctx,
729 144f0625 Michael Niedermayer
                             void *data, int *data_size,
730 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
731 144f0625 Michael Niedermayer
{
732
    MpegEncContext *s = avctx->priv_data;
733
    int i;
734 115329f1 Diego Biurrun
    AVFrame *pict = data;
735 144f0625 Michael Niedermayer
736
#ifdef DEBUG
737 267f7edc Steve L'Homme
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
738 144f0625 Michael Niedermayer
#endif
739
740
    /* no supplementary picture */
741
    if (buf_size == 0) {
742
        return 0;
743
    }
744 8e784825 Michael Niedermayer
745 144f0625 Michael Niedermayer
    if(avctx->slice_count){
746
        for(i=0; i<avctx->slice_count; i++){
747
            int offset= avctx->slice_offset[i];
748
            int size;
749 115329f1 Diego Biurrun
750 144f0625 Michael Niedermayer
            if(i+1 == avctx->slice_count)
751
                size= buf_size - offset;
752
            else
753
                size= avctx->slice_offset[i+1] - offset;
754
755 473a200d Michael Niedermayer
            rv10_decode_packet(avctx, buf+offset, size);
756 144f0625 Michael Niedermayer
        }
757
    }else{
758 473a200d Michael Niedermayer
        rv10_decode_packet(avctx, buf, buf_size);
759 144f0625 Michael Niedermayer
    }
760 115329f1 Diego Biurrun
761 60dfd147 Wolfgang Scherer
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
762 473a200d Michael Niedermayer
        ff_er_frame_end(s);
763 de6d9b64 Fabrice Bellard
        MPV_frame_end(s);
764 115329f1 Diego Biurrun
765 5430b070 Michael Niedermayer
        if (s->pict_type == B_TYPE || s->low_delay) {
766
            *pict= *(AVFrame*)s->current_picture_ptr;
767
        } else if (s->last_picture_ptr != NULL) {
768
            *pict= *(AVFrame*)s->last_picture_ptr;
769 b40cd4e0 Michael Niedermayer
        }
770 5430b070 Michael Niedermayer
771
        if(s->last_picture_ptr || s->low_delay){
772 9993064e Michael Niedermayer
            *data_size = sizeof(AVFrame);
773 5430b070 Michael Niedermayer
            ff_print_debug_info(s, pict);
774
        }
775 473a200d Michael Niedermayer
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
776 de6d9b64 Fabrice Bellard
    }
777 144f0625 Michael Niedermayer
778 de6d9b64 Fabrice Bellard
    return buf_size;
779
}
780
781
AVCodec rv10_decoder = {
782
    "rv10",
783
    CODEC_TYPE_VIDEO,
784
    CODEC_ID_RV10,
785
    sizeof(MpegEncContext),
786
    rv10_decode_init,
787
    NULL,
788
    rv10_decode_end,
789
    rv10_decode_frame,
790 3cf33c37 Michael Niedermayer
    CODEC_CAP_DR1
791 de6d9b64 Fabrice Bellard
};
792 68b94c35 Michael Niedermayer
793
AVCodec rv20_decoder = {
794
    "rv20",
795
    CODEC_TYPE_VIDEO,
796
    CODEC_ID_RV20,
797
    sizeof(MpegEncContext),
798
    rv10_decode_init,
799
    NULL,
800
    rv10_decode_end,
801
    rv10_decode_frame,
802 934982c4 Michael Niedermayer
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
803 bc17df09 Michael Niedermayer
    .flush= ff_mpeg_flush,
804 68b94c35 Michael Niedermayer
};