moVideoGraph.h

Go to the documentation of this file.

/*******************************************************************************

                                moVideoGraph.h

  ****************************************************************************
  *                                                                          *
  *   This source 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 code 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.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa
  Andrés Colubri

*******************************************************************************/

#ifndef __MO_VIDEOGRAPH_H__
#define __MO_VIDEOGRAPH_H__

#include "moTypes.h"
#include "moText.h"
#include "moBuckets.h"
#include "moArray.h"
#include "moAbstract.h"

/*
    RESOLUCIONES

  http://en.wikipedia.org/wiki/Display_resolution


Digital TV standard     Resolution  Display aspect ratio    Pixels
Video CD    352 �240 (NTSC)    4:3 (non-square pixels)     84,480
            352 �288 (PAL)     101,376
China Video Disc    352 �480 (NTSC)    4:3 (non-square pixels)     168,960
                    352 �576 (PAL)     202,725
SVCD    480 �480 (NTSC)    4:3 (non-square pixels)     230,400
        480 �576 (PAL)     276,480
EDTV 480p   640 �480   4:3 or 16:9     307,200
            704 �480   337,920
            852 �480   408,960
DVD     704 �480 (NTSC)    4:3 or 16:9 (non-square pixels)     337,920
        704 �576 (PAL)     405,504
D1  720 �480 (NTSC)    4:3 or 16:9 (non-square pixels)     345,600
    720 �576 (PAL)     414,720
D1 (NTSC with square pixels)    720 �540   4:3     388,800
HDTV 720p   1280 �720  16:9    921,600
HDTV 1080p, 1080i   1920 �1080     16:9    2,073,600
*/

enum moVideoMode {
    PAL_D1 = 414720, //720 x 576
    NTSC_D1 = 345600, //720 x 480
    NTSC_SQUARE = 388800, //720x540

    NTSC_VDISC = 168960, //352x480
    PAL_VDISC = 202725, //352x576

    NTSC_SVCD = 230400, //480x480
    PAL_SVCD = 276480, //480x576

    NTSC_VCD = 84480, //352x240
    PAL_VCD = 101376, //352x288

    PAL_DVD = 337920, //704 x 576
    NTSC_DVD = 405504,//704 x 480

    HDTV_720p = 921600, //1280x720
    HDTV_1080p = 2073600, //1920x1080

    VGA = 307200, //640 x 480
    HVGA = 76800, //320 x 240
    CGA = 64000, //320x200
    MOVIDEOMODE_UNKNOWN
};


enum moAudioMode {
  MONO_44100_8 = 10844100,
  MONO_44100_16 = 11644100,
  MONO_44100_24 = 12444100,
  MONO_44100_32 = 13244100,
  MONO_48000_8 = 10848000,
  MONO_48000_16 = 11648000,
  MONO_48000_24 = 12448000,
  MONO_48000_32 = 13248000,
  ESTEREO_44100_8 = 20844100,
  ESTEREO_44100_16 = 21644100,
  ESTEREO_44100_24 = 22444100,
  ESTEREO_44100_32 = 23244100,
  ESTEREO_48000_8 = 2848000,
  ESTEREO_48000_16 = 21648000,
  ESTEREO_48000_24 = 22448000,
  ESTEREO_48000_32 = 23248000,
    MOAUDIOMODE_UNKNOWN
};


enum moColorMode {
    DEFAULT = 0,
    YUV = 1,
    RGB = 2,
    I420 = 3,
    YUY2 = 4
};

enum moStreamState {

  MO_STREAMSTATE_UNKNOWN=-1,
  MO_STREAMSTATE_PAUSED,
  MO_STREAMSTATE_PLAYING,
  MO_STREAMSTATE_WAITING,
  MO_STREAMSTATE_READY,
  MO_STREAMSTATE_STOPPED
};


class LIBMOLDEO_API moVideoFormat {

    public:
        moVideoFormat() {
            m_VideoMode = MOVIDEOMODE_UNKNOWN;
            m_Height = 0;
            m_Width = 0;
            m_BitRate = 0;
            m_TimePerFrame = 0;
            m_BitCount = 0;
            m_BufferSize = 0;
            m_FrameRate = 0;
            m_WaitForFormat = true;
            m_RedMask = 0;
            m_GreenMask = 0;
            m_BlueMask = 0;
        }

        void SetVideoMode() {
            switch(m_BufferSize) {
                case PAL_D1:
                case NTSC_D1:
                case NTSC_SQUARE:
                case NTSC_VDISC:
                case PAL_VDISC:
                case NTSC_SVCD:
                case PAL_SVCD:
                case NTSC_VCD:
                case PAL_VCD:
                case PAL_DVD:
                case NTSC_DVD:
                case HDTV_720p:
                case HDTV_1080p:
                case VGA:
                case HVGA:
                case CGA:
                    m_VideoMode = (moVideoMode)m_BufferSize;
                    break;

                default:
                    m_VideoMode = MOVIDEOMODE_UNKNOWN;
                    break;

            }
        }

        moVideoMode m_VideoMode;
        moColorMode m_ColorMode;
        MOuint m_Height;
        MOuint m_Width;
        MOuint m_BitRate; 
        MOuint m_TimePerFrame; 
        MOuint m_BitCount;
        MOuint m_BufferSize;
        MOuint m_FrameRate;
        MOboolean m_WaitForFormat;
        MOuint m_RedMask;
        MOuint m_GreenMask;
        MOuint m_BlueMask;
        MOuint m_AlphaMask;

};


class LIBMOLDEO_API moAudioFormat {

    public:
        moAudioFormat() {
            m_AudioMode = MOAUDIOMODE_UNKNOWN;
            m_Width = 0;
      m_Depth = 0;
            m_BitRate = 0;
            m_TimePerSample = 0;
            m_BitCount = 0;
            m_Channels = 0;
            m_BufferSize = 0;
            m_SampleRate = 0;
            m_WaitForFormat = true;
        }

        void SetAudioMode() {
            switch(m_BufferSize) {
                case MONO_44100_8:
                case MONO_44100_16:
                case MONO_44100_24:
                case MONO_44100_32:
                case MONO_48000_8:
                case MONO_48000_16:
                case MONO_48000_24:
                case MONO_48000_32:
                case ESTEREO_44100_8:
                case ESTEREO_44100_16:
                case ESTEREO_44100_24:
                case ESTEREO_44100_32:
                case ESTEREO_48000_8:
                case ESTEREO_48000_16:
                case ESTEREO_48000_24:
                case ESTEREO_48000_32:
                    m_AudioMode = (moAudioMode)m_BufferSize;
                    break;

                default:
                    m_AudioMode = MOAUDIOMODE_UNKNOWN;
                    break;

            }
        }

        moAudioMode m_AudioMode;
        //moColorMode m_ColorMode;
        MOuint m_Width;
        MOuint m_Depth;
        MOuint m_Channels;
    MOuint m_BitRate; 
    MOuint m_SampleSize; 
        MOuint m_SampleRate; 
        MOuint m_TimePerSample; 
        MOuint m_BitCount;
        MOuint m_BufferSize;
    MOboolean m_WaitForFormat;
};


class LIBMOLDEO_API moVideoSample {

    public:

        moVideoSample() {
            m_pSampleBuffer = NULL;
        }

        moVideoSample& operator = ( moVideoSample& p_vs) {
            m_VideoFormat = p_vs.m_VideoFormat;
            m_pSampleBuffer = p_vs.m_pSampleBuffer;
            return (*this);
        }

        moVideoSample( moVideoFormat p_videoformat, MOpointer p_buffer ) {

            m_VideoFormat = p_videoformat;
            m_pSampleBuffer = p_buffer;

        }


        void SetVideoSample( moVideoFormat p_videoformat, MOpointer p_buffer ) {
            m_VideoFormat = p_videoformat;
            m_pSampleBuffer = p_buffer;
        }

        moVideoFormat   m_VideoFormat;
        void*           m_pSampleBuffer;

};


class LIBMOLDEO_API moCaptureDevice {
    public:

        moCaptureDevice();

        moCaptureDevice( const moText &p_name, const moText &p_description, const moText &p_path, MOint p_deviceport = 0, MOint p_sourcewidth = 0, MOint p_sourceheight = 0, MOint p_bpp = 0, MOint p_fliph=0, MOint p_flipv=0 );

        moCaptureDevice( const moCaptureDevice &src ) {
            (*this) = src;
        }

        moCaptureDevice &operator = (const moCaptureDevice &src)
        {
            m_bPresent = src.m_bPresent;
            m_bPreferred = src.m_bPreferred;
            m_Name = src.m_Name;
            m_Description = src.m_Description;
            m_Path = src.m_Path ;
            m_VideoFormat = src.m_VideoFormat;
            m_LabelName = src.m_LabelName;
            m_DevicePort = src.m_DevicePort;
            m_SourceWidth = src.m_SourceWidth;
            m_SourceHeight = src.m_SourceHeight;
            m_SourceBpp = src.m_SourceBpp;
      m_SourceFlipH = src.m_SourceFlipH;
      m_SourceFlipV = src.m_SourceFlipV;

            return *this;
        }

    virtual ~moCaptureDevice() {
    }



        void SetName( const moText &p_name ) {
            m_Name = p_name;
        }

        const moText& GetName() const {
            return m_Name;
        }

        const moText& GetDescription() const {
            return m_Description;
        }

        const moText& GetPath() const {
            return m_Path;
        }

        MOint GetPort() const {
            return m_DevicePort;
        }

        moVideoFormat& GetVideoFormat() {

            return m_VideoFormat;
        }

        void SetVideoFormat( const moVideoFormat &p_videoformat ) {

            m_VideoFormat = p_videoformat;

        }

        void Present( bool p = true ) {
            m_bPresent = p;
        }

        bool IsPresent() const {
            return m_bPresent;
        }

        void SetLabelName( const moText &p_labelname ) {
            m_LabelName = p_labelname;
        }

        const moText& GetLabelName() const {
            return m_LabelName;
        }

    int GetSourceWidth() const {
        return m_SourceWidth;
    }

    int GetSourceHeight() const {
        return m_SourceHeight;
    }

    int GetSourceBpp() const {
        return m_SourceBpp;
    }

    int GetSourceFlipH() const {
        return m_SourceFlipH;
    }

    int GetSourceFlipV() const {
        return m_SourceFlipV;
    }

    void SetPreffered( bool setpreferred = true) {
      m_bPreferred = setpreferred;
    }

    bool IsPreferred() {
      return m_bPreferred;
    }


    public:
        bool            m_bPresent;
        bool      m_bPreferred;
        moText          m_Name;
        moText          m_Description;
        moText          m_Path;
        moVideoFormat   m_VideoFormat;
        MOint           m_DevicePort;

        MOint           m_SourceWidth;
        MOint           m_SourceHeight;
        MOint           m_SourceBpp;
        MOint           m_SourceFlipH;
        MOint           m_SourceFlipV;

        moText          m_LabelName;

};


moDeclareExportedDynamicArray(moCaptureDevice, moCaptureDevices);


class LIBMOLDEO_API moVideoFramework : public moAbstract {

    public:

        moVideoFramework();
        virtual ~moVideoFramework();


        virtual void SetPreferredDevices( moCaptureDevices* p_pPreferredDevices );


        virtual void SetPreferredFormat( const moCaptureDevice &p_CaptureDevice );


        virtual moCaptureDevices*   GetPreferredDevices() {
            return &m_PreferredDevices;
        }


        virtual moCaptureDevices*   GetCaptureDevices() {
            return &m_CaptureDevices;
        }


        virtual moCaptureDevices* LoadCaptureDevices() = 0;


        virtual moCaptureDevices* UpdateCaptureDevices() = 0;


        virtual bool    CheckCaptureDevice( int i ) = 0;


        virtual bool    AddCaptureDevice(  moCaptureDevice& p_capdev ) = 0;



        virtual void CleanCaptureDevices() {
            m_CaptureDevices.Empty();
        }

    protected:
        moCaptureDevices    m_CaptureDevices;
        moCaptureDevices    m_PreferredDevices;

};


class LIBMOLDEO_API moVideoGraph : public moAbstract {

    public:

    moVideoGraph();
    virtual ~moVideoGraph();

//================================================
//  INITIALIZATION AND FINALIZATION METHODS
//================================================

    virtual bool InitGraph() = 0;


    virtual bool FinishGraph() = 0;

    virtual bool BuildLiveGraph( moBucketsPool *pBucketsPool, moCaptureDevice p_capdev) = 0;


    virtual bool BuildLiveVideoGraph( moText filename, moBucketsPool* pBucketsPool) = 0;

    virtual bool BuildLiveQTVideoGraph( moText filename, moBucketsPool* pBucketsPool) = 0;


    virtual bool BuildRecordGraph( moText filename, moBucketsPool* pBucketsPool) = 0;

//================================================
//  CONTROL METHODS
//================================================

    virtual void Play() = 0;


    virtual void Stop() = 0;


    virtual void Pause() = 0;


    virtual void Seek( MOuint frame, float rate = 1.0 ) = 0;


    virtual bool IsRunning() = 0;


    virtual MOulong GetFramesLength() = 0;


  virtual MOulong GetPosition() = 0;


  virtual MOulong GetDuration() = 0;


    virtual MObyte* GetFrameBuffer(MOlong *size) = 0;


    moVideoMode     GetVideoMode();


    virtual void SetVolume( float volume ) = 0;


    virtual void SetBalance( float balance ) = 0;

    virtual void SetBrightness( float brightness ) = 0;
    virtual void SetContrast( float contrast ) = 0;
    virtual void SetSaturation( float saturation ) = 0;
    virtual void SetHue( float hue ) = 0;
    virtual bool IsEOS() = 0;
    virtual void SetEOS(bool iseos) = 0;



    moVideoFormat   GetVideoFormat();


    moAudioFormat   GetAudioFormat();


    virtual moStreamState    GetState();


    static moText          StateToText( moStreamState state );

    protected:

    moVideoFormat       m_VideoFormat;
  moAudioFormat     m_AudioFormat;

};









#endif