---

avistream.hh

/*
 * PIAVE - PIAVE Is A Video Editor
 *
 * Copyright (C) 2002 Rolf Dubitzky, rolf@dubitzky.de
 *
 */

/*
 * This program 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.
 */


#if ! defined( AVISTREAM_HH )
#define AVISTREAM_HH

// PIAVE
#include "libpiave/plugin.hh"
#include "libpiave/avstream.hh"
#include "libpiave/videoformat.hh"

namespace PIAVE {

    class PropertyNode;
    class Frame;

    /*
     *    plugin wrapper for raw DV stream
     */
    class InAviStreamPlugin : public Plugin
    {
      public:
        InAviStreamPlugin();
        virtual PluginBase * newElement( const PropertyNode * p = 0 );
    };

    class OutAviStreamPlugin : public Plugin
    {
      public:
        OutAviStreamPlugin();
        virtual PluginBase * newElement( const PropertyNode * p = 0 );
    };


#define RIFF_NO_PARENT_IDX  (-1)
#define RIFF_LISTSIZE       (4)
#define RIFF_HEADERSIZE     (8)

    struct AviRect
    {
        int16_t top, bottom, left, right;
    };

    struct AviStreamHeader
    {
        AviStreamHeader(){};
        FOURCC fccType;
        FOURCC fccHandler;
        int32_t dwFlags;                /* Contains AVITF_* flags */
        int16_t wPriority;
        int16_t wLanguage;
        int32_t dwInitialFrames;
        int32_t dwScale;
        int32_t dwRate;                 /* dwRate / dwScale == samples/second */
        int32_t dwStart;
        int32_t dwLength;               /* In units above... */
        int32_t dwSuggestedBufferSize;
        int32_t dwQuality;
        int32_t dwSampleSize;
        AviRect rcFrame;
    };

    struct DVINFO
    {
        int32_t dwDVAAuxSrc;
        int32_t dwDVAAuxCtl;
        int32_t dwDVAAuxSrc1;
        int32_t dwDVAAuxCtl1;
        int32_t dwDVVAuxSrc;
        int32_t dwDVVAuxCtl;
        int32_t dwDVReserved[2];
    };

    struct BITMAPINFOHEADER
    {
        int32_t  biSize;
        uint32_t biWidth;
        uint32_t biHeight;
        int16_t  biPlanes;
        int16_t  biBitCount;
        uint32_t  biCompression;
        int32_t  biSizeImage;
        uint32_t biXPelsPerMeter;
        uint32_t biYPelsPerMeter;
        int32_t  biClrUsed;
        int32_t  biClrImportant;
    };

    struct WAVEFORMATEX
    {
        int16_t wFormatTag;
        int16_t nChannels;
        int32_t nSamplesPerSec;
        int32_t nAvgBytesPerSec;
        int16_t nBlockAlign;
        int16_t wBitsPerSample;
        int16_t cbSize;
        int16_t dummy;
    };

    struct AviSuperIndex
    {
        int16_t wLongsPerEntry;
        uint8_t bIndexSubType;
        uint8_t bIndexType;
        int32_t nEntriesInUse;
        int32_t dwChunkId;
        int32_t dwReserved[3];
        struct AviSuperIndexEntry
        {
            uint64_t qwOffset;
            int32_t dwSize;
            int32_t dwDuration;
        } aIndex[2014];
    };

    struct AviStdIndex {
        int16_t  wLongsPerEntry;
        uint8_t  bIndexSubType;
        uint8_t  bIndexType;
        int32_t  nEntriesInUse;
        int32_t  dwChunkId;
        uint64_t qwBaseOffset;
        int32_t  dwReserved;
        struct AviStdIndexEntry {
            int32_t dwOffset;
            int32_t dwSize;
        } aIndex[4028];
    };
    
    struct AviSimpleIndex {
        struct AviSimpleIndexEntry {
            FOURCC      dwChunkId;
            int32_t     dwFlags;
            int32_t     dwOffset;
            int32_t     dwSize;
        } aIndex[20000];
        int32_t  nEntriesInUse;
    };

    struct AviDirEntry
    {
        FOURCC  type;
        FOURCC  name;
        off_t   length;
        off_t   offset;
        int     parentList;
        int     writtenFlag;

        AviDirEntry();
        AviDirEntry( const FOURCC& t, const FOURCC& n, int l, int o, int p);
    };

    struct RIFFChunk
    {
        FOURCC      type;
        int         length;
    };
    
    struct MainAVIHeader
    {
        int32_t dwMicroSecPerFrame;

        int32_t dwMaxBytesPerSec;

        int32_t dwPaddingGranularity;

        int32_t dwFlags;

        int32_t dwTotalFrames;
        int32_t dwInitialFrames;
        int32_t dwStreams;
        int32_t dwSuggestedBufferSize;

        int32_t dwWidth;
        int32_t dwHeight;

        int32_t dwReserved[4];
    };

    class AviContainer
    {
      public:
        AviContainer();
        ~AviContainer();

      public:
#define AVI_SMALL_INDEX (0x01)
#define AVI_LARGE_INDEX (0x02)
#define AVI_INDEX_OF_INDEXES (0x00)
#define AVI_INDEX_OF_CHUNKS (0x01)
#define AVI_INDEX_2FIELD (0x01)
 
        int newDirEntry( const FOURCC& type, const FOURCC& name, 
                         off_t length, int list );
        int getDirEntry( const FOURCC& type , int n=0 );
        int setDirEntry( int idx, const AviDirEntry& entry );

        std::vector<AviDirEntry>  dir;

        MainAVIHeader       mainHdr;
        AviSimpleIndex      *idx1;
        int                 file_list;
        int                 riff_list;
        int                 hdrl_list;
        int                 avih_chunk;
        int                 movi_list;
        int                 junk_chunk;
        int                 idx1_chunk;
        
        AviStreamHeader     streamHdr[2];
        AviSuperIndex       *indx[2];
        AviStdIndex         *ix[2];
        int                 indx_chunk[2];
        int                 ix_chunk[2];
        int                 strl_list[2];
        int                 strh_chunk[2];
        int                 strf_chunk[2];
        
        int                 index_type;
        int                 current_ix00;
        
        int                 dmlh[62];
        int                 odml_list;
        int                 dmlh_chunk;
        bool                isUpdateIdx1;

    };

    /*
     *  Class InAviStream
     *  handles raw dv streams as produced by libdv, i.e. dvgrab
     *  \todo check VideoInfo and compare to PIAVE::Global
     */

    class InAviStream : public InAVFStream
    {
      public:
        InAviStream( const std::string& fileName ) throw(exception);
        virtual ~InAviStream();

        virtual Frame getFrame( Time t );

        virtual void decodeVideo( Frame & f, uint8_t * dest = 0 );
        virtual void decodeAudio( Frame & f, uint8_t * dest = 0 );

        virtual PropertyNode * getProperties(PropertyNode * p=0) const;

      private:

        void parseHeader();
        void parseList( int parent_idx );
        void parseChunk( int parent_idx );
        void readChunk( int idx, void * data );
        void readIndex();
        
        int findStreamWithType( FOURCC type );
        int findStreamWithHandler( FOURCC format );

      private:
        AVDecoderIFace  * _dvDecoder;
        bool              _hasAviAudio;
        int               _frameSize;
        AviContainer    * _container;
    };

    class OutAviStream : public OutAVFStream
    {
      public:
        OutAviStream( const std::string& fileName );
        ~OutAviStream();
        virtual void putFrame( Frame & f );

        virtual PropertyNode * getProperties(PropertyNode * p=0) const;

      private:
        AVEncoderIFace  * _dvEncoder;
        int _frameSize;
    };


}

#endif

---