Libav 0.7.1
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 Libav.
00007  *
00008  * Libav 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  * Libav 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 Libav; 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(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
00297         if (get_bits(&s->gb, 3)){
00298             av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
00299             return -1;
00300         }
00301     }
00302 
00303     i= get_bits(&s->gb, 2);
00304     switch(i){
00305     case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
00306     case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
00307     case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
00308     case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
00309     default:
00310         av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
00311         return -1;
00312     }
00313 
00314     if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
00315         av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
00316         return -1;
00317     }
00318 
00319     if (get_bits1(&s->gb)){
00320         av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
00321         return -1;
00322     }
00323 
00324     s->qscale = get_bits(&s->gb, 5);
00325     if(s->qscale==0){
00326         av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
00327         return -1;
00328     }
00329     if(s->avctx->sub_id == 0x30203002){
00330         if (get_bits1(&s->gb)){
00331             av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
00332             return -1;
00333         }
00334     }
00335 
00336     if(s->avctx->has_b_frames){
00337         int f, new_w, new_h;
00338         int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0;
00339 
00340         if (get_bits1(&s->gb)){
00341             av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
00342         }
00343         seq= get_bits(&s->gb, 13)<<2;
00344 
00345         f= get_bits(&s->gb, av_log2(v)+1);
00346 
00347         if(f){
00348             new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
00349             new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
00350         }else{
00351             new_w= s->orig_width ;
00352             new_h= s->orig_height;
00353         }
00354         if(new_w != s->width || new_h != s->height){
00355             av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
00356             if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
00357                 return -1;
00358             MPV_common_end(s);
00359             avcodec_set_dimensions(s->avctx, new_w, new_h);
00360             s->width  = new_w;
00361             s->height = new_h;
00362             if (MPV_common_init(s) < 0)
00363                 return -1;
00364         }
00365 
00366         if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00367             av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v);
00368         }
00369     }else{
00370         seq= get_bits(&s->gb, 8)*128;
00371     }
00372 
00373 //     if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this
00374     mb_pos= ff_h263_decode_mba(s);
00375 /*    }else{
00376         mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
00377         s->mb_x= mb_pos % s->mb_width;
00378         s->mb_y= mb_pos / s->mb_width;
00379     }*/
00380 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
00381     seq |= s->time &~0x7FFF;
00382     if(seq - s->time >  0x4000) seq -= 0x8000;
00383     if(seq - s->time < -0x4000) seq += 0x8000;
00384     if(seq != s->time){
00385         if(s->pict_type!=AV_PICTURE_TYPE_B){
00386             s->time= seq;
00387             s->pp_time= s->time - s->last_non_b_time;
00388             s->last_non_b_time= s->time;
00389         }else{
00390             s->time= seq;
00391             s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00392             if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
00393                 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
00394                 return FRAME_SKIPPED;
00395             }
00396             ff_mpeg4_init_direct_mv(s);
00397         }
00398     }
00399 //    printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
00400 /*for(i=0; i<32; i++){
00401     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
00402 }
00403 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
00404     s->no_rounding= get_bits1(&s->gb);
00405 
00406     s->f_code = 1;
00407     s->unrestricted_mv = 1;
00408     s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
00409 //    s->alt_inter_vlc=1;
00410 //    s->obmc=1;
00411 //    s->umvplus=1;
00412     s->modified_quant=1;
00413     if(!s->avctx->lowres)
00414         s->loop_filter=1;
00415 
00416     if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00417             av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
00418                    seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
00419     }
00420 
00421     assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
00422 
00423     return s->mb_width*s->mb_height - mb_pos;
00424 }
00425 
00426 static av_cold int rv10_decode_init(AVCodecContext *avctx)
00427 {
00428     MpegEncContext *s = avctx->priv_data;
00429     static int done=0;
00430 
00431     if (avctx->extradata_size < 8) {
00432         av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
00433         return -1;
00434     }
00435 
00436     MPV_decode_defaults(s);
00437 
00438     s->avctx= avctx;
00439     s->out_format = FMT_H263;
00440     s->codec_id= avctx->codec_id;
00441     avctx->flags |= CODEC_FLAG_EMU_EDGE;
00442 
00443     s->orig_width = s->width  = avctx->coded_width;
00444     s->orig_height= s->height = avctx->coded_height;
00445 
00446     s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
00447     avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
00448 
00449     if (avctx->sub_id == 0x10000000) {
00450         s->rv10_version= 0;
00451         s->low_delay=1;
00452     } else if (avctx->sub_id == 0x10001000) {
00453         s->rv10_version= 3;
00454         s->low_delay=1;
00455     } else if (avctx->sub_id == 0x10002000) {
00456         s->rv10_version= 3;
00457         s->low_delay=1;
00458         s->obmc=1;
00459     } else if (avctx->sub_id == 0x10003000) {
00460         s->rv10_version= 3;
00461         s->low_delay=1;
00462     } else if (avctx->sub_id == 0x10003001) {
00463         s->rv10_version= 3;
00464         s->low_delay=1;
00465     } else if (    avctx->sub_id == 0x20001000
00466                || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
00467         s->low_delay=1;
00468     } else if (    avctx->sub_id == 0x30202002
00469                ||  avctx->sub_id == 0x30203002
00470                || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
00471         s->low_delay=0;
00472         s->avctx->has_b_frames=1;
00473     } else
00474         av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
00475 
00476     if(avctx->debug & FF_DEBUG_PICT_INFO){
00477         av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
00478     }
00479 
00480     avctx->pix_fmt = PIX_FMT_YUV420P;
00481 
00482     if (MPV_common_init(s) < 0)
00483         return -1;
00484 
00485     h263_decode_init_vlc(s);
00486 
00487     /* init rv vlc */
00488     if (!done) {
00489         INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
00490                  rv_lum_bits, 1, 1,
00491                  rv_lum_code, 2, 2, 16384);
00492         INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
00493                  rv_chrom_bits, 1, 1,
00494                  rv_chrom_code, 2, 2, 16388);
00495         done = 1;
00496     }
00497 
00498     return 0;
00499 }
00500 
00501 static av_cold int rv10_decode_end(AVCodecContext *avctx)
00502 {
00503     MpegEncContext *s = avctx->priv_data;
00504 
00505     MPV_common_end(s);
00506     return 0;
00507 }
00508 
00509 static int rv10_decode_packet(AVCodecContext *avctx,
00510                              const uint8_t *buf, int buf_size, int buf_size2)
00511 {
00512     MpegEncContext *s = avctx->priv_data;
00513     int mb_count, mb_pos, left, start_mb_x;
00514 
00515     init_get_bits(&s->gb, buf, buf_size*8);
00516     if(s->codec_id ==CODEC_ID_RV10)
00517         mb_count = rv10_decode_picture_header(s);
00518     else
00519         mb_count = rv20_decode_picture_header(s);
00520     if (mb_count < 0) {
00521         av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
00522         return -1;
00523     }
00524 
00525     if (s->mb_x >= s->mb_width ||
00526         s->mb_y >= s->mb_height) {
00527         av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
00528         return -1;
00529     }
00530     mb_pos = s->mb_y * s->mb_width + s->mb_x;
00531     left = s->mb_width * s->mb_height - mb_pos;
00532     if (mb_count > left) {
00533         av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
00534         return -1;
00535     }
00536 
00537     if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
00538         if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
00539             ff_er_frame_end(s);
00540             MPV_frame_end(s);
00541             s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
00542         }
00543         if(MPV_frame_start(s, avctx) < 0)
00544             return -1;
00545         ff_er_frame_start(s);
00546     } else {
00547         if (s->current_picture_ptr->pict_type != s->pict_type) {
00548             av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
00549             return -1;
00550         }
00551     }
00552 
00553     av_dlog(avctx, "qscale=%d\n", s->qscale);
00554 
00555     /* default quantization values */
00556     if(s->codec_id== CODEC_ID_RV10){
00557         if(s->mb_y==0) s->first_slice_line=1;
00558     }else{
00559         s->first_slice_line=1;
00560         s->resync_mb_x= s->mb_x;
00561     }
00562     start_mb_x= s->mb_x;
00563     s->resync_mb_y= s->mb_y;
00564     if(s->h263_aic){
00565         s->y_dc_scale_table=
00566         s->c_dc_scale_table= ff_aic_dc_scale_table;
00567     }else{
00568         s->y_dc_scale_table=
00569         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00570     }
00571 
00572     if(s->modified_quant)
00573         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00574 
00575     ff_set_qscale(s, s->qscale);
00576 
00577     s->rv10_first_dc_coded[0] = 0;
00578     s->rv10_first_dc_coded[1] = 0;
00579     s->rv10_first_dc_coded[2] = 0;
00580     s->block_wrap[0]=
00581     s->block_wrap[1]=
00582     s->block_wrap[2]=
00583     s->block_wrap[3]= s->b8_stride;
00584     s->block_wrap[4]=
00585     s->block_wrap[5]= s->mb_stride;
00586     ff_init_block_index(s);
00587     /* decode each macroblock */
00588 
00589     for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
00590         int ret;
00591         ff_update_block_index(s);
00592         av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00593 
00594         s->mv_dir = MV_DIR_FORWARD;
00595         s->mv_type = MV_TYPE_16X16;
00596         ret=ff_h263_decode_mb(s, s->block);
00597 
00598         if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
00599             av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
00600             s->gb.size_in_bits= 8*buf_size2;
00601             ret= SLICE_OK;
00602         }
00603 
00604         if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
00605             av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
00606             return -1;
00607         }
00608         if(s->pict_type != AV_PICTURE_TYPE_B)
00609             ff_h263_update_motion_val(s);
00610         MPV_decode_mb(s, s->block);
00611         if(s->loop_filter)
00612             ff_h263_loop_filter(s);
00613 
00614         if (++s->mb_x == s->mb_width) {
00615             s->mb_x = 0;
00616             s->mb_y++;
00617             ff_init_block_index(s);
00618         }
00619         if(s->mb_x == s->resync_mb_x)
00620             s->first_slice_line=0;
00621         if(ret == SLICE_END) break;
00622     }
00623 
00624     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);
00625 
00626     return s->gb.size_in_bits;
00627 }
00628 
00629 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
00630 {
00631     if(avctx->slice_count) return avctx->slice_offset[n];
00632     else                   return AV_RL32(buf + n*8);
00633 }
00634 
00635 static int rv10_decode_frame(AVCodecContext *avctx,
00636                              void *data, int *data_size,
00637                              AVPacket *avpkt)
00638 {
00639     const uint8_t *buf = avpkt->data;
00640     int buf_size = avpkt->size;
00641     MpegEncContext *s = avctx->priv_data;
00642     int i;
00643     AVFrame *pict = data;
00644     int slice_count;
00645     const uint8_t *slices_hdr = NULL;
00646 
00647     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00648 
00649     /* no supplementary picture */
00650     if (buf_size == 0) {
00651         return 0;
00652     }
00653 
00654     if(!avctx->slice_count){
00655         slice_count = (*buf++) + 1;
00656         slices_hdr = buf + 4;
00657         buf += 8 * slice_count;
00658     }else
00659         slice_count = avctx->slice_count;
00660 
00661     for(i=0; i<slice_count; i++){
00662         int offset= get_slice_offset(avctx, slices_hdr, i);
00663         int size, size2;
00664 
00665         if(i+1 == slice_count)
00666             size= buf_size - offset;
00667         else
00668             size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
00669 
00670         if(i+2 >= slice_count)
00671             size2= buf_size - offset;
00672         else
00673             size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
00674 
00675         if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
00676             i++;
00677     }
00678 
00679     if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
00680         ff_er_frame_end(s);
00681         MPV_frame_end(s);
00682 
00683         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
00684             *pict= *(AVFrame*)s->current_picture_ptr;
00685         } else if (s->last_picture_ptr != NULL) {
00686             *pict= *(AVFrame*)s->last_picture_ptr;
00687         }
00688 
00689         if(s->last_picture_ptr || s->low_delay){
00690             *data_size = sizeof(AVFrame);
00691             ff_print_debug_info(s, pict);
00692         }
00693         s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
00694     }
00695 
00696     return buf_size;
00697 }
00698 
00699 AVCodec ff_rv10_decoder = {
00700     "rv10",
00701     AVMEDIA_TYPE_VIDEO,
00702     CODEC_ID_RV10,
00703     sizeof(MpegEncContext),
00704     rv10_decode_init,
00705     NULL,
00706     rv10_decode_end,
00707     rv10_decode_frame,
00708     CODEC_CAP_DR1,
00709     .max_lowres = 3,
00710     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
00711     .pix_fmts= ff_pixfmt_list_420,
00712 };
00713 
00714 AVCodec ff_rv20_decoder = {
00715     "rv20",
00716     AVMEDIA_TYPE_VIDEO,
00717     CODEC_ID_RV20,
00718     sizeof(MpegEncContext),
00719     rv10_decode_init,
00720     NULL,
00721     rv10_decode_end,
00722     rv10_decode_frame,
00723     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
00724     .flush= ff_mpeg_flush,
00725     .max_lowres = 3,
00726     .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
00727     .pix_fmts= ff_pixfmt_list_420,
00728 };