Changeset 206

Show
Ignore:
Timestamp:
05/20/06 13:12:11 (16 years ago)
Author:
pieterpalmers
Message:

- end of another day... implemented the 'ports' that represent the demuxed data streams (audio, midi and control)

Files:

Legend:

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

    r204 r206  
    6666} 
    6767 
     68int IsoHandler::busreset_handler(raw1394handle_t handle, unsigned int generation) 
     69{        
     70        debugOutput( DEBUG_LEVEL_VERBOSE, "Busreset happened, generation %d...\n", generation); 
     71 
     72        IsoHandler *handler=static_cast<IsoHandler *>(raw1394_get_userdata(handle)); 
     73        assert(handler); 
     74        return handler->handleBusReset(generation); 
     75} 
     76 
     77 
    6878/* Base class implementation */ 
    6979bool 
    7080IsoHandler::initialize() 
    7181{ 
    72         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     82        debugOutput( DEBUG_LEVEL_VERBOSE, "IsoHandler (%p) enter...\n",this); 
    7383 
    7484    m_handle = raw1394_new_handle_on_port( m_port ); 
     
    8494 
    8595        raw1394_set_userdata(m_handle, static_cast<void *>(this)); 
     96        if(raw1394_busreset_notify (m_handle, RAW1394_NOTIFY_ON)) { 
     97                debugWarning("Could not enable busreset notification.\n"); 
     98                debugWarning(" Error message: %s\n",strerror(errno)); 
     99        } 
     100 
     101        raw1394_set_bus_reset_handler(m_handle, busreset_handler); 
    86102 
    87103    return true; 
     
    96112void IsoHandler::dumpInfo() 
    97113{ 
    98         debugOutput( DEBUG_LEVEL_NORMAL, "  Stream type  : %s\n", 
     114 
     115        int channel=-1; 
     116        if (m_Client) channel=m_Client->getChannel(); 
     117 
     118        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Handler type    : %s\n", 
    99119             (this->getType()==EHT_Receive ? "Receive" : "Transmit")); 
    100         debugOutput( DEBUG_LEVEL_NORMAL, "  Packet count : %d\n",this->getPacketCount()); 
     120        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Port, Channel  : %d, %d\n", 
     121             m_port, channel); 
     122        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Packet count   : %d (%d dropped)\n\n", 
     123             this->getPacketCount(), this->getDroppedCount()); 
    101124 
    102125}; 
     
    111134IsoRecvHandler::IsoRecvHandler(int port, unsigned int buf_packets,  
    112135                               unsigned int max_packet_size, int irq) 
    113                 : IsoHandler(port, buf_packets,max_packet_size,irq), m_Client(0) 
     136                : IsoHandler(port, buf_packets,max_packet_size,irq) 
    114137{ 
    115138        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     
    125148bool 
    126149IsoRecvHandler::initialize() { 
    127         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     150        debugOutput( DEBUG_LEVEL_VERBOSE, "IsoRecvHandler enter...\n"); 
    128151 
    129152        IsoHandler *base=static_cast<IsoHandler *>(this); 
     
    147170                     length, channel, cycle ); 
    148171        m_packetcount++; 
     172        m_dropped+=dropped; 
    149173 
    150174        if(m_Client) { 
     
    176200                debugFatal("Could not do receive initialisation!\n" ); 
    177201 
     202                m_Client=0; 
     203 
    178204                return -1; 
    179205        } 
     
    199225        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    200226        return raw1394_iso_recv_start(m_handle, cycle, -1, 0); 
     227} 
     228 
     229int IsoRecvHandler::handleBusReset(unsigned int generation) { 
     230        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     231        //TODO: implement busreset 
     232        return 0; 
    201233} 
    202234 
     
    206238                : IsoHandler(port), m_prebuffers(0) 
    207239{ 
    208         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     240        debugOutput( DEBUG_LEVEL_VERBOSE, "IsoXmitHandler enter...\n"); 
    209241 
    210242} 
     
    214246                  m_speed(RAW1394_ISO_SPEED_400), m_prebuffers(0) 
    215247{ 
    216         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     248        debugOutput( DEBUG_LEVEL_VERBOSE, "IsoXmitHandler enter...\n"); 
    217249 
    218250} 
     
    223255                  m_speed(speed), m_prebuffers(0) 
    224256{ 
    225         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     257        debugOutput( DEBUG_LEVEL_VERBOSE, "IsoXmitHandler enter...\n"); 
    226258 
    227259} 
     
    272304                     *length, cycle ); 
    273305        m_packetcount++; 
     306        m_dropped+=dropped; 
    274307 
    275308        if(m_Client) { 
     
    306339                debugFatal("Could not do xmit initialisation!\n" ); 
    307340 
     341                m_Client=0; 
     342 
    308343                return -1; 
    309344        } 
     
    329364        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    330365        return raw1394_iso_xmit_start(m_handle, cycle, m_prebuffers); 
     366} 
     367 
     368int IsoXmitHandler::handleBusReset(unsigned int generation) { 
     369        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     370        //TODO: implement busreset 
     371        return 0; 
    331372} 
    332373 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandler.h

    r204 r206  
    6262                IsoHandler(int port)  
    6363                   : m_handle(0), m_port(port),  
    64                    m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1), m_packetcount(0), m_Client(0) 
     64                   m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1), 
     65                   m_packetcount(0), m_dropped(0), m_Client(0) 
    6566                {} 
    6667 
    6768                IsoHandler(int port, unsigned int buf_packets, unsigned int max_packet_size, int irq)  
    6869                   : m_handle(0), m_port(port),  
    69                    m_buf_packets(buf_packets), m_max_packet_size( max_packet_size), m_irq_interval(irq), 
    70                    m_packetcount(0), m_Client(0) 
     70                   m_buf_packets(buf_packets), m_max_packet_size( max_packet_size),  
     71                   m_irq_interval(irq), m_packetcount(0), m_dropped(0), m_Client(0) 
    7172                {} 
    7273 
     
    8788                void resetPacketCount() {m_packetcount=0;}; 
    8889 
     90                int getDroppedCount() {return m_dropped;}; 
     91                void resetDroppedCount() {m_dropped=0;}; 
     92 
    8993                virtual enum EHandlerType getType() = 0; 
    9094 
     
    9599                void dumpInfo(); 
    96100 
    97                 bool inUse() {return (m_Client !=0) ;}; 
     101                bool inUse() {return (m_Client != 0) ;}; 
    98102                virtual bool isStreamRegistered(IsoStream *s) {return (m_Client == s);}; 
    99103 
     
    109113 
    110114                int m_packetcount; 
     115                int m_dropped; 
    111116 
    112117                IsoStream *m_Client; 
    113118 
    114     DECLARE_DEBUG_MODULE; 
     119                virtual int handleBusReset(unsigned int generation) = 0; 
     120 
     121                DECLARE_DEBUG_MODULE; 
    115122 
    116123        private: 
    117  
     124                static int busreset_handler(raw1394handle_t handle, unsigned int generation); 
    118125 
    119126 
     
    142149 
    143150        private: 
    144                 IsoStream *m_Client
     151                int handleBusReset(unsigned int generation)
    145152 
    146153                static enum raw1394_iso_disposition  
     
    186193        private: 
    187194 
     195                int handleBusReset(unsigned int generation); 
     196 
    188197                static enum raw1394_iso_disposition iso_transmit_handler(raw1394handle_t handle, 
    189198                                unsigned char *data, unsigned int *length, 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandlerManager.cpp

    r204 r206  
    169169    { 
    170170                if((*it)->isStreamRegistered(stream)) { 
     171                        debugOutput( DEBUG_LEVEL_VERBOSE, "stream already registered!\n"); 
    171172                        (*it)->unregisterStream(stream); 
    172173                } 
     
    179180        if (stream->getType()==IsoStream::EST_Receive) { 
    180181                IsoRecvHandler *h = new IsoRecvHandler(stream->getPort()); 
     182                debugOutput( DEBUG_LEVEL_VERBOSE, " registering IsoRecvHandler\n"); 
     183 
    181184                if(!h) { 
    182185                        debugFatal("Could not create IsoRecvHandler\n"); 
     
    203206                        return -1; 
    204207                } 
     208                debugOutput( DEBUG_LEVEL_VERBOSE, " registered stream (%p) with handler (%p)\n",stream,h); 
    205209        } 
    206210         
    207211        if (stream->getType()==IsoStream::EST_Transmit) { 
    208212                IsoXmitHandler *h = new IsoXmitHandler(stream->getPort()); 
     213 
     214                debugOutput( DEBUG_LEVEL_VERBOSE, " registering IsoXmitHandler\n"); 
     215 
    209216                if(!h) { 
    210217                        debugFatal("Could not create IsoXmitHandler\n"); 
     
    231238                        return -1; 
    232239                } 
     240                debugOutput( DEBUG_LEVEL_VERBOSE, " registered stream (%p) with handler (%p)\n",stream,h); 
    233241 
    234242        } 
    235243 
    236244        m_IsoStreams.push_back(stream); 
     245        debugOutput( DEBUG_LEVEL_VERBOSE, " %d streams, %d handlers registered\n", 
     246                                          m_IsoStreams.size(), m_IsoHandlers.size()); 
    237247 
    238248        return 0; 
     
    251261                if((*it)->isStreamRegistered(stream)) { 
    252262                        (*it)->unregisterStream(stream); 
     263                        debugOutput( DEBUG_LEVEL_VERBOSE, " unregistered stream (%p) from handler (%p)...\n",stream,*it); 
    253264                } 
    254265    } 
     
    264275        if ( *it == stream ) {  
    265276            m_IsoStreams.erase(it); 
     277                        debugOutput( DEBUG_LEVEL_VERBOSE, " deleted stream (%p) from list...\n", *it); 
    266278                        return 0; 
    267279        } 
     
    282294    { 
    283295                if(!((*it)->inUse())) { 
     296                        debugOutput( DEBUG_LEVEL_VERBOSE, " handler (%p) not in use\n",*it); 
    284297                        toUnregister.push_back(*it); 
    285298                } 
     
    291304    { 
    292305                unregisterHandler(*it); 
     306                debugOutput( DEBUG_LEVEL_VERBOSE, " deleting handler (%p)\n",*it); 
    293307    } 
    294308 
     
    306320          ++it ) 
    307321    { 
     322                debugOutput( DEBUG_LEVEL_VERBOSE, " starting handler (%p)\n",*it); 
    308323                (*it)->start(cycle); 
    309324    } 
     
    318333          ++it ) 
    319334    { 
     335                debugOutput( DEBUG_LEVEL_VERBOSE, " stopping handler (%p)\n",*it); 
    320336                (*it)->stop(); 
    321337    } 
    322  
    323 
    324  
     338
    325339 
    326340void IsoHandlerManager::dumpInfo() { 
    327         debugOutput( DEBUG_LEVEL_NORMAL, "Dumping IsoHandlerManager Stream handler information...\n"); 
     341        debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping IsoHandlerManager Stream handler information...\n"); 
    328342        int i=0; 
    329343 
    330         // fill the fd map 
    331     for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
    332           it != m_IsoHandlers.end(); 
    333           ++it ) 
    334     { 
    335                 debugOutput( DEBUG_LEVEL_NORMAL, " Stream %d\n",i++); 
     344    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     345          it != m_IsoHandlers.end(); 
     346          ++it ) 
     347    { 
     348                debugOutputShort( DEBUG_LEVEL_NORMAL, " Stream %d (%p)\n",i++,*it); 
    336349 
    337350                (*it)->dumpInfo(); 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.cpp

    r204 r206  
    6262        return 0; 
    6363} 
     64 
     65void IsoStream::dumpInfo() 
     66{ 
     67 
     68        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Stream type    : %s\n", 
     69             (this->getType()==EST_Receive ? "Receive" : "Transmit")); 
     70        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Port, Channel  : %d, %d\n", 
     71             m_port, m_channel); 
     72 
     73}; 
    6474 
    6575/* buffered variant of the ISO stream */ 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.h

    r204 r206  
    7575                              unsigned char *tag, unsigned char *sy, 
    7676                              int cycle, unsigned int dropped, unsigned int max_length); 
     77 
     78                void dumpInfo(); 
    7779         
    7880        protected: 
  • branches/libfreebob-2.0/src/libstreaming/Port.cpp

    r203 r206  
    2828 
    2929#include "Port.h" 
     30 #include <stdlib.h> 
    3031 
    3132namespace FreebobStreaming { 
     
    3637IMPL_DEBUG_MODULE( ControlPort, ControlPort, DEBUG_LEVEL_NORMAL ); 
    3738 
     39Port::Port(std::string name, enum E_BufferType type, int buffsize)  
     40  : m_Name(name), 
     41    m_BufferType(type), 
     42    m_enabled(true), 
     43    m_buffersize(buffsize), 
     44        m_buffer(0), 
     45    m_buffer_attached(false) 
     46{ 
     47 
     48        allocateInternalBuffer(); 
    3849} 
     50 
     51Port::Port(std::string name, enum E_BufferType type, int buffsize, void* externalbuffer)  
     52  : m_Name(name), 
     53    m_BufferType(type), 
     54    m_enabled(true), 
     55    m_buffersize(buffsize), 
     56        m_buffer(externalbuffer), 
     57    m_buffer_attached(true) 
     58{ 
     59         
     60} 
     61 
     62int Port::attachBuffer(void *buff) { 
     63 
     64        if(m_buffer_attached) { 
     65                debugFatal("already has a buffer attached\n"); 
     66                return -1; 
     67        } 
     68 
     69        freeInternalBuffer(); 
     70 
     71        m_buffer=buff; 
     72 
     73        m_buffer_attached=true; 
     74 
     75} 
     76 
     77// detach the user buffer, allocates an internal buffer 
     78int Port::detachBuffer() { 
     79        if(!m_buffer_attached) { 
     80                debugWarning("does not have a buffer attached\n"); 
     81                if(m_buffer) { 
     82                        return 0;        
     83                } // if no buffer present, there should be one allocated 
     84        } 
     85 
     86        m_buffer_attached=false; 
     87 
     88        return allocateInternalBuffer(); 
     89 
     90} 
     91 
     92int Port::allocateInternalBuffer() { 
     93        int event_size=getEventSize(); 
     94 
     95        if(m_buffer_attached) { 
     96                debugWarning("has an external buffer attached, not allocating\n"); 
     97                return -1; 
     98        } 
     99 
     100        if(m_buffer) { 
     101                debugWarning("already has an internal buffer attached, re-allocating\n"); 
     102                freeInternalBuffer(); 
     103        } 
     104 
     105        m_buffer=calloc(m_buffersize,event_size); 
     106        if (!m_buffer) { 
     107                debugFatal("could not allocate internal buffer\n"); 
     108                m_buffersize=0; 
     109                return -1; 
     110        } 
     111 
     112        return 0; 
     113} 
     114 
     115void Port::freeInternalBuffer() { 
     116        if(m_buffer_attached) { 
     117                debugWarning("has an external buffer attached, not free-ing\n"); 
     118                return; 
     119        } 
     120        if(m_buffer) { 
     121                free(m_buffer); 
     122                m_buffer=0; 
     123        } 
     124} 
     125 
     126unsigned int AudioPort::getEventSize() { 
     127        switch (m_DataType) { 
     128                case E_Float: 
     129                        return sizeof(float); 
     130                case E_Int24: // 24 bit 2's complement, packed in a 32bit integer (LSB's) 
     131                        return sizeof(uint32_t); 
     132                default: 
     133                        return 0; 
     134        } 
     135} 
     136 
     137unsigned int MidiPort::getEventSize() { 
     138        switch (m_DataType) { 
     139                case E_Byte: 
     140                        return sizeof(char); 
     141                default: 
     142                        return 0; 
     143        } 
     144} 
     145 
     146unsigned int ControlPort::getEventSize() { 
     147        switch (m_DataType) { 
     148                case E_Default: 
     149                        return sizeof(uint32_t); 
     150                default: 
     151                        return 0; 
     152        } 
     153} 
     154 
     155} 
  • branches/libfreebob-2.0/src/libstreaming/Port.h

    r203 r206  
    3434namespace FreebobStreaming { 
    3535 
    36 class PortManager; 
    37  
    3836class Port { 
    3937 
     
    4442                E_PacketBuffered, 
    4543                E_PeriodBuffered, 
    46               E_SampleBuffered 
     44//            E_SampleBuffered 
    4745        }; 
    4846 
    49         Port()  
    50           : m_Name(std::string("Undefined")),  
    51             m_manager(0), 
    52             m_BufferType(E_PacketBuffered), 
    53                 m_enabled(true) 
     47        Port(std::string name, enum E_BufferType type, int buffsize); 
     48        Port(std::string name, enum E_BufferType type, int buffsize, void *externalbuffer); 
     49 
     50        virtual ~Port()  
    5451          {}; 
    55  
    56         Port(std::string name)  
    57           : m_Name(name), 
    58             m_manager(0), 
    59             m_BufferType(E_PacketBuffered), 
    60                 m_enabled(true) 
    61           {}; 
    62  
    63         Port(enum E_BufferType type)  
    64           : m_Name(std::string("Undefined")), 
    65             m_manager(0), 
    66             m_BufferType(type), 
    67                 m_enabled(true) 
    68           {}; 
    69  
    70         Port(enum E_BufferType type, std::string name)  
    71           : m_Name(name), 
    72             m_manager(0), 
    73             m_BufferType(type), 
    74                 m_enabled(true) 
    75           {}; 
    76  
    77         Port(std::string name, enum E_BufferType type)  
    78           : m_Name(name), 
    79             m_manager(0), 
    80             m_BufferType(type), 
    81                 m_enabled(true) 
    82           {}; 
    83  
    84         virtual ~Port(); 
    8552 
    8653        std::string getName() {return m_Name;}; 
     
    9360        enum E_BufferType getBufferType() {return m_BufferType;}; 
    9461 
     62        // returns the size in bytes of the events in the port buffer 
     63        virtual unsigned int getEventSize() = 0; 
     64 
     65        // NOT THREAD SAFE! 
     66        // attaches a user buffer to the port. 
     67        // deallocates the internal buffer, if there was one 
     68        // buffersize is in 'events' 
     69        int attachBuffer(void *buff); 
     70 
     71        // detach the user buffer, allocates an internal buffer 
     72        int detachBuffer(); 
     73 
     74        int getBufferSize() {return m_buffersize;}; 
     75        void *getBuffer() {return m_buffer;}; 
     76 
    9577protected: 
    9678        std::string m_Name; 
    97         PortManager *m_manager; 
    9879 
    9980        enum E_BufferType m_BufferType; 
    10081 
    10182        bool m_enabled; 
     83        int m_buffersize; 
     84        void *m_buffer; 
     85        bool m_buffer_attached; 
    10286 
     87        int allocateInternalBuffer(); 
     88        void freeInternalBuffer(); 
     89 
     90        // call this when the event size is changed 
     91        void eventSizeChanged(); 
    10392 
    10493    DECLARE_DEBUG_MODULE; 
     
    111100        enum E_DataType { 
    112101                E_Float, 
    113                 E_UInt24 
     102                E_Int24 
    114103        }; 
    115104 
    116         AudioPort(); 
     105        AudioPort(std::string name, int buffsize)  
     106          : Port(name, E_PeriodBuffered, buffsize), 
     107            m_DataType(E_Int24) 
     108        {}; 
     109 
     110        AudioPort(std::string name, enum E_BufferType type, int buffsize)  
     111          : Port(name, type, buffsize), 
     112            m_DataType(E_Int24) 
     113        {}; 
     114        AudioPort(std::string name, enum E_BufferType type, int buffsize, void *externalbuffer)  
     115          : Port(name, type, buffsize, externalbuffer), 
     116            m_DataType(E_Int24) 
     117        {}; 
     118 
     119        AudioPort(std::string name, enum E_DataType datatype, 
     120                  enum E_BufferType type, int buffsize)  
     121          : Port(name, type, buffsize), 
     122            m_DataType(datatype) 
     123        {}; 
     124        AudioPort(std::string name, enum E_DataType datatype,  
     125                  enum E_BufferType type, int buffsize, void *externalbuffer)  
     126          : Port(name, type, buffsize, externalbuffer), 
     127            m_DataType(datatype) 
     128        {}; 
     129 
    117130        virtual ~AudioPort(); 
    118131 
    119132        enum E_DataType getType() {return m_DataType;}; 
     133        unsigned int getEventSize(); 
    120134 
    121135protected: 
     
    133147        }; 
    134148 
    135         MidiPort(); 
     149        MidiPort(std::string name, int buffsize)  
     150          : Port(name, E_PacketBuffered, buffsize),  
     151            m_DataType(E_Byte) 
     152        {}; 
    136153        virtual ~MidiPort(); 
    137154 
    138155        enum E_DataType getType() {return m_DataType;}; 
     156        unsigned int getEventSize(); 
    139157 
    140158protected: 
     
    152170        }; 
    153171 
    154         ControlPort(); 
     172        ControlPort(std::string name, int buffsize)  
     173          : Port(name, E_PeriodBuffered, buffsize), 
     174            m_DataType(E_Default) 
     175        {}; 
    155176        virtual ~ControlPort(); 
    156177 
    157178        enum E_DataType getType() {return m_DataType;}; 
     179        unsigned int getEventSize(); 
    158180 
    159181protected: 
  • branches/libfreebob-2.0/src/libstreaming/PortManager.cpp

    r204 r206  
    2828 
    2929#include "PortManager.h" 
     30#include "Port.h" 
    3031 
    3132namespace FreebobStreaming { 
     
    4647        assert(port); 
    4748 
    48         m_Ports.push_back(port); 
     49        switch(port->getBufferType()) { 
     50        case (Port::E_PacketBuffered): 
     51                debugOutput( DEBUG_LEVEL_VERBOSE, "Adding packet buffered port %s\n",port->getName().c_str()); 
     52                m_PacketPorts.push_back(port); 
     53                break; 
     54        case Port::E_PeriodBuffered: 
     55                debugOutput( DEBUG_LEVEL_VERBOSE, "Adding period buffered port %s\n",port->getName().c_str()); 
     56                m_PeriodPorts.push_back(port); 
     57                break; 
     58/*      case Port::E_SampleBuffered: 
     59                m_SamplePorts.push_back(port); 
     60                break;*/ 
     61        default: 
     62                debugFatal("Unsupported port type!"); 
     63                return -1; 
     64        } 
    4965 
    5066        return 0; 
     
    5571        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    5672        assert(port); 
     73        debugOutput( DEBUG_LEVEL_VERBOSE, "deleting port %s\n",port->getName().c_str()); 
    5774 
    58     for ( PortVectorIterator it = m_Ports.begin(); 
    59           it != m_Ports.end(); 
     75    for ( PortVectorIterator it = m_PacketPorts.begin(); 
     76          it != m_PacketPorts.end(); 
    6077          ++it ) 
    6178    { 
    6279        if ( *it == port ) {  
    63             m_Ports.erase(it); 
     80            m_PacketPorts.erase(it); 
    6481                        return 0; 
    6582        } 
    6683    } 
     84 
     85    for ( PortVectorIterator it = m_PeriodPorts.begin(); 
     86          it != m_PeriodPorts.end(); 
     87          ++it ) 
     88    { 
     89        if ( *it == port ) {  
     90            m_PeriodPorts.erase(it); 
     91                        return 0; 
     92        } 
     93    } 
     94 
     95//     for ( PortVectorIterator it = m_SamplePorts.begin(); 
     96//           it != m_SamplePorts.end(); 
     97//           ++it ) 
     98//     { 
     99//         if ( *it == port ) {  
     100//             m_SamplePorts.erase(it); 
     101//                      return 0; 
     102//         } 
     103//     } 
     104        debugOutput( DEBUG_LEVEL_VERBOSE, " => port not found\n"); 
    67105 
    68106        return -1; //not found 
  • branches/libfreebob-2.0/src/libstreaming/PortManager.h

    r203 r206  
    5050 
    5151protected: 
    52         PortVector m_Ports; 
     52        PortVector m_PacketPorts; 
     53        PortVector m_PeriodPorts; 
     54//      PortVector m_SamplePorts; 
    5355 
    5456    DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessor.cpp

    r203 r206  
    3232 
    3333IMPL_DEBUG_MODULE( StreamProcessor, StreamProcessor, DEBUG_LEVEL_NORMAL ); 
     34IMPL_DEBUG_MODULE( ReceiveStreamProcessor, ReceiveStreamProcessor, DEBUG_LEVEL_NORMAL ); 
     35IMPL_DEBUG_MODULE( TransmitStreamProcessor, TransmitStreamProcessor, DEBUG_LEVEL_NORMAL ); 
    3436 
    35 StreamProcessor::StreamProcessor(enum IsoStream::EStreamType type, int channel)  
    36         : IsoStream(type, channel) { 
     37StreamProcessor::StreamProcessor(enum IsoStream::EStreamType type, int channel, int port)  
     38        : IsoStream(type, channel, port) { 
    3739 
    3840} 
     
    4547                              unsigned char channel, unsigned char tag, unsigned char sy,  
    4648                                  unsigned int cycle, unsigned int dropped) { 
    47         int retval; 
     49 
     50        debugWarning("BUG: received packet in StreamProcessor base class!\n"); 
     51 
     52        return -1; 
     53
     54 
     55int StreamProcessor::getPacket(unsigned char *data, unsigned int *length, 
     56                              unsigned char *tag, unsigned char *sy, 
     57                              int cycle, unsigned int dropped, unsigned int max_length) { 
     58         
     59        debugWarning("BUG: packet requested from StreamProcessor base class!\n"); 
     60 
     61        return -1; 
     62
     63 
     64void StreamProcessor::dumpInfo() 
     65
     66 
     67        debugOutputShort( DEBUG_LEVEL_NORMAL, " StreamProcessor information\n"); 
     68         
     69        ((IsoStream*)this)->dumpInfo(); 
     70}; 
     71 
     72 
     73ReceiveStreamProcessor::ReceiveStreamProcessor(int channel, int port)  
     74        : StreamProcessor(IsoStream::EST_Receive, channel, port) { 
     75 
     76
     77 
     78ReceiveStreamProcessor::~ReceiveStreamProcessor() { 
     79 
     80
     81 
     82int ReceiveStreamProcessor::putPacket(unsigned char *data, unsigned int length,  
     83                              unsigned char channel, unsigned char tag, unsigned char sy,  
     84                                  unsigned int cycle, unsigned int dropped) { 
    4885 
    4986        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
     
    5491} 
    5592 
    56 int StreamProcessor::getPacket(unsigned char *data, unsigned int *length, 
    57                               unsigned char *tag, unsigned char *sy, 
    58                               int cycle, unsigned int dropped, unsigned int max_length) { 
    59         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
    60                      "sending packet: length=%d, cycle=%d\n", 
    61                      *length, cycle ); 
     93void ReceiveStreamProcessor::reset() { 
    6294 
    63         int retval; 
     95        debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting processors...\n"); 
     96         
     97        // reset the boundary counter 
     98        m_framecounter = 0; 
     99 
     100
     101 
     102int ReceiveStreamProcessor::transfer() { 
     103 
     104        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n"); 
     105// TODO: implement 
     106 
     107        return 0; 
     108
     109 
     110 
     111TransmitStreamProcessor::TransmitStreamProcessor(int channel, int port)  
     112        : StreamProcessor(IsoStream::EST_Transmit, channel, port) { 
     113 
     114
     115 
     116TransmitStreamProcessor::~TransmitStreamProcessor() { 
     117 
     118
     119 
     120int TransmitStreamProcessor::getPacket(unsigned char *data, unsigned int *length, 
     121                      unsigned char *tag, unsigned char *sy, 
     122                      int cycle, unsigned int dropped, unsigned int max_length) { 
     123        memcpy(data,&cycle,sizeof(cycle)); 
    64124        *length=sizeof(cycle); 
    65125        *tag = 1; 
     
    69129} 
    70130 
     131void TransmitStreamProcessor::reset() { 
    71132 
     133        debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting processors...\n"); 
     134// TODO: implement 
     135 
     136} 
     137 
     138int TransmitStreamProcessor::transfer() { 
     139 
     140        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n"); 
     141// TODO: implement 
     142 
     143        return 0; 
     144} 
    72145 
    73146 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessor.h

    r203 r206  
    4545        }; 
    4646 
    47         StreamProcessor(enum IsoStream::EStreamType type, int channel); 
     47        StreamProcessor(enum IsoStream::EStreamType type, int channel, int port); 
    4848        virtual ~StreamProcessor(); 
    4949 
     
    5757                      int cycle, unsigned int dropped, unsigned int max_length); 
    5858 
    59         enum EProcessorType getType() { return m_type;}
     59        virtual enum EProcessorType getType() =0
    6060 
    6161        void setPeriodSize(unsigned int period); 
     
    6868        bool xrunOccurred() { return (m_xruns>0);}; 
    6969 
    70         bool periodDone() { return (m_framecounter > m_period); }; 
     70        bool isOnePeriodReady() { return (m_framecounter > m_period); }; 
    7171        unsigned int getNbPeriodsReady() { if(m_period) return m_framecounter/m_period; else return 0;}; 
    7272 
     73        virtual int transfer() =0; // transfer the buffer contents from/to client 
     74 
     75        virtual void reset() =0; // reset the streams & buffers (e.g. after xrun) 
     76 
     77        void dumpInfo(); 
    7378 
    7479protected: 
     
    8085        unsigned int m_framecounter; 
    8186 
    82         enum EProcessorType m_type; 
     87    DECLARE_DEBUG_MODULE; 
     88 
     89 
     90}; 
     91 
     92class ReceiveStreamProcessor : public StreamProcessor { 
     93 
     94public: 
     95        ReceiveStreamProcessor(int channel, int port); 
     96 
     97        virtual ~ReceiveStreamProcessor(); 
     98 
     99 
     100        virtual enum EProcessorType getType() {return E_Receive;}; 
     101 
     102        int putPacket(unsigned char *data, unsigned int length,  
     103                      unsigned char channel, unsigned char tag, unsigned char sy,  
     104                          unsigned int cycle, unsigned int dropped); 
     105 
     106        int transfer(); // transfer the buffer contents from/to client 
     107 
     108        void reset(); // reset the streams & buffers (e.g. after xrun) 
     109 
     110protected: 
     111 
     112    DECLARE_DEBUG_MODULE; 
     113 
     114 
     115}; 
     116 
     117class TransmitStreamProcessor : public StreamProcessor { 
     118 
     119public: 
     120        TransmitStreamProcessor(int channel, int port); 
     121 
     122        virtual ~TransmitStreamProcessor(); 
     123 
     124        virtual enum EProcessorType getType() {return E_Transmit;}; 
     125 
     126        int  
     127                getPacket(unsigned char *data, unsigned int *length, 
     128                      unsigned char *tag, unsigned char *sy, 
     129                      int cycle, unsigned int dropped, unsigned int max_length); 
     130 
     131        int transfer(); // transfer the buffer contents from/to client 
     132 
     133        void reset(); // reset the streams & buffers (e.g. after xrun) 
     134 
     135protected: 
    83136 
    84137    DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.cpp

    r204 r206  
    2929#include "StreamProcessorManager.h" 
    3030#include "StreamProcessor.h" 
     31#include <errno.h> 
    3132 
    3233namespace FreebobStreaming { 
     
    3435IMPL_DEBUG_MODULE( StreamProcessorManager, StreamProcessorManager, DEBUG_LEVEL_NORMAL ); 
    3536 
    36 StreamProcessorManager::StreamProcessorManager(unsigned int period) { 
     37StreamProcessorManager::StreamProcessorManager(unsigned int period, unsigned int nb_buffers) 
     38        : m_nb_buffers(nb_buffers), m_period(period), m_xruns(0) { 
    3739 
    3840} 
     
    4446int StreamProcessorManager::registerProcessor(StreamProcessor *processor) 
    4547{ 
     48        debugOutput( DEBUG_LEVEL_VERBOSE, "Registering processor (%p) with manager\n",processor); 
    4649        assert(processor); 
    4750 
     
    6164int StreamProcessorManager::unregisterProcessor(StreamProcessor *processor) 
    6265{ 
     66        debugOutput( DEBUG_LEVEL_VERBOSE, "Unregistering processor (%p) with manager\n",processor); 
    6367        assert(processor); 
    6468 
     
    9599{ 
    96100        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     101        if(sem_init(&m_period_semaphore, 0, 0)) { 
     102                debugFatal( "Cannot init packet transfer semaphore\n"); 
     103                debugFatal( " Error: %s\n",strerror(errno)); 
     104                return false; 
     105        } else { 
     106                debugOutput( DEBUG_LEVEL_VERBOSE,"FREEBOB: successfull init of packet transfer semaphore\n"); 
     107        } 
    97108        return true; 
    98109} 
    99110 
    100  
    101111bool StreamProcessorManager::Execute() 
    102112{ 
    103113        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
     114 
     115        bool period_ready=true; 
     116        m_xrun_has_occured=false; 
     117 
     118//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
     119        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     120                it != m_ReceiveProcessors.end(); 
     121                ++it ) { 
     122                period_ready = period_ready && (*it)->isOnePeriodReady(); 
     123                m_xrun_has_occured = m_xrun_has_occured || (*it)->xrunOccurred(); 
     124        } 
     125 
     126//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
     127        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     128                it != m_TransmitProcessors.end(); 
     129                ++it ) { 
     130                period_ready = period_ready && (*it)->isOnePeriodReady(); 
     131                m_xrun_has_occured = m_xrun_has_occured || (*it)->xrunOccurred(); 
     132        } 
     133 
     134        if(m_xrun_has_occured) { 
     135                // do xrun signaling/handling 
     136                m_xruns++; 
     137                sem_post(&m_period_semaphore); 
     138                return false; 
     139        } 
     140 
     141        if(period_ready) { 
     142                // signal the waiting thread(s?) that a period is ready 
     143                sem_post(&m_period_semaphore); 
     144        } 
     145 
    104146        return true; 
    105147 
    106148} 
    107149 
     150int StreamProcessorManager::waitForPeriod() { 
     151        int ret; 
     152        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
     153 
     154        // Wait for packetizer thread to signal a period completion 
     155        sem_wait(&m_period_semaphore); 
     156         
     157        if(m_xrun_has_occured) { 
     158                // notify the driver of the underrun 
     159                ret = 0; 
     160        } else { 
     161                ret=m_period; 
     162        } 
     163         
     164        return ret; 
     165 
     166} 
     167 
     168void StreamProcessorManager::reset() { 
     169 
     170        debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting processors...\n"); 
     171 
     172        /*  
     173         * Reset means: 
     174         * Bringing all buffers & connections into a know state 
     175         *   - Clear all capture buffers 
     176         *   - Put nb_periods*period_size of null frames into the playback buffers 
     177         *  => implemented by a reset() call, implementation dependant on the type 
     178         */ 
     179         
     180//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
     181        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     182                it != m_ReceiveProcessors.end(); 
     183                ++it ) { 
     184                (*it)->reset(); 
     185        } 
     186 
     187//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
     188        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     189                it != m_TransmitProcessors.end(); 
     190                ++it ) { 
     191                (*it)->reset(); 
     192        } 
     193} 
     194 
     195int StreamProcessorManager::transfer() { 
     196 
     197        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n"); 
     198 
     199        // a static cast could make sure that there is no performance 
     200        // penalty for the virtual functions (to be checked) 
     201 
     202//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
     203        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     204                it != m_ReceiveProcessors.end(); 
     205                ++it ) {  
     206                (*it)->transfer(); 
     207        } 
     208 
     209//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
     210        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     211                it != m_TransmitProcessors.end(); 
     212                ++it ) { 
     213                (*it)->transfer(); 
     214        } 
     215 
     216        return 0; 
     217} 
     218 
     219void StreamProcessorManager::dumpInfo() { 
     220        debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping StreamProcessorManager information...\n"); 
     221 
     222        debugOutputShort( DEBUG_LEVEL_NORMAL, " Receive processors...\n"); 
     223        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     224                it != m_ReceiveProcessors.end(); 
     225                ++it ) { 
     226                (*it)->dumpInfo(); 
     227        } 
     228 
     229        debugOutputShort( DEBUG_LEVEL_NORMAL, " Transmit processors...\n"); 
     230        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     231                it != m_TransmitProcessors.end(); 
     232                ++it ) { 
     233                (*it)->dumpInfo(); 
     234        } 
     235 
     236} 
     237 
    108238} // end of namespace 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.h

    r203 r206  
    3131#include "../debugmodule/debugmodule.h" 
    3232#include "FreebobThread.h" 
     33#include <semaphore.h> 
    3334 
    3435#include <vector> 
     
    4849public: 
    4950 
    50         StreamProcessorManager(unsigned int period); 
     51        StreamProcessorManager(unsigned int period, unsigned int nb_buffers); 
    5152        virtual ~StreamProcessorManager(); 
    5253 
    5354        int initialize(); // to be called immediately after the construction 
    5455        int prepare(); // to be called after the processors are registered 
     56 
     57        void setVerboseLevel(int l) { setDebugLevel( l ); }; 
     58        void dumpInfo(); 
    5559 
    5660        // this is the setup API 
     
    6771        // the client-side functions 
    6872        bool xrunOccurred(); 
     73        int getXrunCount() {return m_xruns;}; 
     74 
    6975        int waitForPeriod(); // wait for the next period 
     76 
    7077        int transfer(); // transfer the buffer contents from/to client 
    7178 
     
    7986        bool Init(); 
    8087 
    81 protected: 
     88        // thread sync primitives 
     89        sem_t m_period_semaphore; 
     90        // this may only be written by the packet thread, and read by  
     91        // the waiting thread. The packet thread terminates if this is 
     92        // true, therefore it will never by updated again. 
     93        // it can only be set to true before the period semaphore is  
     94        // signalled, which the waiting thread is waiting for. Therefore 
     95        // this variable is protected by the semaphore. 
     96        bool m_xrun_has_occured;  
    8297 
     98        // processor list 
    8399        StreamProcessorVector m_ReceiveProcessors; 
    84100        StreamProcessorVector m_TransmitProcessors; 
     
    86102        unsigned int m_nb_buffers; 
    87103        unsigned int m_period; 
     104        unsigned int m_xruns; 
     105 
    88106 
    89107    DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/tests/streaming/test-isohandling.cpp

    r205 r206  
    7373        rcs->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    7474 
    75         IsoStream *rcs2 = new IsoStream(IsoStream::EST_Receive,1,2); 
    76         if(!rcs2) { 
    77                 printf("Could not create receive IsoStream\n"); 
    78                 return -1; 
    79         } 
    80         rcs2->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     75        StreamProcessor *spt = new TransmitStreamProcessor(3,2); 
     76        if(!spt) { 
     77                printf("Could not create transmit StreamProcessor\n"); 
     78                return -1; 
     79        } 
     80        spt->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     81 
     82        StreamProcessor *spr = new ReceiveStreamProcessor(1,2); 
     83        if(!spr) { 
     84                printf("Could not create receive StreamProcessor\n"); 
     85                return -1; 
     86        } 
     87        spr->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    8188 
    8289        // now we have an xmit stream, attached to an xmit handler 
     
    9097 
    9198        isomanager->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    92          
     99        printf("----------------------\n"); 
    93100        if (isomanager->registerStream(xms)) { 
    94101                printf("Could not register transmit handler with the manager\n"); 
    95102                return -1; 
    96103        } 
     104        printf("----------------------\n"); 
     105 
    97106        if (isomanager->registerStream(rcs)) { 
    98107                printf("Could not register receive handler with the manager\n"); 
    99108                return -1; 
    100109        } 
    101         if (isomanager->registerStream(rcs2)) { 
    102                 printf("Could not register receive handler 2 with the manager\n"); 
    103                 return -1; 
    104         } 
     110        printf("----------------------\n"); 
     111 
     112        if (isomanager->registerStream(spt)) { 
     113                printf("Could not register transmit stream processor with the ISO manager\n"); 
     114                return -1; 
     115        } 
     116        printf("----------------------\n"); 
     117 
     118        if (isomanager->registerStream(spr)) { 
     119                printf("Could not register receive stream processor with the ISO manager\n"); 
     120                return -1; 
     121        } 
     122        printf("----------------------\n"); 
     123 
    105124        // also create a processor as a dummy for the stream runner 
    106125         
    107         StreamProcessorManager *procMan = new StreamProcessorManager(512); 
     126        StreamProcessorManager *procMan = new StreamProcessorManager(512,3); 
    108127        if(!procMan) { 
    109128                printf("Could not create StreamProcessor\n"); 
    110129                return -1; 
    111130        } 
     131        procMan->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     132 
     133        printf("----------------------\n"); 
     134        if (procMan->registerProcessor(spt)) { 
     135                printf("Could not register transmit stream processor with the Processor manager\n"); 
     136                return -1; 
     137        } 
     138        printf("----------------------\n"); 
     139 
     140        if (procMan->registerProcessor(spr)) { 
     141                printf("Could not register receive stream processor with the Processor manager\n"); 
     142                return -1; 
     143        } 
     144        printf("----------------------\n"); 
    112145 
    113146        // now create the runner that does the actual streaming 
     
    122155        // start the runner 
    123156        thread->Start(); 
     157        printf("----------------------\n"); 
    124158 
    125159        if(isomanager->startHandlers()) { 
     
    127161                return -1; 
    128162        } 
     163        printf("----------------------\n"); 
    129164 
    130165        while(run) { 
     166                printf("\n"); 
     167                printf("============================================\n"); 
    131168                isomanager->dumpInfo(); 
     169                printf("--------------------------------------------\n"); 
     170                procMan->dumpInfo(); 
     171                printf("============================================\n"); 
     172                printf("\n"); 
     173 
    132174                sleep(1); 
    133175        } 
     
    139181        isomanager->unregisterStream(xms); 
    140182        isomanager->unregisterStream(rcs); 
    141         isomanager->unregisterStream(rcs2); 
     183        isomanager->unregisterStream(spt); 
     184        isomanager->unregisterStream(spr); 
     185 
     186        procMan->unregisterProcessor(spt); 
     187        procMan->unregisterProcessor(spr); 
    142188 
    143189        delete thread; 
     
    146192        delete isomanager; 
    147193 
    148         delete rcs2; 
    149194        delete rcs; 
    150195        delete xms; 
     196        delete spt; 
     197        delete spr; 
    151198 
    152199        printf("Bye...\n");