Changeset 503

Show
Ignore:
Timestamp:
07/28/07 03:45:29 (14 years ago)
Author:
ppalmers
Message:

- put all libavc stuff into it's own name namespace (AVC)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/echoaudio/src/bebob/bebob_avdevice.cpp

    r502 r503  
    4141#include <sstream> 
    4242 
     43using namespace AVC; 
     44 
    4345namespace BeBoB { 
    4446 
  • branches/echoaudio/src/bebob/bebob_avdevice.h

    r502 r503  
    4848class ConfigRom; 
    4949class Ieee1394Service; 
    50 class SubunitPlugSpecificDataPlugAddress; 
    5150 
    5251namespace BeBoB { 
     
    121120                                  Util::IODeserialize& deser, 
    122121                  Ieee1394Service& ieee1394Service ); 
    123     AvDeviceSubunitAudio* getAudioSubunit( subunit_id_t subunitId ) 
     122    AvDeviceSubunitAudio* getAudioSubunit( AVC::subunit_id_t subunitId ) 
    124123        { return dynamic_cast<AvDeviceSubunitAudio*>( 
    125124                   getSubunit( AVC1394_SUBUNIT_AUDIO , subunitId ));}; 
     
    131130    bool discoverPlugs(); 
    132131    bool discoverPlugsPCR( AvPlug::EAvPlugDirection plugDirection, 
    133                            plug_id_t plugMaxId ); 
     132                           AVC::plug_id_t plugMaxId ); 
    134133    bool discoverPlugsExternal( AvPlug::EAvPlugDirection plugDirection, 
    135                                 plug_id_t plugMaxId ); 
     134                                AVC::plug_id_t plugMaxId ); 
    136135    bool discoverPlugConnections(); 
    137136    bool discoverSyncModes(); 
    138137    bool discoverSubUnitsPlugConnections(); 
    139138 
    140     AvDeviceSubunit* getSubunit( subunit_type_t subunitType, 
    141                                  subunit_id_t subunitId ) const; 
     139    AvDeviceSubunit* getSubunit( AVC::subunit_type_t subunitType, 
     140                                 AVC::subunit_id_t subunitId ) const; 
    142141 
    143     unsigned int getNrOfSubunits( subunit_type_t subunitType ) const; 
     142    unsigned int getNrOfSubunits( AVC::subunit_type_t subunitType ) const; 
    144143    AvPlugConnection* getPlugConnection( AvPlug& srcPlug ) const; 
    145144 
  • branches/echoaudio/src/bebob/bebob_avdevice_subunit.cpp

    r502 r503  
    3434#include <sstream> 
    3535 
     36using namespace AVC; 
     37 
    3638IMPL_DEBUG_MODULE( BeBoB::AvDeviceSubunit, BeBoB::AvDeviceSubunit, DEBUG_LEVEL_VERBOSE ); 
    3739 
  • branches/echoaudio/src/bebob/bebob_avdevice_subunit.h

    r502 r503  
    4242 public: 
    4343    AvDeviceSubunit( AvDevice& avDevice, 
    44              ESubunitType type, 
    45              subunit_t id, 
     44             AVC::ESubunitType type, 
     45             AVC::subunit_t id, 
    4646             int verboseLevel ); 
    4747    virtual ~AvDeviceSubunit(); 
     
    5353    bool addPlug( AvPlug& plug ); 
    5454 
    55     subunit_t getSubunitId() 
     55    AVC::subunit_t getSubunitId() 
    5656    { return m_sbId; } 
    57     ESubunitType getSubunitType() 
     57    AVC::ESubunitType getSubunitType() 
    5858    { return m_sbType; } 
    5959 
    6060    AvPlugVector& getPlugs() 
    6161    { return m_plugs; } 
    62     AvPlug* getPlug(AvPlug::EAvPlugDirection direction, plug_id_t plugId); 
     62    AvPlug* getPlug(AvPlug::EAvPlugDirection direction, AVC::plug_id_t plugId); 
    6363 
    6464 
     
    7676    bool discoverPlugs(); 
    7777    bool discoverPlugs(AvPlug::EAvPlugDirection plugDirection, 
    78                        plug_id_t plugMaxId ); 
     78                       AVC::plug_id_t plugMaxId ); 
    7979 
    8080    virtual bool serializeChild( Glib::ustring basePath, 
     
    8686 protected: 
    8787    AvDevice*                m_avDevice; 
    88     ESubunitType m_sbType; 
    89     subunit_t                m_sbId; 
     88    AVC::ESubunitType m_sbType; 
     89    AVC::subunit_t                m_sbId; 
    9090    int                      m_verboseLevel; 
    9191 
     
    102102 public: 
    103103    AvDeviceSubunitAudio( AvDevice& avDevice, 
    104               subunit_t id, 
     104              AVC::subunit_t id, 
    105105              int verboseLevel ); 
    106106    AvDeviceSubunitAudio(); 
     
    117117    bool discoverFunctionBlocks(); 
    118118    bool discoverFunctionBlocksDo( 
    119         ExtendedSubunitInfoCmd::EFunctionBlockType fbType ); 
     119        AVC::ExtendedSubunitInfoCmd::EFunctionBlockType fbType ); 
    120120    bool createFunctionBlock( 
    121         ExtendedSubunitInfoCmd::EFunctionBlockType fbType, 
    122         ExtendedSubunitInfoPageData& data ); 
     121        AVC::ExtendedSubunitInfoCmd::EFunctionBlockType fbType, 
     122        AVC::ExtendedSubunitInfoPageData& data ); 
    123123 
    124124    FunctionBlock::ESpecialPurpose convertSpecialPurpose( 
    125         function_block_special_purpose_t specialPurpose ); 
     125        AVC::function_block_special_purpose_t specialPurpose ); 
    126126 
    127127    virtual bool serializeChild( Glib::ustring basePath, 
     
    140140 public: 
    141141    AvDeviceSubunitMusic( AvDevice& avDevice, 
    142               subunit_t id, 
     142              AVC::subunit_t id, 
    143143              int verboseLevel ); 
    144144    AvDeviceSubunitMusic(); 
  • branches/echoaudio/src/bebob/bebob_avplug.cpp

    r502 r503  
    3030 
    3131#include <sstream> 
     32 
     33using namespace AVC; 
    3234 
    3335namespace BeBoB { 
  • branches/echoaudio/src/bebob/bebob_avplug.h

    r502 r503  
    3737 
    3838#include <glibmm/ustring.h> 
     39 
     40#warning clean up the samplerate mess 
     41#include "ffadodevice.h" 
    3942 
    4043class Ieee1394Service; 
     
    8184        ConfigRom& configRom, 
    8285            AvPlugManager& plugManager, 
    83         ESubunitType subunitType, 
    84         subunit_id_t subunitId, 
    85         function_block_type_t functionBlockType, 
    86         function_block_type_t functionBlockId, 
     86        AVC::ESubunitType subunitType, 
     87        AVC::subunit_id_t subunitId, 
     88        AVC::function_block_type_t functionBlockType, 
     89        AVC::function_block_type_t functionBlockId, 
    8790        EAvPlugAddressType plugAddressType, 
    8891        EAvPlugDirection plugDirection, 
    89         plug_id_t plugId, 
     92        AVC::plug_id_t plugId, 
    9093        int verboseLevel ); 
    9194    AvPlug( const AvPlug& rhs ); 
     
    100103    int getGlobalId() const 
    101104        { return m_globalId; } 
    102     plug_id_t getPlugId() const 
     105    AVC::plug_id_t getPlugId() const 
    103106        { return m_id; } 
    104     ESubunitType getSubunitType() const 
     107    AVC::ESubunitType getSubunitType() const 
    105108        { return m_subunitType; } 
    106     subunit_id_t getSubunitId() const 
     109    AVC::subunit_id_t getSubunitId() const 
    107110        { return m_subunitId; } 
    108111    const char* getName() const 
     
    110113    EAvPlugDirection getPlugDirection() const 
    111114        { return m_direction; } 
    112     sampling_frequency_t getSamplingFrequency() const 
     115    AVC::sampling_frequency_t getSamplingFrequency() const 
    113116        { return m_samplingFrequency; } 
    114117    int getSampleRate() const; // 22050, 24000, 32000, ... 
     
    123126        { return m_infoPlugType; } 
    124127 
    125     function_block_type_t getFunctionBlockType() const 
     128    AVC::function_block_type_t getFunctionBlockType() const 
    126129        { return m_functionBlockType; } 
    127     function_block_id_t getFunctionBlockId() const 
     130    AVC::function_block_id_t getFunctionBlockId() const 
    128131        { return m_functionBlockId; } 
    129132 
     
    133136        { return m_outputConnections; } 
    134137 
    135     static PlugAddress::EPlugDirection convertPlugDirection( 
     138    static AVC::PlugAddress::EPlugDirection convertPlugDirection( 
    136139    EAvPlugDirection direction); 
    137140 
     
    149152 public: 
    150153    struct ChannelInfo { 
    151         stream_position_t          m_streamPosition; 
    152         stream_position_location_t m_location; 
    153     Glib::ustring              m_name; 
     154        AVC::stream_position_t          m_streamPosition; 
     155        AVC::stream_position_location_t m_location; 
     156        Glib::ustring                   m_name; 
    154157    }; 
    155158    typedef std::vector<ChannelInfo> ChannelInfoVector; 
    156159 
    157160    struct ClusterInfo { 
    158     int                      m_index; 
    159     port_type_t              m_portType; 
    160     Glib::ustring            m_name; 
    161  
    162         nr_of_channels_t         m_nrOfChannels; 
     161        int                      m_index; 
     162        AVC::port_type_t         m_portType; 
     163        Glib::ustring            m_name; 
     164 
     165        AVC::nr_of_channels_t    m_nrOfChannels; 
    163166        ChannelInfoVector        m_channelInfos; 
    164     stream_format_t          m_streamFormat; 
     167        AVC::stream_format_t     m_streamFormat; 
    165168    }; 
    166169    typedef std::vector<ClusterInfo> ClusterInfoVector; 
     
    183186    bool discoverConnectionsOutput(); 
    184187 
    185     ExtendedPlugInfoCmd setPlugAddrToPlugInfoCmd(); 
    186  
    187     ExtendedStreamFormatCmd setPlugAddrToStreamFormatCmd( 
    188     ExtendedStreamFormatCmd::ESubFunction subFunction); 
    189  
    190     SignalSourceCmd setSrcPlugAddrToSignalCmd(); 
     188    AVC::ExtendedPlugInfoCmd setPlugAddrToPlugInfoCmd(); 
     189 
     190    AVC::ExtendedStreamFormatCmd setPlugAddrToStreamFormatCmd( 
     191            AVC::ExtendedStreamFormatCmd::ESubFunction subFunction); 
     192 
     193    AVC::SignalSourceCmd setSrcPlugAddrToSignalCmd(); 
    191194 
    192195    void setDestPlugAddrToSignalCmd( 
    193     SignalSourceCmd& signalSourceCmd, AvPlug& plug ); 
     196            AVC::SignalSourceCmd& signalSourceCmd, AvPlug& plug ); 
    194197 
    195198    void debugOutputClusterInfos( int debugLevel ); 
    196199 
    197     bool copyClusterInfo(ExtendedPlugInfoPlugChannelPositionSpecificData& 
     200    bool copyClusterInfo(AVC::ExtendedPlugInfoPlugChannelPositionSpecificData& 
    198201                         channelPositionData ); 
    199202 
     
    202205    bool discoverConnectionsFromSpecificData( 
    203206        EAvPlugDirection discoverDirection, 
    204         PlugAddressSpecificData* plugAddress, 
     207        AVC::PlugAddressSpecificData* plugAddress, 
    205208        AvPlugVector& connections ); 
    206209 
    207210    AvPlug* getPlugDefinedBySpecificData( 
    208         UnitPlugSpecificDataPlugAddress* pUnitPlugAddress, 
    209         SubunitPlugSpecificDataPlugAddress* pSubunitPlugAddress, 
    210         FunctionBlockPlugSpecificDataPlugAddress* pFunctionBlockPlugAddress ); 
     211        AVC::UnitPlugSpecificDataPlugAddress* pUnitPlugAddress, 
     212        AVC::SubunitPlugSpecificDataPlugAddress* pSubunitPlugAddress, 
     213        AVC::FunctionBlockPlugSpecificDataPlugAddress* pFunctionBlockPlugAddress ); 
    211214 
    212215    EAvPlugDirection toggleDirection( EAvPlugDirection direction ) const; 
     
    248251            , m_index( 0xff ) 
    249252            {} 
    250     sampling_frequency_t  m_samplingFrequency; 
    251     bool                  m_isSyncStream; 
    252     number_of_channels_t  m_audioChannels; 
    253     number_of_channels_t  m_midiChannels; 
    254     byte_t                m_index; 
     253    AVC::sampling_frequency_t  m_samplingFrequency; 
     254    bool                       m_isSyncStream; 
     255    AVC::number_of_channels_t  m_audioChannels; 
     256    AVC::number_of_channels_t  m_midiChannels; 
     257    byte_t                     m_index; 
    255258    }; 
    256259    typedef std::vector<FormatInfo> FormatInfoVector; 
     
    259262    Ieee1394Service*             m_p1394Service; 
    260263    ConfigRom*                   m_pConfigRom; 
    261     ESubunitType     m_subunitType; 
    262     subunit_id_t                 m_subunitId; 
    263     function_block_type_t        m_functionBlockType; 
    264     function_block_id_t          m_functionBlockId; 
     264    AVC::ESubunitType     m_subunitType; 
     265    AVC::subunit_id_t                 m_subunitId; 
     266    AVC::function_block_type_t        m_functionBlockType; 
     267    AVC::function_block_id_t          m_functionBlockId; 
    265268    EAvPlugAddressType           m_addressType; 
    266269    EAvPlugDirection             m_direction; 
    267     plug_id_t                    m_id; 
     270    AVC::plug_id_t                    m_id; 
    268271    EAvPlugType                  m_infoPlugType; 
    269     nr_of_channels_t             m_nrOfChannels; 
     272    AVC::nr_of_channels_t             m_nrOfChannels; 
    270273    Glib::ustring                m_name; 
    271274    ClusterInfoVector            m_clusterInfos; 
    272     sampling_frequency_t         m_samplingFrequency; 
     275    AVC::sampling_frequency_t         m_samplingFrequency; 
    273276    FormatInfoVector             m_formatInfos; 
    274277    AvPlugVector                 m_inputConnections; 
     
    298301    void showPlugs() const; 
    299302 
    300     AvPlug* getPlug( ESubunitType subunitType, 
    301                      subunit_id_t subunitId, 
    302              function_block_type_t functionBlockType, 
    303              function_block_id_t functionBlockId, 
     303    AvPlug* getPlug( AVC::ESubunitType subunitType, 
     304                     AVC::subunit_id_t subunitId, 
     305                     AVC::function_block_type_t functionBlockType, 
     306                     AVC::function_block_id_t functionBlockId, 
    304307                     AvPlug::EAvPlugAddressType plugAddressType, 
    305308                     AvPlug::EAvPlugDirection plugDirection, 
    306                      plug_id_t plugId ) const; 
     309                     AVC::plug_id_t plugId ) const; 
    307310    AvPlug* getPlug( int iGlobalId ) const; 
    308     AvPlugVector getPlugsByType( ESubunitType subunitType, 
    309                  subunit_id_t subunitId, 
    310                  function_block_type_t functionBlockType, 
    311                  function_block_id_t functionBlockId, 
     311    AvPlugVector getPlugsByType( AVC::ESubunitType subunitType, 
     312                 AVC::subunit_id_t subunitId, 
     313                 AVC::function_block_type_t functionBlockType, 
     314                 AVC::function_block_id_t functionBlockId, 
    312315                 AvPlug::EAvPlugAddressType plugAddressType, 
    313316                 AvPlug::EAvPlugDirection plugDirection, 
  • branches/echoaudio/src/bebob/bebob_dl_codes.cpp

    r445 r503  
    2424#include "bebob/bebob_dl_codes.h" 
    2525#include "bebob/bebob_dl_bcd.h" 
     26 
     27using namespace AVC; 
    2628 
    2729unsigned short BeBoB::CommandCodes::m_gCommandId = 0; 
  • branches/echoaudio/src/bebob/bebob_dl_codes.h

    r502 r503  
    6969    virtual ~CommandCodes(); 
    7070 
    71         virtual bool serialize( IOSSerialize& se ); 
    72         virtual bool deserialize( IISDeserialize& de ); 
     71        virtual bool serialize( AVC::IOSSerialize& se ); 
     72        virtual bool deserialize( AVC::IISDeserialize& de ); 
    7373 
    7474        virtual size_t getMaxSize(); 
     
    127127        virtual ~CommandCodesReset(); 
    128128 
    129         virtual bool serialize( IOSSerialize& se ); 
    130         virtual bool deserialize( IISDeserialize& de ); 
     129        virtual bool serialize( AVC::IOSSerialize& se ); 
     130        virtual bool deserialize( AVC::IISDeserialize& de ); 
    131131 
    132132        EStartMode getStartMode() const 
     
    147147        virtual ~CommandCodesProgramGUID(); 
    148148 
    149         virtual bool serialize( IOSSerialize& se ); 
    150         virtual bool deserialize( IISDeserialize& de ); 
     149        virtual bool serialize( AVC::IOSSerialize& se ); 
     150        virtual bool deserialize( AVC::IISDeserialize& de ); 
    151151 
    152152        fb_octlet_t getGUID() const 
     
    177177        virtual ~CommandCodesDownloadStart(); 
    178178 
    179         virtual bool serialize( IOSSerialize& se ); 
    180         virtual bool deserialize( IISDeserialize& de ); 
     179        virtual bool serialize( AVC::IOSSerialize& se ); 
     180        virtual bool deserialize( AVC::IISDeserialize& de ); 
    181181 
    182182        bool setDate( fb_octlet_t date ) 
     
    218218        virtual ~CommandCodesDownloadBlock(); 
    219219 
    220         virtual bool serialize( IOSSerialize& se ); 
    221         virtual bool deserialize( IISDeserialize& de ); 
     220        virtual bool serialize( AVC::IOSSerialize& se ); 
     221        virtual bool deserialize( AVC::IISDeserialize& de ); 
    222222 
    223223    bool setSeqNumber( fb_quadlet_t seqNumber ) 
     
    247247        virtual ~CommandCodesDownloadEnd(); 
    248248 
    249         virtual bool serialize( IOSSerialize& se ); 
    250         virtual bool deserialize( IISDeserialize& de ); 
     249        virtual bool serialize( AVC::IOSSerialize& se ); 
     250        virtual bool deserialize( AVC::IISDeserialize& de ); 
    251251 
    252252        fb_quadlet_t getRespCrc32() const 
     
    268268        virtual ~CommandCodesInitializePersParam(); 
    269269 
    270         virtual bool serialize( IOSSerialize& se ); 
    271         virtual bool deserialize( IISDeserialize& de ); 
     270        virtual bool serialize( AVC::IOSSerialize& se ); 
     271        virtual bool deserialize( AVC::IISDeserialize& de ); 
    272272    }; 
    273273 
     
    280280        virtual ~CommandCodesInitializeConfigToFactorySetting(); 
    281281 
    282         virtual bool serialize( IOSSerialize& se ); 
    283         virtual bool deserialize( IISDeserialize& de ); 
     282        virtual bool serialize( AVC::IOSSerialize& se ); 
     283        virtual bool deserialize( AVC::IISDeserialize& de ); 
    284284    }; 
    285285 
     
    296296        virtual ~CommandCodesGo(); 
    297297 
    298         virtual bool serialize( IOSSerialize& se ); 
    299         virtual bool deserialize( IISDeserialize& de ); 
     298        virtual bool serialize( AVC::IOSSerialize& se ); 
     299        virtual bool deserialize( AVC::IISDeserialize& de ); 
    300300 
    301301        EStartMode getStartMode() const 
  • branches/echoaudio/src/bebob/bebob_dl_mgr.cpp

    r502 r503  
    3434 
    3535#include <cstdio> 
     36 
     37using namespace AVC; 
    3638 
    3739namespace BeBoB { 
  • branches/echoaudio/src/bebob/bebob_functionblock.cpp

    r451 r503  
    2727#include "libieee1394/configrom.h" 
    2828 
     29using namespace AVC; 
     30 
    2931IMPL_DEBUG_MODULE( BeBoB::FunctionBlock, BeBoB::FunctionBlock, DEBUG_LEVEL_NORMAL ); 
    3032 
  • branches/echoaudio/src/bebob/bebob_functionblock.h

    r455 r503  
    5151 
    5252    FunctionBlock( AvDeviceSubunit& subunit, 
    53            function_block_type_t type, 
    54                    function_block_type_t subtype, 
    55                    function_block_id_t id, 
     53           AVC::function_block_type_t type, 
     54                   AVC::function_block_type_t subtype, 
     55                   AVC::function_block_id_t id, 
    5656                   ESpecialPurpose purpose, 
    57                    no_of_input_plugs_t nrOfInputPlugs, 
    58                    no_of_output_plugs_t nrOfOutputPlugs, 
     57                   AVC::no_of_input_plugs_t nrOfInputPlugs, 
     58                   AVC::no_of_output_plugs_t nrOfOutputPlugs, 
    5959                   int verbose ); 
    6060    FunctionBlock( const FunctionBlock& rhs ); 
     
    6767    virtual const char* getName() = 0; 
    6868     
    69     function_block_type_t getType() {return m_type;}; 
    70     function_block_type_t getSubtype() {return m_subtype;}; 
    71     function_block_id_t getId() {return m_id;}; 
     69    AVC::function_block_type_t getType() {return m_type;}; 
     70    AVC::function_block_type_t getSubtype() {return m_subtype;}; 
     71    AVC::function_block_id_t getId() {return m_id;}; 
    7272 
    7373    bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const; 
     
    7878protected: 
    7979    bool discoverPlugs( AvPlug::EAvPlugDirection plugDirection, 
    80                         plug_id_t plugMaxId ); 
     80                        AVC::plug_id_t plugMaxId ); 
    8181 
    8282protected: 
    8383    AvDeviceSubunit*      m_subunit; 
    84     function_block_type_t m_type; 
    85     function_block_type_t m_subtype; 
    86     function_block_id_t   m_id; 
     84    AVC::function_block_type_t m_type; 
     85    AVC::function_block_type_t m_subtype; 
     86    AVC::function_block_id_t   m_id; 
    8787    ESpecialPurpose       m_purpose; 
    88     no_of_input_plugs_t   m_nrOfInputPlugs; 
    89     no_of_output_plugs_t  m_nrOfOutputPlugs; 
     88    AVC::no_of_input_plugs_t   m_nrOfInputPlugs; 
     89    AVC::no_of_output_plugs_t  m_nrOfOutputPlugs; 
    9090    int                   m_verbose; 
    9191    AvPlugVector          m_plugs; 
     
    103103public: 
    104104    FunctionBlockSelector(AvDeviceSubunit& subunit, 
    105                           function_block_id_t id, 
     105                          AVC::function_block_id_t id, 
    106106                          ESpecialPurpose purpose, 
    107                           no_of_input_plugs_t nrOfInputPlugs, 
    108                           no_of_output_plugs_t nrOfOutputPlugs, 
     107                          AVC::no_of_input_plugs_t nrOfInputPlugs, 
     108                          AVC::no_of_output_plugs_t nrOfOutputPlugs, 
    109109                          int verbose); 
    110110    FunctionBlockSelector( const FunctionBlockSelector& rhs ); 
     
    128128public: 
    129129    FunctionBlockFeature(AvDeviceSubunit& subunit, 
    130                          function_block_id_t id, 
     130                         AVC::function_block_id_t id, 
    131131                         ESpecialPurpose purpose, 
    132                          no_of_input_plugs_t nrOfInputPlugs, 
    133                          no_of_output_plugs_t nrOfOutputPlugs, 
     132                         AVC::no_of_input_plugs_t nrOfInputPlugs, 
     133                         AVC::no_of_output_plugs_t nrOfOutputPlugs, 
    134134                         int verbose); 
    135135    FunctionBlockFeature( const FunctionBlockFeature& rhs ); 
     
    170170public: 
    171171    FunctionBlockEnhancedMixer( AvDeviceSubunit& subunit, 
    172                                 function_block_id_t id, 
     172                                AVC::function_block_id_t id, 
    173173                                ESpecialPurpose purpose, 
    174                                 no_of_input_plugs_t nrOfInputPlugs, 
    175                                 no_of_output_plugs_t nrOfOutputPlugs, 
     174                                AVC::no_of_input_plugs_t nrOfInputPlugs, 
     175                                AVC::no_of_output_plugs_t nrOfOutputPlugs, 
    176176                                int verbose ); 
    177177    FunctionBlockEnhancedMixer(); 
     
    195195public: 
    196196    FunctionBlockProcessing( AvDeviceSubunit& subunit, 
    197                              function_block_id_t id, 
     197                             AVC::function_block_id_t id, 
    198198                             ESpecialPurpose purpose, 
    199                              no_of_input_plugs_t nrOfInputPlugs, 
    200                              no_of_output_plugs_t nrOfOutputPlugs, 
     199                             AVC::no_of_input_plugs_t nrOfInputPlugs, 
     200                             AVC::no_of_output_plugs_t nrOfOutputPlugs, 
    201201                             int verbose ); 
    202202    FunctionBlockProcessing( const FunctionBlockProcessing& rhs ); 
     
    220220public: 
    221221    FunctionBlockCodec(AvDeviceSubunit& subunit, 
    222                        function_block_id_t id, 
     222                       AVC::function_block_id_t id, 
    223223                       ESpecialPurpose purpose, 
    224                        no_of_input_plugs_t nrOfInputPlugs, 
    225                        no_of_output_plugs_t nrOfOutputPlugs, 
     224                       AVC::no_of_input_plugs_t nrOfInputPlugs, 
     225                       AVC::no_of_output_plugs_t nrOfOutputPlugs, 
    226226                       int verbose); 
    227227    FunctionBlockCodec( const FunctionBlockCodec& rhs ); 
  • branches/echoaudio/src/bebob/GenericMixer.cpp

    r502 r503  
    4343 
    4444using namespace OSC; 
     45using namespace AVC; 
    4546 
    4647namespace BeBoB { 
  • branches/echoaudio/src/ffado.cpp

    r502 r503  
    144144void ffado_sleep_after_avc_command( int time ) 
    145145{ 
    146     AVCCommand::setSleepAfterAVCCommand( time ); 
     146    AVC::AVCCommand::setSleepAfterAVCCommand( time ); 
    147147} 
  • branches/echoaudio/src/ffadodevice.cpp

    r500 r503  
    9494    return true; 
    9595} 
     96 
     97 
     98int 
     99convertESamplingFrequency(ESamplingFrequency freq) 
     100{ 
     101    int value = 0; 
     102 
     103    switch ( freq ) { 
     104    case eSF_22050Hz: 
     105        value = 22050; 
     106        break; 
     107    case eSF_24000Hz: 
     108        value = 24000; 
     109        break; 
     110    case eSF_32000Hz: 
     111        value = 32000; 
     112        break; 
     113    case eSF_44100Hz: 
     114        value = 44100; 
     115        break; 
     116    case eSF_48000Hz: 
     117        value = 48000; 
     118        break; 
     119    case eSF_88200Hz: 
     120        value = 88200; 
     121        break; 
     122    case eSF_96000Hz: 
     123        value = 96000; 
     124        break; 
     125    case eSF_176400Hz: 
     126        value = 176400; 
     127        break; 
     128    case eSF_192000Hz: 
     129        value = 192000; 
     130        break; 
     131    case eSF_AnyLow: 
     132        value = 48000; 
     133        break; 
     134    case eSF_AnyMid: 
     135        value = 96000; 
     136        break; 
     137    case eSF_AnyHigh: 
     138        value = 192000; 
     139        break; 
     140    default: 
     141        value = 0; 
     142    } 
     143 
     144 
     145    return value; 
     146} 
     147 
     148ESamplingFrequency 
     149parseSampleRate( int sampleRate ) 
     150{ 
     151    ESamplingFrequency efreq; 
     152    switch ( sampleRate ) { 
     153    case 22050: 
     154        efreq = eSF_22050Hz; 
     155        break; 
     156    case 24000: 
     157        efreq = eSF_24000Hz; 
     158        break; 
     159    case 32000: 
     160        efreq = eSF_32000Hz; 
     161        break; 
     162    case 44100: 
     163        efreq = eSF_44100Hz; 
     164        break; 
     165    case 48000: 
     166        efreq = eSF_48000Hz; 
     167        break; 
     168    case 88200: 
     169        efreq = eSF_88200Hz; 
     170        break; 
     171    case 96000: 
     172        efreq = eSF_96000Hz; 
     173        break; 
     174    case 176400: 
     175        efreq = eSF_176400Hz; 
     176        break; 
     177    case 192000: 
     178        efreq = eSF_192000Hz; 
     179        break; 
     180    default: 
     181        efreq = eSF_DontCare; 
     182    } 
     183 
     184    return efreq; 
     185} 
     186 
     187std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ) 
     188{ 
     189    char* str; 
     190    switch ( samplingFrequency ) { 
     191    case eSF_22050Hz: 
     192        str = "22050"; 
     193        break; 
     194    case eSF_24000Hz: 
     195        str = "24000"; 
     196        break; 
     197    case eSF_32000Hz: 
     198        str = "32000"; 
     199        break; 
     200    case eSF_44100Hz: 
     201        str = "44100"; 
     202        break; 
     203    case eSF_48000Hz: 
     204        str = "48000"; 
     205        break; 
     206    case eSF_88200Hz: 
     207        str = "88200"; 
     208        break; 
     209    case eSF_96000Hz: 
     210        str = "96000"; 
     211        break; 
     212    case eSF_176400Hz: 
     213        str = "176400"; 
     214        break; 
     215    case eSF_192000Hz: 
     216        str = "192000"; 
     217        break; 
     218    case eSF_DontCare: 
     219    default: 
     220        str = "unknown"; 
     221    } 
     222    return stream << str; 
     223}; 
  • branches/echoaudio/src/ffadodevice.h

    r500 r503  
    2626#define FFADODEVICE_H 
    2727 
    28 #include "libavc/avc_definitions.h" 
    2928#include "libutil/OptionContainer.h" 
    3029#include "libosc/OscNode.h" 
    3130 
    32 class ConfigRom; 
     31// class ConfigRom; 
     32#include "libieee1394/configrom.h" 
    3333class Ieee1394Service; 
    3434 
     
    3636    class StreamProcessor; 
    3737} 
     38 
     39/** 
     40 * \brief the possible sampling frequencies 
     41 */ 
     42enum ESamplingFrequency { 
     43    eSF_22050Hz = 0x00, 
     44    eSF_24000Hz = 0x01, 
     45    eSF_32000Hz = 0x02, 
     46    eSF_44100Hz = 0x03, 
     47    eSF_48000Hz = 0x04, 
     48    eSF_88200Hz = 0x0A, 
     49    eSF_96000Hz = 0x05, 
     50    eSF_176400Hz = 0x06, 
     51    eSF_192000Hz = 0x07, 
     52    eSF_AnyLow   = 0x0B, 
     53    eSF_AnyMid   = 0x0C, 
     54    eSF_AnyHigh  = 0x0D, 
     55    eSF_None     = 0x0E, 
     56    eSF_DontCare = 0x0F, 
     57}; 
     58 
     59/** 
     60 * \brief Convert from ESamplingFrequency to an integer 
     61 * @param freq 
     62 * @return 
     63 */ 
     64int convertESamplingFrequency(ESamplingFrequency freq); 
     65/** 
     66 * \brief Convert from integer to ESamplingFrequency 
     67 * @param sampleRate 
     68 * @return 
     69 */ 
     70ESamplingFrequency parseSampleRate( int sampleRate ); 
     71 
     72std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ); 
     73 
    3874/*! 
    3975@brief Base class for device support 
  • branches/echoaudio/src/libavc/audiosubunit/avc_function_block.cpp

    r502 r503  
    2727#include "libieee1394/ieee1394service.h" 
    2828 
     29 
     30namespace AVC { 
     31 
     32 
    2933///////////////////////////////// 
    3034 
     
    702706    return new FunctionBlockCmd( *this ); 
    703707} 
     708 
     709} 
  • branches/echoaudio/src/libavc/audiosubunit/avc_function_block.h

    r502 r503  
    3131#include <vector> 
    3232using namespace std; 
     33 
     34namespace AVC { 
     35 
    3336 
    3437class FunctionBlockFeatureVolume: public IBusData 
     
    273276}; 
    274277 
     278} 
     279 
    275280#endif 
  • branches/echoaudio/src/libavc/avc_definitions.cpp

    r445 r503  
    2525 
    2626 
    27 int 
    28 convertESamplingFrequency(ESamplingFrequency freq) 
    29 
    30     int value = 0; 
    31  
    32     switch ( freq ) { 
    33     case eSF_22050Hz: 
    34         value = 22050; 
    35         break; 
    36     case eSF_24000Hz: 
    37         value = 24000; 
    38         break; 
    39     case eSF_32000Hz: 
    40         value = 32000; 
    41         break; 
    42     case eSF_44100Hz: 
    43         value = 44100; 
    44         break; 
    45     case eSF_48000Hz: 
    46         value = 48000; 
    47         break; 
    48     case eSF_88200Hz: 
    49         value = 88200; 
    50         break; 
    51     case eSF_96000Hz: 
    52         value = 96000; 
    53         break; 
    54     case eSF_176400Hz: 
    55         value = 176400; 
    56         break; 
    57     case eSF_192000Hz: 
    58         value = 192000; 
    59         break; 
    60     case eSF_AnyLow: 
    61         value = 48000; 
    62         break; 
    63     case eSF_AnyMid: 
    64         value = 96000; 
    65         break; 
    66     case eSF_AnyHigh: 
    67         value = 192000; 
    68         break; 
    69     default: 
    70         value = 0; 
    71     } 
     27namespace AVC { 
    7228 
    7329 
    74     return value; 
    7530} 
    76  
    77 ESamplingFrequency 
    78 parseSampleRate( int sampleRate ) 
    79 { 
    80     ESamplingFrequency efreq; 
    81     switch ( sampleRate ) { 
    82     case 22050: 
    83         efreq = eSF_22050Hz; 
    84         break; 
    85     case 24000: 
    86         efreq = eSF_24000Hz; 
    87         break; 
    88     case 32000: 
    89         efreq = eSF_32000Hz; 
    90         break; 
    91     case 44100: 
    92         efreq = eSF_44100Hz; 
    93         break; 
    94     case 48000: 
    95         efreq = eSF_48000Hz; 
    96         break; 
    97     case 88200: 
    98         efreq = eSF_88200Hz; 
    99         break; 
    100     case 96000: 
    101         efreq = eSF_96000Hz; 
    102         break; 
    103     case 176400: 
    104         efreq = eSF_176400Hz; 
    105         break; 
    106     case 192000: 
    107         efreq = eSF_192000Hz; 
    108         break; 
    109     default: 
    110         efreq = eSF_DontCare; 
    111     } 
    112  
    113     return efreq; 
    114 } 
    115  
    116 std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ) 
    117 { 
    118     char* str; 
    119     switch ( samplingFrequency ) { 
    120     case eSF_22050Hz: 
    121         str = "22050"; 
    122         break; 
    123     case eSF_24000Hz: 
    124         str = "24000"; 
    125         break; 
    126     case eSF_32000Hz: 
    127         str = "32000"; 
    128         break; 
    129     case eSF_44100Hz: 
    130         str = "44100"; 
    131         break; 
    132     case eSF_48000Hz: 
    133         str = "48000"; 
    134         break; 
    135     case eSF_88200Hz: 
    136         str = "88200"; 
    137         break; 
    138     case eSF_96000Hz: 
    139         str = "96000"; 
    140         break; 
    141     case eSF_176400Hz: 
    142         str = "176400"; 
    143         break; 
    144     case eSF_192000Hz: 
    145         str = "192000"; 
    146         break; 
    147     case eSF_DontCare: 
    148     default: 
    149         str = "unknown"; 
    150     } 
    151     return stream << str; 
    152 }; 
  • branches/echoaudio/src/libavc/avc_definitions.h

    r499 r503  
    2727#include <libavc1394/avc1394.h> 
    2828#include <ostream> 
     29 
     30 
     31namespace AVC { 
    2932 
    3033typedef byte_t ctype_t; 
     
    8386typedef quadlet_t company_id_t; 
    8487 
    85 /** 
    86  * \brief the possible sampling frequencies 
    87  */ 
    88 enum ESamplingFrequency { 
    89     eSF_22050Hz = 0x00, 
    90     eSF_24000Hz = 0x01, 
    91     eSF_32000Hz = 0x02, 
    92     eSF_44100Hz = 0x03, 
    93     eSF_48000Hz = 0x04, 
    94     eSF_88200Hz = 0x0A, 
    95     eSF_96000Hz = 0x05, 
    96     eSF_176400Hz = 0x06, 
    97     eSF_192000Hz = 0x07, 
    98     eSF_AnyLow   = 0x0B, 
    99     eSF_AnyMid   = 0x0C, 
    100     eSF_AnyHigh  = 0x0D, 
    101     eSF_None     = 0x0E, 
    102     eSF_DontCare = 0x0F, 
    103 }; 
    104  
    105 /** 
    106  * \brief Convert from ESamplingFrequency to an integer 
    107  * @param freq 
    108  * @return 
    109  */ 
    110 int convertESamplingFrequency(ESamplingFrequency freq); 
    111 /** 
    112  * \brief Convert from integer to ESamplingFrequency 
    113  * @param sampleRate 
    114  * @return 
    115  */ 
    116 ESamplingFrequency parseSampleRate( int sampleRate ); 
    117  
    118 std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ); 
    119  
    12088#define AVC1394_SUBUNIT_AUDIO 1 
    12189#define AVC1394_SUBUNIT_PRINTER 2 
     
    148116}; 
    149117 
     118} 
    150119 
    151120#endif // AVDDEFINITIONS_H 
  • branches/echoaudio/src/libavc/ccm/avc_signal_source.cpp

    r502 r503  
    3232 
    3333#define AVC1394_CMD_SIGNAL_SOURCE 0x1A 
     34 
     35namespace AVC { 
     36 
    3437 
    3538SignalUnitAddress::SignalUnitAddress() 
     
    283286    return m_signalDestination; 
    284287} 
     288 
     289} 
  • branches/echoaudio/src/libavc/ccm/avc_signal_source.h

    r502 r503  
    2929 
    3030#include <libavc1394/avc1394.h> 
     31 
     32namespace AVC { 
     33 
    3134 
    3235class SignalAddress: public IBusData 
     
    98101}; 
    99102 
     103} 
    100104 
    101105#endif // AVCSIGNALSOURCE_H 
  • branches/echoaudio/src/libavc/descriptors/avc_descriptor.cpp

    r502 r503  
    2828#include "libieee1394/ieee1394service.h" 
    2929 
     30namespace AVC { 
     31 
    3032AVCDescriptorSpecifier::AVCDescriptorSpecifier( enum EType type ) 
    3133    : m_type ( type ) 
     
    540542    return result; 
    541543} 
     544 
     545} 
  • branches/echoaudio/src/libavc/descriptors/avc_descriptor.h

    r502 r503  
    4444#include <string> 
    4545 
     46class Ieee1394Service; 
     47 
     48namespace AVC { 
     49 
    4650class IOSSerialize; 
    4751class IISDeserialize; 
    48 class Ieee1394Service; 
    49  
    50  
    5152/** 
    5253 * The specifier used to indicate the target descriptor 
     
    246247// }; 
    247248 
     249} 
     250 
    248251#endif // AVCDESCRIPTOR_H 
  • branches/echoaudio/src/libavc/descriptors/avc_descriptor_cmd.cpp

    r502 r503  
    3232 
    3333using namespace std; 
     34 
     35namespace AVC { 
    3436 
    3537OpenDescriptorCmd::OpenDescriptorCmd(Ieee1394Service& ieee1394service) 
     
    231233        default: return eInvalid; 
    232234    } 
    233      
    234 
     235
     236 
     237
  • branches/echoaudio/src/libavc/descriptors/avc_descriptor_cmd.h

    r502 r503  
    2828 
    2929#include <libavc1394/avc1394.h> 
     30 
     31namespace AVC { 
     32 
    3033 
    3134// defined in avc1394.h 
     
    119122}; 
    120123 
     124} 
     125 
    121126#endif // AVCDESCRIPTORCMD_H 
  • branches/echoaudio/src/libavc/general/avc_connect.cpp

    r502 r503  
    3131using namespace std; 
    3232 
     33namespace AVC { 
     34 
    3335ConnectCmd::ConnectCmd(Ieee1394Service& ieee1394service) 
    3436    : AVCCommand( ieee1394service, AVC1394_CMD_CONNECT ) 
     
    5355    return true; 
    5456} 
     57 
     58} 
  • branches/echoaudio/src/libavc/general/avc_connect.h

    r502 r503  
    2828 
    2929#include <libavc1394/avc1394.h> 
     30namespace AVC { 
    3031 
    3132class ConnectCmd: public AVCCommand 
     
    4243}; 
    4344 
     45} 
    4446 
    4547#endif // AVCCONNECT_H 
  • branches/echoaudio/src/libavc/general/avc_extended_cmd_generic.cpp

    r502 r503  
    2525#include "../util/avc_serialize.h" 
    2626#include "libieee1394/ieee1394service.h" 
     27 
     28namespace AVC { 
    2729 
    2830UnitPlugAddress::UnitPlugAddress( EPlugType plugType,  plug_type_t plugId ) 
     
    557559} 
    558560 
    559  
     561
  • branches/echoaudio/src/libavc/general/avc_extended_cmd_generic.h

    r502 r503  
    2626 
    2727#include "avc_generic.h" 
     28 
     29namespace AVC { 
    2830 
    2931//////////////////////////////////////////////////////////// 
     
    286288}; 
    287289 
     290} 
    288291 
    289292#endif 
  • branches/echoaudio/src/libavc/general/avc_extended_plug_info.cpp

    r502 r503  
    3131using namespace std; 
    3232 
     33namespace AVC { 
     34 
    3335///////////////////////////////////////// 
    3436///////////////////////////////////////// 
     
    855857    return true; 
    856858} 
     859 
     860} 
  • branches/echoaudio/src/libavc/general/avc_extended_plug_info.h

    r502 r503  
    3232#include <string> 
    3333#include <vector> 
     34 
     35namespace AVC { 
    3436 
    3537class ExtendedPlugInfoPlugTypeSpecificData : public IBusData 
     
    316318}; 
    317319 
     320} 
    318321 
    319322#endif 
  • branches/echoaudio/src/libavc/general/avc_extended_subunit_info.cpp

    r502 r503  
    3030#define NR_OF_PAGE_DATA 5 
    3131#define SIZE_OF_PAGE_ENTRY 5 
     32 
     33namespace AVC { 
    3234 
    3335ExtendedSubunitInfoPageData::ExtendedSubunitInfoPageData() 
     
    156158    return status; 
    157159} 
     160 
     161} 
  • branches/echoaudio/src/libavc/general/avc_extended_subunit_info.h

    r502 r503  
    3131#include <string> 
    3232#include <vector> 
     33 
     34namespace AVC { 
     35 
    3336 
    3437class ExtendedSubunitInfoPageData: public IBusData 
     
    105108}; 
    106109 
     110} 
     111 
    107112#endif 
  • branches/echoaudio/src/libavc/general/avc_generic.cpp

    r502 r503  
    3131 
    3232#define DEBUG_EXTRA_VERBOSE 5 
     33 
     34 
     35namespace AVC { 
    3336 
    3437IMPL_DEBUG_MODULE( AVCCommand, AVCCommand, DEBUG_LEVEL_NORMAL ); 
     
    332335    return responseToStrings[eResponse]; 
    333336} 
     337 
     338} 
  • branches/echoaudio/src/libavc/general/avc_generic.h

    r502 r503  
    3232#include <libavc1394/avc1394.h> 
    3333 
     34class Ieee1394Service; 
     35 
     36namespace AVC { 
     37 
    3438class IOSSerialize; 
    3539class IISDeserialize; 
    36 class Ieee1394Service; 
    3740 
    3841const int fcpFrameMaxLength = 512; 
     
    135138const char* responseToString( AVCCommand::EResponse eResponse ); 
    136139 
     140} 
     141 
    137142#endif // AVCGENERIC_H 
  • branches/echoaudio/src/libavc/general/avc_plug_info.cpp

    r502 r503  
    3030 
    3131using namespace std; 
     32 
     33namespace AVC { 
    3234 
    3335PlugInfoCmd::PlugInfoCmd( Ieee1394Service& ieee1394service, 
     
    155157    return true; 
    156158} 
     159 
     160} 
  • branches/echoaudio/src/libavc/general/avc_plug_info.h

    r502 r503  
    3333#define AVC1394_PLUG_INFO_SUBFUNCTION_SERIAL_BUS_GENERIC_BUS_PLUG_BLUETOOTH    0x40 
    3434#define AVC1394_PLUG_INFO_SUBFUNCTION_SERIAL_BUS_NOT_USED                      0xFF 
     35 
     36 
     37namespace AVC { 
    3538 
    3639 
     
    7477}; 
    7578 
     79} 
    7680 
    7781#endif // AVCPLUGINFO_H 
  • branches/echoaudio/src/libavc/general/avc_subunit_info.cpp

    r502 r503  
    3030 
    3131using namespace std; 
     32 
     33namespace AVC { 
     34 
    3235 
    3336SubUnitInfoCmd::SubUnitInfoCmd( Ieee1394Service& ieee1349service ) 
     
    9699    return true; 
    97100} 
     101 
     102} 
  • branches/echoaudio/src/libavc/general/avc_subunit_info.h

    r502 r503  
    2929#include <libavc1394/avc1394.h> 
    3030 
     31 
     32namespace AVC { 
    3133 
    3234// No extended subunit queries supported 
     
    7375}; 
    7476 
     77} 
    7578 
    7679#endif // AVCSUBUNITINFO_H 
  • branches/echoaudio/src/libavc/general/avc_unit_info.cpp

    r502 r503  
    3030 
    3131using namespace std; 
     32 
     33namespace AVC { 
     34 
    3235 
    3336UnitInfoCmd::UnitInfoCmd( Ieee1394Service& ieee1349service ) 
     
    8487    return true; 
    8588} 
     89 
     90} 
  • branches/echoaudio/src/libavc/general/avc_unit_info.h

    r502 r503  
    2828 
    2929#include <libavc1394/avc1394.h> 
     30 
     31namespace AVC { 
     32 
    3033 
    3134class UnitInfoCmd: public AVCCommand 
     
    6871}; 
    6972 
     73} 
    7074 
    7175#endif // AVCUNITINFO_H 
  • branches/echoaudio/src/libavc/musicsubunit/avc_descriptor_music.cpp

    r502 r503  
    3434// info block implementations 
    3535 
     36namespace AVC { 
     37 
     38 
    3639AVCMusicGeneralStatusInfoBlock::AVCMusicGeneralStatusInfoBlock( ) 
    3740    : AVCInfoBlock( 0x8100 ) 
     
    638641} 
    639642 
     643} 
  • branches/echoaudio/src/libavc/musicsubunit/avc_descriptor_music.h

    r502 r503  
    3939#include <vector> 
    4040 
     41class Ieee1394Service; 
     42 
     43namespace AVC { 
     44 
     45 
    4146class IOSSerialize; 
    4247class IISDeserialize; 
    43 class Ieee1394Service; 
    4448 
    4549/** 
     
    242246}; 
    243247 
     248} 
     249 
    244250#endif // AVCDESCRIPTORMUSIC_H 
  • branches/echoaudio/src/libavc/streamformat/avc_extended_stream_format.cpp

    r502 r503  
    2727 
    2828#include <netinet/in.h> 
     29 
     30#warning clean up the samplerate mess 
     31#include "ffadodevice.h" 
     32 
     33namespace AVC { 
    2934 
    3035/////////////////////////////////////////////////////////// 
     
    388393    return true; 
    389394} 
     395 
     396} 
  • branches/echoaudio/src/libavc/streamformat/avc_extended_stream_format.h

    r502 r503  
    3131#include <iostream> 
    3232#include <vector> 
     33 
     34namespace AVC { 
    3335 
    3436#define AVC1394_STREAM_FORMAT_SUPPORT            0x2F 
     
    287289}; 
    288290 
     291} 
     292 
    289293#endif // AVCEXTENDEDSTREAMFROMAT_H 
  • branches/echoaudio/src/libavc/util/avc_serialize.cpp

    r502 r503  
    2828 
    2929#include <netinet/in.h> 
     30 
     31 
     32namespace AVC { 
     33 
    3034 
    3135IMPL_DEBUG_MODULE( CoutSerializer, CoutSerializer, DEBUG_LEVEL_NORMAL ); 
     
    304308} 
    305309 
     310} 
  • branches/echoaudio/src/libavc/util/avc_serialize.h

    r502 r503  
    2929#include <libraw1394/raw1394.h> // byte_t and quadlet_t declaration 
    3030#include <string> 
     31 
     32namespace AVC { 
    3133 
    3234// Interfaces 
     
    158160}; 
    159161 
     162} 
    160163#endif // SERIALIZE_H 
    161164