ieee1394io.h

Go to the documentation of this file.

/*
* ieee1394io.cc -- asynchronously grabbing DV data
* Copyright (C) 2000 Arne Schirmacher <arne@schirmacher.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.
*/

#ifndef _IEEE1394IO_H
#define _IEEE1394IO_H 1

#include <libraw1394/raw1394.h>
#include <libraw1394/csr.h>
#include "dv1394.h"

#include <string>
using std::string;
#include <deque>
using std::deque;

class Frame;

class IEEE1394Reader
{
protected:
        int droppedFrames;

        Frame   *currentFrame;

        deque < Frame* > inFrames;

        deque < Frame* > outFrames;

public:

        IEEE1394Reader( int chn = 63, int frames = 50 );
        virtual ~IEEE1394Reader();

        // Mutex protected public methods
        virtual bool StartThread( void ) = 0;
        virtual void StopThread( void ) = 0;
        Frame* GetFrame( void );
        void DoneWithFrame( Frame* );
        int GetOutQueueSize( void )
        {
                return outFrames.size();
        }
        int GetInQueueSize( void )
        {
                return inFrames.size();
        }
        int GetDroppedFrames( void )
        {
                return droppedFrames;
        }
        void ResetDroppedFrames( void )
        {
                droppedFrames = 0;
        }

        // These two public methods are not mutex protected
        virtual bool Open( void ) = 0;
        virtual void Close( void ) = 0;

        bool WaitForAction( );
        void TriggerAction( );

        virtual bool StartReceive( void ) = 0;
        virtual void StopReceive( void ) = 0;

protected:
        int     channel;

        pthread_t thread;

        pthread_mutex_t mutex;

        // This condition and mutex are used to indicate when new frames are
        // received
        pthread_mutex_t condition_mutex;
        pthread_cond_t condition;

        bool isRunning;

        void Flush( void );
};


class raw1394Reader: public IEEE1394Reader
{
private:

        int     port;

        raw1394handle_t handle;

public:

        raw1394Reader( int crd = 0, int chn = 63, int frames = 50 );
        ~raw1394Reader();

        bool Open( void );
        void Close( void );
        bool StartReceive( void );
        void StopReceive( void );
        bool StartThread( void );
        void StopThread( void );
        int Handler( int channel, size_t length, quadlet_t *data );
        void *Thread();

private:
        static int HandlerProxy( raw1394handle_t handle, int channel, size_t length, quadlet_t *data );
        static void* ThreadProxy( void *arg );
};


class dv1394Reader: public IEEE1394Reader
{
private:

        unsigned char *m_dv1394_map;
        int m_dv1394_fd;

public:

        dv1394Reader( int chn = 63, int frames = 50 );
        ~dv1394Reader();

        bool Open( void );
        void Close( void );
        bool StartReceive( void );
        void StopReceive( void );
        bool StartThread( void );
        void StopThread( void );
        void* Thread( );

private:
        bool Handler( int handle );
        static void* ThreadProxy( void *arg );
};


class AVC
{
private:
        int     port;

        pthread_mutex_t avc_mutex;

        raw1394handle_t avc_handle;

public:
        AVC( int crd = 0 );
        ~AVC();

        int isPhyIDValid( int id );
        void Noop( void );
        int Play( int id );
        int Pause( int id );
        int Stop( int id );
        int FastForward( int id );
        int Rewind( int id );
        int Forward( int id );
        int Back( int id );
        int NextScene( int id );
        int PreviousScene( int id );
        int Record( int id );
        int Shuttle( int id, int speed );
        unsigned int TransportStatus( int id );
        bool Timecode( int id, char* timecode );
        int getNodeId( const char *guid );

private:
        static int ResetHandler( raw1394handle_t handle, unsigned int generation );

};

class IEEE1394Writer
{
protected:
        int     m_fd;
        string m_deviceName;
        unsigned int m_channel;
        unsigned int    m_nBuffers;
        unsigned int    m_cip_n;
        unsigned int    m_cip_d;
        unsigned int    m_syt_offset;

public:
        IEEE1394Writer()
        {}
        ;
        virtual ~IEEE1394Writer()
        {}
        ;
        virtual void SendFrame( Frame &frame ) = 0;
        bool isValid( void )
        {
                return ( m_fd >= 0 );
        }

};


class dv1394Writer: public IEEE1394Writer
{
private:
        bool isInitialised;

public:

        dv1394Writer( string device, unsigned int channel, unsigned int nBuffers,
                      unsigned int cip_n, unsigned int cip_d, unsigned int syt_offset );
        ~dv1394Writer();
        void SendFrame( Frame &frame );
};

#endif

---