• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/rv10.c

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

Generated on Fri Sep 16 2011 17:17:42 for FFmpeg by  doxygen 1.7.1