---

avstream.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( AVSTREAM_HH )
#define AVSTREAM_HH

// stdc
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>

// stdc++
#include <string>
#include <map>

// PIAVE
#include "piave_base.hh"
#include "exception.hh"
#include "videoformat.hh"
#include "plugin.hh"

namespace PIAVE {

    class Frame;

    class Stream : public PluginBase
    {
      public:
        enum StreamState {
            state_closed,
            state_open,
            state_error
        };

      public:
        Stream() : PluginBase(), _state( state_closed ) {}
        virtual ~Stream() {}

        StreamState getState() const { return _state; }

        void setState( StreamState s ) { _state = s; }

      private:
        StreamState _state;
    };

    class InAVStreamIFace : public Stream
    {
      public:
        InAVStreamIFace();
        virtual ~InAVStreamIFace();
        virtual Frame getFrame( Time t ) = 0;
        virtual void decodeMetaData( Frame & f ) {}
        virtual void decodeVideo( Frame & f, uint8_t * dest = 0 ) = 0;
        virtual void decodeAudio( Frame & f, uint8_t * dest = 0 ) = 0;

        void setVideoFmt( VideoFmt v ) { _videoFmt = v; }
        VideoFmt getVideoFmt() const { return _videoFmt; }

      private:
        VideoFmt  _videoFmt;
        
      protected:
        int       _deliveredFrames;
        PropertyNode * _frameProperties;
    };

    class OutAVStreamIFace : public Stream
    {
      public:
        OutAVStreamIFace() : 
          Stream(), _recievedFrames( 0 ) {}
        virtual ~OutAVStreamIFace();

        virtual void putFrame( Frame & f ) = 0;

        void setVideoFmt( VideoFmt v ) { _videoFmt = v; }
        VideoFmt getVideoFmt() const { return _videoFmt; }

      private:
        VideoFmt  _videoFmt;

      protected:
        int       _recievedFrames;
    };

    class InAudioStreamIFace : public Stream
    {
      public:
        InAudioStreamIFace() : Stream() {}
        virtual ~InAudioStreamIFace() {}
        virtual Frame getFrame( Time t ) = 0;
        virtual void decodeMetaData( Frame & f ) {}
        virtual void decodeAudio( Frame & f, uint8_t * dest = 0  ) = 0;
    };

    class OutAudioStreamIFace  : public Stream
    {
      public:
        OutAudioStreamIFace() : Stream() {}
        virtual void putFrame( Frame & f ) = 0;
    };


    /***
     * \class InFileStream
     *      defines interface for streams from files
     *
     *  \todo   others might come from v4l grabber devices, etc.
     *  \todo   handle buffered IO - FILE
     *  \todo : 
     *    -  mpeg, avi, streams ... ? via libavcodev 
     *    -  pure audio streams ... ? lame ? SDL ?
     *    -  pure image streams, i.e. .png for overlay ? glib ? imagemagick ?
     */ 
    class InFileStream
    {
      public:
        InFileStream( const std::string& fileName );
        virtual ~InFileStream();

        void                 seek( Time t ) { _pos=t; }
        Time                 length() const { return _length; };
        const std::string    getFileName() const { return _fileName; };
        virtual off_t        getFileSize();

      protected:
        void setLength( Time t ) { _length = t; };

      protected:
        int             _fd;

      private:
        std::string     _fileName;
        Time            _length;     // length in seconds
        Time            _pos;        // pos in seconds
        struct stat     _stat;
        
    };

    class OutFileStream
    {
      public:
        OutFileStream( const std::string& fileName );
        virtual ~OutFileStream();

        const std::string  getFileName() const { return _fileName; };

        virtual void closeFD();

      protected:
        int             _fd;

      private:
        std::string   _fileName;
    };


    class InAVFStream : public InFileStream, public InAVStreamIFace
    {
      public:
        InAVFStream( const std::string& fileName ) :
          InFileStream( fileName ), InAVStreamIFace() {}
    };

    class OutAVFStream : public OutFileStream, public OutAVStreamIFace
    {
      public:
        OutAVFStream( const std::string& fileName ) :
          OutFileStream( fileName ), OutAVStreamIFace() {}
        virtual ~OutAVFStream() { INFO( "~OutAVFStream" ); }
    };


    /*
     *  interface for decoders and encoders
     *
     */
    class CodecIFace : public PluginBase
    {
      public:
        CodecIFace() : PluginBase(), _videoFmt(), _initialized( false ) {}
        double getFPS()  const { return _videoFmt.fps; }
        int    getWidth()  const { return _videoFmt.width; }
        int    getHeight() const { return _videoFmt.height; }
        double getAspect() const { return _videoFmt.aspect; }
        int    getSizePixels() const { return _videoFmt.width * _videoFmt.height; }
        int    isInitialized() const { return _initialized; }

        void   setFPS( double fps ) { _videoFmt.fps = fps; }
        void   setWidth( int width ) { _videoFmt.width = width; }
        void   setHeight( int height ) { _videoFmt.height = height; }
        void   setAspect( double aspect ) { _videoFmt.aspect = aspect; }
        void   setInitialized( bool i ) { _initialized = i; }
        void      setVideoFmt( VideoFmt v ) { _videoFmt = v; }
        VideoFmt  getVideoFmt() const { return _videoFmt; }

        virtual bool init( uint8_t * data = 0 ) throw (exception) = 0;

        virtual PropertyNode * getFrameProperties( PropertyNode * node ) { return 0; };

      private:
        VideoFmt           _videoFmt;
        bool               _initialized;
    };

    class AVDecoderIFace : public CodecIFace
    {
      public:
        virtual void decodeMetaData( Frame & f, PropertyNode * p ) {};
        virtual void decodeVideo( Frame & f, uint8_t * dest = 0 ) = 0;
        virtual void decodeAudio( Frame & f, uint8_t * dest = 0 ) = 0;
    };

    class AVEncoderIFace : public CodecIFace
    {
      public:
//        virtual void encodeMetaData( Frame & f, PropertyNode * p ) {};
        virtual void encodeVideo( Frame & f, uint8_t * dest = 0 ) = 0;
        virtual void encodeAudio( Frame & f, uint8_t * dest = 0 ) = 0;
    };

};

#endif

---