Changeset 462

Show
Ignore:
Timestamp:
04/09/07 13:41:33 (14 years ago)
Author:
ppalmers
Message:

- Rework the OSC space to something more usable

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/bebob/GenericMixer.cpp

    r458 r462  
    3636#include "libieee1394/ieee1394service.h" 
    3737 
     38#include <string> 
    3839#include <sstream> 
     40#include <iostream> 
     41 
    3942#include <assert.h> 
    4043 
     
    4245 
    4346namespace BeBoB { 
     47 
     48template <class T> 
     49bool from_string(T& t,  
     50                 const std::string& s,  
     51                 std::ios_base& (*f)(std::ios_base&)) 
     52{ 
     53  std::istringstream iss(s); 
     54  return !(iss >> f >> t).fail(); 
     55} 
    4456 
    4557IMPL_DEBUG_MODULE( GenericMixer, GenericMixer, DEBUG_LEVEL_NORMAL ); 
     
    6173OscResponse  
    6274GenericMixer::processOscMessage(OscMessage *m) { 
    63     debugOutput(DEBUG_LEVEL_NORMAL, "Message\n"); 
    64      
     75    debugOutput( DEBUG_LEVEL_NORMAL, "PROCESS: %s\n", m->getPath().c_str()); 
     76     
     77    std::string path=m->getPath(); 
     78     
     79    // delete leading slashes 
     80    if(path.find_first_of('/')==0) path=path.substr(1,path.size()); 
     81 
     82    // delete trailing slashes 
     83    if(path.find_last_of('/')==path.size()-1) path=path.substr(0,path.size()-1); 
     84     
     85    std::string target=""; 
     86    std::string newpath=""; 
     87     
     88    if (path == "") return processOscMessageRoot(m); 
     89     
     90    // not targetted at the root node, continue processing 
     91    int firstsep=path.find_first_of('/'); 
     92    if (firstsep == -1) { // this will most likely be a list request 
     93        target=path; 
     94        newpath=""; 
     95    } else { 
     96        target=path.substr(0,firstsep); 
     97        newpath=path.substr(firstsep+1); 
     98    } 
     99     
     100    if(target == "Selector") return processOscMessageSelector(newpath, m); 
     101    if(target == "Feature") return processOscMessageFeature(newpath, m); 
     102    if(target == "Processing") return processOscMessageProcessing(newpath, m); 
     103     
     104    // unhandled 
     105    return OscResponse(OscResponse::eUnhandled); 
     106
     107 
     108//// MIXER ROOT MESSAGES 
     109 
     110OscResponse  
     111GenericMixer::processOscMessageRoot(OscMessage *m) { 
     112 
    65113    unsigned int nbArgs=m->nbArguments(); 
    66114    if (nbArgs>=1) { 
     
    68116        if(arg0.isString()) { // first argument should be a string command 
    69117            string cmd=arg0.getString(); 
    70             debugOutput( DEBUG_LEVEL_NORMAL, "(%p) CMD? %s\n", this, cmd.c_str()); 
     118            debugOutput( DEBUG_LEVEL_NORMAL, "(%p) CMD: %s\n", this, cmd.c_str()); 
     119             
    71120            if(cmd == "list") { 
    72                 debugOutput( DEBUG_LEVEL_NORMAL, "Listing mixer elements...\n"); 
    73                 OscMessage rm=mixerListChildren(); 
    74                 return OscResponse(rm); 
    75             } 
     121                debugOutput( DEBUG_LEVEL_NORMAL, "Listing root elements...\n"); 
     122                return OscResponse(rootListChildren()); 
     123            } 
     124//             if(cmd == "params") { 
     125//                 debugOutput( DEBUG_LEVEL_NORMAL, "Listing root params...\n"); 
     126//                 return OscResponse(rootListParams()); 
     127//             } 
     128//             if(cmd == "get") { 
     129//                  
     130//             } 
     131//             if(cmd == "set") { 
     132//                  
     133//             } 
     134            return OscResponse(OscResponse::eUnhandled); 
     135        } else { 
     136            debugWarning("Wrong command datatype\n"); 
     137            return OscResponse(OscResponse::eError); 
     138        } 
     139    } else { 
     140        debugWarning("Not enough arguments\n"); 
     141        return OscResponse(OscResponse::eError); 
     142    } 
     143
     144 
     145OscResponse 
     146GenericMixer::rootListChildren() { 
     147    OscMessage m; 
     148 
     149    debugOutput(DEBUG_LEVEL_NORMAL,"Listing root elements...\n"); 
     150 
     151    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     152    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     153 
     154    bool hasSelector=false; 
     155    bool hasFeature=false; 
     156    bool hasProcessing=false; 
     157    bool hasCodec=false; 
     158 
     159    for ( FunctionBlockVector::iterator it = functions.begin(); 
     160          it != functions.end(); 
     161          ++it ) 
     162    { 
     163        hasSelector |= (((*it)->getType())==FunctionBlockCmd::eFBT_Selector); 
     164        hasFeature |= (((*it)->getType())==FunctionBlockCmd::eFBT_Feature); 
     165        hasProcessing |= (((*it)->getType())==FunctionBlockCmd::eFBT_Processing); 
     166        hasCodec |= (((*it)->getType())==FunctionBlockCmd::eFBT_Codec); 
     167    } 
     168 
     169    if (hasSelector) m.addArgument("Selector"); 
     170    if (hasFeature) m.addArgument("Feature"); 
     171    if (hasProcessing) m.addArgument("Processing"); 
     172    if (hasCodec) m.addArgument("Codec"); 
     173 
     174    return OscResponse(m); 
     175
     176 
     177//// SELECTOR MESSAGES 
     178 
     179OscResponse  
     180GenericMixer::processOscMessageSelector(std::string path, OscMessage *m) { 
     181    debugOutput( DEBUG_LEVEL_NORMAL, "Selector: %s\n", path.c_str()); 
     182     
     183    // delete leading slashes 
     184    if(path.find_first_of('/')==0) path=path.substr(1,path.size()); 
     185 
     186    // delete trailing slashes 
     187    if(path.find_last_of('/')==path.size()-1) path=path.substr(0,path.size()-1); 
     188     
     189    int id=-1; 
     190    if ((path != "") && (!from_string<int>(id, path, std::dec))) { 
     191        debugWarning( "could not get id\n" ); 
     192        return OscResponse(OscResponse::eError); 
     193    } 
     194     
     195    unsigned int nbArgs=m->nbArguments(); 
     196    if (nbArgs>=1) { 
     197        OscArgument arg0=m->getArgument(0); 
     198        if(arg0.isString()) { // first argument should be a string command 
     199            string cmd=arg0.getString(); 
     200            debugOutput( DEBUG_LEVEL_NORMAL, "(%p) CMD: %s\n", this, cmd.c_str()); 
     201             
     202            if(cmd == "list") { 
     203                debugOutput( DEBUG_LEVEL_NORMAL, "Listing selector elements...\n"); 
     204                return selectorListChildren(id); 
     205            } 
     206            if(cmd == "params") { 
     207                debugOutput( DEBUG_LEVEL_NORMAL, "Listing selector %d params...\n", id); 
     208                return selectorListParams(id); 
     209            } 
     210            if(cmd == "get") { 
     211                if (nbArgs<2 || !m->getArgument(1).isString()) { 
     212                    debugWarning("Argument error\n"); 
     213                    m->print(); 
     214                    return OscResponse(OscResponse::eError); 
     215                } 
     216                debugOutput( DEBUG_LEVEL_NORMAL, "Getting selector params %s...\n", 
     217                    m->getArgument(1).getString().c_str()); 
     218                return selectorGetParam(id,m->getArgument(1).getString(), m); 
     219            } 
     220            if(cmd == "set") { 
     221                if (nbArgs<3 || !m->getArgument(1).isString() || !m->getArgument(2).isNumeric()) { 
     222                    debugWarning("Argument error\n"); 
     223                    m->print(); 
     224                    return OscResponse(OscResponse::eError); 
     225                } 
     226                debugOutput( DEBUG_LEVEL_NORMAL, "Setting selector param %s...\n", 
     227                    m->getArgument(1).getString().c_str()); 
     228                return selectorSetParam(id,m->getArgument(1).getString(), m); 
     229            } 
     230            return OscResponse(OscResponse::eUnhandled); 
     231        } else { 
     232            debugWarning("Wrong command datatype\n"); 
     233            return OscResponse(OscResponse::eError); 
     234        } 
     235    } else { 
     236        debugWarning("Not enough arguments\n"); 
     237        return OscResponse(OscResponse::eError); 
     238    } 
     239
     240 
     241/* 
    76242            if(cmd == "set") { 
    77243                debugOutput( DEBUG_LEVEL_NORMAL, "setting mixer element...\n"); 
     
    100266                    int value=m->getArgument(3).toInt(); 
    101267                     
    102                     return mixerSetSelectorValue(id, value); 
     268                    return setSelectorValue(id, value); 
    103269                } 
    104270                 
     
    164330    // default action: don't change response 
    165331    return OscResponse(OscResponse::eUnhandled); 
    166 
    167  
    168 OscMessage 
    169 GenericMixer::mixerListChildren() { 
    170     OscMessage m; 
    171  
    172     debugOutput(DEBUG_LEVEL_NORMAL,"Listing mixer elements...\n"); 
    173  
    174     assert(m_device.getAudioSubunit(0)); // FIXME!! 
    175     FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
    176  
    177     for ( FunctionBlockVector::iterator it = functions.begin(); 
    178           it != functions.end(); 
    179           ++it ) 
    180     { 
    181         std::ostringstream ostrm; 
    182         ostrm << (*it)->getName() << "/" << (int)((*it)->getId()); 
    183         m.addArgument(ostrm.str()); 
    184     } 
    185  
    186     m.print(); 
    187     return m; 
    188 
    189  
    190 OscResponse 
    191 GenericMixer::mixerGetSelectorValue(int fb_id) { 
    192     OscMessage m; 
    193      
     332}*/ 
     333 
     334OscResponse 
     335GenericMixer::selectorListChildren(int id) { 
     336    OscMessage m; 
     337 
     338    if (id != -1) return m; 
     339 
     340    debugOutput(DEBUG_LEVEL_NORMAL,"Listing selector elements...\n"); 
     341     
     342    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     343    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     344 
     345    for ( FunctionBlockVector::iterator it = functions.begin(); 
     346          it != functions.end(); 
     347          ++it ) 
     348    { 
     349        std::ostringstream ostrm; 
     350        if (((*it)->getType()) == FunctionBlockCmd::eFBT_Selector) { 
     351            ostrm << (int)((*it)->getId()); 
     352            m.addArgument(ostrm.str()); 
     353        } 
     354    } 
     355    return OscResponse(m); 
     356
     357 
     358OscResponse 
     359GenericMixer::selectorListParams(int id) { 
     360    OscMessage m; 
     361 
     362    if (id == -1) return m; 
     363 
     364    debugOutput(DEBUG_LEVEL_NORMAL,"Listing selector params...\n"); 
     365     
     366    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     367    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     368 
     369    for ( FunctionBlockVector::iterator it = functions.begin(); 
     370          it != functions.end(); 
     371          ++it ) 
     372    { 
     373        std::ostringstream ostrm; 
     374        if ((((*it)->getType()) == FunctionBlockCmd::eFBT_Selector) 
     375            && (((*it)->getId()) == id)) 
     376        { 
     377            m.addArgument("name"); 
     378            m.addArgument("value"); 
     379        } 
     380    } 
     381    return OscResponse(m); 
     382
     383 
     384OscResponse 
     385GenericMixer::selectorGetParam(int id, std::string p, OscMessage *src) { 
     386    OscMessage m; 
     387 
     388    if (id == -1) return m; 
     389 
     390    debugOutput(DEBUG_LEVEL_NORMAL,"Getting selector parameter: '%s'\n", p.c_str()); 
     391     
     392    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     393    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     394 
     395    for ( FunctionBlockVector::iterator it = functions.begin(); 
     396          it != functions.end(); 
     397          ++it ) 
     398    { 
     399        std::ostringstream ostrm; 
     400        if ((((*it)->getType()) == FunctionBlockCmd::eFBT_Selector) 
     401            && (((*it)->getId()) == id)) 
     402        { 
     403            if (p=="name") { 
     404                m.addArgument("testname"); 
     405            } else if (p=="value") { 
     406                int value; 
     407                if( getSelectorValue(id, value) ) { 
     408                    m.addArgument(value); 
     409                } 
     410            } 
     411        } 
     412    } 
     413    return OscResponse(m); 
     414
     415 
     416OscResponse 
     417GenericMixer::selectorSetParam(int id, std::string p, OscMessage *src) { 
     418    OscMessage m; 
     419 
     420    if (id == -1) return m; 
     421 
     422    debugOutput(DEBUG_LEVEL_NORMAL,"Setting selector parameter: '%s'\n", p.c_str()); 
     423     
     424    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     425    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     426 
     427    for ( FunctionBlockVector::iterator it = functions.begin(); 
     428          it != functions.end(); 
     429          ++it ) 
     430    { 
     431        std::ostringstream ostrm; 
     432        if ((((*it)->getType()) == FunctionBlockCmd::eFBT_Selector) 
     433            && (((*it)->getId()) == id)) 
     434        { 
     435            if (p=="name") { 
     436 
     437            } else if (p=="value") { 
     438                assert(src->nbArguments()>=3); 
     439                int value=src->getArgument(2).toInt(); 
     440                if( ! setSelectorValue(id, value) ) { 
     441                    return OscResponse(OscResponse::eError); 
     442                } 
     443            } 
     444        } 
     445    } 
     446    return OscResponse(m); 
     447
     448 
     449bool 
     450GenericMixer::getSelectorValue(int fb_id, int &value) { 
    194451    debugOutput(DEBUG_LEVEL_NORMAL,"Get selector %d value...\n", 
    195452        fb_id); 
     
    208465    if ( !fbCmd.fire() ) { 
    209466        debugError( "FunctionBlockCmd failed\n" ); 
    210         return OscResponse(OscResponse::eError)
     467        return false
    211468    } 
    212469 
     
    216473    } 
    217474     
    218     if (fbCmd.getResponse() != AVCCommand::eR_Accepted) { 
    219         return OscResponse(OscResponse::eError); 
    220     } 
    221      
    222     m.addArgument((int32_t)(fbCmd.m_pFBSelector->m_inputFbPlugNumber)); 
    223  
    224     return OscResponse(m); 
    225 
    226  
    227 OscResponse 
    228 GenericMixer::mixerSetSelectorValue(int fb_id, int value) { 
    229     OscMessage m; 
    230      
     475    value=(int)(fbCmd.m_pFBSelector->m_inputFbPlugNumber); 
     476    return (fbCmd.getResponse() == AVCCommand::eR_Implemented); 
     477
     478 
     479bool 
     480GenericMixer::setSelectorValue(int fb_id, int value) { 
    231481    debugOutput(DEBUG_LEVEL_NORMAL,"Set selector %d to %d...\n", 
    232482        fb_id, value); 
     
    245495    if ( !fbCmd.fire() ) { 
    246496        debugError( "FunctionBlockCmd failed\n" ); 
    247         return OscResponse(OscResponse::eError)
     497        return false
    248498    } 
    249499 
     
    253503    } 
    254504 
    255     if (fbCmd.getResponse() != AVCCommand::eR_Accepted) { 
     505    return (fbCmd.getResponse() == AVCCommand::eR_Accepted); 
     506
     507 
     508 
     509//// FEATURE 
     510OscResponse  
     511GenericMixer::processOscMessageFeature(std::string path, OscMessage *m) { 
     512    debugOutput( DEBUG_LEVEL_NORMAL, "Feature: %s\n", path.c_str()); 
     513    // delete leading slashes 
     514    if(path.find_first_of('/')==0) path=path.substr(1,path.size()); 
     515 
     516    // delete trailing slashes 
     517    if(path.find_last_of('/')==path.size()-1) path=path.substr(0,path.size()-1); 
     518     
     519    int id=-1; 
     520    if ((path != "") && (!from_string<int>(id, path, std::dec))) { 
     521        debugWarning( "could not get id\n" ); 
    256522        return OscResponse(OscResponse::eError); 
    257523    } 
    258524     
    259     return OscResponse(m); 
    260 
    261  
    262 OscResponse  
    263 GenericMixer::mixerSetFeatureVolumeValue(int fb_id, int channel,  
     525    unsigned int nbArgs=m->nbArguments(); 
     526    if (nbArgs>=1) { 
     527        OscArgument arg0=m->getArgument(0); 
     528        if(arg0.isString()) { // first argument should be a string command 
     529            string cmd=arg0.getString(); 
     530            debugOutput( DEBUG_LEVEL_NORMAL, "(%p) CMD: %s\n", this, cmd.c_str()); 
     531             
     532            if(cmd == "list") { 
     533                debugOutput( DEBUG_LEVEL_NORMAL, "Listing feature elements...\n"); 
     534                return featureListChildren(id); 
     535            } 
     536            if(cmd == "params") { 
     537                debugOutput( DEBUG_LEVEL_NORMAL, "Listing feature %d params...\n", id); 
     538                return featureListParams(id); 
     539            } 
     540            if(cmd == "get") { 
     541                if (nbArgs<2 || !m->getArgument(1).isString()) { 
     542                    debugWarning("Argument error\n"); 
     543                    m->print(); 
     544                    return OscResponse(OscResponse::eError); 
     545                } 
     546                debugOutput( DEBUG_LEVEL_NORMAL, "Getting feature param %s...\n", 
     547                    m->getArgument(1).getString().c_str()); 
     548                return featureGetParam(id,m->getArgument(1).getString(), m); 
     549            } 
     550            if(cmd == "set") { 
     551                if (nbArgs<3 || !m->getArgument(1).isString()) { 
     552                    debugWarning("Argument error\n"); 
     553                    m->print(); 
     554                    return OscResponse(OscResponse::eError); 
     555                } 
     556                debugOutput( DEBUG_LEVEL_NORMAL, "Setting feature param %s...\n", 
     557                    m->getArgument(1).getString().c_str()); 
     558                return featureSetParam(id,m->getArgument(1).getString(), m); 
     559            } 
     560            return OscResponse(OscResponse::eUnhandled); 
     561        } else { 
     562            debugWarning("Wrong command datatype\n"); 
     563            return OscResponse(OscResponse::eError); 
     564        } 
     565    } else { 
     566        debugWarning("Not enough arguments\n"); 
     567        return OscResponse(OscResponse::eError); 
     568    } 
     569 
     570
     571 
     572OscResponse 
     573GenericMixer::featureListChildren(int id) { 
     574    OscMessage m; 
     575 
     576    if (id != -1) return m; 
     577 
     578    debugOutput(DEBUG_LEVEL_NORMAL,"Listing feature elements...\n"); 
     579     
     580    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     581    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     582 
     583    for ( FunctionBlockVector::iterator it = functions.begin(); 
     584          it != functions.end(); 
     585          ++it ) 
     586    { 
     587        std::ostringstream ostrm; 
     588        if (((*it)->getType()) == FunctionBlockCmd::eFBT_Feature) { 
     589            ostrm << (int)((*it)->getId()); 
     590            m.addArgument(ostrm.str()); 
     591        } 
     592    } 
     593    return OscResponse(m); 
     594
     595 
     596OscResponse 
     597GenericMixer::featureListParams(int id) { 
     598    OscMessage m; 
     599 
     600    if (id == -1) return m; 
     601 
     602    debugOutput(DEBUG_LEVEL_NORMAL,"Listing feature params...\n"); 
     603     
     604    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     605    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     606 
     607    for ( FunctionBlockVector::iterator it = functions.begin(); 
     608          it != functions.end(); 
     609          ++it ) 
     610    { 
     611        std::ostringstream ostrm; 
     612        if ((((*it)->getType()) == FunctionBlockCmd::eFBT_Feature) 
     613            && (((*it)->getId()) == id)) 
     614        { 
     615            m.addArgument("name"); 
     616            m.addArgument("volume"); 
     617        } 
     618    } 
     619    return OscResponse(m); 
     620
     621 
     622OscResponse 
     623GenericMixer::featureGetParam(int id, std::string p, OscMessage *src) { 
     624    OscMessage m; 
     625 
     626    if (id == -1) return m; 
     627     
     628    debugOutput(DEBUG_LEVEL_NORMAL,"Getting feature parameter: '%s'\n", p.c_str()); 
     629     
     630    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     631    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     632 
     633    for ( FunctionBlockVector::iterator it = functions.begin(); 
     634          it != functions.end(); 
     635          ++it ) 
     636    { 
     637        std::ostringstream ostrm; 
     638        if ((((*it)->getType()) == FunctionBlockCmd::eFBT_Feature) 
     639            && (((*it)->getId()) == id)) 
     640        { 
     641            if (p=="name") { 
     642                m.addArgument("testname"); 
     643            } else if (p=="volume") { 
     644                if (src->nbArguments()<3) return OscResponse(OscResponse::eError); 
     645                int value; 
     646                int channel=src->getArgument(2).toInt(); 
     647                
     648                if( getFeatureVolumeValue(id, channel, value) ) { 
     649                    m.addArgument(value); 
     650                } 
     651            } 
     652        } 
     653    } 
     654    return OscResponse(m); 
     655
     656 
     657OscResponse 
     658GenericMixer::featureSetParam(int id, std::string p, OscMessage *src) { 
     659    OscMessage m; 
     660 
     661    if (id == -1) return m; 
     662 
     663    debugOutput(DEBUG_LEVEL_NORMAL,"Setting feature parameter: '%s'\n", p.c_str()); 
     664     
     665    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     666    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     667 
     668    for ( FunctionBlockVector::iterator it = functions.begin(); 
     669          it != functions.end(); 
     670          ++it ) 
     671    { 
     672        std::ostringstream ostrm; 
     673        if ((((*it)->getType()) == FunctionBlockCmd::eFBT_Feature) 
     674            && (((*it)->getId()) == id)) 
     675        { 
     676            if (p=="name") { 
     677                m.addArgument("testname"); 
     678            } else if (p=="volume") { 
     679                if (src->nbArguments()<4) return OscResponse(OscResponse::eError); 
     680                int channel=src->getArgument(2).toInt(); 
     681                int value=src->getArgument(3).toInt();; 
     682                
     683                if( !setFeatureVolumeValue(id, channel, value) ) { 
     684                    return OscResponse(OscResponse::eError); 
     685                } 
     686            } 
     687        } 
     688    } 
     689    return OscResponse(m); 
     690
     691 
     692 
     693bool  
     694GenericMixer::getFeatureVolumeValue(int fb_id, int channel, int &volume) { 
     695    OscMessage m; 
     696     
     697    debugOutput(DEBUG_LEVEL_NORMAL,"Get feature volume %d channel %d...\n", 
     698        fb_id, channel); 
     699 
     700    FunctionBlockCmd fbCmd( m_p1394Service, 
     701                            FunctionBlockCmd::eFBT_Feature, 
     702                            fb_id, 
     703                            FunctionBlockCmd::eCA_Current ); 
     704    fbCmd.setNodeId( m_device.getNodeId()  ); 
     705    fbCmd.setSubunitId( 0x00 ); 
     706    fbCmd.setCommandType( AVCCommand::eCT_Status ); 
     707    fbCmd.m_pFBFeature->m_audioChannelNumber=channel; 
     708    fbCmd.m_pFBFeature->m_controlSelector=FunctionBlockFeature::eCSE_Feature_Volume; 
     709    fbCmd.m_pFBFeature->m_pVolume->m_volume=0; 
     710 
     711    if ( !fbCmd.fire() ) { 
     712        debugError( "cmd failed\n" ); 
     713        return false; 
     714    } 
     715     
     716    if ( getDebugLevel() >= DEBUG_LEVEL_NORMAL ) { 
     717        CoutSerializer se; 
     718        fbCmd.serialize( se ); 
     719    } 
     720 
     721    volume=(int)(fbCmd.m_pFBFeature->m_pVolume->m_volume); 
     722     
     723    return (fbCmd.getResponse() == AVCCommand::eR_Implemented); 
     724
     725 
     726bool  
     727GenericMixer::setFeatureVolumeValue(int fb_id, int channel,  
    264728                                        int volume) { 
    265     OscMessage m; 
    266      
    267729    debugOutput(DEBUG_LEVEL_NORMAL,"Set feature volume %d channel %d to %d...\n", 
    268730        fb_id, channel, volume); 
     
    281743    if ( !fbCmd.fire() ) { 
    282744        debugError( "cmd failed\n" ); 
    283     } 
    284  
    285     if (fbCmd.getResponse() != AVCCommand::eR_Accepted) { 
    286         return OscResponse(OscResponse::eError); 
    287     } 
    288  
    289     return OscResponse(m); 
    290 
     745        return false; 
     746    } 
     747 
     748    if ( getDebugLevel() >= DEBUG_LEVEL_NORMAL ) { 
     749        CoutSerializer se; 
     750        fbCmd.serialize( se ); 
     751    } 
     752 
     753    return (fbCmd.getResponse() == AVCCommand::eR_Accepted); 
     754
     755 
     756//// PROCESSING 
    291757 
    292758OscResponse  
    293 GenericMixer::mixerGetFeatureVolumeValue(int fb_id, int channel) { 
    294     OscMessage m; 
    295      
    296     debugOutput(DEBUG_LEVEL_NORMAL,"Get feature volume %d channel %d...\n", 
    297         fb_id, channel); 
    298  
    299     FunctionBlockCmd fbCmd( m_p1394Service, 
    300                             FunctionBlockCmd::eFBT_Feature, 
    301                             fb_id, 
    302                             FunctionBlockCmd::eCA_Current ); 
    303     fbCmd.setNodeId( m_device.getNodeId()  ); 
    304     fbCmd.setSubunitId( 0x00 ); 
    305     fbCmd.setCommandType( AVCCommand::eCT_Status ); 
    306     fbCmd.m_pFBFeature->m_audioChannelNumber=channel; 
    307     fbCmd.m_pFBFeature->m_controlSelector=FunctionBlockFeature::eCSE_Feature_Volume; 
    308     fbCmd.m_pFBFeature->m_pVolume->m_volume=0; 
    309  
    310     if ( !fbCmd.fire() ) { 
    311         debugError( "cmd failed\n" ); 
    312     } 
    313  
    314     if (fbCmd.getResponse() != AVCCommand::eR_Accepted) { 
    315         return OscResponse(OscResponse::eError); 
    316     } 
    317      
    318     m.addArgument((int32_t)(fbCmd.m_pFBFeature->m_pVolume->m_volume)); 
    319  
     759GenericMixer::processOscMessageProcessing(std::string path, OscMessage *m) { 
     760    debugOutput( DEBUG_LEVEL_NORMAL, "Processing: %s\n", path.c_str()); 
     761    return OscResponse(OscResponse::eUnhandled); 
     762
     763 
     764OscResponse 
     765GenericMixer::processingListChildren(int id) { 
     766    OscMessage m; 
     767     
     768    if (id != -1) return m; 
     769     
     770    debugOutput(DEBUG_LEVEL_NORMAL,"Listing processing elements...\n"); 
     771 
     772    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     773    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     774 
     775    for ( FunctionBlockVector::iterator it = functions.begin(); 
     776          it != functions.end(); 
     777          ++it ) 
     778    { 
     779        std::ostringstream ostrm; 
     780        if (((*it)->getType()) == FunctionBlockCmd::eFBT_Processing) { 
     781            ostrm << (int)((*it)->getId()); 
     782            m.addArgument(ostrm.str()); 
     783        } 
     784    } 
     785    return OscResponse(m); 
     786
     787 
     788//// CODEC 
     789 
     790OscResponse 
     791GenericMixer::codecListChildren(int id) { 
     792    OscMessage m; 
     793 
     794    if (id != -1) return m; 
     795     
     796    debugOutput(DEBUG_LEVEL_NORMAL,"Listing codec elements...\n"); 
     797 
     798    assert(m_device.getAudioSubunit(0)); // FIXME!! 
     799    FunctionBlockVector functions=m_device.getAudioSubunit(0)->getFunctionBlocks(); 
     800 
     801    for ( FunctionBlockVector::iterator it = functions.begin(); 
     802          it != functions.end(); 
     803          ++it ) 
     804    { 
     805        std::ostringstream ostrm; 
     806        if (((*it)->getType()) == FunctionBlockCmd::eFBT_Codec) { 
     807            ostrm << (int)((*it)->getId()); 
     808            m.addArgument(ostrm.str()); 
     809        } 
     810    } 
    320811    return OscResponse(m); 
    321812} 
  • trunk/libffado/src/bebob/GenericMixer.h

    r455 r462  
    4848 
    4949protected: 
    50     OSC::OscMessage mixerListChildren(); 
    51     OSC::OscResponse mixerGetSelectorValue(int id); 
    52     OSC::OscResponse mixerSetSelectorValue(int id, int value); 
     50    OSC::OscResponse processOscMessageRoot(OSC::OscMessage *m); 
     51    OSC::OscResponse processOscMessageSelector(std::string, OSC::OscMessage *m); 
     52    OSC::OscResponse processOscMessageFeature(std::string, OSC::OscMessage *m); 
     53    OSC::OscResponse processOscMessageProcessing(std::string, OSC::OscMessage *m); 
     54 
     55protected: 
     56    OSC::OscResponse rootListChildren(); 
     57    OSC::OscResponse selectorListChildren(int); 
     58    OSC::OscResponse selectorListParams(int id); 
     59    OSC::OscResponse selectorGetParam(int id, std::string p, OSC::OscMessage *src); 
     60    OSC::OscResponse selectorSetParam(int id, std::string p, OSC::OscMessage *src); 
     61 
     62    OSC::OscResponse featureListChildren(int); 
     63    OSC::OscResponse featureListParams(int id); 
     64    OSC::OscResponse featureGetParam(int id, std::string p, OSC::OscMessage *src); 
     65    OSC::OscResponse featureSetParam(int id, std::string p, OSC::OscMessage *src); 
    5366     
    54     OSC::OscResponse mixerSetFeatureVolumeValue(int id, int channel, int volume); 
    55     OSC::OscResponse mixerGetFeatureVolumeValue(int fb_id, int channel); 
     67    OSC::OscResponse processingListChildren(int); 
     68    OSC::OscResponse codecListChildren(int); 
     69     
     70    bool getSelectorValue(int id, int &value); 
     71    bool setSelectorValue(int id, int value); 
     72     
     73    bool getFeatureVolumeValue(int fb_id, int channel, int &volume); 
     74    bool setFeatureVolumeValue(int id, int channel, int volume); 
    5675     
    5776protected: 
  • trunk/libffado/src/libieee1394/configrom.cpp

    r445 r462  
    592592            debugOutput( DEBUG_LEVEL_VERBOSE, "(%p) CMD? %s\n", this, cmd.c_str()); 
    593593            if(cmd == "params") { 
    594                 debugOutput( DEBUG_LEVEL_VERBOSE, "Listing node children...\n"); 
     594                debugOutput( DEBUG_LEVEL_VERBOSE, "Listing node params...\n"); 
    595595                OSC::OscMessage& rm=r.getMessage(); 
    596596                rm.addArgument("GUID"); 
  • trunk/libffado/src/libosc/OscServer.cpp

    r445 r462  
    178178        return 0; 
    179179    } else { 
    180         debugOutput(DEBUG_LEVEL_VERBOSE, " Not handled...\n"); 
     180        if (r.isError()) { 
     181            debugOutput(DEBUG_LEVEL_VERBOSE, " Error in message...\n"); 
     182        } else { 
     183            debugOutput(DEBUG_LEVEL_VERBOSE, " Not handled...\n"); 
     184        } 
    181185        m.print(); 
    182186        return 1;  // not handled 
  • trunk/libffado/support/mixer/mixer_phase88.ui.h

    r459 r462  
    2222    print "switching front/back state to %d" % state 
    2323 
    24     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "selector", 10, state]).sendlocal(17820)                         
     24    osc.Message("/devicemanager/dev0/GenericMixer/Selector/10", ["set", "value", state]).sendlocal(17820)                         
    2525} 
    2626 
     
    2828{ 
    2929    print "switching out assign to %d" % a0 
    30     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "selector", 6, a0]).sendlocal(17820) 
     30    osc.Message("/devicemanager/dev0/GenericMixer/Selector/6", ["set", "value", a0]).sendlocal(17820) 
    3131} 
    3232 
     
    3434{ 
    3535    print "switching input assign to %d" % a0 
    36     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "selector", 7, a0]).sendlocal(17820) 
     36    osc.Message("/devicemanager/dev0/GenericMixer/Selector/7", ["set", "value", a0]).sendlocal(17820) 
    3737} 
    3838 
     
    4040{ 
    4141    print "switching sync source to %d" % a0 
    42     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "selector", 9, a0]).sendlocal(17820) 
     42    osc.Message("/devicemanager/dev0/GenericMixer/Selector/9", ["set", "value", a0]).sendlocal(17820) 
    4343} 
    4444 
     
    4646{ 
    4747    print "switching external sync source to %d" % a0 
    48     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "selector", 8, a0]).sendlocal(17820) 
     48    osc.Message("/devicemanager/dev0/GenericMixer/Selector/8", ["set", "value", a0]).sendlocal(17820) 
    4949} 
    50  
    5150 
    5251void Phase88Control::setVolume12( int ) 
     
    5453    vol = -a0 
    5554    print "setting volume for 1/2 to %d" % vol 
    56     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 2 , 0, vol]).sendlocal(17820) 
     55    osc.Message("/devicemanager/dev0/GenericMixer/Feature/2", ["set", "volume", 0, vol]).sendlocal(17820) 
    5756} 
    58  
    5957 
    6058void Phase88Control::setVolume34( int ) 
     
    6260    vol = -a0 
    6361    print "setting volume for 3/4 to %d" % vol 
    64     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 3 , 0, vol]).sendlocal(17820) 
     62    osc.Message("/devicemanager/dev0/GenericMixer/Feature/3", ["set", "volume", 0, vol]).sendlocal(17820) 
    6563} 
    66  
    6764 
    6865void Phase88Control::setVolume56( int ) 
     
    7067    vol = -a0 
    7168    print "setting volume for 5/6 to %d" % vol 
    72     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 4 , 0, vol]).sendlocal(17820) 
    73  
     69    osc.Message("/devicemanager/dev0/GenericMixer/Feature/4", ["set", "volume", 0, vol]).sendlocal(17820) 
    7470} 
    7571 
     
    7874    vol = -a0 
    7975    print "setting volume for 7/8 to %d" % vol 
    80     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 5 , 0, vol]).sendlocal(17820) 
     76    osc.Message("/devicemanager/dev0/GenericMixer/Feature/5", ["set", "volume", 0, vol]).sendlocal(17820) 
    8177} 
    8278 
     
    8581    vol = -a0 
    8682    print "setting volume for S/PDIF to %d" % vol 
    87     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 6 , 0, vol]).sendlocal(17820)    
     83    osc.Message("/devicemanager/dev0/GenericMixer/Feature/6", ["set", "volume", 0, vol]).sendlocal(17820)    
    8884} 
    8985 
     
    9288    vol = -a0 
    9389    print "setting volume for WavePlay to %d" % vol 
    94     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 1 , 0, vol]).sendlocal(17820) 
     90    osc.Message("/devicemanager/dev0/GenericMixer/Feature/7", ["set", "volume", 0, vol]).sendlocal(17820) 
    9591} 
    9692 
     
    9995    vol = -a0 
    10096    print "setting master volume to %d" % vol 
    101     osc.Message("/devicemanager/dev0/GenericMixer", ["set", "volume", 7 , 0, vol]).sendlocal(17820)     
     97    osc.Message("/devicemanager/dev0/GenericMixer/Feature/1", ["set", "volume", 0, vol]).sendlocal(17820)     
    10298}