Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MP4Decoder.hpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       MP4Decoder.hpp                                                *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

/***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifndef AFX_MP4DECODER_HPP
#define AFX_MP4DECODER_HPP

#if _MSC_VER > 1000
#pragma once
#endif                          // _MSC_VER > 1000


#include "ffmpegInterface.h"
#include "xvidInterface.h"

#include "VideoAdaptor.hpp"
#include "UncompressedVideoFrame.hpp"
#ifdef ISOMP4
#include "ISOMovies.h"
#endif
#include "IO.hpp"

class VideoESInfo;
class UncompressedVideoFrame;


class MP4Decoder:public VideoAdaptor {
public:


        typedef enum eCoderType{XVID = 1, FFMPEG} meCoderType;

        MP4Decoder(VideoESInfo * pESInfo, bool enableSwitching = false, 
                                                 UncompressedVideoFrame::ColorSpace colorSpace = UncompressedVideoFrame::ColorSpaceYV12,
#ifdef ENABLE_FFMPEG   // default codec (if avail) is ffmpeg
                                                 meCoderType coderType= FFMPEG);
#else
                                                 meCoderType coderType= XVID);
#endif

        virtual ~ MP4Decoder();
                
        static bool isValidVisualFrame(const u8* payload);

        static bool isValidDecoderConfig(const u8* payload);

        list < Frame * >adapt(Frame * frm);

        list < Frame * >close();

        Adaptor *clone();

        void initialize();

        void setCoderType(eCoderType coderType = XVID);

        static xvidColorSpace mapToXVIDColorspace(UncompressedVideoFrame::ColorSpace colorSpace);
        /*
                Maps a CodecID to a String, returns the String UNKNOWN_CODEC if                 @param codec_id is invalid.
        */
        static const char* codecToString(CodecID codec_id);

        /*
                Maps a String to a CodecID
        */
        static int stringToCodec(const char* codec_string);
        
        static ffmpegColorSpace mapToFFMPEGColorspace(UncompressedVideoFrame::ColorSpace colorSpace);

        u32 getTranscodingCosts() const;
private:
        eCoderType meCoder;

        int DecoderInit(char **pDecoderHandle, CodecID codecID, unsigned int uiWidth, unsigned int uiHeight);

        void DecoderClose(char **pDecoderHandle);

        int DecodeFrame(char *pDecoderHandle, char *pCompressedFrame, 
                                                                        int iCFSize, char* pYUVFrame, UncompressedVideoFrame::ColorSpace eColorSpace);

        char *mpDecoder;

        UncompressedVideoFrame::ColorSpace mColorSpace;

        u32 mFrameSize;

        char *mpBuffer;

        int lenDecoded;

        uint muiLastFrameStart;

        uint muiLastFrameEnd;

        u32 muiFrameNumber;

        u8 *mpOutBuf;

        AU *auBuffer[2];

        uint muiWidth;

        uint muiHeight;

        u8* decConfig;
        u8* newDecConfig;
        u8 decConfigSize;

        bool enableSwitching;


        typedef struct {
                unsigned int aspect_ratio_info;
                unsigned int par_width;
                unsigned int par_height;
        } structAspectRatio;

        typedef struct {
                unsigned int vol_control_parameters;
                unsigned int chroma_format;
                unsigned int low_delay;
                unsigned int vbv_parameters;
                unsigned int first_half_bit_rate;
                unsigned int latter_half_bit_rate;
                unsigned int first_half_vbv_buffer_size;
                unsigned int latter_half_vbv_buffer_size;
                unsigned int first_half_vbv_occupancy;
                unsigned int latter_half_vbv_occupancy;
        } structVOLControlParameters;

        typedef struct {
                unsigned int quant_type;
                unsigned int load_intra_quant_mat;
                unsigned int load_nonintra_quant_mat;
                unsigned int load_intra_quant_mat_grayscale;
                unsigned int load_nonintra_quant_mat_grayscale;

                unsigned int intra_quant_matrix[64];
                unsigned int nonintra_quant_matrix[64];
                unsigned int intra_quant_matrix_grayscale[64];
                unsigned int nonintra_quant_matrix_grayscale[64];
        } structQuant;

        typedef struct {
                // Visual Object Sequence 
                unsigned int profile_and_level_indication;
                // Visual Object
                unsigned int is_visual_object_identifier;
                unsigned int visual_object_verid;
                unsigned int visual_object_priority;
                unsigned int visual_object_type;
                // Video Object Header
                unsigned int video_object_layer_startcode;
                // Video Object Layer
                unsigned int video_object_layer_start_code;
                unsigned int short_video_header;
                unsigned int video_object_layer_id;
                unsigned int random_accessbile_vol;
                unsigned int video_object_type_indication;
                unsigned int is_object_layer_identifier;
                unsigned int video_object_layer_verid;
                unsigned int video_object_layer_priority;

                structAspectRatio aspectRatio;
                structVOLControlParameters volControlParameters;

                unsigned int video_object_layer_shape;
                unsigned int vop_time_increment_resolution;
                unsigned int vop_time_incrememt_bits_needed;
                unsigned int fixed_vop_rate;
                unsigned int fixed_vop_time_increment;

                unsigned int video_object_layer_width;
                unsigned int video_object_layer_height;

                unsigned int interlaced;
                unsigned int obmc_disable;
                unsigned int sprite_enable;
                unsigned int not_8_bit;
                unsigned int quant_precision;
                unsigned int bits_per_pixel;

                unsigned int no_gray_quant_update;
                unsigned int composition_method;
                unsigned int linear_composition;

                structQuant quant;

                unsigned int complexity_estimation_disable;
                unsigned int resync_marker_disable;
                unsigned int data_partitioned;
                unsigned int reversible_vlc;
                unsigned int scalability;
        } structMP4Header;

        structMP4Header mp4Header;

        u8 mcByte;

        u8 *mpcData;

        int miSize;

        bool mbEOD;

        int miCurrentNoBytes;

        int miCurrentBit;

        int miBookmarkedCurrentBit;

        int miBookmarkedByte;

        int miBookmarkedCurrentNoBytes;

        void initializeParser(u8 * pFramem, u32 iSize);

        void initializeMP4HeaderStruct();

        void nextByte();

        bool bytealigned();

        int getBit();

        int getBits(int iNumber);

        int nextBits(int iNumber);

        void nextStartCode();

        void loadQuantizerMatrix(unsigned int puiMatrix[]);

        void readMarkerBitFunc(int iLine);
        void bookmark();
        void restore();

        bool parseVOSHeader();

        bool parseVOHeader();

        bool video_signal_type_func();

        bool parseUserData();

        bool parseVideoObjectHeader();
        bool parseVOLHeader();
};

#endif

© ViTooKi 2003 :: [Lite version] Created with Doxygen