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