Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ ac52613c

History | View | Annotate | Download (25.7 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 5fc32c27 Alex Beregszaszi
                if (get_bits1(&s->gb) == 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 7ae7300e Alex Beregszaszi
                skip_bits(&s->gb, 11);
204 de6d9b64 Fabrice Bellard
                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 7ae7300e Alex Beregszaszi
                skip_bits(&s->gb, 9);
220 de6d9b64 Fabrice Bellard
                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
233 f544a5fc Diego Biurrun
#if defined(CONFIG_RV10_ENCODER) || defined(CONFIG_RV20_ENCODER)
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 9701840b Aurelien Jacobs
    put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE));
244 de6d9b64 Fabrice Bellard
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 9701840b Aurelien Jacobs
    if (s->pict_type == FF_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 910f02a0 Diego Biurrun
       to display the macroblocks 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 6647ab80 Ramiro Polla
    put_sbits(&s->pb, 8, picture_number); //FIXME wrong, but correct is not known
269 d0271e8a Michael Niedermayer
    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 9701840b Aurelien Jacobs
//    assert(s->h263_aic== (s->pict_type == FF_I_TYPE));
277 d0271e8a Michael Niedermayer
    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 9701840b Aurelien Jacobs
    s->h263_aic= s->pict_type == FF_I_TYPE;
283 d0271e8a Michael Niedermayer
    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 f544a5fc Diego Biurrun
#endif /* defined(CONFIG_RV10_ENCODER) || defined(CONFIG_RV20_ENCODER) */
308 7604246d Wolfgang Hesseler
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 5fc32c27 Alex Beregszaszi
    marker = get_bits1(&s->gb);
316 de6d9b64 Fabrice Bellard
317 5fc32c27 Alex Beregszaszi
    if (get_bits1(&s->gb))
318 9701840b Aurelien Jacobs
        s->pict_type = FF_P_TYPE;
319 de6d9b64 Fabrice Bellard
    else
320 9701840b Aurelien Jacobs
        s->pict_type = FF_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 5fc32c27 Alex Beregszaszi
    pb_frame = get_bits1(&s->gb);
324 de6d9b64 Fabrice Bellard
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 9701840b Aurelien Jacobs
    if (s->pict_type == FF_I_TYPE) {
341 de6d9b64 Fabrice Bellard
        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 910f02a0 Diego Biurrun
       to display the macroblocks 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 9701840b Aurelien Jacobs
    case 0: s->pict_type= FF_I_TYPE; break;
406
    case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
407
    case 2: s->pict_type= FF_P_TYPE; break;
408
    case 3: s->pict_type= FF_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 9701840b Aurelien Jacobs
    if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
415 fddae1c3 Michael Niedermayer
        av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
416
        return -1;
417
    }
418 115329f1 Diego Biurrun
419 5fc32c27 Alex Beregszaszi
    if (get_bits1(&s->gb)){
420 473c7582 Michael Niedermayer
        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 5fc32c27 Alex Beregszaszi
        if (get_bits1(&s->gb)){
431 b40cd4e0 Michael Niedermayer
            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 5fc32c27 Alex Beregszaszi
        if (get_bits1(&s->gb)){
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 9701840b Aurelien Jacobs
        if(s->pict_type!=FF_B_TYPE){
486 b40cd4e0 Michael Niedermayer
            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 9701840b Aurelien Jacobs
    s->h263_aic= s->pict_type == FF_I_TYPE;
509 68b94c35 Michael Niedermayer
//    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 9701840b Aurelien Jacobs
    assert(s->pict_type != FF_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 98a6fff9 Zuxy Meng
static av_cold int rv10_decode_init(AVCodecContext *avctx)
526 de6d9b64 Fabrice Bellard
{
527
    MpegEncContext *s = avctx->priv_data;
528 7604246d Wolfgang Hesseler
    static int done=0;
529 de6d9b64 Fabrice Bellard
530 ac52613c Laurent Aimar
    if (avctx->extradata_size < 8) {
531
        av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
532
        return -1;
533
    }
534
535 3edcacde Michael Niedermayer
    MPV_decode_defaults(s);
536 115329f1 Diego Biurrun
537 9db99069 Michael Niedermayer
    s->avctx= avctx;
538 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
539 40a12840 Michael Niedermayer
    s->codec_id= avctx->codec_id;
540 de6d9b64 Fabrice Bellard
541
    s->width = avctx->width;
542
    s->height = avctx->height;
543
544 fb3d155c Michael Niedermayer
    s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
545 fead30d4 Alex Beregszaszi
    avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
546 78a5ec27 Michael Niedermayer
547 c21f308e Roman Shaposhnik
    if (avctx->sub_id == 0x10000000) {
548 144f0625 Michael Niedermayer
        s->rv10_version= 0;
549 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
550 c21f308e Roman Shaposhnik
    } else if (avctx->sub_id == 0x10002000) {
551 8a36717a Michael Niedermayer
        s->rv10_version= 3;
552
        s->low_delay=1;
553
        s->obmc=1;
554 c21f308e Roman Shaposhnik
    } else if (avctx->sub_id == 0x10003000) {
555 144f0625 Michael Niedermayer
        s->rv10_version= 3;
556 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
557 c21f308e Roman Shaposhnik
    } else if (avctx->sub_id == 0x10003001) {
558 144f0625 Michael Niedermayer
        s->rv10_version= 3;
559 b40cd4e0 Michael Niedermayer
        s->low_delay=1;
560 c21f308e Roman Shaposhnik
    } else if (    avctx->sub_id == 0x20001000
561
               || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
562 ac49f3ef Michael Niedermayer
        s->low_delay=1;
563 c21f308e Roman Shaposhnik
    } else if (    avctx->sub_id == 0x30202002
564
               ||  avctx->sub_id == 0x30203002
565
               || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
566 ac49f3ef Michael Niedermayer
        s->low_delay=0;
567
        s->avctx->has_b_frames=1;
568 c21f308e Roman Shaposhnik
    } else
569 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
570 115329f1 Diego Biurrun
571 423962dc Michael Niedermayer
    if(avctx->debug & FF_DEBUG_PICT_INFO){
572
        av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
573
    }
574 644a9262 Michael Niedermayer
575
    avctx->pix_fmt = PIX_FMT_YUV420P;
576
577 de6d9b64 Fabrice Bellard
    if (MPV_common_init(s) < 0)
578
        return -1;
579
580
    h263_decode_init_vlc(s);
581
582
    /* init rv vlc */
583
    if (!done) {
584 115329f1 Diego Biurrun
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
585 de6d9b64 Fabrice Bellard
                 rv_lum_bits, 1, 1,
586 073c2593 Burkhard Plaum
                 rv_lum_code, 2, 2, 1);
587 115329f1 Diego Biurrun
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
588 de6d9b64 Fabrice Bellard
                 rv_chrom_bits, 1, 1,
589 073c2593 Burkhard Plaum
                 rv_chrom_code, 2, 2, 1);
590 de6d9b64 Fabrice Bellard
        done = 1;
591
    }
592
593
    return 0;
594
}
595
596 98a6fff9 Zuxy Meng
static av_cold int rv10_decode_end(AVCodecContext *avctx)
597 de6d9b64 Fabrice Bellard
{
598
    MpegEncContext *s = avctx->priv_data;
599
600
    MPV_common_end(s);
601
    return 0;
602
}
603
604 115329f1 Diego Biurrun
static int rv10_decode_packet(AVCodecContext *avctx,
605 16db3585 Michael Niedermayer
                             const uint8_t *buf, int buf_size)
606 de6d9b64 Fabrice Bellard
{
607
    MpegEncContext *s = avctx->priv_data;
608 e2887363 Michael Niedermayer
    int mb_count, mb_pos, left, start_mb_x;
609 de6d9b64 Fabrice Bellard
610 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
611 68b94c35 Michael Niedermayer
    if(s->codec_id ==CODEC_ID_RV10)
612
        mb_count = rv10_decode_picture_header(s);
613
    else
614
        mb_count = rv20_decode_picture_header(s);
615 de6d9b64 Fabrice Bellard
    if (mb_count < 0) {
616 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
617 de6d9b64 Fabrice Bellard
        return -1;
618
    }
619 115329f1 Diego Biurrun
620 de6d9b64 Fabrice Bellard
    if (s->mb_x >= s->mb_width ||
621
        s->mb_y >= s->mb_height) {
622 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
623 de6d9b64 Fabrice Bellard
        return -1;
624
    }
625
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
626
    left = s->mb_width * s->mb_height - mb_pos;
627
    if (mb_count > left) {
628 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
629 de6d9b64 Fabrice Bellard
        return -1;
630
    }
631 9701840b Aurelien Jacobs
//if(s->pict_type == FF_P_TYPE) return 0;
632 de6d9b64 Fabrice Bellard
633 bed1707c Michael Niedermayer
    if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
634 473a200d Michael Niedermayer
        if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
635
            ff_er_frame_end(s);
636
            MPV_frame_end(s);
637
            s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
638
        }
639 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
640
            return -1;
641 473a200d Michael Niedermayer
        ff_er_frame_start(s);
642 de6d9b64 Fabrice Bellard
    }
643
644
#ifdef DEBUG
645 267f7edc Steve L'Homme
    av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale);
646 de6d9b64 Fabrice Bellard
#endif
647
648
    /* default quantization values */
649 68b94c35 Michael Niedermayer
    if(s->codec_id== CODEC_ID_RV10){
650
        if(s->mb_y==0) s->first_slice_line=1;
651
    }else{
652 115329f1 Diego Biurrun
        s->first_slice_line=1;
653 e2887363 Michael Niedermayer
        s->resync_mb_x= s->mb_x;
654 68b94c35 Michael Niedermayer
    }
655 e2887363 Michael Niedermayer
    start_mb_x= s->mb_x;
656 37921ffd Michael Niedermayer
    s->resync_mb_y= s->mb_y;
657 68b94c35 Michael Niedermayer
    if(s->h263_aic){
658 115329f1 Diego Biurrun
        s->y_dc_scale_table=
659 68b94c35 Michael Niedermayer
        s->c_dc_scale_table= ff_aic_dc_scale_table;
660
    }else{
661
        s->y_dc_scale_table=
662
        s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
663
    }
664 332f9ac4 Michael Niedermayer
665
    if(s->modified_quant)
666
        s->chroma_qscale_table= ff_h263_chroma_qscale_table;
667 115329f1 Diego Biurrun
668 554daa24 Michael Niedermayer
    ff_set_qscale(s, s->qscale);
669 332f9ac4 Michael Niedermayer
670 de6d9b64 Fabrice Bellard
    s->rv10_first_dc_coded[0] = 0;
671
    s->rv10_first_dc_coded[1] = 0;
672
    s->rv10_first_dc_coded[2] = 0;
673 8e784825 Michael Niedermayer
//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]);
674 ab00685a Michael Niedermayer
    s->block_wrap[0]=
675
    s->block_wrap[1]=
676
    s->block_wrap[2]=
677 137c8468 Michael Niedermayer
    s->block_wrap[3]= s->b8_stride;
678 ab00685a Michael Niedermayer
    s->block_wrap[4]=
679 137c8468 Michael Niedermayer
    s->block_wrap[5]= s->mb_stride;
680 4d2858de Michael Niedermayer
    ff_init_block_index(s);
681 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
682 8a36717a Michael Niedermayer
683
    for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
684 68b94c35 Michael Niedermayer
        int ret;
685 4d2858de Michael Niedermayer
        ff_update_block_index(s);
686 de6d9b64 Fabrice Bellard
#ifdef DEBUG
687 267f7edc Steve L'Homme
        av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
688 de6d9b64 Fabrice Bellard
#endif
689 8a36717a Michael Niedermayer
690 de6d9b64 Fabrice Bellard
        s->mv_dir = MV_DIR_FORWARD;
691 115329f1 Diego Biurrun
        s->mv_type = MV_TYPE_16X16;
692 68b94c35 Michael Niedermayer
        ret=ff_h263_decode_mb(s, s->block);
693
694 473a200d Michael Niedermayer
        if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
695 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
696 de6d9b64 Fabrice Bellard
            return -1;
697
        }
698 9701840b Aurelien Jacobs
        if(s->pict_type != FF_B_TYPE)
699 8e784825 Michael Niedermayer
            ff_h263_update_motion_val(s);
700 4d2858de Michael Niedermayer
        MPV_decode_mb(s, s->block);
701 332f9ac4 Michael Niedermayer
        if(s->loop_filter)
702
            ff_h263_loop_filter(s);
703
704 de6d9b64 Fabrice Bellard
        if (++s->mb_x == s->mb_width) {
705
            s->mb_x = 0;
706
            s->mb_y++;
707 4d2858de Michael Niedermayer
            ff_init_block_index(s);
708 de6d9b64 Fabrice Bellard
        }
709 68b94c35 Michael Niedermayer
        if(s->mb_x == s->resync_mb_x)
710
            s->first_slice_line=0;
711
        if(ret == SLICE_END) break;
712 de6d9b64 Fabrice Bellard
    }
713
714 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);
715 473a200d Michael Niedermayer
716 144f0625 Michael Niedermayer
    return buf_size;
717
}
718
719 16db3585 Michael Niedermayer
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
720 dd55d4a3 Kostya Shishkov
{
721
    if(avctx->slice_count) return avctx->slice_offset[n];
722
    else                   return AV_RL32(buf + n*8);
723
}
724
725 115329f1 Diego Biurrun
static int rv10_decode_frame(AVCodecContext *avctx,
726 144f0625 Michael Niedermayer
                             void *data, int *data_size,
727 16db3585 Michael Niedermayer
                             const uint8_t *buf, int buf_size)
728 144f0625 Michael Niedermayer
{
729
    MpegEncContext *s = avctx->priv_data;
730
    int i;
731 115329f1 Diego Biurrun
    AVFrame *pict = data;
732 dd55d4a3 Kostya Shishkov
    int slice_count;
733 16db3585 Michael Niedermayer
    const uint8_t *slices_hdr = NULL;
734 144f0625 Michael Niedermayer
735
#ifdef DEBUG
736 267f7edc Steve L'Homme
    av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
737 144f0625 Michael Niedermayer
#endif
738
739
    /* no supplementary picture */
740
    if (buf_size == 0) {
741
        return 0;
742
    }
743 8e784825 Michael Niedermayer
744 dd55d4a3 Kostya Shishkov
    if(!avctx->slice_count){
745
        slice_count = (*buf++) + 1;
746
        slices_hdr = buf + 4;
747
        buf += 8 * slice_count;
748
    }else
749
        slice_count = avctx->slice_count;
750
751 63e6c176 Kostya Shishkov
    for(i=0; i<slice_count; i++){
752
        int offset= get_slice_offset(avctx, slices_hdr, i);
753
        int size;
754 115329f1 Diego Biurrun
755 63e6c176 Kostya Shishkov
        if(i+1 == slice_count)
756
            size= buf_size - offset;
757
        else
758
            size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
759 144f0625 Michael Niedermayer
760 63e6c176 Kostya Shishkov
        rv10_decode_packet(avctx, buf+offset, size);
761
    }
762 115329f1 Diego Biurrun
763 60dfd147 Wolfgang Scherer
    if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
764 473a200d Michael Niedermayer
        ff_er_frame_end(s);
765 de6d9b64 Fabrice Bellard
        MPV_frame_end(s);
766 115329f1 Diego Biurrun
767 9701840b Aurelien Jacobs
        if (s->pict_type == FF_B_TYPE || s->low_delay) {
768 5430b070 Michael Niedermayer
            *pict= *(AVFrame*)s->current_picture_ptr;
769
        } else if (s->last_picture_ptr != NULL) {
770
            *pict= *(AVFrame*)s->last_picture_ptr;
771 b40cd4e0 Michael Niedermayer
        }
772 5430b070 Michael Niedermayer
773
        if(s->last_picture_ptr || s->low_delay){
774 9993064e Michael Niedermayer
            *data_size = sizeof(AVFrame);
775 5430b070 Michael Niedermayer
            ff_print_debug_info(s, pict);
776
        }
777 473a200d Michael Niedermayer
        s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
778 de6d9b64 Fabrice Bellard
    }
779 144f0625 Michael Niedermayer
780 de6d9b64 Fabrice Bellard
    return buf_size;
781
}
782
783
AVCodec rv10_decoder = {
784
    "rv10",
785
    CODEC_TYPE_VIDEO,
786
    CODEC_ID_RV10,
787
    sizeof(MpegEncContext),
788
    rv10_decode_init,
789
    NULL,
790
    rv10_decode_end,
791
    rv10_decode_frame,
792 162d4fc9 Stefano Sabatini
    CODEC_CAP_DR1,
793 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
794 de6d9b64 Fabrice Bellard
};
795 68b94c35 Michael Niedermayer
796
AVCodec rv20_decoder = {
797
    "rv20",
798
    CODEC_TYPE_VIDEO,
799
    CODEC_ID_RV20,
800
    sizeof(MpegEncContext),
801
    rv10_decode_init,
802
    NULL,
803
    rv10_decode_end,
804
    rv10_decode_frame,
805 934982c4 Michael Niedermayer
    CODEC_CAP_DR1 | CODEC_CAP_DELAY,
806 bc17df09 Michael Niedermayer
    .flush= ff_mpeg_flush,
807 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
808 68b94c35 Michael Niedermayer
};