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