Changeset 183

Show
Ignore:
Timestamp:
03/29/06 14:57:53 (17 years ago)
Author:
wagi
Message:

2006-03-30 Daniel Wagner <wagi@monom.org>

  • configure.ac: Version bump to 0.6.0
  • src/*: Verbose bool turned int verbose level.
  • src/libfreebobavc/*: Moved fire implementation to
    base class (AVCCommand).
  • libfreebob/freebob.h: freebob_sleep_after_avc_command
    workaround added.
  • tests/test-freebob.c: Verbose bool turned into verbose level.
    Workaround: sleep after avc command added.
  • tests/streaming/Makefile.am (*_SOURCES): Added libavc1394 to LDADD.
  • tests/Makefile.am (*_SOURCES): Likewise.
  • tests/streaming/teststreaming2.c (fid_in): compiler warning fixed.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libfreebob/ChangeLog

    r181 r183  
     12006-03-30  Daniel Wagner  <wagi@monom.org> 
     2 
     3        * configure.ac: Version bump to 0.6.0 
     4 
     5        * src/*: Verbose bool turned int verbose level. 
     6         
     7        * src/libfreebobavc/*: Moved fire implementation to  
     8        base class (AVCCommand).  
     9         
     10        * libfreebob/freebob.h: freebob_sleep_after_avc_command 
     11        workaround added. 
     12 
     13        * tests/test-freebob.c: Verbose bool turned into verbose level. 
     14        Workaround: sleep after avc command added. 
     15 
     16        * tests/streaming/Makefile.am (*_SOURCES): Added libavc1394 to LDADD. 
     17        * tests/Makefile.am (*_SOURCES): Likewise. 
     18         
     19        * tests/streaming/teststreaming2.c (fid_in): compiler warning fixed. 
     20 
    1212006-03-20  Daniel Wagner  <wagi@monom.org> 
    222 

  • trunk/libfreebob/configure.ac

    r181 r183  
    2222 
    2323m4_define(freebob_major_version, 0) 
    24 m4_define(freebob_minor_version, 5) 
    25 m4_define(freebob_micro_version, 2) 
     24m4_define(freebob_minor_version, 6) 
     25m4_define(freebob_micro_version, 0) 
    2626 
    2727m4_define(freebob_version, freebob_major_version.freebob_minor_version.freebob_micro_version) 

  • trunk/libfreebob/libfreebob/freebob.h

    r165 r183  
    113113 
    114114int 
    115 freebob_discover_devices( freebob_handle_t freebob_handle, int verbose ); 
     115freebob_discover_devices( freebob_handle_t freebob_handle, int verbose_level ); 
    116116 
    117117 
    …… 
    161161freebob_get_version(); 
    162162 
     163/* various function */ 
     164 
     165/* workaround: wait usec after each AVC command. 
     166   will disapear as soon bug is fixed */     
     167void freebob_sleep_after_avc_command( int time ); 
     168 
    163169#ifdef __cplusplus 
    164170} 

  • trunk/libfreebob/src/avdevice.cpp

    r173 r183  
    4343                    ConfigRom* configRom, 
    4444                    int nodeId, 
    45                     bool verbose ) 
     45                    int verboseLevel ) 
    4646    :  m_1394Service( ieee1394service ) 
    4747    , m_configRom( configRom ) 
    4848    , m_nodeId( nodeId ) 
    49     , m_verbose( verbose ) 
    50     , m_plugManager( verbose ) 
    51 { 
    52     if ( m_verbose ) { 
     49    , m_verboseLevel( verboseLevel ) 
     50    , m_plugManager( verboseLevel ) 
     51{ 
     52    if ( m_verboseLevel ) { 
    5353        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    5454    } 
    …… 
    127127    plugInfoCmd.setNodeId( m_nodeId ); 
    128128    plugInfoCmd.setCommandType( AVCCommand::eCT_Status ); 
     129    plugInfoCmd.setVerbose( m_verboseLevel ); 
    129130 
    130131    if ( !plugInfoCmd.fire() ) { 
    …… 
    191192                                    plugDirection, 
    192193                                    plugId, 
    193                                     m_verbose ); 
     194                                    m_verboseLevel ); 
    194195        if ( !plug || !plug->discover() ) { 
    195196            debugError( "plug discovering failed\n" ); 
    …… 
    224225                                    plugDirection, 
    225226                                    plugId, 
    226                                     m_verbose ); 
     227                                    m_verboseLevel ); 
    227228        if ( !plug || !plug->discover() ) { 
    228229            debugError( "plug discovering failed\n" ); 
    …… 
    434435    subUnitInfoCmd.m_page = 0; 
    435436    subUnitInfoCmd.setNodeId( m_nodeId ); 
     437    subUnitInfoCmd.setVerbose( m_verboseLevel ); 
    436438    if ( !subUnitInfoCmd.fire() ) { 
    437439        debugError( "Subunit info command failed\n" ); 
    …… 
    453455        switch( subunit_type ) { 
    454456        case AVCCommand::eST_Audio: 
    455             subunit = new AvDeviceSubunitAudio( *this, subunitId, m_verbose ); 
     457            subunit = new AvDeviceSubunitAudio( *this, subunitId, 
     458                                                m_verboseLevel ); 
    456459            if ( !subunit ) { 
    457460                debugFatal( "Could not allocate AvDeviceSubunitAudio\n" ); 
    …… 
    460463            break; 
    461464        case AVCCommand::eST_Music: 
    462             subunit = new AvDeviceSubunitMusic( *this, subunitId, m_verbose ); 
     465            subunit = new AvDeviceSubunitMusic( *this, subunitId, 
     466                                                m_verboseLevel ); 
    463467            if ( !subunit ) { 
    464468                debugFatal( "Could not allocate AvDeviceSubunitMusic\n" ); 
    …… 
    686690        extStreamFormatCmd.setIndexInStreamFormat( i ); 
    687691        extStreamFormatCmd.setCommandType( AVCCommand::eCT_Status ); 
     692        extStreamFormatCmd.setVerbose( m_verboseLevel ); 
    688693 
    689694        cmdSuccess = extStreamFormatCmd.fire(); 
    …… 
    742747        ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommand ); 
    743748    extStreamFormatCmd.setCommandType( AVCCommand::eCT_Control ); 
     749    extStreamFormatCmd.setVerbose( m_verboseLevel ); 
    744750 
    745751    if ( !extStreamFormatCmd.fire() ) { 

  • trunk/libfreebob/src/avdevice.h

    r171 r183  
    4040              ConfigRom* configRom, 
    4141              int nodeId, 
    42               bool verbose ); 
     42              int verboseLevel ); 
    4343    virtual ~AvDevice(); 
    4444 
    …… 
    102102    ConfigRom*       m_configRom; 
    103103    int              m_nodeId; 
    104     bool             m_verbose; 
     104    int              m_verboseLevel; 
    105105 
    106106    AvPlugVector     m_pcrPlugs; 

  • trunk/libfreebob/src/avdevicesubunit.cpp

    r175 r183  
    3535                                  AVCCommand::ESubunitType type, 
    3636                                  subunit_t id, 
    37                                   bool verbose) 
     37                                  int verboseLevel ) 
    3838    : m_avDevice( &avDevice ) 
    3939    , m_sbType( type ) 
    4040    , m_sbId( id ) 
    41     , m_verbose( verbose ) 
    42 { 
    43     if ( m_verbose ) { 
     41    , m_verboseLevel( verboseLevel ) 
     42{ 
     43    if ( m_verboseLevel ) { 
    4444        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    4545    } 
    …… 
    7676    plugInfoCmd.setSubunitType( m_sbType ); 
    7777    plugInfoCmd.setSubunitId( m_sbId ); 
     78    plugInfoCmd.setVerbose( m_verboseLevel ); 
    7879 
    7980    if ( !plugInfoCmd.fire() ) { 
    …… 
    142143                                   plugDirection, 
    143144                                   plugIdx, 
    144                                    m_verbose ); 
     145                                   m_verboseLevel ); 
    145146        if ( !plug || !plug->discover() ) { 
    146147            debugError( "plug discover failed\n" ); 
    …… 
    184185AvDeviceSubunitAudio::AvDeviceSubunitAudio( AvDevice& avDevice, 
    185186                                            subunit_t id, 
    186                                             bool verbose ) 
    187     : AvDeviceSubunit( avDevice, AVCCommand::eST_Audio, id, verbose ) 
     187                                            int verboseLevel ) 
     188    : AvDeviceSubunit( avDevice, AVCCommand::eST_Audio, id, verboseLevel ) 
    188189{ 
    189190} 
    …… 
    279280    extSubunitInfoCmd.setSubunitId( getSubunitId() ); 
    280281    extSubunitInfoCmd.setSubunitType( getSubunitType() ); 
     282    extSubunitInfoCmd.setVerbose( m_verboseLevel ); 
    281283 
    282284    extSubunitInfoCmd.m_fbType = fbType; 
    …… 
    326328                                        data.m_noOfInputPlugs, 
    327329                                        data.m_noOfOutputPlugs, 
    328                                         m_verbose ); 
     330                                        m_verboseLevel ); 
    329331    } 
    330332    break; 
    …… 
    336338                                       data.m_noOfInputPlugs, 
    337339                                       data.m_noOfOutputPlugs, 
    338                                        m_verbose ); 
     340                                       m_verboseLevel ); 
    339341    } 
    340342    break; 
    …… 
    349351                                                 data.m_noOfInputPlugs, 
    350352                                                 data.m_noOfOutputPlugs, 
    351                                                  m_verbose ); 
     353                                                 m_verboseLevel ); 
    352354        } 
    353355        break; 
    …… 
    366368                                              data.m_noOfInputPlugs, 
    367369                                              data.m_noOfOutputPlugs, 
    368                                               m_verbose ); 
     370                                              m_verboseLevel ); 
    369371            debugWarning( "Dummy function block processing created. " 
    370372                          "Implementation is missing\n" ); 
    …… 
    379381                                     data.m_noOfInputPlugs, 
    380382                                     data.m_noOfOutputPlugs, 
    381                                      m_verbose ); 
     383                                     m_verboseLevel ); 
    382384        debugWarning( "Dummy function block codec created. " 
    383385                      "Implementation is missing\n" ); 
    …… 
    427429AvDeviceSubunitMusic::AvDeviceSubunitMusic( AvDevice& avDevice, 
    428430                                            subunit_t id, 
    429                                             bool verbose ) 
    430     : AvDeviceSubunit( avDevice, AVCCommand::eST_Music, id, verbose ) 
     431                                            int verboseLevel ) 
     432    : AvDeviceSubunit( avDevice, AVCCommand::eST_Music, id, verboseLevel ) 
    431433{ 
    432434} 

  • trunk/libfreebob/src/avdevicesubunit.h

    r173 r183  
    3939                     AVCCommand::ESubunitType type, 
    4040                     subunit_t id, 
    41                      bool verbose ); 
     41                     int verboseLevel ); 
    4242    virtual ~AvDeviceSubunit(); 
    4343 
    …… 
    7070    AVCCommand::ESubunitType m_sbType; 
    7171    subunit_t                m_sbId; 
    72     bool                     m_verbose; 
     72    int                      m_verboseLevel; 
    7373 
    7474    AvPlugVector             m_plugs; 
    …… 
    8585    AvDeviceSubunitAudio( AvDevice& avDevice, 
    8686                          subunit_t id, 
    87                           bool verbose ); 
     87                          int verboseLevel ); 
    8888    virtual ~AvDeviceSubunitAudio(); 
    8989 
    …… 
    115115    AvDeviceSubunitMusic( AvDevice& avDevice, 
    116116                          subunit_t id, 
    117                           bool verbose ); 
     117                          int verboseLevel ); 
    118118    virtual ~AvDeviceSubunitMusic(); 
    119119 

  • trunk/libfreebob/src/avplug.cpp

    r181 r183  
    4040                EAvPlugDirection plugDirection, 
    4141                plug_id_t plugId, 
    42                 bool verbose ) 
     42                int verboseLevel ) 
    4343    : m_1394Service( &ieee1394Service ) 
    4444    , m_nodeId( nodeId ) 
    …… 
    5353    , m_nrOfChannels( 0 ) 
    5454    , m_plugManager( &plugManager ) 
    55     , m_verbose( verbose ) 
     55    , m_verboseLevel( verboseLevel ) 
    5656    , m_globalId( m_globalIdCounter++ ) 
    5757{ 
    58     if ( m_verbose ) { 
     58    if ( m_verboseLevel ) { 
    5959        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    6060    } 
    …… 
    9090    , m_formatInfos( rhs.m_formatInfos ) 
    9191    , m_plugManager( rhs.m_plugManager ) 
    92     , m_verbose( rhs.m_verbose ) 
    93 { 
    94     if ( m_verbose ) { 
     92    , m_verboseLevel( rhs.m_verboseLevel ) 
     93{ 
     94    if ( m_verboseLevel ) { 
    9595        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    9696    } 
    …… 
    173173    SignalSourceCmd signalSourceCmd = setSrcPlugAddrToSignalCmd(); 
    174174    setDestPlugAddrToSignalCmd( signalSourceCmd, plug ); 
     175    signalSourceCmd.setVerbose( m_verboseLevel ); 
    175176 
    176177    if ( !signalSourceCmd.fire() ) { 
    …… 
    226227    extendedPlugInfoInfoType.initialize(); 
    227228    extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     229    extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    228230 
    229231    if ( !extPlugInfoCmd.fire() ) { 
    …… 
    287289    extendedPlugInfoInfoType.initialize(); 
    288290    extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     291    extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    289292 
    290293    if ( !extPlugInfoCmd.fire() ) { 
    …… 
    319322    extendedPlugInfoInfoType.initialize(); 
    320323    extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     324    extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    321325 
    322326    if ( !extPlugInfoCmd.fire() ) { 
    …… 
    350354    extendedPlugInfoInfoType.initialize(); 
    351355    extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     356    extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    352357 
    353358    if ( !extPlugInfoCmd.fire() ) { 
    …… 
    397402            extendedPlugInfoInfoType.initialize(); 
    398403            extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     404            extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    399405 
    400406            ExtendedPlugInfoInfoType* infoType = 
    …… 
    456462        extendedPlugInfoInfoType.initialize(); 
    457463        extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     464        extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    458465 
    459466        extPlugInfoCmd.getInfoType()->m_plugClusterInfo->m_clusterIndex = 
    …… 
    492499    ExtendedStreamFormatCmd extStreamFormatCmd = 
    493500        setPlugAddrToStreamFormatCmd( ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommand ); 
     501    extStreamFormatCmd.setVerbose( m_verboseLevel ); 
    494502 
    495503    if ( !extStreamFormatCmd.fire() ) { 
    …… 
    615623        setPlugAddrToStreamFormatCmd( 
    616624            ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommandList); 
     625    extStreamFormatCmd.setVerbose( m_verboseLevel ); 
    617626 
    618627    int i = 0; 
    …… 
    712721    extendedPlugInfoInfoType.initialize(); 
    713722    extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     723    extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    714724 
    715725    if ( !extPlugInfoCmd.fire() ) { 
    …… 
    763773    extendedPlugInfoInfoType.initialize(); 
    764774    extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     775    extPlugInfoCmd.setVerbose( m_verboseLevel ); 
    765776 
    766777    if ( !extPlugInfoCmd.fire() ) { 
    …… 
    14391450 
    14401451 
    1441 AvPlugManager::AvPlugManager( bool verbose ) 
    1442     : m_verbose( verbose ) 
    1443 { 
    1444     if ( m_verbose ) { 
     1452AvPlugManager::AvPlugManager( int verboseLevel ) 
     1453    : m_verboseLevel( verboseLevel ) 
     1454{ 
     1455    if ( m_verboseLevel ) { 
    14451456        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    14461457    } 
    …… 
    14481459 
    14491460AvPlugManager::AvPlugManager( const AvPlugManager& rhs ) 
    1450     : m_verbose( rhs.m_verbose ) 
    1451 { 
    1452     if ( m_verbose ) { 
     1461    : m_verboseLevel( rhs.m_verboseLevel ) 
     1462{ 
     1463    if ( m_verboseLevel ) { 
    14531464        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    14541465    } 

  • trunk/libfreebob/src/avplug.h

    r175 r183  
    7878            EAvPlugDirection plugDirection, 
    7979            plug_id_t plugId, 
    80             bool verbose ); 
     80            int verboseLevel ); 
    8181    AvPlug( const AvPlug& rhs ); 
    8282    virtual ~AvPlug(); 
    …… 
    241241    AvPlugManager*           m_plugManager; 
    242242 
    243     bool                     m_verbose; 
     243    int                      m_verboseLevel; 
    244244 
    245245    int                      m_globalId; 
    …… 
    257257{ 
    258258public: 
    259     AvPlugManager( bool verbose ); 
     259    AvPlugManager( int verboseLevel ); 
    260260    AvPlugManager( const AvPlugManager& rhs ); 
    261261    ~AvPlugManager(); 
    …… 
    282282 
    283283private: 
    284     bool         m_verbose; 
     284    int          m_verboseLevel; 
    285285    AvPlugVector m_plugs; 
    286286 

  • trunk/libfreebob/src/devicemanager.cpp

    r168 r183  
    7171 
    7272bool 
    73 DeviceManager::discover( bool verbose ) 
    74 { 
    75     if ( verbose ) { 
     73DeviceManager::discover( int verboseLevel ) 
     74{ 
     75    if ( verboseLevel ) { 
    7676        setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    7777    } 
    …… 
    108108        } 
    109109 
    110         AvDevice* avDevice = new AvDevice( m_1394Service, configRom, nodeId, verbose ); 
     110        AvDevice* avDevice = new AvDevice( m_1394Service, 
     111                                           configRom, 
     112                                           nodeId, 
     113                                           verboseLevel ); 
    111114        if ( !avDevice ) { 
    112115            debugError( "discover: Could not allocate AvDevice\n" ); 
    …… 
    121124            return false; 
    122125        } 
    123         if ( verbose ) { 
     126        if ( verboseLevel ) { 
    124127            avDevice->showDevice(); 
    125128        } 

  • trunk/libfreebob/src/devicemanager.h

    r165 r183  
    4242    bool deinitialize(); 
    4343 
    44     bool discover( bool verbose ); 
     44    bool discover( int verboseLevel ); 
    4545 
    4646    bool isValidNode( int node ); 

  • trunk/libfreebob/src/freebob.cpp

    r165 r183  
    3030#include "avdevice.h" 
    3131 
     32#include "libfreebobavc/avc_generic.h" 
     33 
    3234#include <stdio.h> 
    3335#include <stdlib.h> 
    …… 
    333335    return; 
    334336} 
     337 
     338void freebob_sleep_after_avc_command( int time ) 
     339{ 
     340    AVCCommand::setSleepAfterAVCCommand( time ); 
     341} 

  • trunk/libfreebob/src/libfreebobavc/avc_connect.cpp

    r138 r183  
    5050    return true; 
    5151} 
    52  
    53 bool 
    54 ConnectCmd::fire( ECommandType commandType, 
    55                    raw1394handle_t handle, 
    56                    unsigned int node_id ) 
    57 { 
    58     bool result = false; 
    59  
    60     #define STREAM_FORMAT_REQUEST_SIZE 20 // XXX random length 
    61     union UPacket { 
    62         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    63         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    64     }; 
    65     typedef union UPacket packet_t; 
    66  
    67     packet_t  req; 
    68     packet_t* resp; 
    69  
    70     setCommandType( commandType ); 
    71     // initialize complete packet 
    72     memset( &req,  0xff,  sizeof( req ) ); 
    73  
    74     BufferSerialize se( req.byte, sizeof( req ) ); 
    75     if ( !serialize( se ) ) { 
    76         printf(  "ConnectCmd::fire: Could not serialize\n" ); 
    77         return false; 
    78     } 
    79  
    80     // reorder the bytes to the correct layout 
    81     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    82         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    83     } 
    84  
    85     if ( isVerbose() ) { 
    86         // debug output 
    87         puts("request:"); 
    88         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    89             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    90         } 
    91     } 
    92  
    93     resp = reinterpret_cast<packet_t*>( 
    94         m_1394Service->transactionBlock( m_nodeId, 
    95                                          req.quadlet, 
    96                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    97     if ( resp ) { 
    98         if ( isVerbose() ) { 
    99             // debug output 
    100             puts("response:"); 
    101             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    102                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    103             } 
    104         } 
    105  
    106         // reorder the bytes to the correct layout 
    107         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    108             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    109         } 
    110  
    111         if ( isVerbose() ) { 
    112             // a more detailed debug output 
    113             printf( "\n" ); 
    114             printf( " idx type                       value\n" ); 
    115             printf( "-------------------------------------\n" ); 
    116             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    117             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    118             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    119  
    120             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    121                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    122             } 
    123         } 
    124  
    125         // parse output 
    126         parseResponse( resp->byte[0] ); 
    127         switch ( getResponse() ) 
    128         { 
    129             case eR_Implemented: 
    130             { 
    131                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    132                 deserialize( de ); 
    133                 result = true; 
    134             } 
    135             break; 
    136             default: 
    137                 printf( "unexpected response received (0x%x)\n", getResponse() ); 
    138         } 
    139     } else { 
    140         printf( "no response\n" ); 
    141     } 
    142  
    143     return result; 
    144 } 

  • trunk/libfreebob/src/libfreebobavc/avc_connect.h

    r125 r183  
    3535    virtual bool deserialize( IISDeserialize& de ); 
    3636 
    37     virtual bool fire( ECommandType commandType, 
    38                        raw1394handle_t handle, 
    39                        unsigned int node_id ); 
     37    virtual const char* getCmdName() const 
     38        { return "ConnectCmd"; } 
    4039}; 
    4140 

  • trunk/libfreebob/src/libfreebobavc/avc_definitions.h

    r172 r183  
    6464typedef byte_t no_of_input_plugs_t; 
    6565typedef byte_t no_of_output_plugs_t; 
     66typedef byte_t info_type_t; 
    6667 
    6768typedef quadlet_t company_id_t; 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_plug_info.cpp

    r175 r183  
    113113    de.read( &length ); 
    114114    m_name.clear(); 
    115     for ( int i = 0; i < length; ++length ) { 
    116         byte_t c; 
    117         de.read( &c ); 
    118         // \todo do correct encoding 
    119         if ( c == '&' ) { 
    120             c = '+'; 
    121         } 
    122         m_name += c; 
    123     } 
     115    char* name; 
     116    de.read( &name, length ); 
     117    m_name = name; 
     118 
    124119    return true; 
    125120} 
    …… 
    500495const char* extendedPlugInfoClusterInfoPortTypeToString( port_type_t portType ) 
    501496{ 
    502     if ( portType > sizeof( extendedPlugInfoPortTypeStrings ) ) { 
     497    if ( portType > ( ( sizeof( extendedPlugInfoPortTypeStrings ) ) 
     498                      / ( sizeof( extendedPlugInfoPortTypeStrings[0] ) ) ) ) { 
    503499        return "Unknown"; 
    504500    } else { 
    …… 
    624620ExtendedPlugInfoInfoType::serialize( IOSSerialize& se ) 
    625621{ 
    626     se.write( m_infoType, "ExtendedPlugInfoInfoType infoType" ); 
     622    // XXX \todo improve IOSSerialize::write interface 
     623    char* buf; 
     624    asprintf( &buf, "ExtendedPlugInfoInfoType infoType (%s)", 
     625              extendedPlugInfoInfoTypeToString( m_infoType ) ); 
     626    se.write( m_infoType, buf ); 
    627627 
    628628    switch ( m_infoType ) { 
    …… 
    748748   return extPlugInfoInfoType; 
    749749} 
     750 
     751const char* extendedPlugInfoInfoTypeStrings[] = 
     752{ 
     753    "PlugType", 
     754    "PlugName", 
     755    "NoOfChannels", 
     756    "ChannelPosition", 
     757    "ChannelName", 
     758    "PlugInput", 
     759    "PlugOutput", 
     760    "ClusterInfo", 
     761}; 
     762 
     763const char* extendedPlugInfoInfoTypeToString( info_type_t infoType ) 
     764{ 
     765    if ( infoType > ( ( sizeof( extendedPlugInfoInfoTypeStrings ) ) 
     766                      / ( sizeof( extendedPlugInfoInfoTypeStrings[0] ) ) ) )  { 
     767        return "Unknown"; 
     768    } else { 
     769        return extendedPlugInfoInfoTypeStrings[infoType]; 
     770    } 
     771} 
     772 
    750773 
    751774////////////////////////////////////////////// 
    …… 
    806829 
    807830bool 
    808 ExtendedPlugInfoCmd::fire() 
    809 { 
    810     bool result = false; 
    811  
    812     #define STREAM_FORMAT_REQUEST_SIZE 20 // XXX random length 
    813     union UPacket { 
    814         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    815         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    816     }; 
    817     typedef union UPacket packet_t; 
    818  
    819     packet_t  req; 
    820     packet_t* resp; 
    821  
    822     // initialize complete packet 
    823     memset( &req,  0xff,  sizeof( req ) ); 
    824  
    825     BufferSerialize se( req.byte, sizeof( req ) ); 
    826     if ( !serialize( se ) ) { 
    827         printf(  "ExtendedPlugInfoCmd::fire: Could not serialize\n" ); 
    828         return false; 
    829     } 
    830  
    831     if ( isVerbose() ) { 
    832         printf( "\n" ); 
    833         printf( " idx type                       value\n" ); 
    834         printf( "-------------------------------------\n" ); 
    835         printf( "  %02d                     ctype: 0x%02x\n", 0, req.byte[0] ); 
    836         printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, req.byte[1] ); 
    837         printf( "  %02d                    opcode: 0x%02x\n", 2, req.byte[2] ); 
    838  
    839         for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    840             printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, req.byte[i] ); 
    841         } 
    842     } 
    843  
    844     // reorder the bytes to the correct layout 
    845     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    846         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    847     } 
    848  
    849     if ( isVerbose() ) { 
    850         // debug output 
    851         puts("request:"); 
    852         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    853             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    854         } 
    855     } 
    856  
    857     resp = reinterpret_cast<packet_t*>( 
    858         m_1394Service->transactionBlock( m_nodeId, 
    859                                          req.quadlet, 
    860                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    861     if ( resp ) { 
    862         if ( isVerbose() ) { 
    863             // debug output 
    864             puts("response:"); 
    865             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    866                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    867             } 
    868         } 
    869  
    870         // reorder the bytes to the correct layout 
    871         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    872             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    873         } 
    874  
    875         if ( isVerbose() ) { 
    876             // a more detailed debug output 
    877             printf( "\n" ); 
    878             printf( " idx type                       value\n" ); 
    879             printf( "-------------------------------------\n" ); 
    880             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    881             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    882             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    883  
    884             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    885                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    886             } 
    887         } 
    888  
    889         // parse output 
    890         parseResponse( resp->byte[0] ); 
    891         switch ( getResponse() ) 
    892         { 
    893         case eR_Implemented: 
    894         case eR_Rejected: 
    895         case eR_NotImplemented: 
    896         { 
    897             BufferDeserialize de( resp->byte, sizeof( req ) ); 
    898             result = deserialize( de ); 
    899         } 
    900         break; 
    901         default: 
    902             printf( "unexpected response received (0x%x)\n", getResponse() ); 
    903         } 
    904     } else { 
    905         printf( "no response\n" ); 
    906     } 
    907  
    908     return result; 
    909 } 
    910  
    911 bool 
    912831ExtendedPlugInfoCmd::setPlugAddress( const PlugAddress& plugAddress ) 
    913832{ 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_plug_info.h

    r157 r183  
    261261    virtual ExtendedPlugInfoInfoType* clone() const; 
    262262 
    263     typedef byte_t info_type_t; 
    264263    info_type_t m_infoType; 
    265264 
    …… 
    274273}; 
    275274 
     275const char* extendedPlugInfoInfoTypeToString( info_type_t infoType ); 
     276 
    276277///////////////////////////////////////////////////////// 
    277278 
    …… 
    295296    virtual bool serialize( IOSSerialize& se ); 
    296297    virtual bool deserialize( IISDeserialize& de ); 
    297  
    298     virtual bool fire(); 
    299298 
    300299    bool setPlugAddress( const PlugAddress& plugAddress ); 
    …… 
    304303        { return m_infoType; } 
    305304 
     305    virtual const char* getCmdName() const 
     306        { return "ExtendedPlugInfoCmd"; } 
     307 
    306308protected: 
    307309    subfunction_t             m_subFunction; 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_stream_format.cpp

    r164 r183  
    360360} 
    361361 
    362 bool 
    363 ExtendedStreamFormatCmd::fire() 
    364 { 
    365     bool result = false; 
    366  
    367     #define STREAM_FORMAT_REQUEST_SIZE 20 // XXX random length 
    368     union UPacket { 
    369         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    370         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    371     }; 
    372     typedef union UPacket packet_t; 
    373  
    374     packet_t  req; 
    375     packet_t* resp; 
    376  
    377     // initialize complete packet 
    378     memset( &req,  0xff,  sizeof( req ) ); 
    379  
    380     BufferSerialize se( req.byte, sizeof( req ) ); 
    381     if ( !serialize( se ) ) { 
    382         printf(  "ExtendedStreamFormatCmd::fire: Could not serialize\n" ); 
    383         return false; 
    384     } 
    385  
    386     // reorder the bytes to the correct layout 
    387     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    388         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    389     } 
    390  
    391     if ( isVerbose() ) { 
    392         // debug output 
    393         puts("request:"); 
    394         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    395             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    396         } 
    397     } 
    398     resp = reinterpret_cast<packet_t*>( 
    399         m_1394Service->transactionBlock( m_nodeId, 
    400                                          req.quadlet, 
    401                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    402     if ( resp ) { 
    403         if ( isVerbose() ) { 
    404             // debug output 
    405             puts("response:"); 
    406             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    407                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    408             } 
    409         } 
    410  
    411         // reorder the bytes to the correct layout 
    412         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    413             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    414         } 
    415  
    416         if ( isVerbose() ) { 
    417             // a more detailed debug output 
    418             printf( "\n" ); 
    419             printf( " idx type                       value\n" ); 
    420             printf( "-------------------------------------\n" ); 
    421             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    422             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    423             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    424  
    425             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    426                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    427             } 
    428         } 
    429  
    430         // parse output 
    431         parseResponse( resp->byte[0] ); 
    432         switch ( getResponse() ) 
    433         { 
    434             case eR_Implemented: 
    435             { 
    436                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    437                 result = deserialize( de ); 
    438             } 
    439             break; 
    440             case eR_Rejected: 
    441                 if ( m_subFunction == eSF_ExtendedStreamFormatInformationCommandList ) { 
    442                     if ( isVerbose() ) { 
    443                         printf( "no futher stream formats defined\n" ); 
    444                     } 
    445                     result = true; 
    446                 } else { 
    447                     printf( "request rejected\n" ); 
    448                 } 
    449                 break; 
    450             default: 
    451                 printf( "unexpected response received (0x%x)\n", getResponse() ); 
    452         } 
    453     } else { 
    454         printf( "no response\n" ); 
    455     } 
    456  
    457     return result; 
    458 } 
    459  
    460362ExtendedStreamFormatCmd::EStatus 
    461363ExtendedStreamFormatCmd::getStatus() 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_stream_format.h

    r164 r183  
    269269    virtual bool deserialize( IISDeserialize& de ); 
    270270 
    271     virtual bool fire(); 
    272  
    273271    EStatus getStatus(); 
    274272    FormatInformation* getFormatInformation(); 
    275273    index_in_stream_format_t getIndex(); 
     274 
     275    virtual const char* getCmdName() const 
     276        { return "ExtendedStreamFormatCmd"; } 
    276277 
    277278protected: 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_subunit_info.cpp

    r172 r183  
    153153    return status; 
    154154} 
    155  
    156 bool 
    157 ExtendedSubunitInfoCmd::fire() 
    158 { 
    159     bool result = false; 
    160  
    161     #define STREAM_FORMAT_REQUEST_SIZE 20 // XXX random length 
    162     union UPacket { 
    163         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    164         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    165     }; 
    166     typedef union UPacket packet_t; 
    167  
    168     packet_t  req; 
    169     packet_t* resp; 
    170  
    171     // initialize complete packet 
    172     memset( &req,  0xff,  sizeof( req ) ); 
    173  
    174     BufferSerialize se( req.byte, sizeof( req ) ); 
    175     if ( !serialize( se ) ) { 
    176         printf(  "ExtendedSubunitInfoCmd::fire: Could not serialize\n" ); 
    177         return false; 
    178     } 
    179  
    180     if ( isVerbose() ) { 
    181         printf( "\n" ); 
    182         printf( " idx type                       value\n" ); 
    183         printf( "-------------------------------------\n" ); 
    184         printf( "  %02d                     ctype: 0x%02x\n", 0, req.byte[0] ); 
    185         printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, req.byte[1] ); 
    186         printf( "  %02d                    opcode: 0x%02x\n", 2, req.byte[2] ); 
    187  
    188         for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    189             printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, req.byte[i] ); 
    190         } 
    191     } 
    192  
    193     // reorder the bytes to the correct layout 
    194     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    195         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    196     } 
    197  
    198     if ( isVerbose() ) { 
    199         // debug output 
    200         puts("request:"); 
    201         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    202             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    203         } 
    204     } 
    205  
    206     resp = reinterpret_cast<packet_t*>( 
    207         m_1394Service->transactionBlock( m_nodeId, 
    208                                          req.quadlet, 
    209                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    210     if ( resp ) { 
    211         if ( isVerbose() ) { 
    212             // debug output 
    213             puts("response:"); 
    214             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    215                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    216             } 
    217         } 
    218  
    219         // reorder the bytes to the correct layout 
    220         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    221             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    222         } 
    223  
    224         if ( isVerbose() ) { 
    225             // a more detailed debug output 
    226             printf( "\n" ); 
    227             printf( " idx type                       value\n" ); 
    228             printf( "-------------------------------------\n" ); 
    229             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    230             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    231             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    232  
    233             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    234                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    235             } 
    236         } 
    237  
    238         // parse output 
    239         parseResponse( resp->byte[0] ); 
    240         switch ( getResponse() ) 
    241         { 
    242             case eR_Implemented: 
    243             { 
    244                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    245                 result = deserialize( de ); 
    246                 break; 
    247             } 
    248             case eR_NotImplemented: 
    249             { 
    250                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    251                 result = deserialize( de ); 
    252             } 
    253             break; 
    254             default: 
    255                 printf( "unexpected response received (0x%x)\n", getResponse() ); 
    256         } 
    257     } else { 
    258         printf( "no response\n" ); 
    259     } 
    260  
    261     return result; 
    262 } 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_subunit_info.h

    r172 r183  
    9393    virtual bool deserialize( IISDeserialize& de ); 
    9494 
    95     virtual bool fire(); 
     95    virtual const char* getCmdName() const 
     96        { return "ExtendedSubunitInfoCmd"; } 
    9697 
    9798    page_t                m_page; 

  • trunk/libfreebob/src/libfreebobavc/avc_generic.cpp

    r172 r183  
    2323#include "ieee1394service.h" 
    2424 
     25#include <netinet/in.h> 
     26 
     27#define DEBUG_EXTRA_VERBOSE 2 
     28 
     29int AVCCommand::m_time = 0; 
     30 
    2531AVCCommand::AVCCommand( Ieee1394Service* ieee1394service, 
    2632                        opcode_t opcode ) 
    …… 
    3137    , m_opcode( opcode ) 
    3238    , m_eResponse( eR_Unknown ) 
    33     , m_verbose( false ) 
     39    , m_verboseLevel( 0 ) 
    3440{ 
    3541} 
    …… 
    7480 
    7581bool 
    76 AVCCommand::parseResponse( byte_t response ) 
    77 { 
    78     m_eResponse = static_cast<EResponse>( response ); 
    79     return true; 
    80 } 
    81  
    82 bool 
    8382AVCCommand::setSubunitType(ESubunitType subunitType) 
    8483{ 
    …… 
    116115 
    117116bool 
    118 AVCCommand::setVerbose( bool enable ) 
    119 { 
    120     m_verbose = enable; 
    121     return true; 
    122 } 
    123  
    124 bool 
    125 AVCCommand::isVerbose() 
    126 { 
    127     return m_verbose; 
    128 } 
    129  
     117AVCCommand::setVerbose( int verboseLevel ) 
     118{ 
     119    m_verboseLevel = verboseLevel; 
     120    return true; 
     121} 
     122 
     123int 
     124AVCCommand::getVerboseLevel() 
     125{ 
     126    return m_verboseLevel; 
     127} 
     128 
     129 
     130void 
     131AVCCommand::showFcpFrame( const unsigned char* buf, 
     132                          unsigned short frameSize ) const 
     133{ 
     134    for ( int i = 0; i < frameSize; ++i ) { 
     135        if ( ( i % 16 ) == 0 ) { 
     136            if ( i > 0 ) { 
     137                printf( "\n" ); 
     138            } 
     139            printf( "  %3d:\t", i ); 
     140        } else if ( ( i % 4 ) == 0 ) { 
     141            printf( " " ); 
     142        } 
     143        printf( "%02x ", buf[i] ); 
     144    } 
     145    printf( "\n" ); 
     146} 
     147 
     148bool 
     149AVCCommand::fire() 
     150{ 
     151    memset( &m_fcpFrame,  0x0,  sizeof( m_fcpFrame ) ); 
     152 
     153    BufferSerialize se( m_fcpFrame, sizeof( m_fcpFrame ) ); 
     154    if ( !serialize( se ) ) { 
     155        printf(  "ExtendedPlugInfoCmd::fire: Could not serialize\n" ); 
     156        return false; 
     157    } 
     158 
     159    unsigned short fcpFrameSize = se.getNrOfProducesBytes(); 
     160 
     161    if ( getVerboseLevel() >= DEBUG_EXTRA_VERBOSE ) { 
     162        printf( "%s:\n", getCmdName() ); 
     163        puts( "  Request:"); 
     164        showFcpFrame( m_fcpFrame, fcpFrameSize ); 
     165 
     166        CoutSerializer se; 
     167        serialize( se ); 
     168    } 
     169 
     170    quadlet_t* resp = m_1394Service->transactionBlock( m_nodeId, 
     171                                                       (quadlet_t*)m_fcpFrame, 
     172                                                       ( fcpFrameSize + 3 ) / 4 ); 
     173    bool result = false; 
     174    if ( resp ) { 
     175        unsigned char* buf = ( unsigned char* ) resp; 
     176 
     177        m_eResponse = ( EResponse )( *buf ); 
     178        switch ( m_eResponse ) 
     179        { 
     180        case eR_Implemented: 
     181        case eR_Rejected: 
     182        case eR_NotImplemented: 
     183        { 
     184            BufferDeserialize de( buf, 512 ); // XXX magic number 
     185            result = deserialize( de ); 
     186 
     187            if ( getVerboseLevel() >= DEBUG_EXTRA_VERBOSE) { 
     188                puts("  Response:"); 
     189                showFcpFrame( buf, de.getNrOfConsumedBytes() ); 
     190 
     191                CoutSerializer se; 
     192                serialize( se ); 
     193            } 
     194        } 
     195        break; 
     196        default: 
     197            printf( "unexpected response received (0x%x)\n", m_eResponse ); 
     198        } 
     199    } else { 
     200        printf( "no response\n" ); 
     201    } 
     202 
     203    if ( getVerboseLevel() >= DEBUG_EXTRA_VERBOSE ) { 
     204        printf( "\n" ); 
     205    } 
     206 
     207    m_1394Service->transactionBlockClose(); 
     208 
     209    usleep( m_time ); 
     210 
     211    return result; 
     212} 
     213 
     214void 
     215AVCCommand::setSleepAfterAVCCommand( int time ) 
     216{ 
     217    m_time = time; 
     218} 
    130219 
    131220const char* subunitTypeStrings[] = 

  • trunk/libfreebob/src/libfreebobavc/avc_generic.h

    r125 r183  
    3131class IISDeserialize; 
    3232class Ieee1394Service; 
     33 
     34const int fcpFrameMaxLength = 512; 
     35typedef unsigned char fcp_frame_t[fcpFrameMaxLength]; 
    3336 
    3437class IBusData { 
    …… 
    8992 
    9093    virtual bool setCommandType( ECommandType commandType ); 
    91     virtual bool fire() = 0; 
     94    virtual bool fire(); 
    9295 
    9396    EResponse getResponse(); 
    …… 
    100103    subunit_id_t getSubunitId(); 
    101104 
    102     bool setVerbose( bool enable ); 
    103     bool isVerbose(); 
     105    bool setVerbose( int verboseLevel ); 
     106    int getVerboseLevel(); 
    104107 
     108    virtual const char* getCmdName() const = 0; 
     109 
     110    // workaround 
     111    static void setSleepAfterAVCCommand( int time ); 
     112protected: 
     113    void showFcpFrame( const unsigned char* buf, 
     114                       unsigned short frameSize ) const; 
    105115 
    106116protected: 
    …… 
    108118    virtual ~AVCCommand() {} 
    109119 
    110     bool parseResponse( byte_t response ); 
    111120    ECommandType getCommandType(); 
    112121 
    113122    Ieee1394Service* m_1394Service; 
    114123    fb_nodeid_t      m_nodeId; 
     124 
     125    fcp_frame_t      m_fcpFrame; 
    115126 
    116127private: 
    …… 
    119130    opcode_t     m_opcode; 
    120131    EResponse    m_eResponse; 
    121     bool         m_verbose; 
     132    int          m_verboseLevel; 
    122133    ECommandType m_commandType; 
     134    static int   m_time; 
    123135}; 
    124136 

  • trunk/libfreebob/src/libfreebobavc/avc_plug_info.cpp

    r164 r183  
    134134 
    135135bool 
    136 PlugInfoCmd::fire() 
    137 { 
    138     bool result = false; 
    139  
    140     #define STREAM_FORMAT_REQUEST_SIZE 20 // XXX random length 
    141     union UPacket { 
    142         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    143         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    144     }; 
    145     typedef union UPacket packet_t; 
    146  
    147     packet_t  req; 
    148     packet_t* resp; 
    149  
    150     // initialize complete packet 
    151     memset( &req,  0xff,  sizeof( req ) ); 
    152  
    153     BufferSerialize se( req.byte, sizeof( req ) ); 
    154     if ( !serialize( se ) ) { 
    155         printf(  "PlugInfoCmd::fire: Could not serialize\n" ); 
    156         return false; 
    157     } 
    158  
    159     // reorder the bytes to the correct layout 
    160     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    161         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    162     } 
    163  
    164     if ( isVerbose() ) { 
    165         // debug output 
    166         puts("request:"); 
    167         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    168             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    169         } 
    170     } 
    171  
    172     resp = reinterpret_cast<packet_t*>( 
    173         m_1394Service->transactionBlock( m_nodeId, 
    174                                          req.quadlet, 
    175                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    176     if ( resp ) { 
    177         if ( isVerbose() ) { 
    178             // debug output 
    179             puts("response:"); 
    180             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    181                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    182             } 
    183         } 
    184  
    185         // reorder the bytes to the correct layout 
    186         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    187             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    188         } 
    189  
    190         if ( isVerbose() ) { 
    191             // a more detailed debug output 
    192             printf( "\n" ); 
    193             printf( " idx type                       value\n" ); 
    194             printf( "-------------------------------------\n" ); 
    195             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    196             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    197             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    198  
    199             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    200                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    201             } 
    202         } 
    203  
    204         // parse output 
    205         parseResponse( resp->byte[0] ); 
    206         switch ( getResponse() ) 
    207         { 
    208             case eR_Implemented: 
    209             { 
    210                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    211                 result = deserialize( de ); 
    212             } 
    213             break; 
    214             default: 
    215                 printf( "unexpected response received (0x%x)\n", getResponse() ); 
    216         } 
    217     } else { 
    218         printf( "no response\n" ); 
    219     } 
    220  
    221     return result; 
    222 } 
    223  
    224 bool 
    225136PlugInfoCmd::setSubFunction( ESubFunction subFunction ) 
    226137{ 

  • trunk/libfreebob/src/libfreebobavc/avc_plug_info.h

    r157 r183  
    5050    virtual bool deserialize( IISDeserialize& de ); 
    5151 
    52     virtual bool fire(); 
    53  
     52    virtual const char* getCmdName() const 
     53        { return "PlugInfoCmd"; } 
    5454 
    5555    nr_of_plugs_t m_serialBusIsochronousInputPlugs; 

  • trunk/libfreebob/src/libfreebobavc/avc_signal_source.cpp

    r164 r183  
    230230 
    231231bool 
    232 SignalSourceCmd::fire() 
    233 { 
    234     bool result = false; 
    235  
    236     #define STREAM_FORMAT_REQUEST_SIZE 20 // XXX random length 
    237     union UPacket { 
    238         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    239         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    240     }; 
    241     typedef union UPacket packet_t; 
    242  
    243     packet_t  req; 
    244     packet_t* resp; 
    245  
    246     // initialize complete packet 
    247     memset( &req,  0xff,  sizeof( req ) ); 
    248  
    249     BufferSerialize se( req.byte, sizeof( req ) ); 
    250     if ( !serialize( se ) ) { 
    251         printf(  "SignalSourceCmd::fire: Could not serialize\n" ); 
    252         return false; 
    253     } 
    254  
    255     // reorder the bytes to the correct layout 
    256     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    257         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    258     } 
    259  
    260     if ( isVerbose() ) { 
    261         // debug output 
    262         puts("request:"); 
    263         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    264             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    265         } 
    266     } 
    267  
    268     resp = reinterpret_cast<packet_t*>( 
    269         m_1394Service->transactionBlock( m_nodeId, 
    270                                          req.quadlet, 
    271                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    272     if ( resp ) { 
    273         if ( isVerbose() ) { 
    274             // debug output 
    275             puts("response:"); 
    276             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    277                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    278             } 
    279         } 
    280  
    281         // reorder the bytes to the correct layout 
    282         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    283             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    284         } 
    285  
    286         if ( isVerbose() ) { 
    287             // a more detailed debug output 
    288             printf( "\n" ); 
    289             printf( " idx type                       value\n" ); 
    290             printf( "-------------------------------------\n" ); 
    291             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    292             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    293             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    294  
    295             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    296                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    297             } 
    298         } 
    299  
    300         // parse output 
    301         parseResponse( resp->byte[0] ); 
    302         switch ( getResponse() ) 
    303         { 
    304         case eR_Implemented: 
    305         case eR_NotImplemented: 
    306         case eR_Accepted: 
    307         case eR_Rejected: 
    308             { 
    309                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    310                 result = deserialize( de ); 
    311             } 
    312             break; 
    313         default: 
    314             printf( "unexpected response received (0x%x)\n", getResponse() ); 
    315         } 
    316     } else { 
    317         printf( "no response\n" ); 
    318     } 
    319  
    320     return result; 
    321 } 
    322  
    323 bool 
    324232SignalSourceCmd::setSignalSource( SignalUnitAddress& signalAddress ) 
    325233{ 

  • trunk/libfreebob/src/libfreebobavc/avc_signal_source.h

    r164 r183  
    7272    virtual bool deserialize( IISDeserialize& de ); 
    7373 
    74     virtual bool fire(); 
     74    virtual const char* getCmdName() const 
     75        { return "SignalSourceCmd"; } 
    7576 
    7677    bool setSignalSource( SignalUnitAddress& signalAddress ); 

  • trunk/libfreebob/src/libfreebobavc/avc_subunit_info.cpp

    r164 r183  
    9393    return true; 
    9494} 
    95  
    96 bool 
    97 SubUnitInfoCmd::fire() 
    98 { 
    99     bool result = false; 
    100  
    101     #define REQUEST_SIZE 2 
    102     union UPacket { 
    103         quadlet_t     quadlet[REQUEST_SIZE]; 
    104         unsigned char byte[REQUEST_SIZE*4]; 
    105     }; 
    106     typedef union UPacket packet_t; 
    107  
    108     packet_t  req; 
    109     packet_t* resp; 
    110  
    111     // initialize complete packet 
    112     memset( &req,  0xff,  sizeof( req ) ); 
    113  
    114     BufferSerialize se( req.byte, sizeof( req ) ); 
    115     if ( !serialize( se ) ) { 
    116         printf(  "UnitInoCmd::fire: Could not serialize\n" ); 
    117         return false; 
    118     } 
    119  
    120     // reorder the bytes to the correct layout 
    121     for (int i = 0; i < REQUEST_SIZE; ++i) { 
    122         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    123     } 
    124  
    125     if ( isVerbose() ) { 
    126         // debug output 
    127         puts("request:"); 
    128         for (int i = 0; i < REQUEST_SIZE; ++i) { 
    129             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    130         } 
    131     } 
    132  
    133     resp = reinterpret_cast<packet_t*>( 
    134         m_1394Service->transactionBlock( m_nodeId, 
    135                                          req.quadlet, 
    136                                          REQUEST_SIZE ) ); 
    137     if ( resp ) { 
    138         if ( isVerbose() ) { 
    139             // debug output 
    140             puts("response:"); 
    141             for ( int i = 0; i < REQUEST_SIZE; ++i ) { 
    142                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    143             } 
    144         } 
    145  
    146         // reorder the bytes to the correct layout 
    147         for ( int i = 0; i < REQUEST_SIZE; ++i ) { 
    148             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    149         } 
    150  
    151         if ( isVerbose() ) { 
    152             // a more detailed debug output 
    153             printf( "\n" ); 
    154             printf( " idx type                       value\n" ); 
    155             printf( "-------------------------------------\n" ); 
    156             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    157             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    158             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    159  
    160             for ( int i = 3; i < REQUEST_SIZE * 4; ++i ) { 
    161                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    162             } 
    163         } 
    164  
    165         // parse output 
    166         parseResponse( resp->byte[0] ); 
    167         switch ( getResponse() ) 
    168         { 
    169         case eR_Implemented: 
    170             { 
    171                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    172                 result = deserialize( de ); 
    173             } 
    174             break; 
    175         case eR_NotImplemented: 
    176                 break; 
    177  
    178         default: 
    179             printf( "unexpected response received (0x%x)\n", getResponse() ); 
    180         } 
    181     } else { 
    182         printf( "no response\n" ); 
    183     } 
    184  
    185     return result; 
    186 } 

  • trunk/libfreebob/src/libfreebobavc/avc_subunit_info.h

    r125 r183  
    3838    virtual bool deserialize( IISDeserialize& de ); 
    3939 
    40     virtual bool fire(); 
     40    virtual const char* getCmdName() const 
     41        { return "SubUnitInfoCmd"; } 
    4142 
    4243    bool clear(); 

  • trunk/libfreebob/src/libfreebobavc/avc_unit_info.cpp

    r164 r183  
    8181    return true; 
    8282} 
    83  
    84 bool 
    85 UnitInfoCmd::fire() 
    86 { 
    87     bool result = false; 
    88  
    89     #define STREAM_FORMAT_REQUEST_SIZE 2 
    90     union UPacket { 
    91         quadlet_t     quadlet[STREAM_FORMAT_REQUEST_SIZE]; 
    92         unsigned char byte[STREAM_FORMAT_REQUEST_SIZE*4]; 
    93     }; 
    94     typedef union UPacket packet_t; 
    95  
    96     packet_t  req; 
    97     packet_t* resp; 
    98  
    99     // initialize complete packet 
    100     memset( &req,  0xff,  sizeof( req ) ); 
    101  
    102     BufferSerialize se( req.byte, sizeof( req ) ); 
    103     if ( !serialize( se ) ) { 
    104         printf(  "UnitInoCmd::fire: Could not serialize\n" ); 
    105         return false; 
    106     } 
    107  
    108     // reorder the bytes to the correct layout 
    109     for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    110         req.quadlet[i] = ntohl( req.quadlet[i] ); 
    111     } 
    112  
    113     if ( isVerbose() ) { 
    114         // debug output 
    115         puts("request:"); 
    116         for (int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i) { 
    117             printf("  %2d: 0x%08x\n", i, req.quadlet[i]); 
    118         } 
    119     } 
    120  
    121     resp = reinterpret_cast<packet_t*>( 
    122         m_1394Service->transactionBlock( m_nodeId, 
    123                                          req.quadlet, 
    124                                          STREAM_FORMAT_REQUEST_SIZE ) ); 
    125     if ( resp ) { 
    126         if ( isVerbose() ) { 
    127             // debug output 
    128             puts("response:"); 
    129             for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    130                 printf( "  %2d: 0x%08x\n", i, resp->quadlet[i] ); 
    131             } 
    132         } 
    133  
    134         // reorder the bytes to the correct layout 
    135         for ( int i = 0; i < STREAM_FORMAT_REQUEST_SIZE; ++i ) { 
    136             resp->quadlet[i] = htonl( resp->quadlet[i] ); 
    137         } 
    138  
    139         if ( isVerbose() ) { 
    140             // a more detailed debug output 
    141             printf( "\n" ); 
    142             printf( " idx type                       value\n" ); 
    143             printf( "-------------------------------------\n" ); 
    144             printf( "  %02d                     ctype: 0x%02x\n", 0, resp->byte[0] ); 
    145             printf( "  %02d subunit_type + subunit_id: 0x%02x\n", 1, resp->byte[1] ); 
    146             printf( "  %02d                    opcode: 0x%02x\n", 2, resp->byte[2] ); 
    147  
    148             for ( int i = 3; i < STREAM_FORMAT_REQUEST_SIZE * 4; ++i ) { 
    149                 printf( "  %02d                operand %2d: 0x%02x\n", i, i-3, resp->byte[i] ); 
    150             } 
    151         } 
    152  
    153         // parse output 
    154         parseResponse( resp->byte[0] ); 
    155         switch ( getResponse() ) 
    156         { 
    157             case eR_Implemented: 
    158             { 
    159                 BufferDeserialize de( resp->byte, sizeof( req ) ); 
    160                 result = deserialize( de ); 
    161             } 
    162             break; 
    163             default: 
    164                 printf( "unexpected response received (0x%x)\n", getResponse() ); 
    165         } 
    166     } else { 
    167         printf( "no response\n" ); 
    168     } 
    169  
    170     return result; 
    171 } 

  • trunk/libfreebob/src/libfreebobavc/avc_unit_info.h

    r125 r183  
    5555    virtual bool deserialize( IISDeserialize& de ); 
    5656 
    57     virtual bool fire(); 
    58  
     57    virtual const char* getCmdName() const 
     58        { return "UnitInfoCmd"; } 
    5959 
    6060    reserved_t  m_reserved; 

  • trunk/libfreebob/src/libfreebobavc/ieee1394service.cpp

    r174 r183  
    2323 
    2424#include <errno.h> 
     25#include <netinet/in.h> 
    2526 
    2627#include <iostream> 
    …… 
    8586                                   int len ) 
    8687{ 
    87     return avc1394_transaction_block( m_handle, nodeId, buf, len,  10 ); 
     88    for (int i = 0; i < len; ++i) { 
     89        buf[i] = ntohl( buf[i] ); 
     90    } 
     91 
     92    fb_quadlet_t* result = 
     93        avc1394_transaction_block( m_handle, nodeId, buf, len,  10 ); 
     94 
     95    for ( int i = 0; i < 512/4; ++i ) { //XXX 
     96        result[i] = htonl( result[i] ); 
     97    } 
     98 
     99    return result; 
    88100} 
     101 
     102 
     103bool 
     104Ieee1394Service::transactionBlockClose() 
     105{ 
     106    avc1394_transaction_block_close( m_handle ); 
     107    return true; 
     108} 

  • trunk/libfreebob/src/libfreebobavc/ieee1394service.h

    r155 r183  
    8484                                    int len ); 
    8585 
    86  
    87      
     86    bool transactionBlockClose(); 
    8887     
    8988private: 

  • trunk/libfreebob/src/libfreebobavc/serialize.cpp

    r125 r183  
    2424#include <iomanip> 
    2525 
    26 using namespace std; 
     26#include <netinet/in.h> 
    2727 
    2828bool 
    2929CoutSerializer::write( byte_t d, const char* name ) 
    3030{ 
    31     cout << name << ": 0x" << setfill( '0' ) << hex << static_cast<unsigned int>( d ) << endl; 
     31    printf( "  %3d:\t0x%02x\t%s\n", m_cnt, d, name ); 
     32    m_cnt += sizeof( byte_t ); 
     33 
    3234    return true; 
    3335} 
    …… 
    3638CoutSerializer::write( quadlet_t d, const char* name ) 
    3739{ 
    38     cout << name << ": 0x" << setfill( '0' ) << setw( 8 ) << hex << d << endl; 
     40    printf( "  %3d:\t0x%08x\t%s\n", m_cnt, d, name ); 
     41    m_cnt += sizeof( quadlet_t ); 
    3942    return true; 
    4043} 
    …… 
    9699        *value = *m_curPos; 
    97100        m_curPos += sizeof( quadlet_t ); 
    98         result = true;; 
     101        result = true; 
     102    } 
     103    return result; 
     104} 
     105 
     106bool 
     107BufferDeserialize::read( char** value, size_t length ) 
     108{ 
     109    bool result = false; 
     110    if ( isCurPosValid() ) { 
     111        *value = ( char* )m_curPos; 
     112        m_curPos += length; 
     113        result = true; 
    99114    } 
    100115    return result; 

  • trunk/libfreebob/src/libfreebobavc/serialize.h

    r125 r183  
    4242    virtual bool read( byte_t* value ) = 0; 
    4343    virtual bool read( quadlet_t* value ) = 0; 
     44    virtual bool read( char** value, size_t length ) = 0; 
    4445    virtual bool peek( byte_t* value ) = 0; 
    4546}; 
    …… 
    5152    CoutSerializer() 
    5253        : IOSSerialize() 
     54        , m_cnt( 0 ) 
    5355        {} 
    5456    virtual ~CoutSerializer() {} 
    …… 
    5658    virtual bool write( byte_t value, const char* name = "" ); 
    5759    virtual bool write( quadlet_t value,  const char* name = "" ); 
     60 
     61private: 
     62    unsigned int m_cnt; 
     63 
    5864}; 
    5965 
    …… 
    7076    virtual bool write( byte_t value, const char* name = "" ); 
    7177    virtual bool write( quadlet_t value,  const char* name = "" ); 
     78 
     79    int getNrOfProducesBytes() const 
     80        { return m_curPos - m_buffer; } 
    7281 
    7382protected: 
    …… 
    92101    virtual bool read( byte_t* value ); 
    93102    virtual bool read( quadlet_t* value ); 
     103    virtual bool read( char** value, size_t length ); 
    94104    virtual bool peek( byte_t* value ); 
     105 
     106    int getNrOfConsumedBytes()  const 
     107        { return m_curPos - m_buffer; } 
    95108 
    96109protected: 
    …… 
    100113    unsigned char* m_buffer; // start of the buffer 
    101114    unsigned char* m_curPos; // current read pos 
    102     size_t m_length; // length of buffer 
     115    size_t m_length;         // size of buffer 
    103116}; 
    104117 

  • trunk/libfreebob/tests/Makefile.am

    r159 r183  
    2525 
    2626test_freebob_SOURCES = test-freebob.c 
    27 test_freebob_LDADD   = $(top_builddir)/src/libfreebob.la $(LIBXML_LIBS) 
     27test_freebob_LDADD   = $(top_builddir)/src/libfreebob.la $(LIBXML_LIBS) -lavc1394 
    2828 
    2929test_extplugcmd_SOURCES = test-extplugcmd.cpp 
    30 test_extplugcmd_LDADD = $(top_builddir)/src/libfreebobavc/libfreebobavc.la 
     30test_extplugcmd_LDADD = $(top_builddir)/src/libfreebobavc/libfreebobavc.la -lavc1394 
    3131 
    3232#TESTS_ENVIRONMENT 

  • trunk/libfreebob/tests/streaming/Makefile.am

    r159 r183  
    2323 
    2424teststreaming_SOURCES = teststreaming.c debugtools.c 
    25 teststreaming_LDADD   = @top_builddir@src/libfreebob.la 
     25teststreaming_LDADD   = @top_builddir@src/libfreebob.la -lavc1394  
    2626 
    2727teststreaming2_SOURCES = teststreaming2.c debugtools.c 
    28 teststreaming2_LDADD   = @top_builddir@src/libfreebob.la 
     28teststreaming2_LDADD   = @top_builddir@src/libfreebob.la -lavc1394 
    2929 
    3030teststreaming3_SOURCES = teststreaming3.c debugtools.c 
    31 teststreaming3_LDADD   = @top_builddir@src/libfreebob.la 
     31teststreaming3_LDADD   = @top_builddir@src/libfreebob.la -lavc1394 
    3232 
    3333testmidistreaming1_SOURCES = testmidistreaming1.c debugtools.c 
    34 testmidistreaming1_LDADD   = @top_builddir@src/libfreebob.la -lasound 
     34testmidistreaming1_LDADD   = @top_builddir@src/libfreebob.la -lasound -lavc1394 

  • trunk/libfreebob/tests/streaming/teststreaming2.c

    r160 r183  
    165165 
    166166                freebob_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
    167                 fprintf(fid_in[i], "Channel name: %s\n"); 
     167                fprintf(fid_in[i], "Channel name: %s\n",name); 
    168168                switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    169169                case freebob_stream_type_audio: 

  • trunk/libfreebob/tests/test-freebob.c

    r169 r183  
    5050    int   node_id; 
    5151    int   node_id_set; 
     52    int   time; 
    5253    char* args[2];   
    5354}; 
    …… 
    5556// The options we understand. 
    5657static struct argp_option options[] = { 
    57     {"verbose",  'v',    0,    0,  "Produce verbose output" }, 
    58     {"quiet",    'q',    0,    0,  "Don't produce any output" }, 
    59     {"silent",   's',    0,    OPTION_ALIAS }, 
    60     {"node",     'n', "id",    0,  "Node to use" }, 
    61     {"port",     'p', "nr",    0,  "IEEE1394 Port to use" }, 
     58    {"quiet",    'q',       0,    0,  "Don't produce any output" }, 
     59    {"silent",   's',       0,    OPTION_ALIAS }, 
     60 
     61    {"verbose",  'v', "level",    0,  "Produce verbose output" }, 
     62 
     63 
     64    {"node",     'n',    "id",    0,  "Node to use" }, 
     65    {"port",     'p',    "nr",    0,  "IEEE1394 Port to use" }, 
     66    {"time",     't',    "time",  0,  "Workaround: sleep <time> usec after AVC command\n" }, 
    6267    { 0 } 
    6368}; 
    …… 
    7984            break; 
    8085        case 'v': 
    81             arguments->verbose = 1; 
     86            if (arg) { 
     87                arguments->verbose = strtol( arg, &tail, 0 ); 
     88                if ( errno ) { 
     89                    fprintf( stderr,  "Could not parse 'verbose' argument\n" ); 
     90                    return ARGP_ERR_UNKNOWN; 
     91                } 
     92            } 
     93            break; 
     94        case 't': 
     95            if (arg) { 
     96                arguments->time = strtol( arg, &tail, 0 ); 
     97                if ( errno ) { 
     98                    fprintf( stderr,  "Could not parse 'time' argument\n" ); 
     99                    return ARGP_ERR_UNKNOWN; 
     100                } 
     101            } 
    82102            break; 
    83103        case 'p': 
    …… 
    143163    arguments.node_id     = 0; 
    144164    arguments.node_id_set = 0; // if we don't specify a node, discover all 
     165    arguments.time        = 0; 
    145166    arguments.args[0]     = ""; 
    146167    arguments.args[1]     = ""; 
    …… 
    153174    } 
    154175 
     176    printf("verbose level = %d\n", arguments.verbose); 
     177 
    155178    printf( "Using freebob library version: %s\n\n", freebob_get_version() ); 
     179 
     180    freebob_sleep_after_avc_command( arguments.time ); 
    156181 
    157182    if ( strcmp( arguments.args[0], "discover" ) == 0 ) {