Statistics
| Branch: | Revision:

ffmpeg / libavcodec / rv10.c @ ea937d01

History | View | Annotate | Download (16.3 KB)

1 de6d9b64 Fabrice Bellard
/*
2
 * RV10 codec
3 ff4ec49e Fabrice Bellard
 * Copyright (c) 2000,2001 Fabrice Bellard.
4 de6d9b64 Fabrice Bellard
 *
5 ff4ec49e Fabrice Bellard
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9 de6d9b64 Fabrice Bellard
 *
10 ff4ec49e Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
11 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ff4ec49e Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14 de6d9b64 Fabrice Bellard
 *
15 ff4ec49e Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 de6d9b64 Fabrice Bellard
 */
19
#include "avcodec.h"
20 6000abfa Fabrice Bellard
#include "dsputil.h"
21 de6d9b64 Fabrice Bellard
#include "mpegvideo.h"
22
23
//#define DEBUG
24
25 68bd11f5 Michael Niedermayer
#define DC_VLC_BITS 14 //FIXME find a better solution
26 a3494679 Michael Niedermayer
27 de6d9b64 Fabrice Bellard
static const UINT16 rv_lum_code[256] =
28
{
29
 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
30
 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
31
 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
32
 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
33
 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
34
 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
35
 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
36
 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
37
 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
38
 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
39
 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
40
 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
41
 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
42
 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
43
 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
44
 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
45
 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
46
 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
47
 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
48
 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
49
 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
50
 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
51
 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
52
 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
53
 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
54
 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
55
 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
56
 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
57
 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
58
 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
59
 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
60
 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
61
};
62
63
static const UINT8 rv_lum_bits[256] = 
64
{
65
 14, 12, 12, 12, 12, 12, 12, 12,
66
 12, 12, 12, 12, 12, 12, 12, 12,
67
 12, 12, 12, 12, 12, 12, 12, 12,
68
 12, 12, 12, 12, 12, 12, 12, 12,
69
 12, 12, 12, 12, 12, 12, 12, 12,
70
 12, 12, 12, 12, 12, 12, 12, 12,
71
 12, 12, 12, 12, 12, 12, 12, 12,
72
 12, 12, 12, 12, 12, 12, 12, 12,
73
 12, 10, 10, 10, 10, 10, 10, 10,
74
 10, 10, 10, 10, 10, 10, 10, 10,
75
 10, 10, 10, 10, 10, 10, 10, 10,
76
 10, 10, 10, 10, 10, 10, 10, 10,
77
 10,  8,  8,  8,  8,  8,  8,  8,
78
  8,  8,  8,  8,  8,  8,  8,  8,
79
  8,  7,  7,  7,  7,  7,  7,  7,
80
  7,  6,  6,  6,  6,  5,  5,  4,
81
  2,  4,  5,  5,  6,  6,  6,  6,
82
  7,  7,  7,  7,  7,  7,  7,  7,
83
  8,  8,  8,  8,  8,  8,  8,  8,
84
  8,  8,  8,  8,  8,  8,  8,  8,
85
 10, 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
 12, 12, 12, 12, 12, 12, 12, 12,
90
 12, 12, 12, 12, 12, 12, 12, 12,
91
 12, 12, 12, 12, 12, 12, 12, 12,
92
 12, 12, 12, 12, 12, 12, 12, 12,
93
 12, 12, 12, 12, 12, 12, 12, 12,
94
 12, 12, 12, 12, 12, 12, 12, 12,
95
 12, 12, 12, 12, 12, 12, 12, 12,
96
 12, 12, 12, 12, 12, 12, 12, 12,
97
};
98
99
static const UINT16 rv_chrom_code[256] =
100
{
101
 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
102
 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
103
 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
104
 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
105
 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
106
 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
107
 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
108
 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
109
 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
110
 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
111
 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
112
 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
113
 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
114
 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
115
 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
116
 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
117
 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
118
 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
119
 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
120
 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
121
 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
122
 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
123
 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
124
 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
125
 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
126
 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
127
 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
128
 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
129
 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
130
 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
131
 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
132
 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
133
};
134
135
static const UINT8 rv_chrom_bits[256] =
136
{
137
 16, 14, 14, 14, 14, 14, 14, 14,
138
 14, 14, 14, 14, 14, 14, 14, 14,
139
 14, 14, 14, 14, 14, 14, 14, 14,
140
 14, 14, 14, 14, 14, 14, 14, 14,
141
 14, 14, 14, 14, 14, 14, 14, 14,
142
 14, 14, 14, 14, 14, 14, 14, 14,
143
 14, 14, 14, 14, 14, 14, 14, 14,
144
 14, 14, 14, 14, 14, 14, 14, 14,
145
 14, 12, 12, 12, 12, 12, 12, 12,
146
 12, 12, 12, 12, 12, 12, 12, 12,
147
 12, 12, 12, 12, 12, 12, 12, 12,
148
 12, 12, 12, 12, 12, 12, 12, 12,
149
 12, 10, 10, 10, 10, 10, 10, 10,
150
 10, 10, 10, 10, 10, 10, 10, 10,
151
 10,  8,  8,  8,  8,  8,  8,  8,
152
  8,  6,  6,  6,  6,  4,  4,  3,
153
  2,  3,  4,  4,  6,  6,  6,  6,
154
  8,  8,  8,  8,  8,  8,  8,  8,
155
 10, 10, 10, 10, 10, 10, 10, 10,
156
 10, 10, 10, 10, 10, 10, 10, 10,
157
 12, 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
 14, 14, 14, 14, 14, 14, 14, 14,
162
 14, 14, 14, 14, 14, 14, 14, 14,
163
 14, 14, 14, 14, 14, 14, 14, 14,
164
 14, 14, 14, 14, 14, 14, 14, 14,
165
 14, 14, 14, 14, 14, 14, 14, 14,
166
 14, 14, 14, 14, 14, 14, 14, 14,
167
 14, 14, 14, 14, 14, 14, 14, 14,
168
 14, 14, 14, 14, 14, 14, 14, 14,
169
};
170
171
static VLC rv_dc_lum, rv_dc_chrom;
172
173
int rv_decode_dc(MpegEncContext *s, int n)
174
{
175
    int code;
176
177
    if (n < 4) {
178 a3494679 Michael Niedermayer
        code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
179 de6d9b64 Fabrice Bellard
        if (code < 0) {
180
            /* XXX: I don't understand why they use LONGER codes than
181
               necessary. The following code would be completely useless
182
               if they had thought about it !!! */
183
            code = get_bits(&s->gb, 7);
184
            if (code == 0x7c) {
185
                code = (INT8)(get_bits(&s->gb, 7) + 1);
186
            } else if (code == 0x7d) {
187
                code = -128 + get_bits(&s->gb, 7);
188
            } else if (code == 0x7e) {
189
                if (get_bits(&s->gb, 1) == 0)
190
                    code = (INT8)(get_bits(&s->gb, 8) + 1);
191
                else
192
                    code = (INT8)(get_bits(&s->gb, 8));
193
            } else if (code == 0x7f) {
194
                get_bits(&s->gb, 11);
195
                code = 1;
196
            }
197
        } else {
198
            code -= 128;
199
        }
200
    } else {
201 a3494679 Michael Niedermayer
        code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
202 de6d9b64 Fabrice Bellard
        /* same remark */
203
        if (code < 0) {
204
            code = get_bits(&s->gb, 9);
205
            if (code == 0x1fc) {
206
                code = (INT8)(get_bits(&s->gb, 7) + 1);
207
            } else if (code == 0x1fd) {
208
                code = -128 + get_bits(&s->gb, 7);
209
            } else if (code == 0x1fe) {
210
                get_bits(&s->gb, 9);
211
                code = 1;
212
            } else {
213 68bd11f5 Michael Niedermayer
                fprintf(stderr, "chroma dc error\n");
214 de6d9b64 Fabrice Bellard
                return 0xffff;
215
            }
216
        } else {
217
            code -= 128;
218
        }
219
    }
220
    return -code;
221
}
222
223
/* write RV 1.0 compatible frame header */
224
void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
225
{
226 4c2bc159 Michael Niedermayer
    int full_frame= 0;
227 0b61920a Michael Niedermayer
228 de6d9b64 Fabrice Bellard
    align_put_bits(&s->pb);
229 0b61920a Michael Niedermayer
    
230 de6d9b64 Fabrice Bellard
    put_bits(&s->pb, 1, 1);        /* marker */
231
232
    put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
233
234
    put_bits(&s->pb, 1, 0);        /* not PB frame */
235
236
    put_bits(&s->pb, 5, s->qscale);
237
238
    if (s->pict_type == I_TYPE) {
239
        /* specific MPEG like DC coding not used */
240
    }
241
    /* if multiple packets per frame are sent, the position at which
242
       to display the macro blocks is coded here */
243 0b61920a Michael Niedermayer
    if(!full_frame){
244
        put_bits(&s->pb, 6, 0);        /* mb_x */
245
        put_bits(&s->pb, 6, 0);        /* mb_y */
246
        put_bits(&s->pb, 12, s->mb_width * s->mb_height);
247
    }
248 de6d9b64 Fabrice Bellard
249
    put_bits(&s->pb, 3, 0);        /* ignored */
250
}
251
252
static int get_num(GetBitContext *gb)
253
{
254
    int n, n1;
255
256
    n = get_bits(gb, 16);
257
    if (n >= 0x4000) {
258
        return n - 0x4000;
259
    } else {
260
        n1 = get_bits(gb, 16);
261
        return (n << 16) | n1;
262
    }
263
}
264
265
/* read RV 1.0 compatible frame header */
266
static int rv10_decode_picture_header(MpegEncContext *s)
267
{
268 144f0625 Michael Niedermayer
    int mb_count, pb_frame, marker, full_frame, unk;
269 de6d9b64 Fabrice Bellard
    
270 144f0625 Michael Niedermayer
    full_frame= s->avctx->slice_count==1;
271
//printf("ff:%d\n", full_frame);
272 de6d9b64 Fabrice Bellard
    marker = get_bits(&s->gb, 1);
273
274
    if (get_bits(&s->gb, 1))
275
        s->pict_type = P_TYPE;
276
    else
277
        s->pict_type = I_TYPE;
278 144f0625 Michael Niedermayer
//printf("h:%X ver:%d\n",h,s->rv10_version);
279 255b3ac2 Michael Niedermayer
    if(!marker) printf("marker missing\n");
280 de6d9b64 Fabrice Bellard
    pb_frame = get_bits(&s->gb, 1);
281
282
#ifdef DEBUG
283
    printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
284
#endif
285
    
286 68bd11f5 Michael Niedermayer
    if (pb_frame){
287
        fprintf(stderr, "pb frame not supported\n");
288 de6d9b64 Fabrice Bellard
        return -1;
289 68bd11f5 Michael Niedermayer
    }
290 de6d9b64 Fabrice Bellard
291
    s->qscale = get_bits(&s->gb, 5);
292 ee3b2be6 Michael Niedermayer
    if(s->qscale==0){
293
        fprintf(stderr, "error, qscale:0\n");
294
        return -1;
295
    }
296 de6d9b64 Fabrice Bellard
297
    if (s->pict_type == I_TYPE) {
298
        if (s->rv10_version == 3) {
299
            /* specific MPEG like DC coding not used */
300
            s->last_dc[0] = get_bits(&s->gb, 8);
301
            s->last_dc[1] = get_bits(&s->gb, 8);
302
            s->last_dc[2] = get_bits(&s->gb, 8);
303
#ifdef DEBUG
304
            printf("DC:%d %d %d\n",
305
                   s->last_dc[0],
306
                   s->last_dc[1],
307
                   s->last_dc[2]);
308
#endif
309
        }
310
    }
311
    /* if multiple packets per frame are sent, the position at which
312
       to display the macro blocks is coded here */
313 144f0625 Michael Niedermayer
    if ((!full_frame) || show_bits(&s->gb, 12)==0) {
314 de6d9b64 Fabrice Bellard
        s->mb_x = get_bits(&s->gb, 6);        /* mb_x */
315
        s->mb_y = get_bits(&s->gb, 6);        /* mb_y */
316
        mb_count = get_bits(&s->gb, 12);
317
    } else {
318
        s->mb_x = 0;
319
        s->mb_y = 0;
320
        mb_count = s->mb_width * s->mb_height;
321
    }
322 68bd11f5 Michael Niedermayer
    unk= get_bits(&s->gb, 3);        /* ignored */
323
//printf("%d\n", unk);
324 de6d9b64 Fabrice Bellard
    s->f_code = 1;
325
    s->unrestricted_mv = 1;
326 255b3ac2 Michael Niedermayer
327 de6d9b64 Fabrice Bellard
    return mb_count;
328
}
329
330
static int rv10_decode_init(AVCodecContext *avctx)
331
{
332
    MpegEncContext *s = avctx->priv_data;
333
    static int done;
334
335 9db99069 Michael Niedermayer
    s->avctx= avctx;
336 de6d9b64 Fabrice Bellard
    s->out_format = FMT_H263;
337
338
    s->width = avctx->width;
339
    s->height = avctx->height;
340
341
    s->h263_rv10 = 1;
342 144f0625 Michael Niedermayer
    switch(avctx->sub_id){
343
    case 0x10000000:
344
        s->rv10_version= 0;
345
        s->h263_long_vectors=0;
346
        break;
347
    case 0x10003000:
348
        s->rv10_version= 3;
349
        s->h263_long_vectors=1;
350
        break;
351
    case 0x10003001:
352
        s->rv10_version= 3;
353
        s->h263_long_vectors=0;
354
        break;
355
    default:
356
        fprintf(stderr, "unknown header %X\n", avctx->sub_id);
357 255b3ac2 Michael Niedermayer
    }
358 144f0625 Michael Niedermayer
//printf("ver:%X\n", avctx->sub_id);
359 3cf33c37 Michael Niedermayer
    s->flags= avctx->flags;
360 de6d9b64 Fabrice Bellard
361
    if (MPV_common_init(s) < 0)
362
        return -1;
363
364
    h263_decode_init_vlc(s);
365
366 ee3b2be6 Michael Niedermayer
    s->y_dc_scale_table=
367
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
368 4d2858de Michael Niedermayer
    s->progressive_sequence=1;
369 ee3b2be6 Michael Niedermayer
370 de6d9b64 Fabrice Bellard
    /* init rv vlc */
371
    if (!done) {
372 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 
373 de6d9b64 Fabrice Bellard
                 rv_lum_bits, 1, 1,
374
                 rv_lum_code, 2, 2);
375 a3494679 Michael Niedermayer
        init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 
376 de6d9b64 Fabrice Bellard
                 rv_chrom_bits, 1, 1,
377
                 rv_chrom_code, 2, 2);
378
        done = 1;
379
    }
380
381
    return 0;
382
}
383
384
static int rv10_decode_end(AVCodecContext *avctx)
385
{
386
    MpegEncContext *s = avctx->priv_data;
387
388
    MPV_common_end(s);
389
    return 0;
390
}
391
392 144f0625 Michael Niedermayer
static int rv10_decode_packet(AVCodecContext *avctx, 
393 de6d9b64 Fabrice Bellard
                             UINT8 *buf, int buf_size)
394
{
395
    MpegEncContext *s = avctx->priv_data;
396
    int i, mb_count, mb_pos, left;
397
398 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, buf, buf_size*8);
399 144f0625 Michael Niedermayer
    
400 de6d9b64 Fabrice Bellard
    mb_count = rv10_decode_picture_header(s);
401
    if (mb_count < 0) {
402 68bd11f5 Michael Niedermayer
        fprintf(stderr, "HEADER ERROR\n");
403 de6d9b64 Fabrice Bellard
        return -1;
404
    }
405
    
406
    if (s->mb_x >= s->mb_width ||
407
        s->mb_y >= s->mb_height) {
408 68bd11f5 Michael Niedermayer
        fprintf(stderr, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
409 de6d9b64 Fabrice Bellard
        return -1;
410
    }
411
    mb_pos = s->mb_y * s->mb_width + s->mb_x;
412
    left = s->mb_width * s->mb_height - mb_pos;
413
    if (mb_count > left) {
414 68bd11f5 Michael Niedermayer
        fprintf(stderr, "COUNT ERROR\n");
415 de6d9b64 Fabrice Bellard
        return -1;
416
    }
417
418
    if (s->mb_x == 0 && s->mb_y == 0) {
419 d6db1c9c Michael Niedermayer
        if(MPV_frame_start(s, avctx) < 0)
420
            return -1;
421 de6d9b64 Fabrice Bellard
    }
422
423
#ifdef DEBUG
424
    printf("qscale=%d\n", s->qscale);
425
#endif
426
427
    /* default quantization values */
428
    s->y_dc_scale = 8;
429
    s->c_dc_scale = 8;
430
    s->rv10_first_dc_coded[0] = 0;
431
    s->rv10_first_dc_coded[1] = 0;
432
    s->rv10_first_dc_coded[2] = 0;
433 ab00685a Michael Niedermayer
434 4d2858de Michael Niedermayer
    if(s->mb_y==0) s->first_slice_line=1;
435
    
436 ab00685a Michael Niedermayer
    s->block_wrap[0]=
437
    s->block_wrap[1]=
438
    s->block_wrap[2]=
439
    s->block_wrap[3]= s->mb_width*2 + 2;
440
    s->block_wrap[4]=
441
    s->block_wrap[5]= s->mb_width + 2;
442 4d2858de Michael Niedermayer
    ff_init_block_index(s);
443 de6d9b64 Fabrice Bellard
    /* decode each macroblock */
444
    for(i=0;i<mb_count;i++) {
445 4d2858de Michael Niedermayer
        ff_update_block_index(s);
446 de6d9b64 Fabrice Bellard
#ifdef DEBUG
447
        printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
448
#endif
449
        
450 eb4b3dd3 Zdenek Kabelac
        s->dsp.clear_blocks(s->block[0]);
451 de6d9b64 Fabrice Bellard
        s->mv_dir = MV_DIR_FORWARD;
452
        s->mv_type = MV_TYPE_16X16; 
453 4d2858de Michael Niedermayer
        if (ff_h263_decode_mb(s, s->block) == SLICE_ERROR) {
454 68bd11f5 Michael Niedermayer
            fprintf(stderr, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
455 de6d9b64 Fabrice Bellard
            return -1;
456
        }
457 4d2858de Michael Niedermayer
        MPV_decode_mb(s, s->block);
458 de6d9b64 Fabrice Bellard
        if (++s->mb_x == s->mb_width) {
459
            s->mb_x = 0;
460
            s->mb_y++;
461 4d2858de Michael Niedermayer
            ff_init_block_index(s);
462
            s->first_slice_line=0;
463 de6d9b64 Fabrice Bellard
        }
464
    }
465
466 144f0625 Michael Niedermayer
    return buf_size;
467
}
468
469
static int rv10_decode_frame(AVCodecContext *avctx, 
470
                             void *data, int *data_size,
471
                             UINT8 *buf, int buf_size)
472
{
473
    MpegEncContext *s = avctx->priv_data;
474
    int i;
475 492cd3a9 Michael Niedermayer
    AVFrame *pict = data; 
476 144f0625 Michael Niedermayer
477
#ifdef DEBUG
478
    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
479
#endif
480
481
    /* no supplementary picture */
482
    if (buf_size == 0) {
483
        *data_size = 0;
484
        return 0;
485
    }
486
    
487
    if(avctx->slice_count){
488
        for(i=0; i<avctx->slice_count; i++){
489
            int offset= avctx->slice_offset[i];
490
            int size;
491
            
492
            if(i+1 == avctx->slice_count)
493
                size= buf_size - offset;
494
            else
495
                size= avctx->slice_offset[i+1] - offset;
496
497
            if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
498
                return -1;
499
        }
500
    }else{
501
        if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
502
            return -1;
503
    }
504
505
    if(s->mb_y>=s->mb_height){
506 de6d9b64 Fabrice Bellard
        MPV_frame_end(s);
507
        
508 492cd3a9 Michael Niedermayer
        *pict= *(AVFrame*)&s->current_picture;
509 144f0625 Michael Niedermayer
    
510 492cd3a9 Michael Niedermayer
        *data_size = sizeof(AVFrame);
511 144f0625 Michael Niedermayer
    }else{
512 de6d9b64 Fabrice Bellard
        *data_size = 0;
513
    }
514 144f0625 Michael Niedermayer
515 de6d9b64 Fabrice Bellard
    return buf_size;
516
}
517
518
AVCodec rv10_decoder = {
519
    "rv10",
520
    CODEC_TYPE_VIDEO,
521
    CODEC_ID_RV10,
522
    sizeof(MpegEncContext),
523
    rv10_decode_init,
524
    NULL,
525
    rv10_decode_end,
526
    rv10_decode_frame,
527 3cf33c37 Michael Niedermayer
    CODEC_CAP_DR1
528 de6d9b64 Fabrice Bellard
};