Changeset 419

Show
Ignore:
Timestamp:
02/25/07 04:28:00 (14 years ago)
Author:
pieterpalmers
Message:

namespace simplification

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/streaming-rework/src/bebob/bebob_avdevice.cpp

    r418 r419  
    8080    debugOutput( DEBUG_LEVEL_VERBOSE, "Created BeBoB::AvDevice (NodeID %d)\n", 
    8181                 nodeId ); 
    82     addOption(FreebobUtil::OptionContainer::Option("snoopMode",false)); 
    83     addOption(FreebobUtil::OptionContainer::Option("id",std::string("dev?"))); 
     82    addOption(Util::OptionContainer::Option("snoopMode",false)); 
     83    addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    8484} 
    8585 
     
    9393    , m_nodeId ( -1 ) 
    9494{ 
    95     addOption(FreebobUtil::OptionContainer::Option("snoopMode",false)); 
    96     addOption(FreebobUtil::OptionContainer::Option("id",std::string("dev?"))); 
     95    addOption(Util::OptionContainer::Option("snoopMode",false)); 
     96    addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    9797} 
    9898 
     
    990990     
    991991    // create & add streamprocessors 
    992     FreebobStreaming::StreamProcessor *p; 
     992    Streaming::StreamProcessor *p; 
    993993     
    994     p=new FreebobStreaming::AmdtpReceiveStreamProcessor( 
     994    p=new Streaming::AmdtpReceiveStreamProcessor( 
    995995                             m_p1394Service->getPort(), 
    996996                             samplerate, 
     
    10041004 
    10051005    if (!addPlugToProcessor(*outputPlug,p, 
    1006         FreebobStreaming::Port::E_Capture)) { 
     1006        Streaming::Port::E_Capture)) { 
    10071007        debugFatal("Could not add plug to processor!\n"); 
    10081008        delete p; 
     
    10151015    if (snoopMode) { 
    10161016        // we are snooping, so this is receive too. 
    1017         p=new FreebobStreaming::AmdtpReceiveStreamProcessor( 
     1017        p=new Streaming::AmdtpReceiveStreamProcessor( 
    10181018                                  m_p1394Service->getPort(), 
    10191019                                  samplerate, 
    10201020                                  inputPlug->getNrOfChannels()); 
    10211021    } else { 
    1022         p=new FreebobStreaming::AmdtpTransmitStreamProcessor( 
     1022        p=new Streaming::AmdtpTransmitStreamProcessor( 
    10231023                                m_p1394Service->getPort(), 
    10241024                                samplerate, 
     
    10351035    if (snoopMode) { 
    10361036        if (!addPlugToProcessor(*inputPlug,p, 
    1037             FreebobStreaming::Port::E_Capture)) { 
     1037            Streaming::Port::E_Capture)) { 
    10381038            debugFatal("Could not add plug to processor!\n"); 
    10391039            return false; 
     
    10421042    } else { 
    10431043        if (!addPlugToProcessor(*inputPlug,p, 
    1044             FreebobStreaming::Port::E_Playback)) { 
     1044            Streaming::Port::E_Playback)) { 
    10451045            debugFatal("Could not add plug to processor!\n"); 
    10461046            return false; 
     
    10551055AvDevice::addPlugToProcessor( 
    10561056    AvPlug& plug, 
    1057     FreebobStreaming::StreamProcessor *processor, 
    1058     FreebobStreaming::AmdtpAudioPort::E_Direction direction) { 
     1057    Streaming::StreamProcessor *processor, 
     1058    Streaming::AmdtpAudioPort::E_Direction direction) { 
    10591059     
    10601060    std::string id=std::string("dev?"); 
     
    10801080            portname << id << "_" << channelInfo->m_name; 
    10811081 
    1082             FreebobStreaming::Port *p=NULL; 
     1082            Streaming::Port *p=NULL; 
    10831083            switch(clusterInfo->m_portType) { 
    10841084            case ExtendedPlugInfoClusterInfoSpecificData::ePT_Speaker: 
     
    10871087            case ExtendedPlugInfoClusterInfoSpecificData::ePT_Line: 
    10881088            case ExtendedPlugInfoClusterInfoSpecificData::ePT_Analog: 
    1089                 p=new FreebobStreaming::AmdtpAudioPort( 
     1089                p=new Streaming::AmdtpAudioPort( 
    10901090                        portname.str(), 
    10911091                        direction, 
     
    10951095                        channelInfo->m_streamPosition - 1, 
    10961096                        channelInfo->m_location, 
    1097                         FreebobStreaming::AmdtpPortInfo::E_MBLA 
     1097                        Streaming::AmdtpPortInfo::E_MBLA 
    10981098                ); 
    10991099                break; 
    11001100 
    11011101            case ExtendedPlugInfoClusterInfoSpecificData::ePT_MIDI: 
    1102                 p=new FreebobStreaming::AmdtpMidiPort( 
     1102                p=new Streaming::AmdtpMidiPort( 
    11031103                        portname.str(), 
    11041104                        direction, 
     
    11081108                        channelInfo->m_streamPosition - 1, 
    11091109                        channelInfo->m_location, 
    1110                         FreebobStreaming::AmdtpPortInfo::E_Midi 
     1110                        Streaming::AmdtpPortInfo::E_Midi 
    11111111                ); 
    11121112 
     
    11421142} 
    11431143 
    1144 FreebobStreaming::StreamProcessor * 
     1144Streaming::StreamProcessor * 
    11451145AvDevice::getStreamProcessorByIndex(int i) { 
    11461146 
     
    11601160    if (i<(int)m_receiveProcessors.size()) { 
    11611161        int n=i; 
    1162         FreebobStreaming::StreamProcessor *p=m_receiveProcessors.at(n); 
     1162        Streaming::StreamProcessor *p=m_receiveProcessors.at(n); 
    11631163         
    11641164        iso_channel=m_p1394Service->allocateIsoChannelCMP( 
     
    11761176    } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) { 
    11771177        int n=i-m_receiveProcessors.size(); 
    1178         FreebobStreaming::StreamProcessor *p=m_transmitProcessors.at(n); 
     1178        Streaming::StreamProcessor *p=m_transmitProcessors.at(n); 
    11791179         
    11801180        iso_channel=m_p1394Service->allocateIsoChannelCMP( 
     
    11991199   if (i<(int)m_receiveProcessors.size()) { 
    12001200        int n=i; 
    1201         FreebobStreaming::StreamProcessor *p=m_receiveProcessors.at(n); 
     1201        Streaming::StreamProcessor *p=m_receiveProcessors.at(n); 
    12021202 
    12031203        // deallocate ISO channel 
     
    12121212    } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) { 
    12131213        int n=i-m_receiveProcessors.size(); 
    1214         FreebobStreaming::StreamProcessor *p=m_transmitProcessors.at(n); 
     1214        Streaming::StreamProcessor *p=m_transmitProcessors.at(n); 
    12151215         
    12161216        // deallocate ISO channel 
  • branches/streaming-rework/src/bebob/bebob_avdevice.h

    r416 r419  
    7171 
    7272    virtual int getStreamCount(); 
    73     virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     73    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    7474 
    7575    virtual bool prepare(); 
     
    149149                 AvPlug::EAvPlugType type); 
    150150 
    151     bool addPlugToProcessor( AvPlug& plug, FreebobStreaming::StreamProcessor *processor, 
    152                              FreebobStreaming::AmdtpAudioPort::E_Direction direction); 
     151    bool addPlugToProcessor( AvPlug& plug, Streaming::StreamProcessor *processor, 
     152                             Streaming::AmdtpAudioPort::E_Direction direction); 
    153153 
    154154    bool setSamplingFrequencyPlug( AvPlug& plug, 
     
    184184 
    185185    // streaming stuff 
    186     typedef std::vector< FreebobStreaming::StreamProcessor * > StreamProcessorVector; 
     186    typedef std::vector< Streaming::StreamProcessor * > StreamProcessorVector; 
    187187    StreamProcessorVector m_receiveProcessors; 
    188188    StreamProcessorVector m_transmitProcessors; 
  • branches/streaming-rework/src/bounce/bounce_avdevice.cpp

    r416 r419  
    6767    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Bounce::BounceDevice (NodeID %d)\n", 
    6868                 nodeId ); 
    69     addOption(FreebobUtil::OptionContainer::Option("snoopMode",false)); 
    70     addOption(FreebobUtil::OptionContainer::Option("id",std::string("dev?"))); 
     69    addOption(Util::OptionContainer::Option("snoopMode",false)); 
     70    addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    7171} 
    7272 
     
    228228bool 
    229229BounceDevice::addPortsToProcessor( 
    230     FreebobStreaming::StreamProcessor *processor, 
    231     FreebobStreaming::Port::E_Direction direction) { 
     230    Streaming::StreamProcessor *processor, 
     231    Streaming::Port::E_Direction direction) { 
    232232 
    233233    debugOutput(DEBUG_LEVEL_VERBOSE,"Adding ports to processor\n"); 
     
    241241    for (i=0;i<BOUNCE_NR_OF_CHANNELS;i++) { 
    242242        char *buff; 
    243         asprintf(&buff,"%s%s_Port%d",id.c_str(),direction==FreebobStreaming::AmdtpAudioPort::E_Playback?"p":"c",i); 
    244  
    245         FreebobStreaming::Port *p=NULL; 
    246         p=new FreebobStreaming::AmdtpAudioPort( 
     243        asprintf(&buff,"%s%s_Port%d",id.c_str(),direction==Streaming::AmdtpAudioPort::E_Playback?"p":"c",i); 
     244 
     245        Streaming::Port *p=NULL; 
     246        p=new Streaming::AmdtpAudioPort( 
    247247                buff, 
    248248                direction, 
     
    252252                i, 
    253253                0, 
    254                 FreebobStreaming::AmdtpPortInfo::E_MBLA 
     254                Streaming::AmdtpPortInfo::E_MBLA 
    255255        ); 
    256256 
     
    285285 
    286286    // create & add streamprocessors 
    287     FreebobStreaming::StreamProcessor *p; 
    288      
    289     p=new FreebobStreaming::AmdtpReceiveStreamProcessor( 
     287    Streaming::StreamProcessor *p; 
     288     
     289    p=new Streaming::AmdtpReceiveStreamProcessor( 
    290290                             m_p1394Service->getPort(), 
    291291                             m_samplerate, 
     
    299299 
    300300    if (!addPortsToProcessor(p, 
    301             FreebobStreaming::Port::E_Capture)) { 
     301            Streaming::Port::E_Capture)) { 
    302302        debugFatal("Could not add plug to processor!\n"); 
    303303        delete p; 
     
    310310    if (snoopMode) { 
    311311        // we are snooping, so this is receive too. 
    312         p=new FreebobStreaming::AmdtpReceiveStreamProcessor( 
     312        p=new Streaming::AmdtpReceiveStreamProcessor( 
    313313                                  m_p1394Service->getPort(), 
    314314                                  m_samplerate, 
    315315                                  BOUNCE_NR_OF_CHANNELS); 
    316316    } else { 
    317         p=new FreebobStreaming::AmdtpTransmitStreamProcessor( 
     317        p=new Streaming::AmdtpTransmitStreamProcessor( 
    318318                                m_p1394Service->getPort(), 
    319319                                m_samplerate, 
     
    330330    if (snoopMode) { 
    331331        if (!addPortsToProcessor(p, 
    332             FreebobStreaming::Port::E_Capture)) { 
     332            Streaming::Port::E_Capture)) { 
    333333            debugFatal("Could not add plug to processor!\n"); 
    334334            delete p; 
     
    338338    } else { 
    339339        if (!addPortsToProcessor(p, 
    340             FreebobStreaming::Port::E_Playback)) { 
     340            Streaming::Port::E_Playback)) { 
    341341            debugFatal("Could not add plug to processor!\n"); 
    342342            delete p; 
     
    354354} 
    355355 
    356 FreebobStreaming::StreamProcessor * 
     356Streaming::StreamProcessor * 
    357357BounceDevice::getStreamProcessorByIndex(int i) { 
    358358    if (i<(int)m_receiveProcessors.size()) { 
     
    369369    if (i<(int)m_receiveProcessors.size()) { 
    370370        int n=i; 
    371         FreebobStreaming::StreamProcessor *p=m_receiveProcessors.at(n); 
     371        Streaming::StreamProcessor *p=m_receiveProcessors.at(n); 
    372372         
    373373        // allocate ISO channel 
     
    407407    } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) { 
    408408        int n=i-m_receiveProcessors.size(); 
    409         FreebobStreaming::StreamProcessor *p=m_transmitProcessors.at(n); 
     409        Streaming::StreamProcessor *p=m_transmitProcessors.at(n); 
    410410         
    411411        // allocate ISO channel 
  • branches/streaming-rework/src/bounce/bounce_avdevice.h

    r416 r419  
    8383        virtual int getStreamCount(); 
    8484         
    85         virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     85        virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    8686         
    8787    bool startStreamByIndex(int i); 
     
    104104 
    105105    // streaming stuff 
    106     typedef std::vector< FreebobStreaming::StreamProcessor * > StreamProcessorVector; 
     106    typedef std::vector< Streaming::StreamProcessor * > StreamProcessorVector; 
    107107    StreamProcessorVector m_receiveProcessors; 
    108108    StreamProcessorVector m_transmitProcessors; 
    109109 
    110110    bool addPortsToProcessor( 
    111        FreebobStreaming::StreamProcessor *processor,  
    112        FreebobStreaming::Port::E_Direction direction); 
     111       Streaming::StreamProcessor *processor,  
     112       Streaming::Port::E_Direction direction); 
    113113 
    114114    DECLARE_DEBUG_MODULE; 
  • branches/streaming-rework/src/devicemanager.cpp

    r413 r419  
    297297 * @return StreamProcessor that is sync source 
    298298 */ 
    299 FreebobStreaming::StreamProcessor * 
     299Streaming::StreamProcessor * 
    300300DeviceManager::getSyncSource() { 
    301301    IAvDevice* device = getAvDeviceByIndex(0); 
  • branches/streaming-rework/src/devicemanager.h

    r407 r419  
    3232class Ieee1394Service; 
    3333class IAvDevice; 
    34 namespace FreebobStreaming { 
     34namespace Streaming { 
    3535    class StreamProcessor; 
    3636} 
     
    6565    bool loadCache( Glib::ustring fileName ); 
    6666 
    67     FreebobStreaming::StreamProcessor *getSyncSource(); 
     67    Streaming::StreamProcessor *getSyncSource(); 
    6868 
    6969protected: 
  • branches/streaming-rework/src/dice/dice_avdevice.cpp

    r415 r419  
    176176} 
    177177 
    178 FreebobStreaming::StreamProcessor * 
     178Streaming::StreamProcessor * 
    179179DiceAvDevice::getStreamProcessorByIndex(int i) { 
    180180 
  • branches/streaming-rework/src/dice/dice_avdevice.h

    r415 r419  
    6565 
    6666    int getStreamCount(); 
    67     FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     67    Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    6868 
    6969    bool prepare(); 
     
    8989    signed int m_iso_recv_channel, m_iso_send_channel; 
    9090     
    91         FreebobStreaming::AmdtpReceiveStreamProcessor *m_receiveProcessor; 
    92         FreebobStreaming::AmdtpTransmitStreamProcessor *m_transmitProcessor; 
     91        Streaming::AmdtpReceiveStreamProcessor *m_receiveProcessor; 
     92        Streaming::AmdtpTransmitStreamProcessor *m_transmitProcessor; 
    9393 
    9494private: 
  • branches/streaming-rework/src/freebob_streaming.cpp

    r415 r419  
    5050DECLARE_GLOBAL_DEBUG_MODULE; 
    5151 
    52 using namespace FreebobStreaming; 
     52using namespace Streaming; 
    5353 
    5454struct _freebob_device 
  • branches/streaming-rework/src/iavdevice.h

    r416 r419  
    2929class Ieee1394Service; 
    3030 
    31 namespace FreebobStreaming { 
     31namespace Streaming { 
    3232    class StreamProcessor; 
    3333} 
     
    3939 
    4040*/ 
    41 class IAvDevice : public FreebobUtil::OptionContainer { 
     41class IAvDevice : public Util::OptionContainer { 
    4242public: 
    4343        virtual ~IAvDevice() {} 
     
    188188         * @return a StreamProcessor object if successful, NULL otherwise 
    189189         */ 
    190         virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i) = 0; 
     190        virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i) = 0; 
    191191         
    192192        /**  
  • branches/streaming-rework/src/libstreaming/AmdtpPort.cpp

    r407 r419  
    2929#include <assert.h> 
    3030 
    31 namespace FreebobStreaming { 
     31namespace Streaming { 
    3232 
    33 } // end of namespace FreebobStreaming 
     33} // end of namespace Streaming 
  • branches/streaming-rework/src/libstreaming/AmdtpPort.h

    r415 r419  
    3737#include "AmdtpPortInfo.h" 
    3838 
    39 namespace FreebobStreaming { 
     39namespace Streaming { 
    4040 
    4141/*! 
     
    9494}; 
    9595 
    96 } // end of namespace FreebobStreaming 
     96} // end of namespace Streaming 
    9797 
    9898#endif /* __FREEBOB_AMDTPPORT__ */ 
  • branches/streaming-rework/src/libstreaming/AmdtpPortInfo.cpp

    r407 r419  
    3030 
    3131 
    32 namespace FreebobStreaming { 
     32namespace Streaming { 
    3333 
    3434 
    35 } // end of namespace FreebobStreaming 
     35} // end of namespace Streaming 
  • branches/streaming-rework/src/libstreaming/AmdtpPortInfo.h

    r415 r419  
    3232#include <string> 
    3333 
    34 namespace FreebobStreaming { 
     34namespace Streaming { 
    3535/*! 
    3636\brief Class containing the stream information for an AMDTP channel 
     
    7878}; 
    7979 
    80 } // end of namespace FreebobStreaming 
     80} // end of namespace Streaming 
    8181 
    8282#endif /* __FREEBOB_AMDTPPORTINFO__ */ 
  • branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp

    r411 r419  
    4040#define TRANSMIT_ADVANCE_CYCLES 1U 
    4141 
    42 namespace FreebobStreaming { 
     42namespace Streaming { 
    4343 
    4444IMPL_DEBUG_MODULE( AmdtpTransmitStreamProcessor, AmdtpTransmitStreamProcessor, DEBUG_LEVEL_NORMAL ); 
     
    14011401} 
    14021402 
    1403 } // end of namespace FreebobStreaming 
     1403} // end of namespace Streaming 
  • branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.h

    r415 r419  
    5555#define IEC61883_AM824_LABEL_MIDI_3X            0x83 
    5656 
    57 namespace FreebobStreaming { 
     57namespace Streaming { 
    5858 
    5959class Port; 
     
    229229 
    230230 
    231 } // end of namespace FreebobStreaming 
     231} // end of namespace Streaming 
    232232 
    233233#endif /* __FREEBOB_AMDTPSTREAMPROCESSOR__ */ 
  • branches/streaming-rework/src/libstreaming/IsoHandler.cpp

    r398 r419  
    5151 
    5252 
    53 namespace FreebobStreaming 
     53namespace Streaming 
    5454{ 
    5555 
  • branches/streaming-rework/src/libstreaming/IsoHandler.h

    r398 r419  
    3535 
    3636enum raw1394_iso_disposition ; 
    37 namespace FreebobStreaming 
     37namespace Streaming 
    3838{ 
    3939 
  • branches/streaming-rework/src/libstreaming/IsoHandlerManager.cpp

    r398 r419  
    3838#define PACKETS_PER_INTERRUPT          4U 
    3939 
    40 namespace FreebobStreaming 
     40namespace Streaming 
    4141{ 
    4242 
     
    7272    if (prio>98) prio=98; 
    7373 
    74     m_isoManagerThread=new FreebobUtil::PosixThread( 
     74    m_isoManagerThread=new Util::PosixThread( 
    7575        this,  
    7676        m_realtime, prio, 
     
    723723} 
    724724 
    725 } // end of namespace FreebobStreaming 
    726  
     725} // end of namespace Streaming 
     726 
  • branches/streaming-rework/src/libstreaming/IsoHandlerManager.h

    r398 r419  
    4040#define USLEEP_AFTER_UPDATE 100 
    4141#define MAX_UPDATE_TRIES 10 
    42 namespace FreebobUtil { 
     42namespace Util { 
    4343    class PosixThread; 
    4444} 
    4545 
    46 namespace FreebobStreaming 
     46namespace Streaming 
    4747{ 
    4848 
     
    6969*/ 
    7070 
    71 class IsoHandlerManager : public FreebobUtil::RunnableInterface 
     71class IsoHandlerManager : public Util::RunnableInterface 
    7272{ 
    7373    friend class StreamProcessorManager; 
     
    151151        bool m_realtime; 
    152152        unsigned int m_priority; 
    153         FreebobUtil::PosixThread *m_isoManagerThread; 
     153        Util::PosixThread *m_isoManagerThread; 
    154154         
    155155         
  • branches/streaming-rework/src/libstreaming/IsoStream.cpp

    r395 r419  
    3030#include <assert.h> 
    3131 
    32 namespace FreebobStreaming 
     32namespace Streaming 
    3333{ 
    3434 
  • branches/streaming-rework/src/libstreaming/IsoStream.h

    r390 r419  
    3333#include "IsoHandler.h" 
    3434 
    35 namespace FreebobStreaming 
     35namespace Streaming 
    3636{ 
    3737 
  • branches/streaming-rework/src/libstreaming/MotuPort.cpp

    r407 r419  
    3030#include <assert.h> 
    3131 
    32 namespace FreebobStreaming { 
     32namespace Streaming { 
    3333 
    34 } // end of namespace FreebobStreaming 
     34} // end of namespace Streaming 
  • branches/streaming-rework/src/libstreaming/MotuPort.h

    r407 r419  
    3737#include "MotuPortInfo.h" 
    3838 
    39 namespace FreebobStreaming { 
     39namespace Streaming { 
    4040 
    4141/*! 
     
    114114}; 
    115115 
    116 } // end of namespace FreebobStreaming 
     116} // end of namespace Streaming 
    117117 
    118118#endif /* __FREEBOB_MOTUPORT__ */ 
  • branches/streaming-rework/src/libstreaming/MotuPortInfo.cpp

    r407 r419  
    2929#include <assert.h> 
    3030 
    31 namespace FreebobStreaming { 
     31namespace Streaming { 
    3232 
    3333 
    34 } // end of namespace FreebobStreaming 
     34} // end of namespace Streaming 
  • branches/streaming-rework/src/libstreaming/MotuPortInfo.h

    r407 r419  
    3232#include <string> 
    3333 
    34 namespace FreebobStreaming { 
     34namespace Streaming { 
    3535/*! 
    3636\brief Class containing the stream information for a Motu channel 
     
    8787}; 
    8888 
    89 } // end of namespace FreebobStreaming 
     89} // end of namespace Streaming 
    9090 
    9191#endif /* __FREEBOB_MOTUPORTINFO__ */ 
  • branches/streaming-rework/src/libstreaming/MotuStreamProcessor.cpp

    r411 r419  
    4242#define TRANSMIT_ADVANCE_CYCLES 1U 
    4343 
    44 namespace FreebobStreaming { 
     44namespace Streaming { 
    4545 
    4646IMPL_DEBUG_MODULE( MotuTransmitStreamProcessor, MotuTransmitStreamProcessor, DEBUG_LEVEL_NORMAL ); 
     
    13901390} 
    13911391 
    1392 } // end of namespace FreebobStreaming 
     1392} // end of namespace Streaming 
  • branches/streaming-rework/src/libstreaming/MotuStreamProcessor.h

    r407 r419  
    3636#include "../libutil/DelayLockedLoop.h" 
    3737 
    38 namespace FreebobStreaming { 
     38namespace Streaming { 
    3939 
    4040class MotuAudioPort; 
     
    177177}; 
    178178 
    179 } // end of namespace FreebobStreaming 
     179} // end of namespace Streaming 
    180180 
    181181#endif /* __FREEBOB_MOTUSTREAMPROCESSOR__ */ 
  • branches/streaming-rework/src/libstreaming/Port.cpp

    r386 r419  
    3232 
    3333 
    34 namespace FreebobStreaming { 
     34namespace Streaming { 
    3535 
    3636IMPL_DEBUG_MODULE( Port, Port, DEBUG_LEVEL_NORMAL ); 
  • branches/streaming-rework/src/libstreaming/Port.h

    r386 r419  
    3535#include "libutil/ringbuffer.h" 
    3636 
    37 namespace FreebobStreaming { 
     37namespace Streaming { 
    3838 
    3939/*! 
  • branches/streaming-rework/src/libstreaming/PortManager.cpp

    r227 r419  
    3232 
    3333 
    34 namespace FreebobStreaming { 
     34namespace Streaming { 
    3535 
    3636IMPL_DEBUG_MODULE( PortManager, PortManager, DEBUG_LEVEL_NORMAL ); 
  • branches/streaming-rework/src/libstreaming/PortManager.h

    r227 r419  
    3434#include <vector> 
    3535 
    36 namespace FreebobStreaming { 
     36namespace Streaming { 
    3737 
    3838class Port; 
  • branches/streaming-rework/src/libstreaming/StreamProcessor.cpp

    r411 r419  
    3535#include <assert.h> 
    3636 
    37 namespace FreebobStreaming { 
     37namespace Streaming { 
    3838 
    3939IMPL_DEBUG_MODULE( StreamProcessor, StreamProcessor, DEBUG_LEVEL_VERBOSE ); 
     
    5858{ 
    5959    // create the timestamped buffer and register ourselves as its client 
    60     m_data_buffer=new FreebobUtil::TimestampedBuffer(this); 
     60    m_data_buffer=new Util::TimestampedBuffer(this); 
    6161 
    6262} 
  • branches/streaming-rework/src/libstreaming/StreamProcessor.h

    r411 r419  
    4040#include "libutil/TimestampedBuffer.h" 
    4141 
    42 namespace FreebobStreaming { 
     42namespace Streaming { 
    4343 
    4444class StreamProcessorManager; 
     
    5454class StreamProcessor : public IsoStream,  
    5555                        public PortManager,  
    56                         public FreebobUtil::TimestampedBufferClient { 
     56                        public Util::TimestampedBufferClient { 
    5757 
    5858    friend class StreamProcessorManager; 
     
    110110 
    111111public: 
    112     FreebobUtil::TimestampedBuffer *m_data_buffer; 
     112    Util::TimestampedBuffer *m_data_buffer; 
    113113 
    114114protected: 
  • branches/streaming-rework/src/libstreaming/StreamProcessorManager.cpp

    r411 r419  
    4343#define ENABLE_DELAY_CYCLES 2000 
    4444 
    45 namespace FreebobStreaming { 
     45namespace Streaming { 
    4646 
    4747IMPL_DEBUG_MODULE( StreamProcessorManager, StreamProcessorManager, DEBUG_LEVEL_NORMAL ); 
  • branches/streaming-rework/src/libstreaming/StreamProcessorManager.h

    r398 r419  
    3838#include <vector> 
    3939 
    40 namespace FreebobStreaming { 
     40namespace Streaming { 
    4141 
    4242class StreamProcessor; 
  • branches/streaming-rework/src/libutil/DelayLockedLoop.cpp

    r277 r419  
    2929#include "DelayLockedLoop.h" 
    3030 
    31 namespace FreebobUtil { 
     31namespace Util { 
    3232 
    3333/** 
  • branches/streaming-rework/src/libutil/DelayLockedLoop.h

    r253 r419  
    2929#define __FREEBOB_DELAYLOCKEDLOOP__ 
    3030 
    31 namespace FreebobUtil { 
     31namespace Util { 
    3232 
    3333class DelayLockedLoop { 
  • branches/streaming-rework/src/libutil/OptionContainer.cpp

    r418 r419  
    3232#include <sstream> 
    3333 
    34 namespace FreebobUtil { 
     34namespace Util { 
    3535 
    3636IMPL_DEBUG_MODULE( OptionContainer, OptionContainer, DEBUG_LEVEL_NORMAL ); 
     
    464464 
    465465 
    466 } // end of namespace FreebobUtil 
     466} // end of namespace Util 
  • branches/streaming-rework/src/libutil/OptionContainer.h

    r418 r419  
    3333#include <string> 
    3434 
    35 namespace FreebobUtil { 
     35namespace Util { 
    3636 
    3737class OptionContainer { 
     
    174174}; 
    175175 
    176 } // end of namespace FreebobUtil 
     176} // end of namespace Util 
    177177 
    178178#endif /* __FREEBOB_OPTIONCONTAINER__ */ 
  • branches/streaming-rework/src/libutil/PacketBuffer.cpp

    r386 r419  
    3131 
    3232 
    33 namespace FreebobStreaming { 
     33namespace Streaming { 
    3434 
    3535IMPL_DEBUG_MODULE( PacketBuffer, PacketBuffer, DEBUG_LEVEL_VERBOSE ); 
  • branches/streaming-rework/src/libutil/PacketBuffer.h

    r386 r419  
    3333#include "libutil/ringbuffer.h" 
    3434 
    35 namespace FreebobStreaming { 
     35namespace Streaming { 
    3636 
    3737class PacketBuffer { 
  • branches/streaming-rework/src/libutil/PosixThread.cpp

    r275 r419  
    3030#include <assert.h> 
    3131 
    32 namespace FreebobUtil 
     32namespace Util 
    3333{ 
    3434 
  • branches/streaming-rework/src/libutil/PosixThread.h

    r254 r419  
    3131#include <pthread.h> 
    3232 
    33 namespace FreebobUtil 
     33namespace Util 
    3434{ 
    3535 
  • branches/streaming-rework/src/libutil/StreamStatistics.cpp

    r386 r419  
    3030#include <stdio.h> 
    3131 
    32 namespace FreebobStreaming { 
     32namespace Streaming { 
    3333 
    3434StreamStatistics::StreamStatistics() 
  • branches/streaming-rework/src/libutil/StreamStatistics.h

    r386 r419  
    3232#include <string> 
    3333 
    34 namespace FreebobStreaming { 
     34namespace Streaming { 
    3535 
    3636class StreamStatistics { 
  • branches/streaming-rework/src/libutil/SystemTimeSource.cpp

    r384 r419  
    3030#include "Time.h" 
    3131 
    32 namespace FreebobUtil { 
     32namespace Util { 
    3333 
    3434IMPL_DEBUG_MODULE( SystemTimeSource, SystemTimeSource, DEBUG_LEVEL_NORMAL ); 
     
    5454} 
    5555 
    56 } // end of namespace FreebobUtil 
     56} // end of namespace Util 
  • branches/streaming-rework/src/libutil/SystemTimeSource.h

    r384 r419  
    3232#include "TimeSource.h" 
    3333 
    34 namespace FreebobUtil { 
     34namespace Util { 
    3535 
    3636class SystemTimeSource  
    37     : public FreebobUtil::TimeSource 
     37    : public Util::TimeSource 
    3838{ 
    3939 
     
    5454}; 
    5555 
    56 } // end of namespace FreebobUtil 
     56} // end of namespace Util 
    5757 
    5858#endif /* __FREEBOB_SYSTEMTIMESOURCE__ */ 
  • branches/streaming-rework/src/libutil/test-dll.cpp

    r253 r419  
    2929#include <stdio.h> 
    3030 
    31 using namespace FreebobUtil; 
     31using namespace Util; 
    3232 
    3333int main() { 
  • branches/streaming-rework/src/libutil/Thread.h

    r266 r419  
    3333#include <pthread.h> 
    3434 
    35 namespace FreebobUtil 
     35namespace Util 
    3636{ 
    3737 
  • branches/streaming-rework/src/libutil/TimeSource.cpp

    r384 r419  
    3636#include "libutil/Time.h" 
    3737 
    38 namespace FreebobUtil { 
     38namespace Util { 
    3939 
    4040IMPL_DEBUG_MODULE( TimeSource, TimeSource, DEBUG_LEVEL_NORMAL ); 
     
    321321} 
    322322 
    323 } // end of namespace FreebobUtil 
     323} // end of namespace Util 
  • branches/streaming-rework/src/libutil/TimeSource.h

    r384 r419  
    3535typedef uint64_t freebob_microsecs_t; 
    3636 
    37 namespace FreebobUtil { 
     37namespace Util { 
    3838 
    3939class TimeSource; 
     
    9696}; 
    9797 
    98 } // end of namespace FreebobUtil 
     98} // end of namespace Util 
    9999 
    100100#endif /* __FREEBOB_TIMESOURCE__ */ 
  • branches/streaming-rework/src/libutil/TimestampedBuffer.cpp

    r411 r419  
    3333#include "assert.h" 
    3434 
    35 namespace FreebobUtil { 
     35namespace Util { 
    3636 
    3737IMPL_DEBUG_MODULE( TimestampedBuffer, TimestampedBuffer, DEBUG_LEVEL_VERBOSE ); 
     
    867867} 
    868868 
    869 } // end of namespace FreebobUtil 
     869} // end of namespace Util 
  • branches/streaming-rework/src/libutil/TimestampedBuffer.h

    r407 r419  
    3232#include "libutil/ringbuffer.h" 
    3333 
    34 namespace FreebobUtil { 
     34namespace Util { 
    3535 
    3636class TimestampedBufferClient; 
     
    195195}; 
    196196 
    197 } // end of namespace FreebobUtil 
     197} // end of namespace Util 
    198198 
    199199#endif /* __FREEBOB_TIMESTAMPEDBUFFER__ */ 
  • branches/streaming-rework/src/libutil/unittests.cpp

    r416 r419  
    2727 
    2828using namespace Util; 
    29 using namespace FreebobUtil; 
    3029 
    3130/////////////////////////////////////// 
  • branches/streaming-rework/src/metrichalo/mh_avdevice.cpp

    r416 r419  
    6464    debugOutput( DEBUG_LEVEL_VERBOSE, "Created MetricHalo::MHAvDevice (NodeID %d)\n", 
    6565                 nodeId ); 
    66     addOption(FreebobUtil::OptionContainer::Option("id",std::string("dev?"))); 
     66    addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    6767 
    6868} 
     
    182182} 
    183183 
    184 FreebobStreaming::StreamProcessor * 
     184Streaming::StreamProcessor * 
    185185MHAvDevice::getStreamProcessorByIndex(int i) { 
    186186 
  • branches/streaming-rework/src/metrichalo/mh_avdevice.h

    r416 r419  
    6666 
    6767    virtual int getStreamCount(); 
    68     virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     68    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    6969 
    7070    virtual bool prepare(); 
  • branches/streaming-rework/src/motu/motu_avdevice.cpp

    r416 r419  
    389389        } 
    390390 
    391         m_receiveProcessor=new FreebobStreaming::MotuReceiveStreamProcessor( 
     391        m_receiveProcessor=new Streaming::MotuReceiveStreamProcessor( 
    392392                m_p1394Service->getPort(), samp_freq, event_size_in); 
    393393 
     
    404404         
    405405        char *buff; 
    406         FreebobStreaming::Port *p=NULL; 
     406        Streaming::Port *p=NULL; 
    407407         
    408408        // retrieve the ID 
     
    413413     
    414414        // Add audio capture ports 
    415         if (!addDirPorts(FreebobStreaming::Port::E_Capture, samp_freq, optical_in_mode)) { 
     415        if (!addDirPorts(Streaming::Port::E_Capture, samp_freq, optical_in_mode)) { 
    416416                return false; 
    417417        } 
     
    421421        // event data. 
    422422        asprintf(&buff,"%s_cap_MIDI0",id.c_str()); 
    423         p = new FreebobStreaming::MotuMidiPort(buff, 
    424                 FreebobStreaming::Port::E_Capture, 4); 
     423        p = new Streaming::MotuMidiPort(buff, 
     424                Streaming::Port::E_Capture, 4); 
    425425        if (!p) { 
    426426                debugOutput(DEBUG_LEVEL_VERBOSE, "Skipped port %s\n", buff); 
     
    438438        // example of adding an control port: 
    439439//    asprintf(&buff,"%s_cap_%s",id.c_str(),"myportnamehere"); 
    440 //    p=new FreebobStreaming::MotuControlPort( 
     440//    p=new Streaming::MotuControlPort( 
    441441//            buff, 
    442 //            FreebobStreaming::Port::E_Capture,  
     442//            Streaming::Port::E_Capture,  
    443443//            0 // you can add all other port specific stuff you  
    444444//              // need to pass by extending MotuXXXPort and MotuPortInfo 
     
    459459 
    460460        // Do the same for the transmit processor 
    461         m_transmitProcessor=new FreebobStreaming::MotuTransmitStreamProcessor( 
     461        m_transmitProcessor=new Streaming::MotuTransmitStreamProcessor( 
    462462                m_p1394Service->getPort(), getSamplingFrequency(), event_size_out); 
    463463 
     
    473473 
    474474        // Add audio playback ports 
    475         if (!addDirPorts(FreebobStreaming::Port::E_Playback, samp_freq, optical_out_mode)) { 
     475        if (!addDirPorts(Streaming::Port::E_Playback, samp_freq, optical_out_mode)) { 
    476476                return false; 
    477477        } 
     
    481481        // of the event data. 
    482482        asprintf(&buff,"%s_pbk_MIDI0",id.c_str()); 
    483         p = new FreebobStreaming::MotuMidiPort(buff, 
    484                 FreebobStreaming::Port::E_Capture, 4); 
     483        p = new Streaming::MotuMidiPort(buff, 
     484                Streaming::Port::E_Capture, 4); 
    485485        if (!p) { 
    486486                debugOutput(DEBUG_LEVEL_VERBOSE, "Skipped port %s\n", buff); 
     
    499499//    asprintf(&buff,"%s_pbk_%s",id.c_str(),"myportnamehere"); 
    500500//     
    501 //    p=new FreebobStreaming::MotuControlPort( 
     501//    p=new Streaming::MotuControlPort( 
    502502//            buff, 
    503 //            FreebobStreaming::Port::E_Playback,  
     503//            Streaming::Port::E_Playback,  
    504504//            0 // you can add all other port specific stuff you  
    505505//              // need to pass by extending MotuXXXPort and MotuPortInfo 
     
    526526} 
    527527 
    528 FreebobStreaming::StreamProcessor * 
     528Streaming::StreamProcessor * 
    529529MotuDevice::getStreamProcessorByIndex(int i) { 
    530530        switch (i) { 
     
    730730/* ======================================================================= */ 
    731731 
    732 bool MotuDevice::addPort(FreebobStreaming::StreamProcessor *s_processor, 
    733   char *name, enum FreebobStreaming::Port::E_Direction direction,  
     732bool MotuDevice::addPort(Streaming::StreamProcessor *s_processor, 
     733  char *name, enum Streaming::Port::E_Direction direction,  
    734734  int position, int size) { 
    735735/* 
     
    739739 * prior to exit. 
    740740 */ 
    741 FreebobStreaming::Port *p=NULL; 
    742  
    743         p = new FreebobStreaming::MotuAudioPort(name, direction, position, size); 
     741Streaming::Port *p=NULL; 
     742 
     743        p = new Streaming::MotuAudioPort(name, direction, position, size); 
    744744 
    745745        if (!p) { 
     
    761761 
    762762bool MotuDevice::addDirPorts( 
    763   enum FreebobStreaming::Port::E_Direction direction,  
     763  enum Streaming::Port::E_Direction direction,  
    764764  unsigned int sample_rate, unsigned int optical_mode) { 
    765765/* 
     
    771771 * create all ports and just disable those which are not active. 
    772772 */ 
    773 const char *mode_str = direction==FreebobStreaming::Port::E_Capture?"cap":"pbk"; 
    774 const char *aux_str = direction==FreebobStreaming::Port::E_Capture?"Mix1":"Phones"; 
    775 FreebobStreaming::StreamProcessor *s_processor; 
     773const char *mode_str = direction==Streaming::Port::E_Capture?"cap":"pbk"; 
     774const char *aux_str = direction==Streaming::Port::E_Capture?"Mix1":"Phones"; 
     775Streaming::StreamProcessor *s_processor; 
    776776unsigned int i, ofs; 
    777777char *buff; 
     
    783783    } 
    784784 
    785         if (direction == FreebobStreaming::Port::E_Capture) { 
     785        if (direction == Streaming::Port::E_Capture) { 
    786786                s_processor = m_receiveProcessor; 
    787787        } else { 
     
    819819                                asprintf(&buff,"%s_%s_AES/EBU%d", id.c_str(), mode_str, i+1); 
    820820                        } else { 
    821                                 if (direction == FreebobStreaming::Port::E_Capture) 
     821                                if (direction == Streaming::Port::E_Capture) 
    822822                                        asprintf(&buff,"%s_%s_Mic%d", id.c_str(), mode_str, i+1); 
    823823                                else 
  • branches/streaming-rework/src/motu/motu_avdevice.h

    r416 r419  
    113113 
    114114    virtual int getStreamCount(); 
    115     virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     115    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    116116 
    117117    virtual bool prepare(); 
     
    140140    signed int m_bandwidth; 
    141141     
    142         FreebobStreaming::MotuReceiveStreamProcessor *m_receiveProcessor; 
    143         FreebobStreaming::MotuTransmitStreamProcessor *m_transmitProcessor; 
     142        Streaming::MotuReceiveStreamProcessor *m_receiveProcessor; 
     143        Streaming::MotuTransmitStreamProcessor *m_transmitProcessor; 
    144144 
    145145private: 
    146         bool addPort(FreebobStreaming::StreamProcessor *s_processor, 
     146        bool addPort(Streaming::StreamProcessor *s_processor, 
    147147                char *name,  
    148                 enum FreebobStreaming::Port::E_Direction direction, 
     148                enum Streaming::Port::E_Direction direction, 
    149149                int position, int size); 
    150150        bool addDirPorts( 
    151                 enum FreebobStreaming::Port::E_Direction direction, 
     151                enum Streaming::Port::E_Direction direction, 
    152152                unsigned int sample_rate, unsigned int optical_mode); 
    153153         
  • branches/streaming-rework/src/rme/rme_avdevice.cpp

    r416 r419  
    189189} 
    190190 
    191 FreebobStreaming::StreamProcessor * 
     191Streaming::StreamProcessor * 
    192192RmeDevice::getStreamProcessorByIndex(int i) { 
    193193    return NULL; 
  • branches/streaming-rework/src/rme/rme_avdevice.h

    r416 r419  
    6767 
    6868    virtual int getStreamCount(); 
    69     virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     69    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    7070 
    7171    virtual bool prepare(); 
  • branches/streaming-rework/tests/streaming/test-isohandling.cpp

    r360 r419  
    3939#include "src/libstreaming/AmdtpPort.h" 
    4040 
    41 using namespace FreebobStreaming; 
     41using namespace Streaming; 
    4242 
    4343 
     
    141141        } 
    142142         
    143         FreebobUtil::PosixThread *thread=new FreebobUtil::PosixThread(procMan); 
     143        Util::PosixThread *thread=new Util::PosixThread(procMan); 
    144144 
    145145 
  • branches/streaming-rework/tests/SytMonitor.h

    r399 r419  
    3333#include "src/libutil/ringbuffer.h" 
    3434 
    35 using namespace FreebobStreaming; 
     35using namespace Streaming; 
    3636 
    3737struct cycle_info { 
  • branches/streaming-rework/tests/test-cycletimer.cpp

    r411 r419  
    4343// #define TEST_PORT_2 
    4444 
    45 using namespace FreebobStreaming; 
    46 using namespace FreebobUtil; 
     45using namespace Streaming; 
     46using namespace Util; 
    4747 
    4848DECLARE_GLOBAL_DEBUG_MODULE; 
  • branches/streaming-rework/tests/test-sytmonitor.cpp

    r398 r419  
    4343#include <pthread.h> 
    4444 
    45 using namespace FreebobStreaming; 
    46 using namespace FreebobUtil; 
     45using namespace Streaming; 
     46using namespace Util; 
    4747 
    4848 
  • branches/streaming-rework/tests/test-timestampedbuffer.cpp

    r407 r419  
    3939#include <pthread.h> 
    4040 
    41 using namespace FreebobUtil; 
     41using namespace Util; 
    4242 
    4343class TimestampedBufferTestClient