Changeset 624

Show
Ignore:
Timestamp:
09/07/07 10:46:04 (15 years ago)
Author:
ppalmers
Message:

some more experiments regarding setting the samplerate on the saffire

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/bebob/focusrite/focusrite_cmd.h

    r619 r624  
    3232 
    3333#define FOCUSRITE_CMD_ID_SAMPLERATE         84 
     34#define FOCUSRITE_CMD_ID_SAMPLERATE_MIRROR  115 
    3435 
    3536#define FOCUSRITE_CMD_ID_PHANTOM14          98 
  • trunk/libffado/src/bebob/focusrite/focusrite_device.cpp

    r622 r624  
    3535                 getConfigRom().getNodeId() ); 
    3636 
     37    // the saffire pro doesn't seem to like it if the commands are too fast 
     38    if (AVC::AVCCommand::getSleepAfterAVCCommand() < 200) { 
     39        AVC::AVCCommand::setSleepAfterAVCCommand( 200 ); 
     40    } 
     41 
    3742    // create control objects for the saffire pro 
    3843    m_Phantom1 = new BinaryControl(*this, FOCUSRITE_CMD_ID_PHANTOM14, 
     
    230235     
    231236    cmd.setVerbose( getDebugLevel() ); 
    232         cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
     237//         cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
    233238     
    234239    cmd.m_id=id; 
     
    254259     
    255260    cmd.setVerbose( getDebugLevel() ); 
    256         cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
     261//         cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
    257262     
    258263    cmd.m_id=id; 
     
    269274 
    270275int 
    271 SaffireProDevice::getSamplingFrequency( ) { 
    272     uint32_t sr; 
    273      
    274     if ( !getSpecificValue(FOCUSRITE_CMD_ID_SAMPLERATE, &sr ) ) { 
    275         debugError( "getSpecificValue failed\n" ); 
    276         return 0; 
    277     } 
    278      
    279     debugOutput( DEBUG_LEVEL_NORMAL, 
    280                      "getSampleRate: %d\n", sr ); 
    281  
    282     switch(sr) { 
     276SaffireProDevice::convertDefToSr( uint32_t def ) { 
     277    switch(def) { 
    283278        case FOCUSRITE_CMD_SAMPLERATE_44K1:  return 44100; 
    284279        case FOCUSRITE_CMD_SAMPLERATE_48K:   return 48000; 
     
    291286} 
    292287 
     288uint32_t 
     289SaffireProDevice::convertSrToDef( int sr ) { 
     290    switch(sr) { 
     291        case 44100:  return FOCUSRITE_CMD_SAMPLERATE_44K1; 
     292        case 48000:  return FOCUSRITE_CMD_SAMPLERATE_48K; 
     293        case 88200:  return FOCUSRITE_CMD_SAMPLERATE_88K2; 
     294        case 96000:  return FOCUSRITE_CMD_SAMPLERATE_96K; 
     295        case 176400: return FOCUSRITE_CMD_SAMPLERATE_176K4; 
     296        case 192000: return FOCUSRITE_CMD_SAMPLERATE_192K; 
     297        default: 
     298            debugWarning("Unsupported samplerate: %d\n", sr); 
     299            return 0; 
     300    } 
     301} 
     302 
     303int 
     304SaffireProDevice::getSamplingFrequency( ) { 
     305    uint32_t sr; 
     306    if ( !getSpecificValue(FOCUSRITE_CMD_ID_SAMPLERATE, &sr ) ) { 
     307        debugError( "getSpecificValue failed\n" ); 
     308        return 0; 
     309    } 
     310     
     311    debugOutput( DEBUG_LEVEL_NORMAL, 
     312                     "getSampleRate: %d\n", sr ); 
     313 
     314    return convertDefToSr(sr); 
     315} 
     316 
    293317bool 
    294318SaffireProDevice::setSamplingFrequencyDo( int s ) 
    295319{ 
    296     uint32_t value; 
    297     switch(s) { 
    298         case 44100:  value=FOCUSRITE_CMD_SAMPLERATE_44K1;break; 
    299         case 48000:  value=FOCUSRITE_CMD_SAMPLERATE_48K;break; 
    300         case 88200:  value=FOCUSRITE_CMD_SAMPLERATE_88K2;break; 
    301         case 96000:  value=FOCUSRITE_CMD_SAMPLERATE_96K;break; 
    302         case 176400: value=FOCUSRITE_CMD_SAMPLERATE_176K4;break; 
    303         case 192000: value=FOCUSRITE_CMD_SAMPLERATE_192K;break; 
    304         default: 
    305             debugWarning("Unsupported samplerate: %d\n", s); 
    306             return false; 
    307     } 
    308  
    309  
     320    uint32_t value=convertSrToDef(s); 
    310321    if ( !setSpecificValue(FOCUSRITE_CMD_ID_SAMPLERATE, value) ) { 
    311322        debugError( "setSpecificValue failed\n" ); 
     
    313324    } 
    314325    return true; 
     326} 
     327 
     328// FIXME: this is not really documented, and is an assumtion 
     329int 
     330SaffireProDevice::getSamplingFrequencyMirror( ) { 
     331    uint32_t sr; 
     332    if ( !getSpecificValue(FOCUSRITE_CMD_ID_SAMPLERATE_MIRROR, &sr ) ) { 
     333        debugError( "getSpecificValue failed\n" ); 
     334        return 0; 
     335    } 
     336     
     337    debugOutput( DEBUG_LEVEL_NORMAL, 
     338                     "getSampleRateMirror: %d\n", sr ); 
     339 
     340    return convertDefToSr(sr); 
    315341} 
    316342 
     
    332358        return true; 
    333359    } else { 
    334  
    335         if(!setSamplingFrequencyDo( s )) { 
    336             debugWarning("setSamplingFrequencyDo failed\n"); 
    337         } 
    338          
    339         // wait for a while 
    340         usleep(100 * 1000); 
    341         int verify=getSamplingFrequency(); 
    342          
    343         debugOutput( DEBUG_LEVEL_NORMAL, 
    344                      "setSampleRate: requested samplerate %d, device now has %d\n", s, verify ); 
    345                       
    346         if (s != verify) { 
    347             debugWarning("setting samplerate failed. trying again...\n"); 
     360        const int max_tries=2; 
     361        int ntries=max_tries+1; 
     362        while(--ntries) { 
    348363            if(!setSamplingFrequencyDo( s )) { 
    349364                debugWarning("setSamplingFrequencyDo failed\n"); 
    350365            } 
    351366             
    352             // wait for a while 
    353             usleep(100 * 1000); 
    354             verify=getSamplingFrequency(); 
    355             debugOutput( DEBUG_LEVEL_NORMAL, 
    356                         "setSampleRate (2): requested samplerate %d, device now has %d\n", s, verify ); 
    357             return (s==verify); 
     367            int timeout=10; // multiples of 1s 
     368//             while(timeout--) { 
     369//                 // wait for a while 
     370//                 usleep(1000 * 1000); 
     371//                  
     372//                 // we should figure out how long to wait before the device 
     373//                 // becomes available again 
     374//                  
     375//                 // rediscover the device 
     376//                 if (discover()) break; 
     377//  
     378//             } 
     379             
     380            if(timeout) { 
     381                int verify=getSamplingFrequency(); 
     382                 
     383                debugOutput( DEBUG_LEVEL_NORMAL, 
     384                            "setSampleRate (try %d): requested samplerate %d, device now has %d\n",  
     385                            max_tries-ntries, s, verify ); 
     386                             
     387                if (s == verify) break; 
     388            } 
    358389        } 
     390         
     391        if (ntries==0) { 
     392            debugError("Setting samplerate failed...\n"); 
     393            return false; 
     394        } 
     395 
    359396        return true; 
    360397    } 
  • trunk/libffado/src/bebob/focusrite/focusrite_device.h

    r622 r624  
    8787private: 
    8888    virtual bool setSamplingFrequencyDo( int ); 
    89      
     89    virtual int getSamplingFrequencyMirror( ); 
     90    int convertDefToSr( uint32_t def ); 
     91    uint32_t convertSrToDef( int sr ); 
     92 
    9093    BinaryControl * m_Phantom1; 
    9194    BinaryControl * m_Phantom2;