---

frame.hh

Go to the documentation of this file.

/*
 * 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 ( FRAME_HH )
#define FRAME_HH

// std c
#include <time.h> 

// std c++
#include <string>
#include <vector>
#include <map>

// PIAVE
#include "piave_base.hh"
#include "videoformat.hh"
#include "bufferpool.hh"

namespace PIAVE {

    class PropertyNode;
    class InAVStreamIFace;

    class VideoBuffer
    {
      public:
        VideoBuffer( int width  = Global::renderFmt.width, 
                     int height = Global::renderFmt.height, 
                     bool allocate = false );
        ~VideoBuffer();

        int   getWidth() const { return _width; }
        int   getHeight() const { return _height; }
        int   getSizePixels() const { return _width * _height; }
        int   getSizeBytes() const { return _sizeBytes; }
        int   getLineStride() const { return _lineStride; }

        bool  hasAlpha() const { return _alphaPixels!=0; }
        void  addAlpha() {};

        uint8_t * getPixels() const { return _pixels->buf(); }
        uint8_t * getAlphaPixels() const { return _alphaPixels->buf(); }

        void lock( bool l = true ) { _is_locked = l; };
        bool isLocked() const { return _is_locked; };

        void dropRef();

        const VideoBuffer & operator=( const VideoBuffer & o );

      private:
        int          _width;
        int          _height;
        int          _lineStride;
        int          _sizeBytes;

        Buffer     * _pixels;       
        Buffer     * _alphaPixels;       
        bool         _is_locked;    
        bool         _is_allocated;    
    };

    class AudioBuffer
    {
      public:
        AudioBuffer();
        virtual ~AudioBuffer();

        Buffer  ** getChannels() { return _channels; };
        int16_t *  getChannel( int i ) const { return _channels[i]?(int16_t*)_channels[i]->buf():0; };
        int        getNChannels() const { return _nChannels; }
        int        getNSamples() const { return _nSamples; }
        bool       isInterleaved() const { return _isInterleaved; }
 
        void  setNChannels( int n ) {  _nChannels = n; };
        void  setNSamples( int n ) {  _nSamples = n; };
        void  setInterleaved( bool s ) {  _isInterleaved = s; };
        

        /*  if the audio data has more than one channel, and the
         *  channels are stored in seperate buffers, they will be
         *  interleaved into a single buffer in channel 0
         */
        Buffer * interleave();

        static const uint MAX_CHANNELS = 10;
        static const uint MAX_SAMPLES = 3000;

        void dropRef();

      private:
        /* number of channels; they may be interleaved into a single
         * buffer 
         */
        int _nChannels; 
        /* are the channels interleaved in a single buffer ?? */
        int _isInterleaved;
        /* number of samples per channel in this buffer */
        int _nSamples;
        
        Buffer * _channels[ MAX_CHANNELS ];
    };


    class Frame
    {
      public:

        Frame();
        Frame( const Frame & o );

        // @{
        Time getPos()    const { return _pos; }
        Time getLength() const { return _length; }
        void setPos( const Time pos )       {  _pos = pos; }
        void setLength( const Time length ) { _length = length; }
        // @}

        // @{
        VideoBuffer  * getVBuf()    const { return _vBuf; };
        AudioBuffer  * getABuf()    const { return _aBuf; };
        // @}

        // @{
        Buffer  * getRawVBuf()    const { return _rawVBuf; };
        Buffer  * getRawABuf()    const { return _rawABuf; };
        // @}

        /* the encoded data is only usefull in context with the
         * the stream where t comes from, i.e. a decoder and maybe
         * surrounding frames
         */
        InAVStreamIFace * getAVContext() const { return _avContext; }
        InAVStreamIFace * getAudioContext() const { return _audioContext; }
        PropertyNode * getProperties();

        /* get properties of this video frame. In case _properties==0
         * decodeMetaData() is called
         */
        PropertyNode * getMetaData();


        /*   the following methods handle the actual decodeing
         *   they are only called if necessary
         */

        void decodeMetaData();

        void decodeVideo( uint8_t * dest = 0 );

        void decodeAudio( uint8_t * dest = 0  );

        bool  getVideoIsDecoded()  const { return _videoIsDecoded; }
        bool  getAudioIsDecoded()  const { return _audioIsDecoded; }

        // @{
        void setRawVBuf( Buffer * evb ) { _rawVBuf = evb; };
        void setRawABuf( Buffer * eab ) { _rawABuf = eab; };
        void setVBuf( VideoBuffer* vb ) { _vBuf = vb; };
        void setABuf( AudioBuffer* ab ) { _aBuf = ab; };
        void setVideoIsDecoded( bool is ) { _videoIsDecoded = is; }
        void setAudioIsDecoded( bool is ) { _audioIsDecoded = is; }
        void setAVContext( InAVStreamIFace * v ) { _avContext = v; }
        void setAudioContext( InAVStreamIFace * a ) { _audioContext = a; }
        void setProperties( PropertyNode * p ) { _properties = p; }
        // @}

        const Frame & operator=( const Frame & o ) { copy(o); };
        const Frame & copy( const Frame & o );
        const Frame & copyVideo( const Frame & o );
        const Frame & copyAudio( const Frame & o );

        void makeWriteableVBuf();

        /* decode data if necessary
         * if target == 0 a new buffer is allocated
         */
        VideoBuffer * makeVBuf();

        /* decode data if necessary
         * if target == 0 a new buffers are allocated
         */
        AudioBuffer * makeABuf();

        void dropRefs();
        void dropVRefs();
        void dropARefs();

      private:
        void addAlpha();

        void flattenAlpha();

      private:
        // the buffers
        VideoBuffer  * _vBuf;
        AudioBuffer  * _aBuf;
        Buffer       * _rawVBuf;
        Buffer       * _rawABuf;

        Time           _pos;
        Time           _length;

        bool           _videoIsDecoded;
        bool           _audioIsDecoded;

        InAVStreamIFace     * _avContext;
        InAVStreamIFace  * _audioContext;

        PropertyNode   * _properties;

    };

};

#endif 

---