Changeset 201

Show
Ignore:
Timestamp:
05/19/06 01:36:34 (16 years ago)
Author:
pieterpalmers
Message:

backup commit

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libfreebob-2.0/src/libstreaming/IsoHandler.cpp

    r200 r201  
    137137                     "received packet: length=%d, channel=%d, cycle=%d\n", 
    138138                     length, channel, cycle ); 
     139        m_packetcount++; 
     140 
     141        if(m_Client) { 
     142                if(m_Client->putPacket(data, length, channel, tag, sy, cycle, dropped)) { 
     143//                      return RAW1394_ISO_AGAIN; 
     144                } 
     145        } 
    139146         
    140147        return RAW1394_ISO_OK; 
    141148} 
    142149 
    143 int IsoRecvHandler::registerStream(IsoRecvStream *stream) 
     150int IsoRecvHandler::registerStream(IsoStream *stream) 
    144151{ 
    145152        assert(stream); 
     
    167174} 
    168175 
    169 int IsoRecvHandler::unregisterStream(IsoRecvStream *stream) 
     176int IsoRecvHandler::unregisterStream(IsoStream *stream) 
    170177{ 
    171178        assert(stream); 
     
    255262                     "sending packet: length=%d, cycle=%d\n", 
    256263                     *length, cycle ); 
     264        m_packetcount++; 
     265 
    257266        if(m_Client) { 
    258         if(m_Client->getPacket(data, length, tag, sy, cycle, dropped)) { 
     267        if(m_Client->getPacket(data, length, tag, sy, cycle, dropped, m_max_packet_size)) { 
    259268//                      return RAW1394_ISO_AGAIN; 
    260269                } 
     
    265274 
    266275// an xmit handler can have only one source IsoStream 
    267 int IsoXmitHandler::registerStream(IsoXmitStream *stream) 
     276int IsoXmitHandler::registerStream(IsoStream *stream) 
    268277{ 
    269278        assert(stream); 
     
    292301} 
    293302 
    294 int IsoXmitHandler::unregisterStream(IsoXmitStream *stream) 
     303int IsoXmitHandler::unregisterStream(IsoStream *stream) 
    295304{ 
    296305        assert(stream); 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandler.h

    r200 r201  
    3939 
    4040class IsoStream; 
    41 class IsoXmitStream; 
    42 class IsoRecvStream; 
    43  
    44 typedef std::vector<IsoStream *> IsoStreamVector; 
    45 typedef std::vector<IsoStream *>::iterator IsoStreamVectorIterator; 
    46 typedef std::vector<IsoXmitStream *> IsoXmitStreamVector; 
    47 typedef std::vector<IsoXmitStream *>::iterator IsoXmitStreamVectorIterator; 
    48 typedef std::vector<IsoRecvStream *> IsoRecvStreamVector; 
    49 typedef std::vector<IsoRecvStream *>::iterator IsoRecvStreamVectorIterator; 
    5041 
    5142/*! 
     
    7162                IsoHandler(int port)  
    7263                   : m_handle(0), m_port(port),  
    73                    m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1) 
     64                   m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1), m_packetcount(0) 
    7465                {} 
    7566 
    7667                IsoHandler(int port, unsigned int buf_packets, unsigned int max_packet_size, int irq)  
    7768                   : m_handle(0), m_port(port),  
    78                    m_buf_packets(buf_packets), m_max_packet_size( max_packet_size), m_irq_interval(irq) 
     69                   m_buf_packets(buf_packets), m_max_packet_size( max_packet_size), m_irq_interval(irq), 
     70                   m_packetcount(0) 
    7971                {} 
    8072 
     
    9284                int getWakeupInterval() { return m_irq_interval;}; 
    9385 
     86                int getPacketCount() {return m_packetcount;}; 
     87                void resetPacketCount() {m_packetcount=0;}; 
     88 
    9489                virtual enum EHandlerType getType() = 0; 
    9590 
    9691                virtual int start(int cycle) = 0; 
    9792                void stop(); 
    98                 int getFileDescriptor() { raw1394_get_fd(m_handle);}; 
     93                int getFileDescriptor() { return raw1394_get_fd(m_handle);}; 
    9994 
    10095        protected: 
     
    10499                unsigned int    m_max_packet_size; 
    105100                int             m_irq_interval; 
     101 
     102                int m_packetcount; 
    106103 
    107104    DECLARE_DEBUG_MODULE; 
     
    129126                enum EHandlerType getType() { return EHT_Receive;}; 
    130127 
    131                 int registerStream(IsoRecvStream *); 
    132                 int unregisterStream(IsoRecvStream *); 
     128                int registerStream(IsoStream *); 
     129                int unregisterStream(IsoStream *); 
    133130 
    134131                int start(int cycle); 
    135132 
    136133        private: 
    137                 IsoRecvStream *m_Client; 
     134                IsoStream *m_Client; 
    138135 
    139136                static enum raw1394_iso_disposition  
     
    169166                enum EHandlerType getType() { return EHT_Transmit;}; 
    170167 
    171                 int registerStream(IsoXmitStream *); 
    172                 int unregisterStream(IsoXmitStream *); 
     168                int registerStream(IsoStream *); 
     169                int unregisterStream(IsoStream *); 
    173170 
    174171                unsigned int getPreBuffers() {return m_prebuffers;}; 
     
    178175 
    179176        private: 
    180                 IsoXmitStream *m_Client; 
     177                IsoStream *m_Client; 
    181178 
    182179                static enum raw1394_iso_disposition iso_transmit_handler(raw1394handle_t handle, 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.cpp

    r200 r201  
    2828 
    2929#include "IsoStream.h" 
     30#include "PacketBuffer.h" 
    3031 
    3132namespace FreebobStreaming 
     
    3334 
    3435IMPL_DEBUG_MODULE( IsoStream, IsoStream, DEBUG_LEVEL_NORMAL ); 
     36IMPL_DEBUG_MODULE( IsoStreamBuffered, IsoStreamBuffered, DEBUG_LEVEL_NORMAL ); 
    3537 
    36 IsoRecvStream::IsoRecvStream(int channel) 
    37                 : IsoStream(channel) 
    38 
    39  
    40 
    41  
    42 IsoRecvStream::~IsoRecvStream() 
    43 
    44  
    45 
    46  
    47 int IsoRecvStream::putPacket(unsigned char *data, unsigned int length,  
     38int IsoStream::putPacket(unsigned char *data, unsigned int length,  
    4839                              unsigned char channel, unsigned char tag, unsigned char sy,  
    4940                                  unsigned int cycle, unsigned int dropped) { 
     
    5344                     length, channel, cycle ); 
    5445 
    55         m_packetcount++; 
    56  
    57  
    5846        return 0; 
    5947} 
    6048 
    61 IsoXmitStream::IsoXmitStream(int channel) 
    62                 : IsoStream(channel) 
    63 
    64  
    65 
    66  
    67 IsoXmitStream::~IsoXmitStream() 
    68 
    69  
    70 
    71  
    72 int IsoXmitStream::getPacket(unsigned char *data, unsigned int *length, 
     49int IsoStream::getPacket(unsigned char *data, unsigned int *length, 
    7350                              unsigned char *tag, unsigned char *sy, 
    74                               int cycle, unsigned int dropped) { 
     51                              int cycle, unsigned int dropped, unsigned int max_length) { 
    7552        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
    7653                     "sending packet: length=%d, cycle=%d\n", 
     
    8259        *sy = 0; 
    8360 
    84         m_packetcount++; 
    8561 
    8662        return 0; 
    8763} 
    8864 
     65/* buffered variant of the ISO stream */ 
     66IsoStreamBuffered::~IsoStreamBuffered() { 
     67        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     68        if(buffer) delete buffer; 
     69 
    8970} 
     71 
     72int IsoStreamBuffered::initialize() { 
     73        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     74        buffer=new PacketBuffer(m_headersize, m_buffersize, m_max_packetsize); 
     75 
     76        if(buffer==NULL) return -1; 
     77 
     78        return buffer->initialize(); 
     79 
     80} 
     81 
     82int IsoStreamBuffered::putPacket(unsigned char *data, unsigned int length,  
     83                              unsigned char channel, unsigned char tag, unsigned char sy,  
     84                                  unsigned int cycle, unsigned int dropped) { 
     85        int retval; 
     86 
     87        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
     88                     "received packet: length=%d, channel=%d, cycle=%d\n", 
     89                     length, channel, cycle ); 
     90        if(buffer) { 
     91                if((retval=buffer->addPacket((quadlet_t *)data,length))) { 
     92                        debugWarning("Receive buffer overflow\n"); 
     93                } 
     94        } 
     95 
     96        return 0; 
     97} 
     98 
     99int IsoStreamBuffered::getPacket(unsigned char *data, unsigned int *length, 
     100                              unsigned char *tag, unsigned char *sy, 
     101                              int cycle, unsigned int dropped, unsigned int max_length) { 
     102        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
     103                     "sending packet: length=%d, cycle=%d\n", 
     104                     *length, cycle ); 
     105 
     106        int retval; 
     107        *length=sizeof(cycle); 
     108        *tag = 1; 
     109        *sy = 0; 
     110 
     111        if(buffer) { 
     112                if((retval=buffer->getNextPacket((quadlet_t *)data,max_length))<0) { 
     113                        debugWarning("Transmit buffer underflow: %d\n",retval); 
     114                        return -1; 
     115                } 
     116                *length=retval; 
     117        } 
     118 
     119        return 0; 
     120} 
     121 
     122int IsoStreamBuffered::getBufferFillPackets() { 
     123 
     124        if(buffer) return buffer->getBufferFillPackets(); 
     125        return -1; 
     126 
     127} 
     128int IsoStreamBuffered::getBufferFillPayload() { 
     129 
     130        if(buffer) return buffer->getBufferFillPayload(); 
     131        return -1; 
     132 
     133} 
     134 
     135void IsoStreamBuffered::setVerboseLevel(int l) {  
     136        setDebugLevel( l );  
     137        if(buffer) { 
     138                buffer->setVerboseLevel(l); 
     139        } 
     140} 
     141 
     142} 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.h

    r200 r201  
    3535{ 
    3636 
     37class PacketBuffer; 
     38 
    3739/*! 
    3840\brief The Base Class for ISO streams 
     
    4951                }; 
    5052 
    51  
    52         IsoStream(int channel) : m_Channel(channel), m_packetcount(0) 
     53        IsoStream(enum EStreamType type, int channel) : m_type(type), m_Channel(channel) 
    5354        {}; 
    5455        virtual ~IsoStream() 
     
    5859 
    5960                int getChannel() {return m_Channel;}; 
    60                 int getPacketCount() {return m_packetcount;}; 
    61                 void resetPacketCount() {m_packetcount=0;}; 
     61 
     62                enum EStreamType getType() { return m_type;}; 
     63 
     64                int initialize() {return 0;}; 
     65 
     66                int  
     67                        putPacket(unsigned char *data, unsigned int length,  
     68                              unsigned char channel, unsigned char tag, unsigned char sy,  
     69                                  unsigned int cycle, unsigned int dropped); 
     70                int  
     71                        getPacket(unsigned char *data, unsigned int *length, 
     72                              unsigned char *tag, unsigned char *sy, 
     73                              int cycle, unsigned int dropped, unsigned int max_length); 
    6274         
    6375        protected: 
     76                enum EStreamType m_type; 
    6477                int m_Channel; 
    65  
    66                 int m_packetcount; 
    6778 
    6879                DECLARE_DEBUG_MODULE; 
     
    7081}; 
    7182 
    72 class IsoRecvStream : public IsoStream 
     83class IsoStreamBuffered : public IsoStream 
    7384{ 
    74         public: 
    75         IsoRecvStream(int); 
    76         virtual ~IsoRecvStream(); 
    7785 
    78                 virtual enum EStreamType getType() { return EST_Receive;}; 
     86    public: 
     87 
     88        IsoStreamBuffered(int headersize,int buffersize, int max_packetsize, enum EStreamType type, int channel)  
     89                   : IsoStream(type,channel), m_headersize(headersize), m_buffersize(buffersize), m_max_packetsize(max_packetsize), buffer(0) 
     90        {}; 
     91        virtual ~IsoStreamBuffered(); 
     92 
     93                void setVerboseLevel(int l); 
     94 
     95                int initialize(); 
    7996 
    8097                int  
     
    8299                              unsigned char channel, unsigned char tag, unsigned char sy,  
    83100                                  unsigned int cycle, unsigned int dropped); 
    84  
    85         private: 
    86  
    87 }; 
    88  
    89 class IsoXmitStream : public IsoStream 
    90 { 
    91          
    92         public: 
    93         IsoXmitStream(int); 
    94         virtual ~IsoXmitStream(); 
    95  
    96                 virtual enum EStreamType getType() { return EST_Transmit;}; 
    97101                int  
    98102                        getPacket(unsigned char *data, unsigned int *length, 
    99103                              unsigned char *tag, unsigned char *sy, 
    100                               int cycle, unsigned int dropped); 
     104                              int cycle, unsigned int dropped, unsigned int max_length); 
     105        int getBufferFillPackets(); 
     106        int getBufferFillPayload(); 
    101107 
    102         private: 
     108        protected: 
     109                int m_headersize; 
     110                int m_buffersize; 
     111                int m_max_packetsize; 
     112 
     113                PacketBuffer *buffer; 
     114 
     115                DECLARE_DEBUG_MODULE; 
    103116 
    104117}; 
  • branches/libfreebob-2.0/src/libstreaming/IsoStreamManager.cpp

    r200 r201  
    4949        assert(stream); 
    5050 
    51         IsoRecvStream *srx; 
    52         IsoXmitStream *stx; 
    53  
    54         srx=dynamic_cast<IsoRecvStream *>(stream); 
    55  
    56         if (srx) { 
    57                 m_IsoRecvStreams.push_back(srx); 
     51        if (stream->getType()==IsoStream::EST_Receive) { 
     52                m_IsoRecvStreams.push_back(stream); 
    5853                return 0; 
    5954        } 
    6055         
    61         stx=dynamic_cast<IsoXmitStream *>(stream); 
    62  
    63         if (stx) { 
    64                 m_IsoXmitStreams.push_back(stx); 
     56        if (stream->getType()==IsoStream::EST_Transmit) { 
     57                m_IsoXmitStreams.push_back(stream); 
    6558                return 0; 
    6659        } 
     
    7366        assert(stream); 
    7467 
    75     for ( IsoRecvStreamVectorIterator it = m_IsoRecvStreams.begin(); 
     68    for ( IsoStreamVectorIterator it = m_IsoRecvStreams.begin(); 
    7669          it != m_IsoRecvStreams.end(); 
    7770          ++it ) 
    7871    { 
    79                 // FIXME: how do I compare these two pointers? 
    80         IsoStream* s = dynamic_cast<IsoStream *>(*it); 
    81         if ( s == stream ) {  
     72        if ( *it == stream ) {  
    8273            m_IsoRecvStreams.erase(it); 
    8374                        return 0; 
     
    8576    } 
    8677 
    87     for ( IsoXmitStreamVectorIterator it = m_IsoXmitStreams.begin(); 
     78    for ( IsoStreamVectorIterator it = m_IsoXmitStreams.begin(); 
    8879          it != m_IsoXmitStreams.end(); 
    8980          ++it ) 
    9081    { 
    91                 // FIXME: how do I compare these two pointers? 
    92         IsoStream* s = dynamic_cast<IsoStream *>(*it); 
    93         if ( s == stream ) {  
     82       if ( *it == stream ) {  
    9483            m_IsoXmitStreams.erase(it); 
    9584                        return 0; 
  • branches/libfreebob-2.0/src/libstreaming/IsoStreamManager.h

    r200 r201  
    3838*/ 
    3939class IsoStream; 
    40 class IsoXmitStream; 
    41 class IsoRecvStream; 
    4240 
    43 typedef std::vector<IsoXmitStream *> IsoXmitStreamVector; 
    44 typedef std::vector<IsoXmitStream *>::iterator IsoXmitStreamVectorIterator; 
    45 typedef std::vector<IsoRecvStream *> IsoRecvStreamVector; 
    46 typedef std::vector<IsoRecvStream *>::iterator IsoRecvStreamVectorIterator; 
     41typedef std::vector<IsoStream *> IsoStreamVector; 
     42typedef std::vector<IsoStream *>::iterator IsoStreamVectorIterator; 
    4743 
    4844class IsoStreamManager 
     
    5753 
    5854        private: 
    59                 IsoRecvStreamVector m_IsoRecvStreams; 
    60                 IsoXmitStreamVector m_IsoXmitStreams; 
     55                IsoStreamVector m_IsoRecvStreams; 
     56                IsoStreamVector m_IsoXmitStreams; 
    6157 
    6258}; 
  • branches/libfreebob-2.0/src/libstreaming/Makefile.am

    r200 r201  
    3535        IsoStreamManager.h \ 
    3636        ringbuffer.c ringbuffer.h \ 
    37         Receiver.cpp Receiver.h 
     37        Receiver.cpp Receiver.h \ 
     38        PacketBuffer.cpp PacketBuffer.h 
    3839 
    3940INCLUDES = $(LIBRAW1394_CFLAGS) $(LIBIEC61883_CFLAGS) -I$(top_srcdir)/src \ 
  • branches/libfreebob-2.0/src/libstreaming/messagebuffer.h

    r199 r201  
    3636#define __FREEBOB_MESSAGEBUFFER_H__ 
    3737 
     38#ifdef __cplusplus 
     39extern "C" { 
     40#endif 
     41 
    3842void freebob_messagebuffer_init(); 
    3943void freebob_messagebuffer_exit(); 
     
    4145void freebob_messagebuffer_add(const char *fmt, ...); 
    4246 
     47#ifdef __cplusplus 
     48} 
     49#endif 
     50 
    4351#endif /* __freebob_messagebuffer_h__ */ 
  • branches/libfreebob-2.0/src/libstreaming/Receiver.cpp

    r200 r201  
    3333IMPL_DEBUG_MODULE( Receiver, Receiver, DEBUG_LEVEL_NORMAL ); 
    3434 
    35 Receiver::Receiver() { 
     35Receiver::Receiver(int periodsize) { 
    3636 
    3737} 
  • branches/libfreebob-2.0/src/libstreaming/Receiver.h

    r200 r201  
    3535namespace FreebobStreaming { 
    3636 
    37 class Receiver : public IsoRecvStream
     37class Receiver
    3838 
    3939public: 
    4040 
    41         Receiver(int periodsize)
     41        Receiver(int periodsize)
    4242        virtual ~Receiver(); 
    4343 
    4444protected: 
    45         int  
     45        int m_period_size; 
    4646private: 
    4747        freebob_ringbuffer_t event_buffer; 
    48 
     48 
     49        DECLARE_DEBUG_MODULE; 
     50 
     51}; 
    4952 
    5053} 
    5154 
    5255#endif /* __FREEBOB_RECEIVER__ */ 
    53  
    54