Changeset 438

Show
Ignore:
Timestamp:
03/13/07 11:29:11 (14 years ago)
Author:
pieterpalmers
Message:

- introduced generic setting of the samplerate, removed AVC depency for other IAvDevices.

Files:

Legend:

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

    r436 r438  
    201201    } 
    202202 
    203     debugOutput( DEBUG_LEVEL_NORMAL, "number of iso input plugs = %d\n", 
     203    debugOutput( DEBUG_LEVEL_VERBOSE, "number of iso input plugs = %d\n", 
    204204                 plugInfoCmd.m_serialBusIsochronousInputPlugs ); 
    205     debugOutput( DEBUG_LEVEL_NORMAL, "number of iso output plugs = %d\n", 
     205    debugOutput( DEBUG_LEVEL_VERBOSE, "number of iso output plugs = %d\n", 
    206206                 plugInfoCmd.m_serialBusIsochronousOutputPlugs ); 
    207     debugOutput( DEBUG_LEVEL_NORMAL, "number of external input plugs = %d\n", 
     207    debugOutput( DEBUG_LEVEL_VERBOSE, "number of external input plugs = %d\n", 
    208208                 plugInfoCmd.m_externalInputPlugs ); 
    209     debugOutput( DEBUG_LEVEL_NORMAL, "number of external output plugs = %d\n", 
     209    debugOutput( DEBUG_LEVEL_VERBOSE, "number of external output plugs = %d\n", 
    210210                 plugInfoCmd.m_externalOutputPlugs ); 
    211211 
     
    266266        } 
    267267 
    268         debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n", 
     268        debugOutput( DEBUG_LEVEL_VERBOSE, "plug '%s' found\n", 
    269269                     plug->getName() ); 
    270270        m_pcrPlugs.push_back( plug ); 
     
    298298        } 
    299299 
    300         debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n", 
     300        debugOutput( DEBUG_LEVEL_VERBOSE, "plug '%s' found\n", 
    301301                     plug->getName() ); 
    302302        m_externalPlugs.push_back( plug ); 
     
    501501                } 
    502502            } 
    503             debugOutput( DEBUG_LEVEL_NORMAL
     503            debugOutput( DEBUG_LEVEL_VERBOSE
    504504                         "Active Sync Connection: '%s' -> '%s'\n", 
    505505                         plug->getName(), 
     
    703703 
    704704bool 
    705 AvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency
     705AvDevice::setSampleRate( ESampleRate sampleRate
    706706{ 
    707707    bool snoopMode=false; 
     
    711711     
    712712    if(snoopMode) { 
    713         int current_sr=getSamplingFrequency(); 
    714         if (current_sr != convertESamplingFrequency( samplingFrequency ) ) { 
     713        ESampleRate current_sr=getSampleRate(); 
     714        if (current_sr != sampleRate ) { 
    715715            debugError("In snoop mode it is impossible to set the sample rate.\n"); 
    716             debugError("Please start the client with the correct setting.\n"); 
     716            debugError("Please start the client with the correct setting (%d).\n", 
     717                convertESampleRate(sampleRate)); 
    717718            return false; 
    718719        } 
     
    721722        AvPlug* plug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Input, 0 ); 
    722723        if ( !plug ) { 
    723             debugError( "setSampleRate: Could not retrieve iso input plug 0\n" ); 
     724            debugError( "Could not retrieve iso input plug 0\n" ); 
    724725            return false; 
    725726        } 
     
    727728        if ( !setSamplingFrequencyPlug( *plug, 
    728729                                        AvPlug::eAPD_Input, 
    729                                         samplingFrequency ) ) 
     730                                        toAvcSamplingFrequency( sampleRate ) ) ) 
    730731        { 
    731             debugError( "setSampleRate: Setting sample rate failed\n" ); 
     732            debugError( "Setting sample rate failed\n" ); 
    732733            return false; 
    733734        } 
     
    735736        plug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Output,  0 ); 
    736737        if ( !plug ) { 
    737             debugError( "setSampleRate: Could not retrieve iso output plug 0\n" ); 
     738            debugError( "Could not retrieve iso output plug 0\n" ); 
    738739            return false; 
    739740        } 
     
    741742        if ( !setSamplingFrequencyPlug( *plug, 
    742743                                        AvPlug::eAPD_Output, 
    743                                         samplingFrequency ) ) 
     744                                        toAvcSamplingFrequency( sampleRate ) ) ) 
    744745        { 
    745             debugError( "setSampleRate: Setting sample rate failed\n" ); 
     746            debugError( "Setting sample rate failed\n" ); 
    746747            return false; 
    747748        } 
    748749     
    749750        debugOutput( DEBUG_LEVEL_VERBOSE, 
    750                      "setSampleRate: Set sample rate to %d\n", 
    751                      convertESamplingFrequency( samplingFrequency ) ); 
     751                     "Set sample rate to %d\n", 
     752                     convertESampleRate( sampleRate ) ); 
    752753        return true; 
    753754    } 
     
    756757} 
    757758 
    758 int 
    759 AvDevice::getSamplingFrequency( ) { 
     759ESampleRate 
     760AvDevice::getSampleRate( ) { 
    760761    AvPlug* inputPlug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Input, 0 ); 
    761762    if ( !inputPlug ) { 
    762         debugError( "setSampleRate: Could not retrieve iso input plug 0\n" ); 
    763         return false; 
     763        debugError( "getSampleRate: Could not retrieve iso input plug 0\n" ); 
     764        return eSF_DontCare; 
    764765    } 
    765766    AvPlug* outputPlug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Output, 0 ); 
    766767    if ( !outputPlug ) { 
    767         debugError( "setSampleRate: Could not retrieve iso output plug 0\n" ); 
    768         return false; 
    769     } 
    770  
    771     int samplerate_playback=inputPlug->getSampleRate(); 
    772     int samplerate_capture=outputPlug->getSampleRate(); 
     768        debugError( "getSampleRate: Could not retrieve iso output plug 0\n" ); 
     769        return eSF_DontCare; 
     770    } 
     771 
     772    ESampleRate samplerate_playback=fromAvcSamplingFrequency( 
     773        parseAvcSamplingFrequency(inputPlug->getSamplingFrequency())); 
     774    ESampleRate samplerate_capture=fromAvcSamplingFrequency( 
     775        parseAvcSamplingFrequency(outputPlug->getSamplingFrequency())); 
    773776 
    774777    if (samplerate_playback != samplerate_capture) { 
     
    815818                  AVCCommand::eR_Implemented ) ) 
    816819        { 
    817             ESamplingFrequency foundFreq = eSF_DontCare; 
     820            ESamplingFrequency foundFreq = eSF_AVC_DontCare; 
    818821 
    819822            FormatInformation* formatInfo = 
     
    850853 
    851854    if ( !cmdSuccess ) { 
    852         debugError( "setSampleRatePlug: Failed to retrieve format info\n" ); 
     855        debugError( "setSamplingFrequencyPlug: Failed to retrieve format info\n" ); 
    853856        return false; 
    854857    } 
    855858 
    856859    if ( !correctFormatFound ) { 
    857         debugError( "setSampleRatePlug: %s plug %d does not support " 
     860        debugError( "setSamplingFrequencyPlug: %s plug %d does not support " 
    858861                    "sample rate %d\n", 
    859862                    plug.getName(), 
    860863                    plug.getPlugId(), 
    861                     convertESamplingFrequency( samplingFrequency ) ); 
     864                    convertAvcSamplingFrequency( samplingFrequency ) ); 
    862865        return false; 
    863866    } 
     
    869872 
    870873    if ( !extStreamFormatCmd.fire() ) { 
    871         debugError( "setSampleRate: Could not set sample rate %d " 
     874        debugError( "setSamplingFrequencyPlug: Could not set sample rate %d " 
    872875                    "to %s plug %d\n", 
    873                     convertESamplingFrequency( samplingFrequency ), 
     876                    convertAvcSamplingFrequency( samplingFrequency ), 
    874877                    plug.getName(), 
    875878                    plug.getPlugId() ); 
     
    979982    AvPlug* inputPlug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Input, 0 ); 
    980983    if ( !inputPlug ) { 
    981         debugError( "setSampleRate: Could not retrieve iso input plug 0\n" ); 
     984        debugError( "Could not retrieve iso input plug 0\n" ); 
    982985        return false; 
    983986    } 
    984987    AvPlug* outputPlug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Output, 0 ); 
    985988    if ( !outputPlug ) { 
    986         debugError( "setSampleRate: Could not retrieve iso output plug 0\n" ); 
    987         return false; 
    988     } 
    989  
    990     int samplerate=outputPlug->getSampleRate(); 
     989        debugError( "Could not retrieve iso output plug 0\n" ); 
     990        return false; 
     991    } 
     992 
     993    ESampleRate samplerate=parseSampleRate(outputPlug->getSampleRate()); 
    991994     
    992995    debugOutput( DEBUG_LEVEL_VERBOSE, "Initializing receive processor...\n"); 
     
    996999    p=new Streaming::AmdtpReceiveStreamProcessor( 
    9971000                             m_p1394Service->getPort(), 
    998                              samplerate
     1001                             convertESampleRate(samplerate)
    9991002                             outputPlug->getNrOfChannels()); 
    10001003 
     
    10211024        p=new Streaming::AmdtpReceiveStreamProcessor( 
    10221025                                  m_p1394Service->getPort(), 
    1023                                   samplerate
     1026                                  convertESampleRate(samplerate)
    10241027                                  inputPlug->getNrOfChannels()); 
    10251028    } else { 
    10261029        p=new Streaming::AmdtpTransmitStreamProcessor( 
    10271030                                m_p1394Service->getPort(), 
    1028                                 samplerate
     1031                                convertESampleRate(samplerate)
    10291032                                inputPlug->getNrOfChannels()); 
    10301033    } 
  • branches/streaming-rework/src/bebob/bebob_avdevice.h

    r436 r438  
    6666    virtual bool discover(); 
    6767 
    68     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    69     virtual int getSamplingFrequency( ); 
     68    bool setSampleRate( ESampleRate ); 
     69    ESampleRate getSampleRate( ); 
    7070 
    7171    virtual int getStreamCount(); 
  • branches/streaming-rework/src/bebob/bebob_avdevice_subunit.cpp

    r420 r438  
    8888    } 
    8989 
    90     debugOutput( DEBUG_LEVEL_NORMAL, "number of source plugs = %d\n", 
     90    debugOutput( DEBUG_LEVEL_VERBOSE, "number of source plugs = %d\n", 
    9191                 plugInfoCmd.m_sourcePlugs ); 
    92     debugOutput( DEBUG_LEVEL_NORMAL, "number of destination output " 
     92    debugOutput( DEBUG_LEVEL_VERBOSE, "number of destination output " 
    9393                 "plugs = %d\n", plugInfoCmd.m_destinationPlugs ); 
    9494 
     
    154154        } 
    155155 
    156         debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n", 
     156        debugOutput( DEBUG_LEVEL_VERBOSE, "plug '%s' found\n", 
    157157                     plug->getName() ); 
    158158        m_plugs.push_back( plug ); 
  • branches/streaming-rework/src/bebob/bebob_avplug.cpp

    r420 r438  
    266266AvPlug::getSampleRate() const 
    267267{ 
    268     return convertESamplingFrequency( static_cast<ESamplingFrequency>( m_samplingFrequency ) ); 
     268    return convertAvcSamplingFrequency( static_cast<ESamplingFrequency>( m_samplingFrequency ) ); 
    269269} 
    270270 
     
    18931893    // beer to get into the mood) 
    18941894 
    1895     printf( "\nSummary\n" ); 
    1896     printf( "-------\n\n" ); 
    1897     printf( "Nr | AddressType     | Direction | SubUnitType | SubUnitId | FunctionBlockType | FunctionBlockId | Id   | Type         |Name\n" ); 
    1898     printf( "---+-----------------+-----------+-------------+-----------+-------------------+-----------------+------+--------------+------\n" ); 
     1895    debugOutputShort( DEBUG_LEVEL_NORMAL, "\nSummary\n" ); 
     1896    debugOutputShort( DEBUG_LEVEL_NORMAL, "-------\n\n" ); 
     1897    debugOutputShort( DEBUG_LEVEL_NORMAL, "Nr | AddressType     | Direction | SubUnitType | SubUnitId | FunctionBlockType | FunctionBlockId | Id   | Type         |Name\n" ); 
     1898    debugOutputShort( DEBUG_LEVEL_NORMAL, "---+-----------------+-----------+-------------+-----------+-------------------+-----------------+------+--------------+------\n" ); 
    18991899 
    19001900    for ( AvPlugVector::const_iterator it = m_plugs.begin(); 
     
    19041904        AvPlug* plug = *it; 
    19051905 
    1906         printf( "%2d | %15s | %9s | %11s |      0x%02x |              0x%02x |            0x%02x | 0x%02x | %12s | %s\n", 
     1906        debugOutputShort( DEBUG_LEVEL_NORMAL, "%2d | %15s | %9s | %11s |      0x%02x |              0x%02x |            0x%02x | 0x%02x | %12s | %s\n", 
    19071907                plug->getGlobalId(), 
    19081908                avPlugAddressTypeToString( plug->getPlugAddressType() ), 
     
    19171917    } 
    19181918 
    1919     printf( "\nConnections\n" ); 
    1920     printf( "-----------\n" ); 
     1919    debugOutputShort( DEBUG_LEVEL_NORMAL, "\nConnections\n" ); 
     1920    debugOutputShort( DEBUG_LEVEL_NORMAL, "-----------\n" ); 
    19211921 
    19221922    AvPlugConnectionOwnerVector connections; 
     
    19431943    } 
    19441944 
    1945     printf( "digraph avcconnections {\n" ); 
     1945    debugOutputShort( DEBUG_LEVEL_NORMAL, "digraph avcconnections {\n" ); 
    19461946    for ( AvPlugConnectionOwnerVector::iterator it = connections.begin(); 
    19471947          it != connections.end(); 
     
    19491949    { 
    19501950        AvPlugConnection& con = *it; 
    1951         printf( "\t\"(%d) %s\" -> \"(%d) %s\"\n", 
     1951        debugOutputShort( DEBUG_LEVEL_NORMAL, "\t\"(%d) %s\" -> \"(%d) %s\"\n", 
    19521952                con.getSrcPlug().getGlobalId(), 
    19531953                con.getSrcPlug().getName(), 
     
    19621962        if ( plug->getFunctionBlockType() != 0xff ) { 
    19631963            if ( plug->getPlugDirection() == AvPlug::eAPD_Input ) { 
    1964                 printf( "\t\"(%d) %s\" -> \"(0x%02x,%d)\"\n", 
     1964                debugOutputShort( DEBUG_LEVEL_NORMAL, "\t\"(%d) %s\" -> \"(0x%02x,%d)\"\n", 
    19651965                        plug->getGlobalId(), 
    19661966                        plug->getName(), 
     
    19681968                        plug->getFunctionBlockId() ); 
    19691969            } else { 
    1970                 printf( "\t\"(0x%02x,%d)\" -> \t\"(%d) %s\"\n", 
     1970                debugOutputShort( DEBUG_LEVEL_NORMAL, "\t\"(0x%02x,%d)\" -> \t\"(%d) %s\"\n", 
    19711971                        plug->getFunctionBlockType(), 
    19721972                        plug->getFunctionBlockId(), 
     
    19911991    { 
    19921992        AvPlug* plug = *it; 
    1993         printf( "\t\"(%d) %s\" [color=%s,style=filled];\n", 
     1993        debugOutputShort( DEBUG_LEVEL_NORMAL, "\t\"(%d) %s\" [color=%s,style=filled];\n", 
    19941994                plug->getGlobalId(), plug->getName(), 
    19951995                colorStrings[plug->getPlugAddressType() ] ); 
    19961996    } 
    19971997 
    1998     printf("}\n" ); 
    1999     printf( "Use \"dot -Tps FILENAME.dot -o FILENAME.ps\" " 
     1998    debugOutputShort( DEBUG_LEVEL_NORMAL,"}\n" ); 
     1999    debugOutputShort( DEBUG_LEVEL_NORMAL, "Use \"dot -Tps FILENAME.dot -o FILENAME.ps\" " 
    20002000            "to generate graph\n"); 
    20012001 
  • branches/streaming-rework/src/bebob/bebob_avplug.h

    r435 r438  
    239239    struct FormatInfo { 
    240240        FormatInfo() 
    241             : m_samplingFrequency( eSF_DontCare ) 
     241            : m_samplingFrequency( eSF_AVC_DontCare ) 
    242242            , m_isSyncStream( false ) 
    243243            , m_audioChannels( 0 ) 
  • branches/streaming-rework/src/bebob/bebob_functionblock.cpp

    r413 r438  
    123123        } 
    124124 
    125         debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n", 
     125        debugOutput( DEBUG_LEVEL_VERBOSE, "plug '%s' found\n", 
    126126                     plug->getName() ); 
    127127        m_plugs.push_back( plug ); 
  • branches/streaming-rework/src/bounce/bounce_avdevice.cpp

    r436 r438  
    5252                            int nodeId ) 
    5353    : IAvDevice( configRom, ieee1394service, nodeId ) 
    54     , m_samplerate (44100
     54    , m_samplerate (eSF_44100Hz
    5555    , m_model( NULL ) 
    5656    , m_Notifier ( NULL ) 
     
    124124} 
    125125 
    126 int BounceDevice::getSamplingFrequency( ) { 
     126ESampleRate 
     127BounceDevice::getSampleRate( ) { 
    127128    return m_samplerate; 
    128129} 
    129130 
    130 bool BounceDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) { 
    131     int retval=convertESamplingFrequency( samplingFrequency ); 
    132     if (retval) { 
    133         m_samplerate=retval; 
    134         return true; 
    135     } else return false; 
     131bool 
     132BounceDevice::setSampleRate( ESampleRate sampleRate ) { 
     133    m_samplerate=sampleRate; 
     134    return true; 
    136135} 
    137136 
  • branches/streaming-rework/src/bounce/bounce_avdevice.h

    r436 r438  
    7373    bool discover(); 
    7474     
    75     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    76     int getSamplingFrequency( ); 
     75    bool setSampleRate( ESampleRate ); 
     76    ESampleRate getSampleRate( ); 
    7777     
    7878    bool prepare(); 
     
    9090 
    9191protected: 
    92     unsigned int m_samplerate; 
     92    ESampleRate m_samplerate; 
    9393    struct VendorModelEntry* m_model; 
    9494 
  • branches/streaming-rework/src/dice/dice_avdevice.cpp

    r436 r438  
    138138} 
    139139 
    140 int  
    141 DiceAvDevice::getSamplingFrequency( ) { 
    142     ESamplingFrequency samplingFrequency; 
     140ESampleRate 
     141DiceAvDevice::getSampleRate( ) { 
     142    ESampleRate samplingFrequency; 
    143143     
    144144    fb_quadlet_t clockreg; 
    145145    if (!readGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, &clockreg)) { 
    146146        debugError("Could not read CLOCK_SELECT register\n"); 
    147         return false; 
     147        return eSF_DontCare; 
    148148    } 
    149149     
     
    165165    } 
    166166     
    167     return convertESamplingFrequency(samplingFrequency)
    168 } 
    169  
    170 bool 
    171 DiceAvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     167    return samplingFrequency
     168} 
     169 
     170bool 
     171DiceAvDevice::setSampleRate( ESampleRate samplingFrequency ) 
    172172{ 
    173173    debugOutput(DEBUG_LEVEL_VERBOSE, "Setting sample rate: %d\n",  
    174         convertESamplingFrequency(samplingFrequency)); 
     174        convertESampleRate(samplingFrequency)); 
    175175         
    176176    bool supported=false; 
     
    228228 
    229229    if (!supported) { 
    230         debugWarning("Unsupported sample rate: %d\n", convertESamplingFrequency(samplingFrequency)); 
     230        debugWarning("Unsupported sample rate: %d\n", convertESampleRate(samplingFrequency)); 
    231231        return false; 
    232232    } 
     
    271271    fb_octlet_t tmp_octlet; 
    272272     
    273     debugOutput(DEBUG_LEVEL_VERBOSE
     273    debugOutputShort(DEBUG_LEVEL_NORMAL
    274274        "%s %s at node %d\n", m_model->vendor_name, m_model->model_name, 
    275275        m_nodeId); 
    276276 
    277     debugOutput(DEBUG_LEVEL_VERBOSE," DICE Parameter Space info:\n"); 
    278     debugOutput(DEBUG_LEVEL_VERBOSE,"  Global  : offset=0x%04X size=%04d\n", m_global_reg_offset, m_global_reg_size); 
    279     debugOutput(DEBUG_LEVEL_VERBOSE,"  TX      : offset=0x%04X size=%04d\n", m_tx_reg_offset, m_tx_reg_size); 
    280     debugOutput(DEBUG_LEVEL_VERBOSE,"                nb=%4d size=%04d\n", m_nb_tx, m_tx_size); 
    281     debugOutput(DEBUG_LEVEL_VERBOSE,"  RX      : offset=0x%04X size=%04d\n", m_rx_reg_offset, m_rx_reg_size); 
    282     debugOutput(DEBUG_LEVEL_VERBOSE,"                nb=%4d size=%04d\n", m_nb_rx, m_rx_size); 
    283     debugOutput(DEBUG_LEVEL_VERBOSE,"  UNUSED1 : offset=0x%04X size=%04d\n", m_unused1_reg_offset, m_unused1_reg_size); 
    284     debugOutput(DEBUG_LEVEL_VERBOSE,"  UNUSED2 : offset=0x%04X size=%04d\n", m_unused2_reg_offset, m_unused2_reg_size); 
    285  
    286     debugOutput(DEBUG_LEVEL_VERBOSE," Global param space:\n"); 
     277    debugOutputShort(DEBUG_LEVEL_NORMAL," DICE Parameter Space info:\n"); 
     278    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Global  : offset=0x%04X size=%04d\n", m_global_reg_offset, m_global_reg_size); 
     279    debugOutputShort(DEBUG_LEVEL_NORMAL,"  TX      : offset=0x%04X size=%04d\n", m_tx_reg_offset, m_tx_reg_size); 
     280    debugOutputShort(DEBUG_LEVEL_NORMAL,"                nb=%4d size=%04d\n", m_nb_tx, m_tx_size); 
     281    debugOutputShort(DEBUG_LEVEL_NORMAL,"  RX      : offset=0x%04X size=%04d\n", m_rx_reg_offset, m_rx_reg_size); 
     282    debugOutputShort(DEBUG_LEVEL_NORMAL,"                nb=%4d size=%04d\n", m_nb_rx, m_rx_size); 
     283    debugOutputShort(DEBUG_LEVEL_NORMAL,"  UNUSED1 : offset=0x%04X size=%04d\n", m_unused1_reg_offset, m_unused1_reg_size); 
     284    debugOutputShort(DEBUG_LEVEL_NORMAL,"  UNUSED2 : offset=0x%04X size=%04d\n", m_unused2_reg_offset, m_unused2_reg_size); 
     285 
     286    debugOutputShort(DEBUG_LEVEL_NORMAL," Global param space:\n"); 
    287287     
    288288    readGlobalRegBlock(DICE_REGISTER_GLOBAL_OWNER, (fb_quadlet_t *)&tmp_octlet,sizeof(fb_octlet_t)); 
    289     debugOutput(DEBUG_LEVEL_VERBOSE,"  Owner            : 0x%016X\n",tmp_octlet); 
     289    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Owner            : 0x%016X\n",tmp_octlet); 
    290290     
    291291    readGlobalReg(DICE_REGISTER_GLOBAL_NOTIFICATION, &tmp_quadlet); 
    292     debugOutput(DEBUG_LEVEL_VERBOSE,"  Notification     : 0x%08X\n",tmp_quadlet); 
     292    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Notification     : 0x%08X\n",tmp_quadlet); 
    293293     
    294294    readGlobalReg(DICE_REGISTER_GLOBAL_NOTIFICATION, &tmp_quadlet); 
    295     debugOutput(DEBUG_LEVEL_VERBOSE,"  Nick name        : %s\n",getDeviceNickName().c_str()); 
     295    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Nick name        : %s\n",getDeviceNickName().c_str()); 
    296296     
    297297    readGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, &tmp_quadlet); 
    298     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock Select     : 0x%02X 0x%02X\n", 
     298    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Clock Select     : 0x%02X 0x%02X\n", 
    299299        (tmp_quadlet>>8) & 0xFF, tmp_quadlet & 0xFF); 
    300300     
    301301    readGlobalReg(DICE_REGISTER_GLOBAL_ENABLE, &tmp_quadlet); 
    302     debugOutput(DEBUG_LEVEL_VERBOSE,"  Enable           : %s\n", 
     302    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Enable           : %s\n", 
    303303        (tmp_quadlet&0x1?"true":"false")); 
    304304     
    305305    readGlobalReg(DICE_REGISTER_GLOBAL_STATUS, &tmp_quadlet); 
    306     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock Status     : %s 0x%02X\n", 
     306    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Clock Status     : %s 0x%02X\n", 
    307307        (tmp_quadlet&0x1?"locked":"not locked"), (tmp_quadlet>>8) & 0xFF); 
    308308     
    309309    readGlobalReg(DICE_REGISTER_GLOBAL_EXTENDED_STATUS, &tmp_quadlet); 
    310     debugOutput(DEBUG_LEVEL_VERBOSE,"  Extended Status  : 0x%08X\n",tmp_quadlet); 
     310    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Extended Status  : 0x%08X\n",tmp_quadlet); 
    311311     
    312312    readGlobalReg(DICE_REGISTER_GLOBAL_SAMPLE_RATE, &tmp_quadlet); 
    313     debugOutput(DEBUG_LEVEL_VERBOSE,"  Samplerate       : 0x%08X (%lu)\n",tmp_quadlet,tmp_quadlet); 
     313    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Samplerate       : 0x%08X (%lu)\n",tmp_quadlet,tmp_quadlet); 
    314314     
    315315    readGlobalReg(DICE_REGISTER_GLOBAL_VERSION, &tmp_quadlet); 
    316     debugOutput(DEBUG_LEVEL_VERBOSE,"  Version          : 0x%08X (%u.%u.%u.%u)\n", 
     316    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Version          : 0x%08X (%u.%u.%u.%u)\n", 
    317317        tmp_quadlet, 
    318318        DICE_DRIVER_SPEC_VERSION_NUMBER_GET_A(tmp_quadlet), 
     
    323323     
    324324    readGlobalReg(DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, &tmp_quadlet); 
    325     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock caps       : 0x%08X\n",tmp_quadlet & 0x1FFF007F); 
     325    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Clock caps       : 0x%08X\n",tmp_quadlet & 0x1FFF007F); 
    326326 
    327327    diceNameVector names=getClockSourceNameString(); 
    328     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock sources    :\n"); 
     328    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Clock sources    :\n"); 
    329329     
    330330    for ( diceNameVectorIterator it = names.begin(); 
     
    332332          ++it ) 
    333333    { 
    334         debugOutput(DEBUG_LEVEL_VERBOSE,"    %s\n", (*it).c_str()); 
    335     } 
    336      
    337     debugOutput(DEBUG_LEVEL_VERBOSE," TX param space:\n"); 
    338     debugOutput(DEBUG_LEVEL_VERBOSE,"  Nb of xmit        : %1d\n", m_nb_tx); 
     334        debugOutputShort(DEBUG_LEVEL_NORMAL,"    %s\n", (*it).c_str()); 
     335    } 
     336     
     337    debugOutputShort(DEBUG_LEVEL_NORMAL," TX param space:\n"); 
     338    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Nb of xmit        : %1d\n", m_nb_tx); 
    339339    for (unsigned int i=0;i<m_nb_tx;i++) { 
    340         debugOutput(DEBUG_LEVEL_VERBOSE,"  Transmitter %d:\n",i); 
     340        debugOutputShort(DEBUG_LEVEL_NORMAL,"  Transmitter %d:\n",i); 
    341341         
    342342        readTxReg(i, DICE_REGISTER_TX_ISOC_BASE, &tmp_quadlet); 
    343         debugOutput(DEBUG_LEVEL_VERBOSE,"   ISO channel       : %3d\n", tmp_quadlet); 
     343        debugOutputShort(DEBUG_LEVEL_NORMAL,"   ISO channel       : %3d\n", tmp_quadlet); 
    344344        readTxReg(i, DICE_REGISTER_TX_SPEED_BASE, &tmp_quadlet); 
    345         debugOutput(DEBUG_LEVEL_VERBOSE,"   ISO speed         : %3d\n", tmp_quadlet); 
     345        debugOutputShort(DEBUG_LEVEL_NORMAL,"   ISO speed         : %3d\n", tmp_quadlet); 
    346346         
    347347        readTxReg(i, DICE_REGISTER_TX_NB_AUDIO_BASE, &tmp_quadlet); 
    348         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb audio channels : %3d\n", tmp_quadlet); 
     348        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Nb audio channels : %3d\n", tmp_quadlet); 
    349349        readTxReg(i, DICE_REGISTER_TX_MIDI_BASE, &tmp_quadlet); 
    350         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb midi channels  : %3d\n", tmp_quadlet); 
     350        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Nb midi channels  : %3d\n", tmp_quadlet); 
    351351         
    352352        readTxReg(i, DICE_REGISTER_TX_AC3_CAPABILITIES_BASE, &tmp_quadlet); 
    353         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 caps          : 0x%08X\n", tmp_quadlet); 
     353        debugOutputShort(DEBUG_LEVEL_NORMAL,"   AC3 caps          : 0x%08X\n", tmp_quadlet); 
    354354        readTxReg(i, DICE_REGISTER_TX_AC3_ENABLE_BASE, &tmp_quadlet); 
    355         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 enable        : 0x%08X\n", tmp_quadlet); 
     355        debugOutputShort(DEBUG_LEVEL_NORMAL,"   AC3 enable        : 0x%08X\n", tmp_quadlet); 
    356356         
    357357        diceNameVector channel_names=getTxNameString(i); 
    358         debugOutput(DEBUG_LEVEL_VERBOSE,"   Channel names     :\n"); 
     358        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Channel names     :\n"); 
    359359        for ( diceNameVectorIterator it = channel_names.begin(); 
    360360            it != channel_names.end(); 
    361361            ++it ) 
    362362        { 
    363             debugOutput(DEBUG_LEVEL_VERBOSE,"     %s\n", (*it).c_str()); 
    364         } 
    365     } 
    366      
    367     debugOutput(DEBUG_LEVEL_VERBOSE," RX param space:\n"); 
    368     debugOutput(DEBUG_LEVEL_VERBOSE,"  Nb of recv        : %1d\n", m_nb_tx); 
     363            debugOutputShort(DEBUG_LEVEL_NORMAL,"     %s\n", (*it).c_str()); 
     364        } 
     365    } 
     366     
     367    debugOutputShort(DEBUG_LEVEL_NORMAL," RX param space:\n"); 
     368    debugOutputShort(DEBUG_LEVEL_NORMAL,"  Nb of recv        : %1d\n", m_nb_tx); 
    369369    for (unsigned int i=0;i<m_nb_rx;i++) { 
    370         debugOutput(DEBUG_LEVEL_VERBOSE,"  Receiver %d:\n",i); 
     370        debugOutputShort(DEBUG_LEVEL_NORMAL,"  Receiver %d:\n",i); 
    371371         
    372372        readTxReg(i, DICE_REGISTER_RX_ISOC_BASE, &tmp_quadlet); 
    373         debugOutput(DEBUG_LEVEL_VERBOSE,"   ISO channel       : %3d\n", tmp_quadlet); 
     373        debugOutputShort(DEBUG_LEVEL_NORMAL,"   ISO channel       : %3d\n", tmp_quadlet); 
    374374        readTxReg(i, DICE_REGISTER_RX_SEQ_START_BASE, &tmp_quadlet); 
    375         debugOutput(DEBUG_LEVEL_VERBOSE,"   Sequence start    : %3d\n", tmp_quadlet); 
     375        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Sequence start    : %3d\n", tmp_quadlet); 
    376376         
    377377        readTxReg(i, DICE_REGISTER_RX_NB_AUDIO_BASE, &tmp_quadlet); 
    378         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb audio channels : %3d\n", tmp_quadlet); 
     378        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Nb audio channels : %3d\n", tmp_quadlet); 
    379379        readTxReg(i, DICE_REGISTER_RX_MIDI_BASE, &tmp_quadlet); 
    380         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb midi channels  : %3d\n", tmp_quadlet); 
     380        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Nb midi channels  : %3d\n", tmp_quadlet); 
    381381         
    382382        readTxReg(i, DICE_REGISTER_RX_AC3_CAPABILITIES_BASE, &tmp_quadlet); 
    383         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 caps          : 0x%08X\n", tmp_quadlet); 
     383        debugOutputShort(DEBUG_LEVEL_NORMAL,"   AC3 caps          : 0x%08X\n", tmp_quadlet); 
    384384        readTxReg(i, DICE_REGISTER_RX_AC3_ENABLE_BASE, &tmp_quadlet); 
    385         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 enable        : 0x%08X\n", tmp_quadlet); 
     385        debugOutputShort(DEBUG_LEVEL_NORMAL,"   AC3 enable        : 0x%08X\n", tmp_quadlet); 
    386386         
    387387        diceNameVector channel_names=getRxNameString(i); 
    388         debugOutput(DEBUG_LEVEL_VERBOSE,"   Channel names     :\n"); 
     388        debugOutputShort(DEBUG_LEVEL_NORMAL,"   Channel names     :\n"); 
    389389        for ( diceNameVectorIterator it = channel_names.begin(); 
    390390            it != channel_names.end(); 
    391391            ++it ) 
    392392        { 
    393             debugOutput(DEBUG_LEVEL_VERBOSE,"     %s\n", (*it).c_str()); 
     393            debugOutputShort(DEBUG_LEVEL_NORMAL,"     %s\n", (*it).c_str()); 
    394394        } 
    395395    } 
     
    414414bool 
    415415DiceAvDevice::prepare() { 
    416     int samplerate=getSamplingFrequency(); 
     416    int samplerate=getSampleRate(); 
    417417 
    418418    // prepare receive SP's 
    419     for (unsigned int i=0;i<m_nb_tx;i++) { 
     419    for (unsigned int i=0;i<1;i++) { 
     420//     for (unsigned int i=0;i<m_nb_tx;i++) { 
    420421        fb_quadlet_t nb_audio; 
    421422        fb_quadlet_t nb_midi; 
     
    504505     
    505506    // prepare transmit SP's 
    506     for (unsigned int i=0;i<m_nb_rx;i++) { 
     507    for (unsigned int i=0;i<1;i++) { 
     508//    for (unsigned int i=0;i<m_nb_rx;i++) { 
    507509        fb_quadlet_t nb_audio; 
    508510        fb_quadlet_t nb_midi; 
  • branches/streaming-rework/src/dice/dice_avdevice.h

    r436 r438  
    6262    void showDevice(); 
    6363 
    64     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    65     int getSamplingFrequency( ); 
     64    bool setSampleRate( ESampleRate ); 
     65    ESampleRate getSampleRate( ); 
    6666 
    6767    int getStreamCount(); 
  • branches/streaming-rework/src/freebob.cpp

    r436 r438  
    132132    IAvDevice* avDevice = freebob_handle->m_deviceManager->getAvDevice( node_id ); 
    133133    if ( avDevice ) { 
    134         if ( avDevice->setSamplingFrequency( parseSampleRate( samplerate ) ) ) { 
     134        if ( avDevice->setSampleRate( parseSampleRate( samplerate ) ) ) { 
    135135            return freebob_handle->m_deviceManager->discover()? 0 : -1; 
    136136        } 
  • branches/streaming-rework/src/freebob_streaming.cpp

    r436 r438  
    162162        // Set the device's sampling rate to that requested 
    163163        // FIXME: does this really belong here?  If so we need to handle errors. 
    164         if (!device->setSamplingFrequency(parseSampleRate(dev->options.sample_rate))) { 
     164        if (!device->setSampleRate(parseSampleRate(dev->options.sample_rate))) { 
    165165            debugOutput(DEBUG_LEVEL_VERBOSE, " => Retry setting samplerate to %d for (%p)\n",  
    166166                        dev->options.sample_rate, device); 
    167167         
    168168            // try again: 
    169             if (!device->setSamplingFrequency(parseSampleRate(dev->options.sample_rate))) { 
     169            if (!device->setSampleRate(parseSampleRate(dev->options.sample_rate))) { 
    170170                delete dev->processorManager; 
    171171                delete dev->m_deviceManager; 
  • branches/streaming-rework/src/iavdevice.h

    r436 r438  
    2222#define IAVDEVICE_H 
    2323 
    24 #include "libavc/avc_definitions.h" 
     24#include "freebob-interface.h" 
    2525#include "libutil/OptionContainer.h" 
    2626#include "libosc/OscNode.h" 
     27#include <ostream> 
    2728 
    2829class ConfigRom; 
     
    3233    class StreamProcessor; 
    3334} 
     35 
    3436/*! 
    3537@brief Base class for device support 
     
    6163         
    6264        /** 
    63          * @brief Set the samping frequency 
    64          * @param samplingFrequency  
     65         * @brief Set the sample rate 
     66         * @param sampleRate  
    6567         * @return true if successful 
    6668         */ 
    67         virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ) = 0; 
    68         /** 
    69          * @brief get the samplingfrequency as an integer 
    70          * @return the sampling frequency as integer 
    71          */ 
    72         virtual int getSamplingFrequency( ) = 0; 
     69        virtual bool setSampleRate( ESampleRate sampleRate ) = 0; 
     70        /** 
     71         * @brief get the sample rate as an integer 
     72         * @return the sample rate as ESampleRate 
     73         */ 
     74        virtual ESampleRate getSampleRate( ) = 0; 
    7375         
    7476    /** 
  • branches/streaming-rework/src/libavc/avc_definitions.cpp

    r415 r438  
    2121#include "avc_definitions.h" 
    2222 
    23  
    2423int 
    25 convertESamplingFrequency(ESamplingFrequency freq) 
     24convertAvcSamplingFrequency(ESamplingFrequency freq) 
    2625{ 
    2726    int value = 0; 
    2827 
    2928    switch ( freq ) { 
    30     case eSF_22050Hz: 
     29    case eSF_AVC_22050Hz: 
    3130        value = 22050; 
    3231        break; 
    33     case eSF_24000Hz: 
     32    case eSF_AVC_24000Hz: 
    3433        value = 24000; 
    3534        break; 
    36     case eSF_32000Hz: 
     35    case eSF_AVC_32000Hz: 
    3736        value = 32000; 
    3837        break; 
    39     case eSF_44100Hz: 
     38    case eSF_AVC_44100Hz: 
    4039        value = 44100; 
    4140        break; 
    42     case eSF_48000Hz: 
     41    case eSF_AVC_48000Hz: 
    4342        value = 48000; 
    4443        break; 
    45     case eSF_88200Hz: 
     44    case eSF_AVC_88200Hz: 
    4645        value = 88200; 
    4746        break; 
    48     case eSF_96000Hz: 
     47    case eSF_AVC_96000Hz: 
    4948        value = 96000; 
    5049        break; 
    51     case eSF_176400Hz: 
     50    case eSF_AVC_176400Hz: 
    5251        value = 176400; 
    5352        break; 
    54     case eSF_192000Hz: 
    55         value = 192000; 
    56         break; 
    57     case eSF_AnyLow: 
    58         value = 48000; 
    59         break; 
    60     case eSF_AnyMid: 
    61         value = 96000; 
    62         break; 
    63     case eSF_AnyHigh: 
     53    case eSF_AVC_192000Hz: 
    6454        value = 192000; 
    6555        break; 
     
    7363 
    7464ESamplingFrequency 
    75 parseSampleRate( int sampleRate ) 
     65parseAvcSamplingFrequency( int sampleRate ) 
    7666{ 
    7767    ESamplingFrequency efreq; 
    7868    switch ( sampleRate ) { 
    7969    case 22050: 
    80         efreq = eSF_22050Hz; 
     70        efreq = eSF_AVC_22050Hz; 
    8171        break; 
    8272    case 24000: 
    83         efreq = eSF_24000Hz; 
     73        efreq = eSF_AVC_24000Hz; 
    8474        break; 
    8575    case 32000: 
    86         efreq = eSF_32000Hz; 
     76        efreq = eSF_AVC_32000Hz; 
    8777        break; 
    8878    case 44100: 
    89         efreq = eSF_44100Hz; 
     79        efreq = eSF_AVC_44100Hz; 
    9080        break; 
    9181    case 48000: 
    92         efreq = eSF_48000Hz; 
     82        efreq = eSF_AVC_48000Hz; 
    9383        break; 
    9484    case 88200: 
    95         efreq = eSF_88200Hz; 
     85        efreq = eSF_AVC_88200Hz; 
    9686        break; 
    9787    case 96000: 
    98         efreq = eSF_96000Hz; 
     88        efreq = eSF_AVC_96000Hz; 
    9989        break; 
    10090    case 176400: 
    101         efreq = eSF_176400Hz; 
     91        efreq = eSF_AVC_176400Hz; 
    10292        break; 
    10393    case 192000: 
    104         efreq = eSF_192000Hz; 
     94        efreq = eSF_AVC_192000Hz; 
    10595        break; 
    10696    default: 
    107         efreq = eSF_DontCare; 
     97        efreq = eSF_AVC_DontCare; 
    10898    } 
    10999 
     
    115105    char* str; 
    116106    switch ( samplingFrequency ) { 
    117     case eSF_22050Hz: 
     107    case eSF_AVC_22050Hz: 
    118108        str = "22050"; 
    119109        break; 
    120     case eSF_24000Hz: 
     110    case eSF_AVC_24000Hz: 
    121111        str = "24000"; 
    122112        break; 
    123     case eSF_32000Hz: 
     113    case eSF_AVC_32000Hz: 
    124114        str = "32000"; 
    125115        break; 
    126     case eSF_44100Hz: 
     116    case eSF_AVC_44100Hz: 
    127117        str = "44100"; 
    128118        break; 
    129     case eSF_48000Hz: 
     119    case eSF_AVC_48000Hz: 
    130120        str = "48000"; 
    131121        break; 
    132     case eSF_88200Hz: 
     122    case eSF_AVC_88200Hz: 
    133123        str = "88200"; 
    134124        break; 
    135     case eSF_96000Hz: 
     125    case eSF_AVC_96000Hz: 
    136126        str = "96000"; 
    137127        break; 
    138     case eSF_176400Hz: 
     128    case eSF_AVC_176400Hz: 
    139129        str = "176400"; 
    140130        break; 
    141     case eSF_192000Hz: 
     131    case eSF_AVC_192000Hz: 
    142132        str = "192000"; 
    143133        break; 
    144     case eSF_DontCare: 
     134    case eSF_AVC_DontCare: 
    145135    default: 
    146136        str = "unknown"; 
     
    148138    return stream << str; 
    149139}; 
     140 
     141ESamplingFrequency 
     142toAvcSamplingFrequency( ESampleRate r ) { 
     143    int value = 0; 
     144 
     145    switch ( r ) { 
     146    case eSF_22050Hz: 
     147        return eSF_AVC_22050Hz; 
     148    case eSF_24000Hz: 
     149        return eSF_AVC_24000Hz; 
     150    case eSF_32000Hz: 
     151        return eSF_AVC_32000Hz; 
     152    case eSF_44100Hz: 
     153        return eSF_AVC_44100Hz; 
     154    case eSF_48000Hz: 
     155        return eSF_AVC_48000Hz; 
     156    case eSF_88200Hz: 
     157        return eSF_AVC_88200Hz; 
     158    case eSF_96000Hz: 
     159        return eSF_AVC_96000Hz; 
     160    case eSF_176400Hz: 
     161        return eSF_AVC_176400Hz; 
     162    case eSF_192000Hz: 
     163        return eSF_AVC_192000Hz; 
     164    default: 
     165        return eSF_AVC_DontCare; 
     166    } 
     167} 
     168 
     169ESampleRate 
     170fromAvcSamplingFrequency( ESamplingFrequency r ) { 
     171    int value = 0; 
     172 
     173    switch ( r ) { 
     174    case eSF_AVC_22050Hz: 
     175        return eSF_22050Hz; 
     176    case eSF_AVC_24000Hz: 
     177        return eSF_24000Hz; 
     178    case eSF_AVC_32000Hz: 
     179        return eSF_32000Hz; 
     180    case eSF_AVC_44100Hz: 
     181        return eSF_44100Hz; 
     182    case eSF_AVC_48000Hz: 
     183        return eSF_48000Hz; 
     184    case eSF_AVC_88200Hz: 
     185        return eSF_88200Hz; 
     186    case eSF_AVC_96000Hz: 
     187        return eSF_96000Hz; 
     188    case eSF_AVC_176400Hz: 
     189        return eSF_176400Hz; 
     190    case eSF_AVC_192000Hz: 
     191        return eSF_192000Hz; 
     192    default: 
     193        return eSF_DontCare; 
     194    } 
     195} 
  • branches/streaming-rework/src/libavc/avc_definitions.h

    r415 r438  
    2424#include <libavc1394/avc1394.h> 
    2525#include <ostream> 
     26#include "freebob-interface.h" 
    2627 
    2728typedef byte_t ctype_t; 
     
    8182 */ 
    8283enum ESamplingFrequency { 
    83     eSF_22050Hz = 0x00, 
    84     eSF_24000Hz = 0x01, 
    85     eSF_32000Hz = 0x02, 
    86     eSF_44100Hz = 0x03, 
    87     eSF_48000Hz = 0x04, 
    88     eSF_88200Hz = 0x0A, 
    89     eSF_96000Hz = 0x05, 
    90     eSF_176400Hz = 0x06, 
    91     eSF_192000Hz = 0x07, 
    92     eSF_AnyLow   = 0x0B, 
    93     eSF_AnyMid   = 0x0C, 
    94     eSF_AnyHigh  = 0x0D, 
    95     eSF_None     = 0x0E, 
    96     eSF_DontCare = 0x0F, 
     84    eSF_AVC_22050Hz = 0x00, 
     85    eSF_AVC_24000Hz = 0x01, 
     86    eSF_AVC_32000Hz = 0x02, 
     87    eSF_AVC_44100Hz = 0x03, 
     88    eSF_AVC_48000Hz = 0x04, 
     89    eSF_AVC_88200Hz = 0x0A, 
     90    eSF_AVC_96000Hz = 0x05, 
     91    eSF_AVC_176400Hz = 0x06, 
     92    eSF_AVC_192000Hz = 0x07, 
     93    eSF_AVC_DontCare = 0x0F, 
    9794}; 
    9895 
     
    10299 * @return  
    103100 */ 
    104 int convertESamplingFrequency(ESamplingFrequency freq); 
     101int convertAvcSamplingFrequency(ESamplingFrequency freq); 
    105102/** 
    106103 * \brief Convert from integer to ESamplingFrequency 
     
    108105 * @return  
    109106 */ 
    110 ESamplingFrequency parseSampleRate( int sampleRate ); 
     107ESamplingFrequency parseAvcSamplingFrequency( int sampleRate ); 
     108 
     109ESampleRate fromAvcSamplingFrequency( ESamplingFrequency r ); 
     110ESamplingFrequency toAvcSamplingFrequency( ESampleRate r ); 
    111111 
    112112std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency ); 
  • branches/streaming-rework/src/libavc/avc_extended_stream_format.cpp

    r413 r438  
    7474    : FormatInformationStreams() 
    7575    , m_reserved0( 0xff ) 
    76     , m_samplingFrequency( eSF_DontCare ) 
     76    , m_samplingFrequency( eSF_AVC_DontCare ) 
    7777    , m_rateControl( eRC_DontCare ) 
    7878    , m_reserved1( 0xff ) 
     
    135135FormatInformationStreamsCompound::FormatInformationStreamsCompound() 
    136136    : FormatInformationStreams() 
    137     , m_samplingFrequency( eSF_DontCare ) 
     137    , m_samplingFrequency( eSF_AVC_DontCare ) 
    138138    , m_rateControl( eRC_DontCare ) 
    139139    , m_numberOfStreamFormatInfos( 0 ) 
  • branches/streaming-rework/src/Makefile.am

    r435 r438  
    1717# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
    1818 
    19 INCLUDES =                                            
    20        $(LIBRAW1394_CFLAGS) $(LIBIEC61883_CFLAGS)     
    21        $(LIBAVC1394_CFLAGS)   
    22        $(LIBXMLCPP_CFLAGS)     $(LIBLO_CFLAGS)                 
    23        -I$(top_srcdir) -I$(top_srcdir)/src 
     19INCLUDES =                        
     20    $(LIBRAW1394_CFLAGS) $(LIBIEC61883_CFLAGS)     
     21    $(LIBAVC1394_CFLAGS)   
     22    $(LIBXMLCPP_CFLAGS)    $(LIBLO_CFLAGS)           
     23    -I$(top_srcdir) -I$(top_srcdir)/src 
    2424 
    2525lib_LTLIBRARIES = libfreebob.la 
    2626 
    27 libfreebob_la_LDFLAGS =                                
    28        -version-info $(LT_VERSION) $(LIBRAW1394_LIBS) 
    29        $(LIBIEC61883_LIBS) $(LIBAVC1394_LIBS)         
    30        $(LIBXMLCPP_LIBS) $(LIBLO_LIBS) \ 
    31        -lpthread -lrt 
     27libfreebob_la_LDFLAGS =                
     28    -version-info $(LT_VERSION) $(LIBRAW1394_LIBS)     
     29    $(LIBIEC61883_LIBS) $(LIBAVC1394_LIBS)         
     30    $(LIBXMLCPP_LIBS) $(LIBLO_LIBS) \ 
     31    -lpthread -lrt 
    3232 
    3333libfreebob_la_LIBADD = -lrt 
    3434 
    3535noinst_HEADERS = \ 
    36     libieee1394/configrom.h libieee1394/csr1212.h \ 
    37     libieee1394/ieee1394service.h libieee1394/ARMHandler.h \ 
     36    libieee1394/configrom.h \ 
     37    libieee1394/csr1212.h \ 
     38    libieee1394/ieee1394service.h \ 
     39    libieee1394/ARMHandler.h \ 
    3840    libieee1394/IEC61883.h \ 
    3941    debugmodule/debugmodule.h \ 
    40         devicemanager.h fbtypes.h iavdevice.h threads.h bebob/bebob_avdevice.h \ 
    41         bebob/bebob_avdevice_subunit.h bebob/bebob_avplug.h bebob/bebob_dl_bcd.h bebob/bebob_dl_codes.h \ 
    42         bebob/bebob_dl_mgr.h bebob/bebob_functionblock.h bounce/bounce_avdevice.h bounce/bounce_slave_avdevice.h \ 
    43         maudio/maudio_avdevice.h motu/motu_avdevice.h rme/rme_avdevice.h \ 
    44         metrichalo/mh_avdevice.h dice/dice_avdevice.h \ 
    45         libavc/avc_connect.h \ 
    46         libavc/avc_definitions.h libavc/avc_extended_cmd_generic.h \ 
    47         libavc/avc_extended_plug_info.h libavc/avc_extended_stream_format.h \ 
    48         libavc/avc_extended_subunit_info.h libavc/avc_function_block.h libavc/avc_generic.h \ 
    49         libavc/avc_plug_info.h libavc/avc_serialize.h libavc/avc_signal_source.h \ 
    50         libavc/avc_subunit_info.h libavc/avc_unit_info.h \ 
    51         libosc/OscArgument.h libosc/OscNode.h libosc/OscResponse.h libosc/OscServer.h libosc/OscMessage.h \ 
    52         libstreaming/AmdtpPort.h libstreaming/AmdtpPortInfo.h libstreaming/AmdtpStreamProcessor.h \ 
    53         libstreaming/AmdtpSlaveStreamProcessor.h \ 
    54         libstreaming/cip.h libstreaming/cycletimer.h libstreaming/IsoHandler.h \ 
    55         libstreaming/IsoHandlerManager.h libstreaming/IsoStream.h libstreaming/MotuPort.h \ 
    56         libstreaming/MotuPortInfo.h libstreaming/MotuStreamProcessor.h \ 
    57         libstreaming/Port.h libstreaming/PortManager.h \ 
    58         libstreaming/StreamProcessor.h libstreaming/StreamProcessorManager.h \ 
    59         libutil/Atomic.h libutil/cycles.h libutil/DelayLockedLoop.h libutil/PosixThread.h \ 
    60         libutil/ringbuffer.h libutil/OptionContainer.h \ 
    61         libutil/PacketBuffer.h libutil/StreamStatistics.h \ 
    62         libutil/serialize.h libutil/SystemTimeSource.h libutil/Thread.h libutil/Time.h \ 
    63         libutil/TimeSource.h libutil/TimestampedBuffer.h 
     42    devicemanager.h \ 
     43    fbtypes.h \ 
     44    iavdevice.h \ 
     45    threads.h \ 
     46    freebob-interface.h \ 
     47    bebob/bebob_avdevice.h \ 
     48    bebob/bebob_avdevice_subunit.h \ 
     49    bebob/bebob_avplug.h \ 
     50    bebob/bebob_dl_bcd.h \ 
     51    bebob/bebob_dl_codes.h \ 
     52    bebob/bebob_dl_mgr.h \ 
     53    bebob/bebob_functionblock.h \ 
     54    bounce/bounce_avdevice.h \ 
     55    bounce/bounce_slave_avdevice.h \ 
     56    maudio/maudio_avdevice.h \ 
     57    motu/motu_avdevice.h rme/rme_avdevice.h \ 
     58    metrichalo/mh_avdevice.h \ 
     59    dice/dice_avdevice.h \ 
     60    libavc/avc_connect.h \ 
     61    libavc/avc_definitions.h \ 
     62    libavc/avc_extended_cmd_generic.h \ 
     63    libavc/avc_extended_plug_info.h \ 
     64    libavc/avc_extended_stream_format.h \ 
     65    libavc/avc_extended_subunit_info.h \ 
     66    libavc/avc_function_block.h \ 
     67    libavc/avc_generic.h \ 
     68    libavc/avc_plug_info.h \ 
     69    libavc/avc_serialize.h \ 
     70    libavc/avc_signal_source.h \ 
     71    libavc/avc_subunit_info.h \ 
     72    libavc/avc_unit_info.h \ 
     73    libosc/OscArgument.h \ 
     74    libosc/OscNode.h \ 
     75    libosc/OscResponse.h \ 
     76    libosc/OscServer.h \ 
     77    libosc/OscMessage.h \ 
     78    libstreaming/AmdtpPort.h \ 
     79    libstreaming/AmdtpPortInfo.h \ 
     80    libstreaming/AmdtpStreamProcessor.h \ 
     81    libstreaming/AmdtpSlaveStreamProcessor.h \ 
     82    libstreaming/cip.h \ 
     83    libstreaming/cycletimer.h \ 
     84    libstreaming/IsoHandler.h \ 
     85    libstreaming/IsoHandlerManager.h \ 
     86    libstreaming/IsoStream.h \ 
     87    libstreaming/MotuPort.h \ 
     88    libstreaming/MotuPortInfo.h \ 
     89    libstreaming/MotuStreamProcessor.h \ 
     90    libstreaming/Port.h \ 
     91    libstreaming/PortManager.h \ 
     92    libstreaming/StreamProcessor.h \ 
     93    libstreaming/StreamProcessorManager.h \ 
     94    libutil/Atomic.h \ 
     95    libutil/cycles.h \ 
     96    libutil/DelayLockedLoop.h \ 
     97    libutil/PosixThread.h \ 
     98    libutil/ringbuffer.h \ 
     99    libutil/OptionContainer.h \ 
     100    libutil/PacketBuffer.h \ 
     101    libutil/StreamStatistics.h \ 
     102    libutil/serialize.h \ 
     103    libutil/SystemTimeSource.h \ 
     104    libutil/Thread.h \ 
     105    libutil/Time.h \ 
     106    libutil/TimeSource.h \ 
     107    libutil/TimestampedBuffer.h 
    64108 
    65109# common sources 
     
    68112        freebob.cpp \ 
    69113        freebob_streaming.cpp \ 
     114        freebob-interface.cpp \ 
    70115        iavdevice.cpp \ 
    71116        debugmodule/debugmodule.cpp \ 
     
    153198nobase_dist_pkgdata_DATA = 
    154199#  bebob specific 
    155 bebob_pkgdata =                                
    156        maudio/refdesign.xml                           
    157        maudio/fw410.xml                               
    158        maudio/fwap.xml 
     200bebob_pkgdata =                
     201    maudio/refdesign.xml               
     202    maudio/fw410.xml                 
     203    maudio/fwap.xml 
    159204 
    160205# programs intended for installation in the 'bin' directory 
  • branches/streaming-rework/src/maudio/maudio_avdevice.cpp

    r436 r438  
    108108 
    109109bool 
    110 AvDevice::setSamplingFrequency( ESamplingFrequency eSamplingFrequency
     110AvDevice::setSampleRate( ESampleRate eSampleRate
    111111{ 
    112112    // not supported 
     
    114114} 
    115115 
    116 int AvDevice::getSamplingFrequency( ) { 
    117     return 44100; 
     116ESampleRate 
     117AvDevice::getSampleRate( ) { 
     118    return parseSampleRate(44100); 
    118119} 
    119120 
  • branches/streaming-rework/src/maudio/maudio_avdevice.h

    r436 r438  
    5959    void showDevice(); 
    6060     
    61     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    62     int getSamplingFrequency( ); 
     61    bool setSampleRate( ESampleRate samplingFrequency ); 
     62    ESampleRate getSampleRate( ); 
    6363 
    6464    bool prepare(); 
  • branches/streaming-rework/src/metrichalo/mh_avdevice.cpp

    r436 r438  
    111111} 
    112112 
    113 int  
    114 MHAvDevice::getSamplingFrequency( ) { 
    115     return 0
     113ESampleRate 
     114MHAvDevice::getSampleRate( ) { 
     115    return eSF_DontCare
    116116} 
    117117 
    118118bool 
    119 MHAvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency
     119MHAvDevice::setSampleRate( ESampleRate sampleRate
    120120{ 
    121  
    122121    return false; 
    123122} 
  • branches/streaming-rework/src/metrichalo/mh_avdevice.h

    r436 r438  
    5454    void showDevice(); 
    5555 
    56     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    57     int getSamplingFrequency( ); 
     56    bool setSampleRate( ESampleRate samplingFrequency ); 
     57    ESampleRate getSampleRate( ); 
    5858 
    5959    int getStreamCount(); 
  • branches/streaming-rework/src/motu/motu_avdevice.cpp

    r436 r438  
    139139} 
    140140 
    141 int  
    142 MotuDevice::getSamplingFrequency( ) { 
     141ESampleRate 
     142MotuDevice::getSampleRate( ) { 
    143143/* 
    144144 * Retrieve the current sample rate from the MOTU device. 
     
    163163                        break; 
    164164        } 
    165         return rate
     165        return parseSampleRate(rate)
    166166} 
    167167 
    168168bool 
    169 MotuDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency
     169MotuDevice::setSampleRate( ESampleRate sampleRate
    170170{ 
    171171/* 
     
    176176        int i, supported=true, cancel_adat=false; 
    177177 
    178         switch ( samplingFrequency ) { 
     178        switch ( sampleRate ) { 
    179179                case eSF_22050Hz: 
    180180                        supported=false; 
     
    312312MotuDevice::prepare() { 
    313313 
    314         int samp_freq = getSamplingFrequency(); 
     314        int samp_freq = getSampleRate(); 
    315315        unsigned int optical_in_mode = getOpticalMode(MOTUFW_DIR_IN); 
    316316        unsigned int optical_out_mode = getOpticalMode(MOTUFW_DIR_OUT); 
     
    433433        // Do the same for the transmit processor 
    434434        m_transmitProcessor=new Streaming::MotuTransmitStreamProcessor( 
    435                 m_p1394Service->getPort(), getSamplingFrequency(), event_size_out); 
     435                m_p1394Service->getPort(), convertESampleRate(getSampleRate()), 
     436                event_size_out); 
    436437 
    437438        m_transmitProcessor->setVerboseLevel(getDebugLevel()); 
     
    664665// bytes (6 bytes) and 8 analog audio channels (each 3 bytes long).  Note that 
    665666// all audio channels are sent using 3 bytes. 
    666 signed int sample_rate = getSamplingFrequency(); 
     667signed int sample_rate = getSampleRate(); 
    667668signed int optical_mode = getOpticalMode(dir); 
    668669signed int size = 4+6+8*3; 
  • branches/streaming-rework/src/motu/motu_avdevice.h

    r436 r438  
    101101    virtual void showDevice(); 
    102102 
    103     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    104     virtual int getSamplingFrequency( ); 
     103    bool setSampleRate( ESampleRate ); 
     104    ESampleRate getSampleRate( ); 
    105105 
    106106    virtual int getStreamCount(); 
  • branches/streaming-rework/src/rme/rme_avdevice.cpp

    r436 r438  
    109109} 
    110110 
    111 int  
    112 RmeDevice::getSamplingFrequency( ) { 
     111ESampleRate  
     112RmeDevice::getSampleRate( ) { 
    113113/* 
    114114 * Retrieve the current sample rate from the RME device. 
    115115 */ 
    116         return 48000
     116        return parseSampleRate(48000)
    117117} 
    118118 
    119119bool 
    120 RmeDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
     120RmeDevice::setSampleRate( ESampleRate samplingFrequency ) 
    121121{ 
    122122/* 
  • branches/streaming-rework/src/rme/rme_avdevice.h

    r436 r438  
    5555    void showDevice(); 
    5656 
    57     bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    58     int getSamplingFrequency( ); 
     57    bool setSampleRate( ESampleRate ); 
     58    ESampleRate getSampleRate( ); 
    5959 
    6060    int getStreamCount();