Libav

libavcodec/rv10.c

Go to the documentation of this file.
00001 /*
00002  * RV10/RV20 decoder
00003  * Copyright (c) 2000,2001 Fabrice Bellard
00004  * Copyright (c) 2002-2004 Michael Niedermayer
00005  *
00006  * This file is part of FFmpeg.
00007  *
00008  * FFmpeg is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * FFmpeg is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with FFmpeg; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00028 #include "avcodec.h"
00029 #include "dsputil.h"
00030 #include "mpegvideo.h"
00031 #include "mpeg4video.h"
00032 #include "h263.h"
00033 
00034 //#define DEBUG
00035 
00036 #define DC_VLC_BITS 14 //FIXME find a better solution
00037 
00038 static const uint16_t rv_lum_code[256] =
00039 {
00040  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
00041  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
00042  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
00043  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
00044  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
00045  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
00046  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
00047  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
00048  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
00049  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
00050  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
00051  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
00052  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
00053  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
00054  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
00055  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
00056  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
00057  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
00058  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
00059  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
00060  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
00061  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
00062  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
00063  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
00064  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
00065  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
00066  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
00067  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
00068  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
00069  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
00070  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
00071  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
00072 };
00073 
00074 static const uint8_t rv_lum_bits[256] =
00075 {
00076  14, 12, 12, 12, 12, 12, 12, 12,
00077  12, 12, 12, 12, 12, 12, 12, 12,
00078  12, 12, 12, 12, 12, 12, 12, 12,
00079  12, 12, 12, 12, 12, 12, 12, 12,
00080  12, 12, 12, 12, 12, 12, 12, 12,
00081  12, 12, 12, 12, 12, 12, 12, 12,
00082  12, 12, 12, 12, 12, 12, 12, 12,
00083  12, 12, 12, 12, 12, 12, 12, 12,
00084  12, 10, 10, 10, 10, 10, 10, 10,
00085  10, 10, 10, 10, 10, 10, 10, 10,
00086  10, 10, 10, 10, 10, 10, 10, 10,
00087  10, 10, 10, 10, 10, 10, 10, 10,
00088  10,  8,  8,  8,  8,  8,  8,  8,
00089   8,  8,  8,  8,  8,  8,  8,  8,
00090   8,  7,  7,  7,  7,  7,  7,  7,
00091   7,  6,  6,  6,  6,  5,  5,  4,
00092   2,  4,  5,  5,  6,  6,  6,  6,
00093   7,  7,  7,  7,  7,  7,  7,  7,
00094   8,  8,  8,  8,  8,  8,  8,  8,
00095   8,  8,  8,  8,  8,  8,  8,  8,
00096  10, 10, 10, 10, 10, 10, 10, 10,
00097  10, 10, 10, 10, 10, 10, 10, 10,
00098  10, 10, 10, 10, 10, 10, 10, 10,
00099  10, 10, 10, 10, 10, 10, 10, 10,
00100  12, 12, 12, 12, 12, 12, 12, 12,
00101  12, 12, 12, 12, 12, 12, 12, 12,
00102  12, 12, 12, 12, 12, 12, 12, 12,
00103  12, 12, 12, 12, 12, 12, 12, 12,
00104  12, 12, 12, 12, 12, 12, 12, 12,
00105  12, 12, 12, 12, 12, 12, 12, 12,
00106  12, 12, 12, 12, 12, 12, 12, 12,
00107  12, 12, 12, 12, 12, 12, 12, 12,
00108 };
00109 
00110 static const uint16_t rv_chrom_code[256] =
00111 {
00112  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
00113  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
00114  0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
00115  0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
00116  0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
00117  0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
00118  0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
00119  0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
00120  0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
00121  0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
00122  0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
00123  0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
00124  0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
00125  0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
00126  0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
00127  0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
00128  0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
00129  0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
00130  0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
00131  0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
00132  0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
00133  0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
00134  0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
00135  0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
00136  0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
00137  0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
00138  0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
00139  0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
00140  0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
00141  0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
00142  0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
00143  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
00144 };
00145 
00146 static const uint8_t rv_chrom_bits[256] =
00147 {
00148  16, 14, 14, 14, 14, 14, 14, 14,
00149  14, 14, 14, 14, 14, 14, 14, 14,
00150  14, 14, 14, 14, 14, 14, 14, 14,
00151  14, 14, 14, 14, 14, 14, 14, 14,
00152  14, 14, 14, 14, 14, 14, 14, 14,
00153  14, 14, 14, 14, 14, 14, 14, 14,
00154  14, 14, 14, 14, 14, 14, 14, 14,
00155  14, 14, 14, 14, 14, 14, 14, 14,
00156  14, 12, 12, 12, 12, 12, 12, 12,
00157  12, 12, 12, 12, 12, 12, 12, 12,
00158  12, 12, 12, 12, 12, 12, 12, 12,
00159  12, 12, 12, 12, 12, 12, 12, 12,
00160  12, 10, 10, 10, 10, 10, 10, 10,
00161  10, 10, 10, 10, 10, 10, 10, 10,
00162  10,  8,  8,  8,  8,  8,  8,  8,
00163   8,  6,  6,  6,  6,  4,  4,  3,
00164   2,  3,  4,  4,  6,  6,  6,  6,
00165   8,  8,  8,  8,  8,  8,  8,  8,
00166  10, 10, 10, 10, 10, 10, 10, 10,
00167  10, 10, 10, 10, 10, 10, 10, 10,
00168  12, 12, 12, 12, 12, 12, 12, 12,
00169  12, 12, 12, 12, 12, 12, 12, 12,
00170  12, 12, 12, 12, 12, 12, 12, 12,
00171  12, 12, 12, 12, 12, 12, 12, 12,
00172  14, 14, 14, 14, 14, 14, 14, 14,
00173  14, 14, 14, 14, 14, 14, 14, 14,
00174  14, 14, 14, 14, 14, 14, 14, 14,
00175  14, 14, 14, 14, 14, 14, 14, 14,
00176  14, 14, 14, 14, 14, 14, 14, 14,
00177  14, 14, 14, 14, 14, 14, 14, 14,
00178  14, 14, 14, 14, 14, 14, 14, 14,
00179  14, 14, 14, 14, 14, 14, 14, 14,
00180 };
00181 
00182 static VLC rv_dc_lum, rv_dc_chrom;
00183 
00184 int rv_decode_dc(MpegEncContext *s, int n)
00185 {
00186     int code;
00187 
00188     if (n < 4) {
00189         code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
00190         if (code < 0) {
00191             /* XXX: I don't understand why they use LONGER codes than
00192                necessary. The following code would be completely useless
00193                if they had thought about it !!! */
00194             code = get_bits(&s->gb, 7);
00195             if (code == 0x7c) {
00196                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
00197             } else if (code == 0x7d) {
00198                 code = -128 + get_bits(&s->gb, 7);
00199             } else if (code == 0x7e) {
00200                 if (get_bits1(&s->gb) == 0)
00201                     code = (int8_t)(get_bits(&s->gb, 8) + 1);
00202                 else
00203                     code = (int8_t)(get_bits(&s->gb, 8));
00204             } else if (code == 0x7f) {
00205                 skip_bits(&s->gb, 11);
00206                 code = 1;
00207             }
00208         } else {
00209             code -= 128;
00210         }
00211     } else {
00212         code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
00213         /* same remark */
00214         if (code < 0) {
00215             code = get_bits(&s->gb, 9);
00216             if (code == 0x1fc) {
00217                 code = (int8_t)(get_bits(&s->gb, 7) + 1);
00218             } else if (code == 0x1fd) {
00219                 code = -128 + get_bits(&s->gb, 7);
00220             } else if (code == 0x1fe) {
00221                 skip_bits(&s->gb, 9);
00222                 code = 1;
00223             } else {
00224                 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
00225                 return 0xffff;
00226             }
00227         } else {
00228             code -= 128;
00229         }
00230     }
00231     return -code;
00232 }
00233 
00234 /* read RV 1.0 compatible frame header */
00235 static int rv10_decode_picture_header(MpegEncContext *s)
00236 {
00237     int mb_count, pb_frame, marker, unk, mb_xy;
00238 
00239     marker = get_bits1(&s->gb);
00240 
00241     if (get_bits1(&s->gb))
00242         s->pict_type = FF_P_TYPE;
00243     else
00244         s->pict_type = FF_I_TYPE;
00245     if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
00246     pb_frame = get_bits1(&s->gb);
00247 
00248     dprintf(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
00249 
00250     if (pb_frame){
00251         av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
00252         return -1;
00253     }
00254 
00255     s->qscale = get_bits(&s->gb, 5);
00256     if(s->qscale==0){
00257         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
00258         return -1;
00259     }
00260 
00261     if (s->pict_type == FF_I_TYPE) {
00262         if (s->rv10_version == 3) {
00263             /* specific MPEG like DC coding not used */
00264             s->last_dc[0] = get_bits(&s->gb, 8);
00265             s->last_dc[1] = get_bits(&s->gb, 8);
00266             s->last_dc[2] = get_bits(&s->gb, 8);
00267             dprintf(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
00268                     s->last_dc[1], s->last_dc[2]);
00269         }
00270     }
00271     /* if multiple packets per frame are sent, the position at which
00272        to display the macroblocks is coded here */
00273 
00274     mb_xy= s->mb_x + s->mb_y*s->mb_width;
00275     if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
00276         s->mb_x = get_bits(&s->gb, 6); /* mb_x */
00277         s->mb_y = get_bits(&s->gb, 6); /* mb_y */
00278         mb_count = get_bits(&s->gb, 12);
00279     } else {
00280         s->mb_x = 0;
00281         s->mb_y = 0;
00282         mb_count = s->mb_width * s->mb_height;
00283     }
00284     unk= get_bits(&s->gb, 3);   /* ignored */
00285     s->f_code = 1;
00286     s->unrestricted_mv = 1;
00287 
00288     return mb_count;
00289 }
00290 
00291 static int rv20_decode_picture_header(MpegEncContext *s)
00292 {
00293     int seq, mb_pos, i;
00294 
00295 #if 0
00296     GetBitContext gb= s->gb;
00297     for(i=0; i<64; i++){
00298         av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb));
00299         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
00300     }
00301     av_log(s->avctx, AV_LOG_DEBUG, "\n");
00302 #endif
00303 #if 0
00304     av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4);
00305     for(i=0; i<s->avctx->extradata_size; i++){
00306         av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]);
00307         if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " ");
00308     }
00309     av_log(s->avctx, AV_LOG_DEBUG, "\n");
00310 #endif
00311 
00312     if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
00313         if (get_bits(&s->gb, 3)){
00314             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
00315             return -1;
00316         }
00317     }
00318 
00319     i= get_bits(&s->gb, 2);
00320     switch(i){
00321     case 0: s->pict_type= FF_I_TYPE; break;
00322     case 1: s->pict_type= FF_I_TYPE; break; //hmm ...
00323     case 2: s->pict_type= FF_P_TYPE; break;
00324     case 3: s->pict_type= FF_B_TYPE; break;
00325     default:
00326         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
00327         return -1;
00328     }
00329 
00330     if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){
00331         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
00332         return -1;
00333     }
00334 
00335     if (get_bits1(&s->gb)){
00336         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
00337         return -1;
00338     }
00339 
00340     s->qscale = get_bits(&s->gb, 5);
00341     if(s->qscale==0){
00342         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
00343         return -1;
00344     }
00345     if(s->avctx->sub_id == 0x30203002){
00346         if (get_bits1(&s->gb)){
00347             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
00348             return -1;
00349         }
00350     }
00351 
00352     if(s->avctx->has_b_frames){
00353         int f, new_w, new_h;
00354         int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
00355 
00356         if (get_bits1(&s->gb)){
00357             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
00358         }
00359         seq= get_bits(&s->gb, 13)<<2;
00360 
00361         f= get_bits(&s->gb, av_log2(v)+1);
00362 
00363         if(f){
00364             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
00365             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
00366         }else{
00367             new_w= s->orig_width ;
00368             new_h= s->orig_height;
00369         }
00370         if(new_w != s->width || new_h != s->height){
00371             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
00372             if (avcodec_check_dimensions(s->avctx, new_w, new_h) < 0)
00373                 return -1;
00374             MPV_common_end(s);
00375             avcodec_set_dimensions(s->avctx, new_w, new_h);
00376             s->width  = new_w;
00377             s->height = new_h;
00378             if (MPV_common_init(s) < 0)
00379                 return -1;
00380         }
00381 
00382         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00383             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
00384         }
00385     }else{
00386         seq= get_bits(&s->gb, 8)*128;
00387     }
00388 
00389 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
00390     mb_pos= ff_h263_decode_mba(s);
00391 /*    }else{
00392         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
00393         s->mb_x= mb_pos % s->mb_width;
00394         s->mb_y= mb_pos / s->mb_width;
00395     }*/
00396 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
00397     seq |= s->time &~0x7FFF;
00398     if(seq - s->time >  0x4000) seq -= 0x8000;
00399     if(seq - s->time < -0x4000) seq += 0x8000;
00400     if(seq != s->time){
00401         if(s->pict_type!=FF_B_TYPE){
00402             s->time= seq;
00403             s->pp_time= s->time - s->last_non_b_time;
00404             s->last_non_b_time= s->time;
00405         }else{
00406             s->time= seq;
00407             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00408             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
00409                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
00410                 return FRAME_SKIPPED;
00411             }
00412             ff_mpeg4_init_direct_mv(s);
00413         }
00414     }
00415 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
00416 /*for(i=0; i<32; i++){
00417     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
00418 }
00419 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
00420     s->no_rounding= get_bits1(&s->gb);
00421 
00422     s->f_code = 1;
00423     s->unrestricted_mv = 1;
00424     s->h263_aic= s->pict_type == FF_I_TYPE;
00425 //    s->alt_inter_vlc=1;
00426 //    s->obmc=1;
00427 //    s->umvplus=1;
00428     s->modified_quant=1;
00429     if(!s->avctx->lowres)
00430         s->loop_filter=1;
00431 
00432     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00433             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
00434                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
00435     }
00436 
00437     assert(s->pict_type != FF_B_TYPE || !s->low_delay);
00438 
00439     return s->mb_width*s->mb_height - mb_pos;
00440 }
00441 
00442 static av_cold int rv10_decode_init(AVCodecContext *avctx)
00443 {
00444     MpegEncContext *s = avctx->priv_data;
00445     static int done=0;
00446 
00447     if (avctx->extradata_size < 8) {
00448         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
00449         return -1;
00450     }
00451 
00452     MPV_decode_defaults(s);
00453 
00454     s->avctx= avctx;
00455     s->out_format = FMT_H263;
00456     s->codec_id= avctx->codec_id;
00457     avctx->flags |= CODEC_FLAG_EMU_EDGE;
00458 
00459     s->orig_width = s->width  = avctx->coded_width;
00460     s->orig_height= s->height = avctx->coded_height;
00461 
00462     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
00463     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
00464 
00465     if (avctx->sub_id == 0x10000000) {
00466         s->rv10_version= 0;
00467         s->low_delay=1;
00468     } else if (avctx->sub_id == 0x10001000) {
00469         s->rv10_version= 3;
00470         s->low_delay=1;
00471     } else if (avctx->sub_id == 0x10002000) {
00472         s->rv10_version= 3;
00473         s->low_delay=1;
00474         s->obmc=1;
00475     } else if (avctx->sub_id == 0x10003000) {
00476         s->rv10_version= 3;
00477         s->low_delay=1;
00478     } else if (avctx->sub_id == 0x10003001) {
00479         s->rv10_version= 3;
00480         s->low_delay=1;
00481     } else if (    avctx->sub_id == 0x20001000
00482                || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
00483         s->low_delay=1;
00484     } else if (    avctx->sub_id == 0x30202002
00485                ||  avctx->sub_id == 0x30203002
00486                || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
00487         s->low_delay=0;
00488         s->avctx->has_b_frames=1;
00489     } else
00490         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
00491 
00492     if(avctx->debug & FF_DEBUG_PICT_INFO){
00493         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
00494     }
00495 
00496     avctx->pix_fmt = PIX_FMT_YUV420P;
00497 
00498     if (MPV_common_init(s) < 0)
00499         return -1;
00500 
00501     h263_decode_init_vlc(s);
00502 
00503     /* init rv vlc */
00504     if (!done) {
00505         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
00506                  rv_lum_bits, 1, 1,
00507                  rv_lum_code, 2, 2, 16384);
00508         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
00509                  rv_chrom_bits, 1, 1,
00510                  rv_chrom_code, 2, 2, 16388);
00511         done = 1;
00512     }
00513 
00514     return 0;
00515 }
00516 
00517 static av_cold int rv10_decode_end(AVCodecContext *avctx)
00518 {
00519     MpegEncContext *s = avctx->priv_data;
00520 
00521     MPV_common_end(s);
00522     return 0;
00523 }
00524 
00525 static int rv10_decode_packet(AVCodecContext *avctx,
00526                              const uint8_t *buf, int buf_size, int buf_size2)
00527 {
00528     MpegEncContext *s = avctx->priv_data;
00529     int mb_count, mb_pos, left, start_mb_x;
00530 
00531     init_get_bits(&s->gb, buf, buf_size*8);
00532     if(s->codec_id ==CODEC_ID_RV10)
00533         mb_count = rv10_decode_picture_header(s);
00534     else
00535         mb_count = rv20_decode_picture_header(s);
00536     if (mb_count < 0) {
00537         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
00538         return -1;
00539     }
00540 
00541     if (s->mb_x >= s->mb_width ||
00542         s->mb_y >= s->mb_height) {
00543         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
00544         return -1;
00545     }
00546     mb_pos = s->mb_y * s->mb_width + s->mb_x;
00547     left = s->mb_width * s->mb_height - mb_pos;
00548     if (mb_count > left) {
00549         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
00550         return -1;
00551     }
00552 
00553     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
00554         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
00555             ff_er_frame_end(s);
00556             MPV_frame_end(s);
00557             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
00558         }
00559         if(MPV_frame_start(s, avctx) < 0)
00560             return -1;
00561         ff_er_frame_start(s);
00562     } else {
00563         if (s->current_picture_ptr->pict_type != s->pict_type) {
00564             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
00565             return -1;
00566         }
00567     }
00568 
00569     dprintf(avctx, "qscale=%d\n", s->qscale);
00570 
00571     /* default quantization values */
00572     if(s->codec_id== CODEC_ID_RV10){
00573         if(s->mb_y==0) s->first_slice_line=1;
00574     }else{
00575         s->first_slice_line=1;
00576         s->resync_mb_x= s->mb_x;
00577     }
00578     start_mb_x= s->mb_x;
00579     s->resync_mb_y= s->mb_y;
00580     if(s->h263_aic){
00581         s->y_dc_scale_table=
00582         s->c_dc_scale_table= ff_aic_dc_scale_table;
00583     }else{
00584         s->y_dc_scale_table=
00585         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00586     }
00587 
00588     if(s->modified_quant)
00589         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00590 
00591     ff_set_qscale(s, s->qscale);
00592 
00593     s->rv10_first_dc_coded[0] = 0;
00594     s->rv10_first_dc_coded[1] = 0;
00595     s->rv10_first_dc_coded[2] = 0;
00596     s->block_wrap[0]=
00597     s->block_wrap[1]=
00598     s->block_wrap[2]=
00599     s->block_wrap[3]= s->b8_stride;
00600     s->block_wrap[4]=
00601     s->block_wrap[5]= s->mb_stride;
00602     ff_init_block_index(s);
00603     /* decode each macroblock */
00604 
00605     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
00606         int ret;
00607         ff_update_block_index(s);
00608         dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00609 
00610         s->mv_dir = MV_DIR_FORWARD;
00611         s->mv_type = MV_TYPE_16X16;
00612         ret=ff_h263_decode_mb(s, s->block);
00613 
00614         if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
00615             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
00616             s->gb.size_in_bits= 8*buf_size2;
00617             ret= SLICE_OK;
00618         }
00619 
00620         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
00621             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
00622             return -1;
00623         }
00624         if(s->pict_type != FF_B_TYPE)
00625             ff_h263_update_motion_val(s);
00626         MPV_decode_mb(s, s->block);
00627         if(s->loop_filter)
00628             ff_h263_loop_filter(s);
00629 
00630         if (++s->mb_x == s->mb_width) {
00631             s->mb_x = 0;
00632             s->mb_y++;
00633             ff_init_block_index(s);
00634         }
00635         if(s->mb_x == s->resync_mb_x)
00636             s->first_slice_line=0;
00637         if(ret == SLICE_END) break;
00638     }
00639 
00640     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);
00641 
00642     return s->gb.size_in_bits;
00643 }
00644 
00645 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
00646 {
00647     if(avctx->slice_count) return avctx->slice_offset[n];
00648     else                   return AV_RL32(buf + n*8);
00649 }
00650 
00651 static int rv10_decode_frame(AVCodecContext *avctx,
00652                              void *data, int *data_size,
00653                              AVPacket *avpkt)
00654 {
00655     const uint8_t *buf = avpkt->data;
00656     int buf_size = avpkt->size;
00657     MpegEncContext *s = avctx->priv_data;
00658     int i;
00659     AVFrame *pict = data;
00660     int slice_count;
00661     const uint8_t *slices_hdr = NULL;
00662 
00663     dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00664 
00665     /* no supplementary picture */
00666     if (buf_size == 0) {
00667         return 0;
00668     }
00669 
00670     if(!avctx->slice_count){
00671         slice_count = (*buf++) + 1;
00672         slices_hdr = buf + 4;
00673         buf += 8 * slice_count;
00674     }else
00675         slice_count = avctx->slice_count;
00676 
00677     for(i=0; i<slice_count; i++){
00678         int offset= get_slice_offset(avctx, slices_hdr, i);
00679         int size, size2;
00680 
00681         if(i+1 == slice_count)
00682             size= buf_size - offset;
00683         else
00684             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
00685 
00686         if(i+2 >= slice_count)
00687             size2= buf_size - offset;
00688         else
00689             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
00690 
00691         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
00692             i++;
00693     }
00694 
00695     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
00696         ff_er_frame_end(s);
00697         MPV_frame_end(s);
00698 
00699         if (s->pict_type == FF_B_TYPE || s->low_delay) {
00700             *pict= *(AVFrame*)s->current_picture_ptr;
00701         } else if (s->last_picture_ptr != NULL) {
00702             *pict= *(AVFrame*)s->last_picture_ptr;
00703         }
00704 
00705         if(s->last_picture_ptr || s->low_delay){
00706             *data_size = sizeof(AVFrame);
00707             ff_print_debug_info(s, pict);
00708         }
00709         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
00710     }
00711 
00712     return buf_size;
00713 }
00714 
00715 AVCodec rv10_decoder = {
00716     "rv10",
00717     AVMEDIA_TYPE_VIDEO,
00718     CODEC_ID_RV10,
00719     sizeof(MpegEncContext),
00720     rv10_decode_init,
00721     NULL,
00722     rv10_decode_end,
00723     rv10_decode_frame,
00724     CODEC_CAP_DR1,
00725     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
00726     .pix_fmts= ff_pixfmt_list_420,
00727 };
00728 
00729 AVCodec rv20_decoder = {
00730     "rv20",
00731     AVMEDIA_TYPE_VIDEO,
00732     CODEC_ID_RV20,
00733     sizeof(MpegEncContext),
00734     rv10_decode_init,
00735     NULL,
00736     rv10_decode_end,
00737     rv10_decode_frame,
00738     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
00739     .flush= ff_mpeg_flush,
00740     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
00741     .pix_fmts= ff_pixfmt_list_420,
00742 };