Changeset 504

Show
Ignore:
Timestamp:
07/28/07 04:28:43 (14 years ago)
Author:
ppalmers
Message:

Converted sample rate setting parameter to a simple integer. The enumerated value
is only valid for the AV/C compliant devices.
(maybe we have to define another enum?)

Files:

Legend:

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

    r503 r504  
    749749 
    750750bool 
    751 AvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
    752 
     751AvDevice::setSamplingFrequency( int s ) 
     752
     753    ESamplingFrequency samplingFrequency=parseSampleRate( s ); 
    753754    bool snoopMode=false; 
    754755    if(!getOption("snoopMode", snoopMode)) { 
  • branches/echoaudio/src/bebob/bebob_avdevice.h

    r503 r504  
    7070    virtual bool discover(); 
    7171 
    72     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     72    virtual bool setSamplingFrequency( int ); 
    7373    virtual int getSamplingFrequency( ); 
    7474 
     
    157157    bool setSamplingFrequencyPlug( AvPlug& plug, 
    158158                                   AvPlug::EAvPlugDirection direction, 
    159                                    ESamplingFrequency samplingFrequency ); 
     159                                   AVC::ESamplingFrequency samplingFrequency ); 
    160160 
    161161    void showAvPlugs( AvPlugVector& plugs ) const; 
  • branches/echoaudio/src/bebob/bebob_avplug.h

    r503 r504  
    245245    struct FormatInfo { 
    246246        FormatInfo() 
    247             : m_samplingFrequency( eSF_DontCare ) 
     247            : m_samplingFrequency( AVC::eSF_DontCare ) 
    248248            , m_isSyncStream( false ) 
    249249            , m_audioChannels( 0 ) 
  • branches/echoaudio/src/bounce/bounce_avdevice.cpp

    r500 r504  
    2828#include "libieee1394/ieee1394service.h" 
    2929 
    30 #include "libavc/avc_plug_info.h" 
    31 #include "libavc/avc_extended_plug_info.h" 
    32 #include "libavc/avc_subunit_info.h" 
    33 #include "libavc/avc_extended_stream_format.h" 
    34 #include "libavc/avc_serialize.h" 
     30#include "libavc/general/avc_plug_info.h" 
     31#include "libavc/general/avc_extended_plug_info.h" 
     32#include "libavc/general/avc_subunit_info.h" 
     33#include "libavc/streamformat/avc_extended_stream_format.h" 
     34#include "libavc/util/avc_serialize.h" 
    3535#include "libavc/avc_definitions.h" 
    3636 
     
    132132} 
    133133 
    134 bool BounceDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) { 
    135     int retval=convertESamplingFrequency( samplingFrequency ); 
    136     if (retval) { 
    137         m_samplerate=retval; 
     134bool BounceDevice::setSamplingFrequency( int samplingFrequency ) { 
     135    if (samplingFrequency) { 
     136        m_samplerate=samplingFrequency; 
    138137        return true; 
    139138    } else return false; 
  • branches/echoaudio/src/bounce/bounce_avdevice.h

    r500 r504  
    2828#include "debugmodule/debugmodule.h" 
    2929#include "libavc/avc_definitions.h" 
    30 #include "libavc/avc_extended_cmd_generic.h" 
     30#include "libavc/general/avc_extended_cmd_generic.h" 
    3131 
    3232#include "libstreaming/AmdtpStreamProcessor.h" 
     
    7777    bool discover(); 
    7878 
    79     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     79    bool setSamplingFrequency( int samplingFrequency ); 
    8080    int getSamplingFrequency( ); 
    8181 
  • branches/echoaudio/src/dice/dice_avdevice.cpp

    r500 r504  
    143143int 
    144144DiceAvDevice::getSamplingFrequency( ) { 
    145     ESamplingFrequency samplingFrequency; 
     145    int samplingFrequency; 
    146146 
    147147    fb_quadlet_t clockreg; 
     
    154154 
    155155    switch (clockreg) { 
    156         case DICE_RATE_32K:      samplingFrequency = eSF_32000Hz;  break; 
    157         case DICE_RATE_44K1:     samplingFrequency = eSF_44100Hz;  break; 
    158         case DICE_RATE_48K:      samplingFrequency = eSF_48000Hz;  break; 
    159         case DICE_RATE_88K2:     samplingFrequency = eSF_88200Hz;  break; 
    160         case DICE_RATE_96K:      samplingFrequency = eSF_96000Hz;  break; 
    161         case DICE_RATE_176K4:    samplingFrequency = eSF_176400Hz; break; 
    162         case DICE_RATE_192K:     samplingFrequency = eSF_192000Hz; break; 
    163         case DICE_RATE_ANY_LOW:  samplingFrequency = eSF_AnyLow;   break; 
    164         case DICE_RATE_ANY_MID:  samplingFrequency = eSF_AnyMid;   break; 
    165         case DICE_RATE_ANY_HIGH: samplingFrequency = eSF_AnyHigh;  break; 
    166         case DICE_RATE_NONE:     samplingFrequency = eSF_None;     break; 
    167         default:                 samplingFrequency = eSF_DontCare; break; 
    168     } 
    169  
    170     return convertESamplingFrequency(samplingFrequency)
    171 } 
    172  
    173 bool 
    174 DiceAvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     156        case DICE_RATE_32K:      samplingFrequency = 32000;  break; 
     157        case DICE_RATE_44K1:     samplingFrequency = 44100;  break; 
     158        case DICE_RATE_48K:      samplingFrequency = 48000;  break; 
     159        case DICE_RATE_88K2:     samplingFrequency = 88200;  break; 
     160        case DICE_RATE_96K:      samplingFrequency = 96000;  break; 
     161        case DICE_RATE_176K4:    samplingFrequency = 176400; break; 
     162        case DICE_RATE_192K:     samplingFrequency = 192000; break; 
     163        case DICE_RATE_ANY_LOW:  samplingFrequency = 0;   break; 
     164        case DICE_RATE_ANY_MID:  samplingFrequency = 0;   break; 
     165        case DICE_RATE_ANY_HIGH: samplingFrequency = 0;  break; 
     166        case DICE_RATE_NONE:     samplingFrequency = 0;     break; 
     167        default:                 samplingFrequency = 0; break; 
     168    } 
     169 
     170    return samplingFrequency
     171} 
     172 
     173bool 
     174DiceAvDevice::setSamplingFrequency( int samplingFrequency ) 
    175175{ 
    176176    debugOutput(DEBUG_LEVEL_VERBOSE, "Setting sample rate: %d\n", 
    177         convertESamplingFrequency(samplingFrequency)); 
     177        (samplingFrequency)); 
    178178 
    179179    bool supported=false; 
     
    182182    switch ( samplingFrequency ) { 
    183183    default: 
    184     case eSF_22050Hz
    185     case eSF_24000Hz
     184    case 22050
     185    case 24000
    186186        supported=false; 
    187187        break; 
    188     case eSF_32000Hz
     188    case 32000
    189189        supported=maskedCheckNotZeroGlobalReg( 
    190190                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    192192        select=DICE_RATE_32K; 
    193193        break; 
    194     case eSF_44100Hz
     194    case 44100
    195195        supported=maskedCheckNotZeroGlobalReg( 
    196196                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    198198        select=DICE_RATE_44K1; 
    199199        break; 
    200     case eSF_48000Hz
     200    case 48000
    201201        supported=maskedCheckNotZeroGlobalReg( 
    202202                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    204204        select=DICE_RATE_48K; 
    205205        break; 
    206     case eSF_88200Hz
     206    case 88200
    207207        supported=maskedCheckNotZeroGlobalReg( 
    208208                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    210210        select=DICE_RATE_88K2; 
    211211        break; 
    212     case eSF_96000Hz
     212    case 96000
    213213        supported=maskedCheckNotZeroGlobalReg( 
    214214                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    216216        select=DICE_RATE_96K; 
    217217        break; 
    218     case eSF_176400Hz
     218    case 176400
    219219        supported=maskedCheckNotZeroGlobalReg( 
    220220                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    222222        select=DICE_RATE_176K4; 
    223223        break; 
    224     case eSF_192000Hz
     224    case 192000
    225225        supported=maskedCheckNotZeroGlobalReg( 
    226226                    DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, 
     
    231231 
    232232    if (!supported) { 
    233         debugWarning("Unsupported sample rate: %d\n", convertESamplingFrequency(samplingFrequency)); 
     233        debugWarning("Unsupported sample rate: %d\n", (samplingFrequency)); 
    234234        return false; 
    235235    } 
  • branches/echoaudio/src/dice/dice_avdevice.h

    r500 r504  
    6666    void showDevice(); 
    6767 
    68     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     68    bool setSamplingFrequency( int samplingFrequency ); 
    6969    int getSamplingFrequency( ); 
    7070 
  • branches/echoaudio/src/ffado.cpp

    r503 r504  
    133133    FFADODevice* avDevice = ffado_handle->m_deviceManager->getAvDevice( node_id ); 
    134134    if ( avDevice ) { 
    135         if ( avDevice->setSamplingFrequency( parseSampleRate( samplerate ) ) ) { 
     135        if ( avDevice->setSamplingFrequency( samplerate ) ) { 
    136136            return ffado_handle->m_deviceManager->discover()? 0 : -1; 
    137137        } 
  • branches/echoaudio/src/ffadodevice.cpp

    r503 r504  
    9494    return true; 
    9595} 
    96  
    97  
    98 int 
    99 convertESamplingFrequency(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  
    148 ESamplingFrequency 
    149 parseSampleRate( 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  
    187 std::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

    r503 r504  
    3636    class StreamProcessor; 
    3737} 
    38  
    39 /** 
    40  * \brief the possible sampling frequencies 
    41  */ 
    42 enum 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  */ 
    64 int convertESamplingFrequency(ESamplingFrequency freq); 
    65 /** 
    66  * \brief Convert from integer to ESamplingFrequency 
    67  * @param sampleRate 
    68  * @return 
    69  */ 
    70 ESamplingFrequency parseSampleRate( int sampleRate ); 
    71  
    72 std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ); 
    7338 
    7439/*! 
     
    10570     * @return true if successful 
    10671     */ 
    107     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ) = 0; 
     72    virtual bool setSamplingFrequency( int samplingFrequency ) = 0; 
    10873    /** 
    10974     * @brief get the samplingfrequency as an integer 
  • branches/echoaudio/src/ffado_streaming.cpp

    r500 r504  
    154154        // Set the device's sampling rate to that requested 
    155155        // FIXME: does this really belong here?  If so we need to handle errors. 
    156         if (!device->setSamplingFrequency(parseSampleRate(dev->options.sample_rate))) { 
     156        if (!device->setSamplingFrequency(dev->options.sample_rate)) { 
    157157            debugOutput(DEBUG_LEVEL_VERBOSE, " => Retry setting samplerate to %d for (%p)\n", 
    158158                        dev->options.sample_rate, device); 
    159159 
    160160            // try again: 
    161             if (!device->setSamplingFrequency(parseSampleRate(dev->options.sample_rate))) { 
     161            if (!device->setSamplingFrequency(dev->options.sample_rate)) { 
    162162                delete dev->processorManager; 
    163163                delete dev->m_deviceManager; 
  • branches/echoaudio/src/genericavc/avc_avdevice.cpp

    r500 r504  
    120120 
    121121bool 
    122 AvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     122AvDevice::setSamplingFrequency( int samplingFrequency ) 
    123123{ 
    124124 
  • branches/echoaudio/src/genericavc/avc_avdevice.h

    r500 r504  
    5555    void showDevice(); 
    5656 
    57     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     57    bool setSamplingFrequency( int ); 
    5858    int getSamplingFrequency( ); 
    5959 
  • branches/echoaudio/src/libavc/avc_definitions.cpp

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

    r503 r504  
    116116}; 
    117117 
     118/** 
     119 * \brief the possible sampling frequencies 
     120 */ 
     121enum ESamplingFrequency { 
     122    eSF_22050Hz = 0x00, 
     123    eSF_24000Hz = 0x01, 
     124    eSF_32000Hz = 0x02, 
     125    eSF_44100Hz = 0x03, 
     126    eSF_48000Hz = 0x04, 
     127    eSF_88200Hz = 0x0A, 
     128    eSF_96000Hz = 0x05, 
     129    eSF_176400Hz = 0x06, 
     130    eSF_192000Hz = 0x07, 
     131    eSF_AnyLow   = 0x0B, 
     132    eSF_AnyMid   = 0x0C, 
     133    eSF_AnyHigh  = 0x0D, 
     134    eSF_None     = 0x0E, 
     135    eSF_DontCare = 0x0F, 
     136}; 
     137 
     138/** 
     139 * \brief Convert from ESamplingFrequency to an integer 
     140 * @param freq 
     141 * @return 
     142 */ 
     143int convertESamplingFrequency(ESamplingFrequency freq); 
     144/** 
     145 * \brief Convert from integer to ESamplingFrequency 
     146 * @param sampleRate 
     147 * @return 
     148 */ 
     149ESamplingFrequency parseSampleRate( int sampleRate ); 
     150 
     151std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ); 
     152 
    118153} 
    119154 
  • branches/echoaudio/src/maudio/maudio_avdevice.cpp

    r445 r504  
    112112 
    113113bool 
    114 AvDevice::setSamplingFrequency( ESamplingFrequency eSamplingFrequency ) 
     114AvDevice::setSamplingFrequency( int eSamplingFrequency ) 
    115115{ 
    116116    // not supported 
  • branches/echoaudio/src/maudio/maudio_avdevice.h

    r502 r504  
    6363    void showDevice(); 
    6464 
    65     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     65    bool setSamplingFrequency(int samplingFrequency ); 
    6666    int getSamplingFrequency( ); 
    6767 
  • branches/echoaudio/src/metrichalo/mh_avdevice.cpp

    r500 r504  
    120120 
    121121bool 
    122 MHAvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     122MHAvDevice::setSamplingFrequency( int samplingFrequency ) 
    123123{ 
    124124 
  • branches/echoaudio/src/metrichalo/mh_avdevice.h

    r500 r504  
    5757    void showDevice(); 
    5858 
    59     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     59    bool setSamplingFrequency( int samplingFrequency ); 
    6060    int getSamplingFrequency( ); 
    6161 
  • branches/echoaudio/src/motu/motu_avdevice.cpp

    r500 r504  
    171171 
    172172bool 
    173 MotuDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     173MotuDevice::setSamplingFrequency( int samplingFrequency ) 
    174174{ 
    175175/* 
     
    181181 
    182182    switch ( samplingFrequency ) { 
    183         case eSF_22050Hz
     183        case 22050
    184184            supported=false; 
    185185            break; 
    186         case eSF_24000Hz
     186        case 24000
    187187            supported=false; 
    188188            break; 
    189         case eSF_32000Hz
     189        case 32000
    190190            supported=false; 
    191191            break; 
    192         case eSF_44100Hz
     192        case 44100
    193193            new_rate = MOTUFW_RATE_BASE_44100 | MOTUFW_RATE_MULTIPLIER_1X; 
    194194            break; 
    195         case eSF_48000Hz
     195        case 48000
    196196            new_rate = MOTUFW_RATE_BASE_48000 | MOTUFW_RATE_MULTIPLIER_1X; 
    197197            break; 
    198         case eSF_88200Hz
     198        case 88200
    199199            new_rate = MOTUFW_RATE_BASE_44100 | MOTUFW_RATE_MULTIPLIER_2X; 
    200200            break; 
    201         case eSF_96000Hz
     201        case 96000
    202202            new_rate = MOTUFW_RATE_BASE_48000 | MOTUFW_RATE_MULTIPLIER_2X; 
    203203            break; 
    204         case eSF_176400Hz
     204        case 176400
    205205            // Currently only the Traveler supports 4x sample rates 
    206206            if (m_motu_model == MOTUFW_MODEL_TRAVELER) { 
     
    210210                supported=false; 
    211211            break; 
    212         case eSF_192000Hz
     212        case 192000
    213213            // Currently only the Traveler supports 4x sample rates 
    214214            if (m_motu_model == MOTUFW_MODEL_TRAVELER) { 
  • branches/echoaudio/src/motu/motu_avdevice.h

    r500 r504  
    104104    virtual void showDevice(); 
    105105 
    106     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     106    virtual bool setSamplingFrequency( int samplingFrequency ); 
    107107    virtual int getSamplingFrequency( ); 
    108108 
  • branches/echoaudio/src/rme/rme_avdevice.cpp

    r500 r504  
    122122 
    123123bool 
    124 RmeDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     124RmeDevice::setSamplingFrequency( int samplingFrequency ) 
    125125{ 
    126126/* 
    127127 * Set the RME device's samplerate. 
    128128 */ 
    129         if (samplingFrequency == eSF_48000Hz
     129        if (samplingFrequency == 48000
    130130                return true; 
    131131        return false; 
  • branches/echoaudio/src/rme/rme_avdevice.h

    r500 r504  
    5959    void showDevice(); 
    6060 
    61     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     61    bool setSamplingFrequency( int samplingFrequency ); 
    6262    int getSamplingFrequency( ); 
    6363 
  • branches/echoaudio/tests/test-ffado.cpp

    r500 r504  
    284284            FFADODevice* avDevice = m_deviceManager->getAvDevice( arguments.node_id ); 
    285285            if ( avDevice ) { 
    286                 if ( avDevice->setSamplingFrequency( parseSampleRate( samplerate ) ) ) { 
     286                if ( avDevice->setSamplingFrequency( samplerate ) ) { 
    287287                    m_deviceManager->discover(); 
    288288                } else { 
     
    301301                FFADODevice* avDevice = m_deviceManager->getAvDevice( node_id ); 
    302302                if ( avDevice ) { 
    303                     if ( !avDevice->setSamplingFrequency( parseSampleRate( samplerate ) ) ) { 
     303                    if ( !avDevice->setSamplingFrequency( samplerate ) ) { 
    304304                        fprintf( stderr, "Could not set samplerate\n" ); 
    305305                    }