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