Changeset 748

Show
Ignore:
Timestamp:
11/29/07 14:26:52 (13 years ago)
Author:
ppalmers
Message:

try to reorganize things such that less information is duplicated

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/dice/dice_avdevice.cpp

    r745 r748  
    674674        // construct the streamprocessor 
    675675        Streaming::AmdtpReceiveStreamProcessor *p; 
    676         p=new Streaming::AmdtpReceiveStreamProcessor( 
    677                              get1394Service().getPort(), 
     676        p=new Streaming::AmdtpReceiveStreamProcessor(*this, 
    678677                             nb_channels); 
    679678 
     
    760759        // construct the streamprocessor 
    761760        Streaming::AmdtpTransmitStreamProcessor *p; 
    762         p=new Streaming::AmdtpTransmitStreamProcessor( 
    763                              get1394Service().getPort(), 
     761        p=new Streaming::AmdtpTransmitStreamProcessor(*this, 
    764762                             nb_channels); 
    765763 
  • trunk/libffado/src/genericavc/avc_avdevice.cpp

    r745 r748  
    418418        return false; 
    419419    } 
    420     p=new Streaming::AmdtpReceiveStreamProcessor( 
    421                              get1394Service().getPort(), 
     420    p=new Streaming::AmdtpReceiveStreamProcessor(*this, 
    422421                             outputPlug->getNrOfChannels()); 
    423422 
     
    442441    if (snoopMode) { 
    443442        // we are snooping, so this is receive too. 
    444         p=new Streaming::AmdtpReceiveStreamProcessor( 
    445                                   get1394Service().getPort(), 
     443        p=new Streaming::AmdtpReceiveStreamProcessor(*this, 
    446444                                  inputPlug->getNrOfChannels()); 
    447445    } else { 
    448         p=new Streaming::AmdtpTransmitStreamProcessor( 
    449                                 get1394Service().getPort(), 
     446        p=new Streaming::AmdtpTransmitStreamProcessor(*this, 
    450447                                inputPlug->getNrOfChannels()); 
    451448    } 
  • trunk/libffado/src/libieee1394/ieee1394service.cpp

    r742 r748  
    2525#include "ieee1394service.h" 
    2626#include "ARMHandler.h" 
     27#include "cycletimer.h" 
    2728 
    2829#include <libavc1394/avc1394.h> 
     
    4344 
    4445Ieee1394Service::Ieee1394Service() 
    45     : m_handle( 0 ), m_resetHandle( 0 ) 
     46    : m_handle( 0 ), m_resetHandle( 0 ), m_rtHandle( 0 ) 
    4647    , m_port( -1 ) 
    4748    , m_threadRunning( false ) 
     
    6364{ 
    6465    stopRHThread(); 
    65  
    6666    for ( arm_handler_vec_t::iterator it = m_armHandlers.begin(); 
    6767          it != m_armHandlers.end(); 
     
    8383        raw1394_destroy_handle( m_resetHandle ); 
    8484    } 
     85    if ( m_rtHandle ) { 
     86        raw1394_destroy_handle( m_rtHandle ); 
     87    } 
    8588} 
    8689 
     
    122125 
    123126    m_resetHandle = raw1394_new_handle_on_port( port ); 
    124     if ( !m_handle ) { 
     127    if ( !m_resetHandle ) { 
    125128        if ( !errno ) { 
    126129            debugFatal("libraw1394 not compatible\n"); 
     
    132135        return false; 
    133136    } 
     137     
     138    m_rtHandle = raw1394_new_handle_on_port( port ); 
     139    if ( !m_rtHandle ) { 
     140        if ( !errno ) { 
     141            debugFatal("libraw1394 not compatible\n"); 
     142        } else { 
     143            debugFatal("Ieee1394Service::initialize: Could not get 1394 handle: %s", 
     144                strerror(errno) ); 
     145            debugFatal("Is ieee1394 and raw1394 driver loaded?\n"); 
     146        } 
     147        return false; 
     148    } 
    134149 
    135150    m_port = port; 
     
    169184nodeid_t Ieee1394Service::getLocalNodeId() { 
    170185    return raw1394_get_local_id(m_handle) & 0x3F; 
     186} 
     187 
     188/** 
     189 * Returns the current value of the cycle timer (in ticks) 
     190 * 
     191 * @return the current value of the cycle timer (in ticks) 
     192 */ 
     193 
     194unsigned int 
     195Ieee1394Service::getCycleTimerTicks() { 
     196    // the new api should be realtime safe. 
     197    // it might cause a reschedule when turning preemption, 
     198    // back on but that won't hurt us if we have sufficient 
     199    // priority 
     200    int err; 
     201    uint32_t cycle_timer; 
     202    uint64_t local_time; 
     203    err=raw1394_read_cycle_timer(m_rtHandle, &cycle_timer, &local_time); 
     204    if(err) { 
     205        debugWarning("raw1394_read_cycle_timer: %s\n", strerror(err)); 
     206    } 
     207    return CYCLE_TIMER_TO_TICKS(cycle_timer); 
     208} 
     209 
     210/** 
     211 * Returns the current value of the cycle timer (as is) 
     212 * 
     213 * @return the current value of the cycle timer (as is) 
     214 */ 
     215 
     216unsigned int 
     217Ieee1394Service::getCycleTimer() { 
     218    // the new api should be realtime safe. 
     219    // it might cause a reschedule when turning preemption, 
     220    // back on but that won't hurt us if we have sufficient 
     221    // priority 
     222    int err; 
     223    uint32_t cycle_timer; 
     224    uint64_t local_time; 
     225    err=raw1394_read_cycle_timer(m_rtHandle, &cycle_timer, &local_time); 
     226    if(err) { 
     227        debugWarning("raw1394_read_cycle_timer: %s\n", strerror(err)); 
     228    } 
     229    return cycle_timer; 
    171230} 
    172231 
  • trunk/libffado/src/libieee1394/ieee1394service.h

    r742 r748  
    9292    */ 
    9393    nodeid_t getLocalNodeId(); 
     94 
     95    /// get the most recent cycle timer value (in ticks) 
     96    unsigned int getCycleTimerTicks(); 
     97    /// get the most recent cycle timer value (as is) 
     98    unsigned int getCycleTimer(); 
     99 
    94100 
    95101   /** 
     
    259265    raw1394handle_t m_handle; 
    260266    raw1394handle_t m_resetHandle; 
     267    raw1394handle_t m_rtHandle; // a handle for operations from the rt thread 
    261268    int             m_port; 
    262269    std::string     m_portName; 
  • trunk/libffado/src/libstreaming/amdtp/AmdtpReceiveStreamProcessor.cpp

    r747 r748  
    2626#include "../StreamProcessorManager.h" 
    2727 
    28 #include "../util/cycletimer.h" 
     28#include "libieee1394/cycletimer.h" 
    2929 
    3030#include <netinet/in.h> 
     
    3535/* --------------------- RECEIVE ----------------------- */ 
    3636 
    37 AmdtpReceiveStreamProcessor::AmdtpReceiveStreamProcessor(int port, int dimension) 
    38     : StreamProcessor(ePT_Receive , port
     37AmdtpReceiveStreamProcessor::AmdtpReceiveStreamProcessor(FFADODevice &parent, int dimension) 
     38    : StreamProcessor(parent, ePT_Receive
    3939    , m_dimension( dimension ) 
    4040{} 
     
    8989                  (length >= 2*sizeof(quadlet_t)); 
    9090    if(ok) { 
    91         uint64_t now = m_handler->getCycleTimer(); 
     91        uint64_t now = m_parent.get1394Service().getCycleTimer(); 
    9292        //=> convert the SYT to a full timestamp in ticks 
    9393        m_last_timestamp = sytRecvToFullTicks((uint32_t)ntohs(packet->syt), 
  • trunk/libffado/src/libstreaming/amdtp/AmdtpReceiveStreamProcessor.h

    r742 r748  
    7575     *                  (midi-muxed is only one stream) 
    7676     */ 
    77     AmdtpReceiveStreamProcessor(int port, int dimension); 
     77    AmdtpReceiveStreamProcessor(FFADODevice &parent, int dimension); 
    7878    virtual ~AmdtpReceiveStreamProcessor() {}; 
    7979 
  • trunk/libffado/src/libstreaming/amdtp/AmdtpTransmitStreamProcessor.cpp

    r747 r748  
    2626#include "../StreamProcessorManager.h" 
    2727 
    28 #include "../util/cycletimer.h" 
     28#include "libieee1394/cycletimer.h" 
    2929 
    3030#include <netinet/in.h> 
     
    4242 
    4343/* transmit */ 
    44 AmdtpTransmitStreamProcessor::AmdtpTransmitStreamProcessor ( int port, int dimension
    45         : StreamProcessor ( ePT_Transmit, port
    46         , m_dimension ( dimension ) 
    47         , m_dbc ( 0 ) 
     44AmdtpTransmitStreamProcessor::AmdtpTransmitStreamProcessor(FFADODevice &parent, int dimension
     45        : StreamProcessor(parent, ePT_Transmit
     46        , m_dimension( dimension ) 
     47        , m_dbc( 0 ) 
    4848{} 
    4949 
  • trunk/libffado/src/libstreaming/amdtp/AmdtpTransmitStreamProcessor.h

    r742 r748  
    7777     *                  (midi-muxed is only one stream) 
    7878     */ 
    79     AmdtpTransmitStreamProcessor(int port, int dimension); 
     79    AmdtpTransmitStreamProcessor(FFADODevice &parent, int dimension); 
    8080    virtual ~AmdtpTransmitStreamProcessor() {}; 
    8181 
  • trunk/libffado/src/libstreaming/generic/StreamProcessor.cpp

    r747 r748  
    2323 
    2424#include "StreamProcessor.h" 
    25 #include "../util/cycletimer.h" 
     25#include "libieee1394/cycletimer.h" 
    2626#include "../StreamProcessorManager.h" 
    2727 
     
    3535IMPL_DEBUG_MODULE( StreamProcessor, StreamProcessor, DEBUG_LEVEL_VERBOSE ); 
    3636 
    37 StreamProcessor::StreamProcessor(enum eProcessorType type, int port) 
    38     : m_processor_type ( type ) 
     37StreamProcessor::StreamProcessor(FFADODevice &parent, enum eProcessorType type) 
     38    : m_parent( parent ) 
     39    , m_processor_type ( type ) 
    3940    , m_channel( -1 ) 
    40     , m_port( port ) 
    4141    , m_handler( NULL ) 
    4242    , m_state( ePS_Created ) 
     
    6464 
    6565uint64_t StreamProcessor::getTimeNow() { 
    66     return m_handler->getCycleTimerTicks(); 
     66    return m_parent.get1394Service().getCycleTimerTicks(); 
    6767} 
    6868 
     
    114114    time_at_period = addTicks(time_at_period, m_manager->getSyncSource().getSyncDelay()); 
    115115 
    116     uint64_t cycle_timer=m_handler->getCycleTimerTicks(); 
     116    uint64_t cycle_timer=m_parent.get1394Service().getCycleTimerTicks(); 
    117117 
    118118    // calculate the time until the next period 
     
    423423    // we the packet we are constructing will be sent out 
    424424    // on 'cycle', not 'now'. 
    425     unsigned int ctr = m_handler->getCycleTimer(); 
     425    unsigned int ctr = m_parent.get1394Service().getCycleTimer(); 
    426426    int now_cycles = (int)CYCLE_TIMER_GET_CYCLES(ctr); 
    427427 
     
    836836             m_manager->getPeriodSize(), m_manager->getNbBuffers()); 
    837837    debugOutput( DEBUG_LEVEL_VERBOSE, " Port: %d, Channel: %d\n", 
    838              m_port,m_channel); 
     838             getPort(), m_channel); 
    839839 
    840840    // initialization can be done without requesting it 
     
    873873    uint64_t tx; 
    874874    if (t < 0) { 
    875         tx = addTicks(m_handler->getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
     875        tx = addTicks(m_parent.get1394Service().getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
    876876    } else { 
    877877        tx = t; 
    878878    } 
    879879    debugOutput(DEBUG_LEVEL_VERBOSE,"for %s SP (%p)\n", ePTToString(getType()), this); 
    880     uint64_t now = m_handler->getCycleTimerTicks(); 
     880    uint64_t now = m_parent.get1394Service().getCycleTimerTicks(); 
    881881    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
    882882                          now, 
     
    902902    uint64_t tx; 
    903903    if (t < 0) { 
    904         tx = addTicks(m_handler->getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
     904        tx = addTicks(m_parent.get1394Service().getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
    905905    } else { 
    906906        tx = t; 
    907907    } 
    908908    debugOutput(DEBUG_LEVEL_VERBOSE,"for %s SP (%p)\n", ePTToString(getType()), this); 
    909     uint64_t now = m_handler->getCycleTimerTicks(); 
     909    uint64_t now = m_parent.get1394Service().getCycleTimerTicks(); 
    910910    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
    911911                          now, 
     
    924924    uint64_t tx; 
    925925    if (t < 0) { 
    926         tx = addTicks(m_handler->getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
     926        tx = addTicks(m_parent.get1394Service().getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
    927927    } else { 
    928928        tx = t; 
    929929    } 
    930930    debugOutput(DEBUG_LEVEL_VERBOSE,"for %s SP (%p)\n", ePTToString(getType()), this); 
    931     uint64_t now = m_handler->getCycleTimerTicks(); 
     931    uint64_t now = m_parent.get1394Service().getCycleTimerTicks(); 
    932932    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
    933933                          now, 
     
    946946    uint64_t tx; 
    947947    if (t < 0) { 
    948         tx = addTicks(m_handler->getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
     948        tx = addTicks(m_parent.get1394Service().getCycleTimerTicks(), 200 * TICKS_PER_CYCLE); 
    949949    } else { 
    950950        tx = t; 
    951951    } 
    952952    debugOutput(DEBUG_LEVEL_VERBOSE,"for %s SP (%p)\n", ePTToString(getType()), this); 
    953     uint64_t now = m_handler->getCycleTimerTicks(); 
     953    uint64_t now = m_parent.get1394Service().getCycleTimerTicks(); 
    954954    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
    955955                          now, 
     
    15301530{ 
    15311531    debugOutputShort( DEBUG_LEVEL_NORMAL, " StreamProcessor %p information\n", this); 
    1532     debugOutputShort( DEBUG_LEVEL_NORMAL, "  Port, Channel  : %d, %d\n", m_port, m_channel); 
     1532    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Port, Channel  : %d, %d\n", getPort(), m_channel); 
    15331533    debugOutputShort( DEBUG_LEVEL_NORMAL, "  StreamProcessor info:\n"); 
    15341534    if (m_handler) { 
    1535         uint64_t now = m_handler->getCycleTimerTicks(); 
     1535        uint64_t now = m_parent.get1394Service().getCycleTimerTicks(); 
    15361536        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Now                   : %011llu (%03us %04uc %04ut)\n", 
    15371537                          now, 
  • trunk/libffado/src/libstreaming/generic/StreamProcessor.h

    r747 r748  
    2424#ifndef __FFADO_STREAMPROCESSOR__ 
    2525#define __FFADO_STREAMPROCESSOR__ 
     26 
     27#include "ffadodevice.h" 
     28#include "libieee1394/ieee1394service.h" 
    2629 
    2730#include "PortManager.h" 
     
    130133 
    131134public: // constructor/destructor 
    132     StreamProcessor(enum eProcessorType type, int port); 
     135    StreamProcessor(FFADODevice &parent, enum eProcessorType type); 
    133136    virtual ~StreamProcessor(); 
     137protected: 
     138    FFADODevice&    m_parent; 
    134139 
    135140public: // the public receive/transmit functions 
     
    255260    bool setChannel(int c) 
    256261        {m_channel = c; return true;}; 
    257     int getPort() {return m_port;}; 
     262    int getPort() {return m_parent.get1394Service().getPort();}; 
    258263    virtual unsigned int getPacketsPerPeriod(); 
    259264    virtual unsigned int getMaxPacketSize() = 0; 
     
    261266    void setHandler( IsoHandler * h) {m_handler = h;}; 
    262267    void clearHandler() {m_handler = NULL;}; 
    263  
    264268private: 
    265269    int m_channel; 
    266     int m_port; 
    267270protected: 
    268271    IsoHandler *m_handler; // needed for local id and cycle counter 
  • trunk/libffado/src/libstreaming/motu/MotuReceiveStreamProcessor.cpp

    r747 r748  
    2727#include "../StreamProcessorManager.h" 
    2828 
    29 #include "../util/cycletimer.h" 
     29#include "libieee1394/cycletimer.h" 
    3030 
    3131#include <math.h> 
     
    6767} 
    6868 
    69 MotuReceiveStreamProcessor::MotuReceiveStreamProcessor(int port, unsigned int event_size) 
    70     : StreamProcessor(ePT_Receive , port
    71     , m_event_size(event_size
     69MotuReceiveStreamProcessor::MotuReceiveStreamProcessor(FFADODevice &parent, unsigned int event_size) 
     70    : StreamProcessor(parent, ePT_Receive
     71    , m_event_size( event_size
    7272{} 
    7373 
     
    137137        // we can just pick it straight from the packet. 
    138138        uint32_t last_sph = ntohl(*(quadlet_t *)(data+8+(n_events-1)*event_length)); 
    139         m_last_timestamp = sphRecvToFullTicks(last_sph, m_handler->getCycleTimer()); 
     139        m_last_timestamp = sphRecvToFullTicks(last_sph, m_parent.get1394Service().getCycleTimer()); 
    140140        return eCRV_OK; 
    141141    } else { 
  • trunk/libffado/src/libstreaming/motu/MotuReceiveStreamProcessor.h

    r742 r748  
    5656     *                  (midi-muxed is only one stream) 
    5757     */ 
    58     MotuReceiveStreamProcessor(int port, unsigned int event_size); 
     58    MotuReceiveStreamProcessor(FFADODevice &parent, unsigned int event_size); 
    5959    virtual ~MotuReceiveStreamProcessor() {}; 
    6060 
  • trunk/libffado/src/libstreaming/motu/MotuTransmitStreamProcessor.cpp

    r747 r748  
    2727#include "../StreamProcessorManager.h" 
    2828 
    29 #include "../util/cycletimer.h" 
     29#include "libieee1394/cycletimer.h" 
    3030 
    3131#include <netinet/in.h> 
     
    5151 
    5252/* transmit */ 
    53 MotuTransmitStreamProcessor::MotuTransmitStreamProcessor ( int port, unsigned int event_size ) 
    54         : StreamProcessor ( ePT_Transmit, port ) 
    55         , m_event_size ( event_size ) 
    56         , m_tx_dbc ( 0 ) 
     53MotuTransmitStreamProcessor::MotuTransmitStreamProcessor(FFADODevice &parent, unsigned int event_size ) 
     54        : StreamProcessor(parent, ePT_Transmit ) 
     55        , m_event_size( event_size ) 
     56        , m_tx_dbc( 0 ) 
    5757{} 
    5858 
  • trunk/libffado/src/libstreaming/motu/MotuTransmitStreamProcessor.h

    r742 r748  
    5555     * Create a MOTU transmit StreamProcessor 
    5656     */ 
    57     MotuTransmitStreamProcessor(int port, unsigned int event_size); 
     57    MotuTransmitStreamProcessor(FFADODevice &parent, unsigned int event_size); 
    5858    virtual ~MotuTransmitStreamProcessor() {}; 
    5959 
  • trunk/libffado/src/libstreaming/StreamProcessorManager.cpp

    r746 r748  
    2525#include "generic/StreamProcessor.h" 
    2626#include "generic/Port.h" 
    27 #include "util/cycletimer.h" 
     27#include "libieee1394/cycletimer.h" 
    2828 
    2929#include <errno.h> 
  • trunk/libffado/src/libstreaming/util/IsoHandler.cpp

    r747 r748  
    2323 
    2424#include "IsoHandler.h" 
    25 #include "cycletimer.h" 
    2625#include "../generic/StreamProcessor.h" 
    2726 
     
    3736#include <iostream> 
    3837using namespace std; 
    39  
    40 #define CC_SLEEP_TIME_AFTER_UPDATE    1000 
    41 #define CC_SLEEP_TIME_AFTER_FAILURE     10 
    42 #define CC_DLL_COEFF     ((0.001)*((float)(CC_SLEEP_TIME_AFTER_UPDATE/1000.0))) 
    43  
    44 #define CC_MAX_RATE_ERROR           (2.0/100.0) 
    45 #define CC_INIT_MAX_TRIES 10 
    46  
    4738 
    4839namespace Streaming 
     
    275266    debugOutput( DEBUG_LEVEL_VERBOSE, "bus reset...\n"); 
    276267 
     268    #define CSR_CYCLE_TIME            0x200 
     269    #define CSR_REGISTER_BASE  0xfffff0000000ULL 
    277270    // do a simple read on ourself in order to update the internal structures 
    278271    // this avoids read failures after a bus reset 
     
    280273    raw1394_read(m_handle, raw1394_get_local_id(m_handle), 
    281274                 CSR_REGISTER_BASE | CSR_CYCLE_TIME, 4, &buf); 
    282  
    283275    return 0; 
    284276} 
    285277 
    286 /** 
    287  * Returns the current value of the cycle timer (in ticks) 
    288  * 
    289  * @return the current value of the cycle timer (in ticks) 
    290  */ 
    291  
    292 unsigned int IsoHandler::getCycleTimerTicks() { 
    293     // the new api should be realtime safe. 
    294     // it might cause a reschedule when turning preemption, 
    295     // back on but that won't hurt us if we have sufficient 
    296     // priority 
    297     int err; 
    298     uint32_t cycle_timer; 
    299     uint64_t local_time; 
    300     err=raw1394_read_cycle_timer(m_handle_util, &cycle_timer, &local_time); 
    301     if(err) { 
    302         debugWarning("raw1394_read_cycle_timer: %s\n", strerror(err)); 
    303     } 
    304     return CYCLE_TIMER_TO_TICKS(cycle_timer); 
    305 } 
    306  
    307 /** 
    308  * Returns the current value of the cycle timer (as is) 
    309  * 
    310  * @return the current value of the cycle timer (as is) 
    311  */ 
    312  
    313 unsigned int IsoHandler::getCycleTimer() { 
    314     // the new api should be realtime safe. 
    315     // it might cause a reschedule when turning preemption, 
    316     // back on but that won't hurt us if we have sufficient 
    317     // priority 
    318     int err; 
    319     uint32_t cycle_timer; 
    320     uint64_t local_time; 
    321     err=raw1394_read_cycle_timer(m_handle_util, &cycle_timer, &local_time); 
    322     if(err) { 
    323         debugWarning("raw1394_read_cycle_timer: %s\n", strerror(err)); 
    324     } 
    325     return cycle_timer; 
    326 } 
    327  
    328278void IsoHandler::dumpInfo() 
    329279{ 
    330  
    331280    int channel=-1; 
    332281    if (m_Client) channel=m_Client->getChannel(); 
  • trunk/libffado/src/libstreaming/util/IsoHandler.h

    r747 r748  
    9595        int getLocalNodeId() {return raw1394_get_local_id( m_handle );}; 
    9696        int getPort() {return m_port;}; 
    97  
    98         /// get the most recent cycle timer value (in ticks) 
    99         unsigned int getCycleTimerTicks(); 
    100         /// get the most recent cycle timer value (as is) 
    101         unsigned int getCycleTimer(); 
    10297 
    10398    protected: 
  • trunk/libffado/src/libutil/TimestampedBuffer.cpp

    r742 r748  
    2323 
    2424#include "libutil/Atomic.h" 
    25 #include "libstreaming/util/cycletimer.h" 
     25#include "libieee1394/cycletimer.h" 
    2626 
    2727#include "TimestampedBuffer.h" 
  • trunk/libffado/src/motu/motu_avdevice.cpp

    r742 r748  
    519519    } 
    520520 
    521     m_receiveProcessor=new Streaming::MotuReceiveStreamProcessor( 
    522         get1394Service().getPort(), event_size_in); 
     521    m_receiveProcessor=new Streaming::MotuReceiveStreamProcessor(*this, event_size_in); 
    523522 
    524523    // The first thing is to initialize the processor.  This creates the 
     
    589588 
    590589    // Do the same for the transmit processor 
    591     m_transmitProcessor=new Streaming::MotuTransmitStreamProcessor( 
    592         get1394Service().getPort(), event_size_out); 
     590    m_transmitProcessor=new Streaming::MotuTransmitStreamProcessor(*this, event_size_out); 
    593591 
    594592    m_transmitProcessor->setVerboseLevel(getDebugLevel()); 
  • trunk/libffado/tests/test-timestampedbuffer.cpp

    r742 r748  
    3737#include <netinet/in.h> 
    3838 
    39 #include "src/libstreaming/util/cycletimer.h" 
     39#include "src/libieee1394/cycletimer.h" 
    4040 
    4141#include "src/libutil/TimestampedBuffer.h"