Cinelerra: hvirtual/quicktime/ffmpeg/libavcodec/rv10.c Source File

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