Changeset 217

Show
Ignore:
Timestamp:
05/22/06 14:54:50 (16 years ago)
Author:
pieterpalmers
Message:

- implemented receive streaming to MBLA audio ports

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libfreebob-2.0/src/libstreaming/AmdtpPort.h

    r207 r217  
    4848                           enum E_DataType datatype, 
    4949                           enum E_BufferType buffertype,  
    50                            int buffsize, 
     50                           unsigned int buffsize, 
    5151                           int position,  
    5252                           int location,  
    53                            int format,  
     53                           enum E_Formats format,  
    5454                           int type) 
    5555        : AudioPort(name, datatype,     buffertype, buffsize), 
     
    6060                           enum E_DataType datatype, 
    6161                           enum E_BufferType buffertype,  
    62                            int buffsize, 
     62                           unsigned int buffsize, 
    6363                       void *externalbuffer, 
    6464                           int position,  
    6565                           int location,  
    66                            int format,  
     66                           enum E_Formats format,  
    6767                           int type) 
    6868        : AudioPort(name, datatype,     buffertype, buffsize, externalbuffer), 
     
    7070        {}; 
    7171 
    72         virtual ~AmdtpAudioPort()
     72        virtual ~AmdtpAudioPort() {}
    7373 
    7474protected: 
     
    8484 
    8585        AmdtpMidiPort(std::string name,  
    86                            int buffsize, 
     86                           unsigned int buffsize, 
    8787                           int position,  
    8888                           int location,  
    89                            int format,  
     89                           enum E_Formats format,  
    9090                           int type) 
    9191        : MidiPort(name, buffsize), 
     
    9393        {}; 
    9494 
    95         virtual ~AmdtpMidiPort()
     95        virtual ~AmdtpMidiPort() {}
    9696 
    9797protected: 
  • branches/libfreebob-2.0/src/libstreaming/AmdtpPortInfo.h

    r207 r217  
    3737 
    3838public: 
     39        enum E_Formats { 
     40                E_MBLA, 
     41                E_Midi, 
     42                E_SPDIF, 
     43        }; 
     44        enum E_Types { 
    3945 
    40         AmdtpPortInfo(std::string name, int position, int location, int format, int type) 
     46        }; 
     47 
     48        AmdtpPortInfo(std::string name, int position, int location, enum E_Formats format, int type) 
    4149          : m_name(name), m_position(position), m_location(location), m_format(format), m_type(type) 
    4250        {}; 
    4351        virtual ~AmdtpPortInfo() {}; 
    4452 
     53 
    4554        std::string getName() {return m_name;}; 
    4655        int getLocation()     {return m_location;}; 
    47         int getPostition()    {return m_position;}; 
    48         int getFormat()       {return m_format;}; 
     56        int getPosition()     {return m_position;}; 
     57        enum E_Formats getFormat()       {return m_format;}; 
    4958        int getType()         {return m_type;}; 
    5059 
     
    5463    int m_position; 
    5564    int m_location; 
    56     int m_format; 
     65    enum E_Formats m_format; 
    5766    int m_type; 
    5867 
  • branches/libfreebob-2.0/src/libstreaming/AmdtpStreamProcessor.cpp

    r212 r217  
    2828 
    2929#include "AmdtpStreamProcessor.h" 
     30#include "Port.h" 
     31#include "AmdtpPort.h" 
     32 
     33#include <netinet/in.h> 
    3034#include <assert.h> 
    3135 
     
    269273                unsigned int nevents=((length / sizeof (quadlet_t)) - 2)/packet->dbs; 
    270274 
    271                 int write_size=nevents*sizeof(quadlet_t)*m_dimension; 
     275                unsigned int write_size=nevents*sizeof(quadlet_t)*m_dimension; 
    272276                // add the data payload to the ringbuffer 
    273277                 
     
    338342// TODO: implement 
    339343         
    340         int read_size=m_period*sizeof(quadlet_t)*m_dimension; 
     344        unsigned int read_size=m_period*sizeof(quadlet_t)*m_dimension; 
    341345        char *dummybuffer=(char *)calloc(sizeof(quadlet_t),m_period*m_dimension); 
    342346        if (freebob_ringbuffer_read(m_event_buffer,(char *)(dummybuffer),read_size) < read_size) { 
    343347                debugWarning("Could not read from event buffer\n"); 
    344348        } 
     349 
     350        receiveBlock(dummybuffer, m_period, 0, 0); 
     351 
    345352        free(dummybuffer); 
    346353 
    347354 
     355 
    348356        return 0; 
    349357} 
    350358 
     359/*  
     360 * write received events to the stream ringbuffers. 
     361 */ 
     362 
     363int AmdtpReceiveStreamProcessor::receiveBlock(char *data,  
     364                                           unsigned int nevents, unsigned int offset, unsigned int dbc) 
     365{ 
     366        int problem=0; 
     367 
     368        for ( PortVectorIterator it = m_PeriodPorts.begin(); 
     369          it != m_PeriodPorts.end(); 
     370          ++it ) 
     371    { 
     372 
     373                //FIXME: make this into a static_cast when not DEBUG? 
     374 
     375                AmdtpPortInfo *pinfo=dynamic_cast<AmdtpPortInfo *>(*it); 
     376                assert(pinfo); // this should not fail!! 
     377 
     378                switch(pinfo->getFormat()) { 
     379                case AmdtpPortInfo::E_MBLA: 
     380                        if(decodeMBLAEventsToPort(static_cast<AmdtpAudioPort *>(*it), (quadlet_t *)data, offset, nevents, dbc)) { 
     381                                debugWarning("Could not decode packet MBLA to port %s",(*it)->getName().c_str()); 
     382                                problem=1; 
     383                        } 
     384                        break; 
     385                case AmdtpPortInfo::E_SPDIF: // still unimplemented 
     386                        break; 
     387        /* for this processor, midi is a packet based port  
     388                case AmdtpPortInfo::E_Midi: 
     389                        break;*/ 
     390                default: // ignore 
     391                        break; 
     392                } 
     393    } 
     394        return problem; 
     395 
     396} 
     397 
     398int AmdtpReceiveStreamProcessor::decodeMBLAEventsToPort(AmdtpAudioPort *p, quadlet_t *data,  
     399                                           unsigned int offset, unsigned int nevents, unsigned int dbc) 
     400{ 
     401        unsigned int j=0; 
     402         
     403        quadlet_t *target_event; 
     404 
     405        target_event=(quadlet_t *)(data + p->getPosition()); 
     406 
     407        switch(p->getDataType()) { 
     408                default: 
     409                case Port::E_Int24: 
     410                        { 
     411                                quadlet_t *buffer=(quadlet_t *)(p->getBufferAddress()); 
     412 
     413                                assert(nevents + offset <= p->getBufferSize()); 
     414 
     415                                buffer+=offset; 
     416 
     417                                for(j = 0; j < nevents; j += 1) { // decode max nsamples 
     418                                        *(buffer)=(ntohl((*target_event) ) & 0x00FFFFFF); 
     419                                        buffer++; 
     420                                        target_event+=m_dimension; 
     421                                } 
     422                        } 
     423                        break; 
     424                case Port::E_Float: 
     425                        { 
     426                                const float multiplier = 1.0f / (float)(0x7FFFFF); 
     427                                float *buffer=(float *)(p->getBufferAddress()); 
     428 
     429                                assert(nevents + offset <= p->getBufferSize()); 
     430 
     431                                buffer+=offset; 
     432 
     433                                for(j = 0; j < nevents; j += 1) { // decode max nsamples                 
     434         
     435                                        unsigned int v = ntohl(*target_event) & 0x00FFFFFF; 
     436                                        // sign-extend highest bit of 24-bit int 
     437                                        int tmp = (int)(v << 8) / 256; 
     438                 
     439                                        *buffer = tmp * multiplier; 
     440                                 
     441                                        buffer++; 
     442                                        target_event+=m_dimension; 
     443                                } 
     444                        } 
     445                        break; 
     446        } 
     447 
     448        return 0; 
     449} 
    351450 
    352451} // end of namespace FreebobStreaming 
  • branches/libfreebob-2.0/src/libstreaming/AmdtpStreamProcessor.h

    r207 r217  
    4141namespace FreebobStreaming { 
    4242 
     43class Port; 
     44class AmdtpAudioPort; 
     45class AmdtpMidiPort; 
     46 
    4347class AmdtpTransmitStreamProcessor  
    4448        : public TransmitStreamProcessor 
     
    6367 
    6468protected: 
     69 
    6570        struct iec61883_cip m_cip_status; 
    6671 
     
    97102protected: 
    98103 
     104        int receiveBlock(char *data, unsigned int nevents, unsigned int offset, unsigned int dbc); 
     105        int decodeMBLAEventsToPort(AmdtpAudioPort *, quadlet_t *data, unsigned int offset, unsigned int nevents, unsigned int dbc); 
     106 
    99107        freebob_ringbuffer_t * m_event_buffer; 
    100108        char* m_cluster_buffer; 
  • branches/libfreebob-2.0/src/libstreaming/Port.cpp

    r210 r217  
    3939IMPL_DEBUG_MODULE( ControlPort, ControlPort, DEBUG_LEVEL_NORMAL ); 
    4040 
    41 Port::Port(std::string name, enum E_BufferType type, int buffsize)  
     41Port::Port(std::string name, enum E_BufferType type, unsigned int buffsize, enum E_DataType datatype)  
    4242  : m_Name(name), 
    4343    m_BufferType(type), 
    4444    m_enabled(true), 
    4545    m_buffersize(buffsize), 
     46        m_datatype(datatype), 
    4647        m_buffer(0), 
    4748    m_buffer_attached(false) 
     
    5152} 
    5253 
    53 Port::Port(std::string name, enum E_BufferType type, int buffsize, void* externalbuffer)  
     54Port::Port(std::string name, enum E_BufferType type, unsigned int buffsize, 
     55           enum E_DataType datatype, void* externalbuffer)  
    5456  : m_Name(name), 
    5557    m_BufferType(type), 
    5658    m_enabled(true), 
    5759    m_buffersize(buffsize), 
     60        m_datatype(datatype), 
    5861        m_buffer(externalbuffer), 
    5962    m_buffer_attached(true) 
     
    126129} 
    127130 
    128 unsigned int AudioPort::getEventSize() { 
    129         switch (m_DataType) { 
     131unsigned int Port::getEventSize() { 
     132        switch (m_datatype) { 
    130133                case E_Float: 
    131134                        return sizeof(float); 
    132135                case E_Int24: // 24 bit 2's complement, packed in a 32bit integer (LSB's) 
    133136                        return sizeof(uint32_t); 
    134                 default: 
    135                         return 0; 
    136         } 
    137 } 
    138  
    139 unsigned int MidiPort::getEventSize() { 
    140         switch (m_DataType) { 
    141137                case E_Byte: 
    142138                        return sizeof(char); 
     
    146142} 
    147143 
    148 unsigned int ControlPort::getEventSize() { 
    149         switch (m_DataType) { 
    150                 case E_Default: 
    151                         return sizeof(uint32_t); 
    152                 default: 
    153                         return 0; 
    154         } 
    155144} 
    156  
    157 } 
  • branches/libfreebob-2.0/src/libstreaming/Port.h

    r206 r217  
    4545        }; 
    4646 
    47         Port(std::string name, enum E_BufferType type, int buffsize); 
    48         Port(std::string name, enum E_BufferType type, int buffsize, void *externalbuffer); 
     47        enum E_DataType { 
     48                E_Float, 
     49                E_Int24, 
     50                E_Byte, 
     51                E_Default, 
     52        }; 
     53 
     54        Port(std::string name, enum E_BufferType type, unsigned int buffsize, enum E_DataType datatype); 
     55        Port(std::string name, enum E_BufferType type, unsigned int buffsize,  
     56             enum E_DataType datatype, void *externalbuffer); 
    4957 
    5058        virtual ~Port()  
     
    6169 
    6270        // returns the size in bytes of the events in the port buffer 
    63         virtual unsigned int getEventSize() = 0; 
     71        unsigned int getEventSize(); 
     72 
     73        enum E_DataType getDataType() {return m_datatype;}; 
    6474 
    6575        // NOT THREAD SAFE! 
     
    7282        int detachBuffer(); 
    7383 
    74         int getBufferSize() {return m_buffersize;}; 
     84        unsigned int getBufferSize() {return m_buffersize;}; 
    7585        void *getBuffer() {return m_buffer;}; 
     86 
     87        void setBufferOffset(unsigned int n); 
     88        // FIXME: this is not really OO, but for performance??? 
     89        void *getBufferAddress() {return m_buffer;}; 
    7690 
    7791protected: 
     
    8195 
    8296        bool m_enabled; 
    83         int m_buffersize; 
     97        unsigned int m_buffersize; 
     98 
     99        enum E_DataType m_datatype; 
     100 
    84101        void *m_buffer; 
    85102        bool m_buffer_attached; 
     
    98115 
    99116public: 
    100         enum E_DataType { 
    101                 E_Float, 
    102                 E_Int24 
    103         }; 
    104117 
    105         AudioPort(std::string name, int buffsize)  
    106           : Port(name, E_PeriodBuffered, buffsize), 
    107             m_DataType(E_Int24) 
     118        AudioPort(std::string name, unsigned int buffsize)  
     119          : Port(name, E_PeriodBuffered, buffsize, E_Int24) 
    108120        {}; 
    109121 
    110         AudioPort(std::string name, enum E_BufferType type, int buffsize)  
    111           : Port(name, type, buffsize), 
    112             m_DataType(E_Int24) 
     122        AudioPort(std::string name, enum E_BufferType type, unsigned int buffsize)  
     123          : Port(name, type, buffsize, E_Int24) 
    113124        {}; 
    114         AudioPort(std::string name, enum E_BufferType type, int buffsize, void *externalbuffer)  
    115           : Port(name, type, buffsize, externalbuffer), 
    116             m_DataType(E_Int24) 
     125        AudioPort(std::string name, enum E_BufferType type, unsigned int buffsize, void *externalbuffer)  
     126          : Port(name, type, buffsize, E_Int24, externalbuffer) 
    117127        {}; 
    118128 
    119129        AudioPort(std::string name, enum E_DataType datatype, 
    120                   enum E_BufferType type, int buffsize)  
    121           : Port(name, type, buffsize), 
    122             m_DataType(datatype) 
     130                  enum E_BufferType type, unsigned int buffsize)  
     131          : Port(name, type, buffsize, datatype) 
    123132        {}; 
    124133        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) 
     134                  enum E_BufferType type, unsigned int buffsize, void *externalbuffer)  
     135          : Port(name, type, buffsize, datatype, externalbuffer) 
    128136        {}; 
    129137 
    130         virtual ~AudioPort()
     138        virtual ~AudioPort() {}
    131139 
    132         enum E_DataType getType() {return m_DataType;}; 
    133         unsigned int getEventSize(); 
    134140 
    135141protected: 
     
    143149 
    144150public: 
    145         enum E_DataType { 
    146                 E_Byte 
    147         }; 
    148151 
    149         MidiPort(std::string name, int buffsize)  
    150           : Port(name, E_PacketBuffered, buffsize),  
    151             m_DataType(E_Byte) 
     152        MidiPort(std::string name, unsigned int buffsize)  
     153          : Port(name, E_PacketBuffered, buffsize, E_Byte) 
    152154        {}; 
    153         virtual ~MidiPort()
     155        virtual ~MidiPort() {}
    154156 
    155         enum E_DataType getType() {return m_DataType;}; 
    156         unsigned int getEventSize(); 
    157157 
    158158protected: 
     
    166166 
    167167public: 
    168         enum E_DataType { 
    169                 E_Default 
    170         }; 
    171168 
    172         ControlPort(std::string name, int buffsize)  
    173           : Port(name, E_PeriodBuffered, buffsize), 
    174             m_DataType(E_Default) 
     169        ControlPort(std::string name, unsigned int buffsize)  
     170          : Port(name, E_PeriodBuffered, buffsize, E_Int24) 
    175171        {}; 
    176         virtual ~ControlPort()
     172        virtual ~ControlPort() {}
    177173 
    178         enum E_DataType getType() {return m_DataType;}; 
    179         unsigned int getEventSize(); 
    180174 
    181175protected: 
    182         enum E_DataType m_DataType; 
    183176 
    184177    DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/tests/streaming/test-isohandling.cpp

    r212 r217  
    2929#include "debugmodule/debugmodule.h" 
    3030 
     31#include <netinet/in.h> 
     32 
    3133#include "IsoHandler.h" 
    3234#include "IsoStream.h" 
     
    3638#include "StreamRunner.h" 
    3739#include "FreebobPosixThread.h" 
     40#include "AmdtpPort.h" 
    3841 
    3942using namespace FreebobStreaming; 
     43 
    4044 
    4145int run; 
     
    146150        printf("----------------------\n"); 
    147151 
     152        AmdtpAudioPort *p1=new AmdtpAudioPort( 
     153                           std::string("Test port 1"),  
     154                           AmdtpAudioPort::E_Int24, 
     155                           AmdtpAudioPort::E_PeriodBuffered,  
     156                           512, 
     157                           1,  
     158                           0,  
     159                           AmdtpPortInfo::E_MBLA,  
     160                           0 
     161                ); 
     162        if (!p1) { 
     163                printf("Could not create port 1\n"); 
     164                return -1; 
     165        } 
     166 
     167        printf("----------------------\n"); 
     168 
     169        if (spr2->addPort(p1)) { 
     170                printf("Could not register port with receive stream processor\n"); 
     171                return -1; 
     172        } 
     173         
    148174        // now create the runner that does the actual streaming 
    149175        StreamRunner *runner = new StreamRunner(isomanager,procMan); 
     
    175201                        printf("--------------------------------------------\n"); 
    176202                        procMan->dumpInfo(); 
     203                        printf("--------------------------------------------\n"); 
     204                        hexDumpQuadlets((quadlet_t*)(p1->getBufferAddress()),10); 
    177205                        printf("============================================\n"); 
    178206                        printf("\n"); 
     
    188216        isomanager->stopHandlers(); 
    189217 
     218        spr->deletePort(p1); 
     219 
    190220//      isomanager->unregisterStream(spt); 
    191221        isomanager->unregisterStream(spr); 
     
    198228        delete thread; 
    199229        delete runner; 
     230 
     231        delete p1; 
     232 
    200233        delete procMan; 
    201234        delete isomanager;