Changeset 754

Show
Ignore:
Timestamp:
12/03/07 14:26:22 (14 years ago)
Author:
ppalmers
Message:

- simplify IsoHandler?
- fix some small issues

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/SConstruct

    r753 r754  
    176176        print "Doing a DEBUG build" 
    177177        # -Werror could be added to, which would force the devs to really remove all the warnings :-) 
    178         env.AppendUnique( CCFLAGS=["-DDEBUG","-Wall","-g"] ) 
     178        env.AppendUnique( CCFLAGS=["-DDEBUG","-Wall","-g"] ) # HACK!! 
    179179else: 
    180180        env.AppendUnique( CCFLAGS=["-O2","-DNDEBUG"] ) 
  • trunk/libffado/src/libieee1394/CycleTimerHelper.cpp

    r753 r754  
    106106bool 
    107107CycleTimerHelper::setThreadParameters(bool rt, int priority) { 
    108     debugOutput( DEBUG_LEVEL_VERBOSE, "(%p) (rt=%d, prio=%d)...\n", this, rt, priority); 
     108    debugOutput( DEBUG_LEVEL_VERBOSE, "(%p) switch to: (rt=%d, prio=%d)...\n", this, rt, priority); 
    109109    if (priority > 98) priority = 98; // cap the priority 
    110110    m_realtime = rt; 
     
    135135    return rate; 
    136136} 
     137 
     138//#define OLD_STYLE 
     139#ifdef OLD_STYLE 
     140 
     141bool 
     142CycleTimerHelper::Execute() 
     143{ 
     144    usleep(m_usecs_per_update); 
     145    return true; 
     146} 
     147uint32_t 
     148CycleTimerHelper::getCycleTimerTicks() 
     149{ 
     150    uint32_t cycle_timer; 
     151    uint64_t local_time; 
     152    if(!m_Parent.readCycleTimerReg(&cycle_timer, &local_time)) { 
     153        debugError("Could not read cycle timer register\n"); 
     154        return false; 
     155    } 
     156    return CYCLE_TIMER_TO_TICKS(cycle_timer); 
     157} 
     158 
     159uint32_t 
     160CycleTimerHelper::getCycleTimerTicks(uint64_t now) 
     161{ 
     162    return getCycleTimerTicks(); 
     163} 
     164 
     165#else 
    137166 
    138167bool 
     
    246275    return retval; 
    247276} 
     277#endif 
    248278 
    249279uint32_t 
  • trunk/libffado/src/libieee1394/ieee1394service.cpp

    r753 r754  
    4545#define FFADO_MAX_FIREWIRE_PORTS 16 
    4646 
    47 #define ISOMANAGER_PRIO_INCREASE         10 
     47#define ISOMANAGER_PRIO_INCREASE         11 
    4848#define CYCLETIMER_HELPER_PRIO_INCREASE  10 
    4949 
     
    274274bool 
    275275Ieee1394Service::setThreadParameters(bool rt, int priority) { 
     276    bool result = true; 
    276277    if (priority > 98) priority = 98; 
    277278    m_base_priority = priority; 
    278279    m_realtime = rt; 
    279280    if (m_pIsoManager) { 
    280         return m_pIsoManager->setThreadParameters(rt, priority + ISOMANAGER_PRIO_INCREASE); 
    281     } else { 
    282         return true
     281        debugOutput(DEBUG_LEVEL_VERBOSE, "Switching IsoManager to (rt=%d, prio=%d)\n", 
     282                                         rt, priority + ISOMANAGER_PRIO_INCREASE); 
     283        result &= m_pIsoManager->setThreadParameters(rt, priority + ISOMANAGER_PRIO_INCREASE)
    283284    } 
    284285    if (m_pCTRHelper) { 
    285         return m_pCTRHelper->setThreadParameters(rt, priority + CYCLETIMER_HELPER_PRIO_INCREASE); 
    286     } else { 
    287         return true; 
    288     } 
     286        debugOutput(DEBUG_LEVEL_VERBOSE, "Switching CycleTimerHelper to (rt=%d, prio=%d)\n",  
     287                                         rt, priority + CYCLETIMER_HELPER_PRIO_INCREASE); 
     288        result &= m_pCTRHelper->setThreadParameters(rt, priority + CYCLETIMER_HELPER_PRIO_INCREASE); 
     289    } 
     290    return result; 
    289291} 
    290292 
     
    315317 * @return the current value of the cycle timer (as is) 
    316318 */ 
    317  
    318319uint32_t 
    319320Ieee1394Service::getCycleTimer() { 
    320     // the new api should be realtime safe. 
    321     // it might cause a reschedule when turning preemption, 
    322     // back on but that won't hurt us if we have sufficient 
    323     // priority 
    324     int err; 
    325     uint32_t cycle_timer; 
    326     uint64_t local_time; 
    327     err=raw1394_read_cycle_timer(m_util_handle, &cycle_timer, &local_time); 
    328     if(err) { 
    329         debugWarning("raw1394_read_cycle_timer: %s\n", strerror(err)); 
    330     } 
    331     return cycle_timer; 
     321    return m_pCTRHelper->getCycleTimer(); 
    332322} 
    333323 
  • trunk/libffado/src/libieee1394/IsoHandler.cpp

    r753 r754  
    4242/* the C callbacks */ 
    4343enum raw1394_iso_disposition 
    44 IsoXmitHandler::iso_transmit_handler(raw1394handle_t handle, 
     44IsoHandler::iso_transmit_handler(raw1394handle_t handle, 
    4545        unsigned char *data, unsigned int *length, 
    4646        unsigned char *tag, unsigned char *sy, 
    4747        int cycle, unsigned int dropped) { 
    4848 
    49     IsoXmitHandler *xmitHandler=static_cast<IsoXmitHandler *>(raw1394_get_userdata(handle)); 
     49    IsoHandler *xmitHandler = static_cast<IsoHandler *>(raw1394_get_userdata(handle)); 
    5050    assert(xmitHandler); 
    5151 
     
    5454 
    5555enum raw1394_iso_disposition 
    56 IsoRecvHandler::iso_receive_handler(raw1394handle_t handle, unsigned char *data, 
     56IsoHandler::iso_receive_handler(raw1394handle_t handle, unsigned char *data, 
    5757                        unsigned int length, unsigned char channel, 
    5858                        unsigned char tag, unsigned char sy, unsigned int cycle, 
    5959                        unsigned int dropped) { 
    6060 
    61     IsoRecvHandler *recvHandler=static_cast<IsoRecvHandler *>(raw1394_get_userdata(handle)); 
     61    IsoHandler *recvHandler = static_cast<IsoHandler *>(raw1394_get_userdata(handle)); 
    6262    assert(recvHandler); 
    6363 
     
    6969    debugOutput( DEBUG_LEVEL_VERBOSE, "Busreset happened, generation %d...\n", generation); 
    7070 
    71     IsoHandler *handler=static_cast<IsoHandler *>(raw1394_get_userdata(handle)); 
     71    IsoHandler *handler = static_cast<IsoHandler *>(raw1394_get_userdata(handle)); 
    7272    assert(handler); 
    7373    return handler->handleBusReset(generation); 
    7474} 
    7575 
    76  
    77 /* Base class implementation */ 
    78 IsoHandler::IsoHandler(IsoHandlerManager& manager) 
    79    : m_manager(manager) 
    80    , m_handle(0) 
    81    , m_buf_packets(400) 
    82    , m_max_packet_size(1024) 
    83    , m_irq_interval(-1) 
    84    , m_packetcount(0) 
    85    , m_dropped(0) 
    86    , m_Client(0) 
     76IsoHandler::IsoHandler(IsoHandlerManager& manager, enum EHandlerType t) 
     77   : m_manager( manager ) 
     78   , m_type ( t ) 
     79   , m_handle( 0 ) 
     80   , m_buf_packets( 400 ) 
     81   , m_max_packet_size( 1024 ) 
     82   , m_irq_interval( -1 ) 
     83   , m_packetcount( 0 ) 
     84   , m_dropped( 0 ) 
     85   , m_Client( 0 ) 
    8786   , m_poll_timeout( 100 ) 
    8887   , m_realtime ( false ) 
    8988   , m_priority ( 0 ) 
    9089   , m_Thread ( NULL ) 
    91    , m_State(E_Created) 
    92 
    93 
    94  
    95 IsoHandler::IsoHandler(IsoHandlerManager& manager, unsigned int buf_packets, unsigned int max_packet_size, int irq) 
    96    : m_manager(manager) 
    97    , m_handle(0) 
    98    , m_buf_packets(buf_packets) 
    99    , m_max_packet_size( max_packet_size) 
    100    , m_irq_interval(irq) 
    101    , m_packetcount(0) 
    102    , m_dropped(0) 
    103    , m_Client(0) 
     90   , m_speed( RAW1394_ISO_SPEED_400 ) 
     91   , m_prebuffers( 0 ) 
     92   , m_State( E_Created ) 
     93
     94
     95 
     96IsoHandler::IsoHandler(IsoHandlerManager& manager, enum EHandlerType t,  
     97                       unsigned int buf_packets, unsigned int max_packet_size, int irq) 
     98   : m_manager( manager ) 
     99   , m_type ( t ) 
     100   , m_handle( 0 ) 
     101   , m_buf_packets( buf_packets ) 
     102   , m_max_packet_size( max_packet_size ) 
     103   , m_irq_interval( irq ) 
     104   , m_packetcount( 0 ) 
     105   , m_dropped( 0 ) 
     106   , m_Client( 0 ) 
    104107   , m_poll_timeout( 100 ) 
    105108   , m_realtime ( false ) 
    106109   , m_priority ( 0 ) 
    107110   , m_Thread ( NULL ) 
    108    , m_State(E_Created) 
     111   , m_speed( RAW1394_ISO_SPEED_400 ) 
     112   , m_prebuffers( 0 ) 
     113   , m_State( E_Created ) 
     114
     115
     116 
     117IsoHandler::IsoHandler(IsoHandlerManager& manager, enum EHandlerType t, unsigned int buf_packets, 
     118                       unsigned int max_packet_size, int irq, 
     119                       enum raw1394_iso_speed speed) 
     120   : m_manager( manager ) 
     121   , m_type ( t ) 
     122   , m_handle( 0 ) 
     123   , m_buf_packets( buf_packets ) 
     124   , m_max_packet_size( max_packet_size ) 
     125   , m_irq_interval( irq ) 
     126   , m_packetcount( 0 ) 
     127   , m_dropped( 0 ) 
     128   , m_Client( 0 ) 
     129   , m_poll_timeout( 100 ) 
     130   , m_realtime ( false ) 
     131   , m_priority ( 0 ) 
     132   , m_Thread ( NULL ) 
     133   , m_speed( speed ) 
     134   , m_prebuffers( 0 ) 
     135   , m_State( E_Created ) 
    109136{ 
    110137} 
     
    162189        return false; 
    163190    } 
    164  
    165     if (m_poll_fd.revents & POLLERR) { 
    166         debugWarning("error on fd for %p\n", this); 
    167     } 
    168  
    169     if (m_poll_fd.revents & POLLHUP) { 
    170         debugWarning("hangup on fd for %p\n",this); 
    171     } 
    172  
    173191    if(m_poll_fd.revents & (POLLIN)) { 
    174         iterate(); 
    175     } 
    176  
     192        if(raw1394_loop_iterate(m_handle)) { 
     193            debugOutput( DEBUG_LEVEL_VERBOSE, 
     194                        "IsoHandler (%p): Failed to iterate handler: %s\n", 
     195                        this,strerror(errno)); 
     196            return false; 
     197        } 
     198    } else { 
     199        if (m_poll_fd.revents & POLLERR) { 
     200            debugWarning("error on fd for %p\n", this); 
     201        } 
     202        if (m_poll_fd.revents & POLLHUP) { 
     203            debugWarning("hangup on fd for %p\n",this); 
     204        } 
     205    } 
    177206    return true; 
    178207} 
     
    180209bool 
    181210IsoHandler::setThreadParameters(bool rt, int priority) { 
    182     debugOutput( DEBUG_LEVEL_VERBOSE, "(%p) (rt=%d, prio=%d)...\n", this, rt, priority); 
     211    debugOutput( DEBUG_LEVEL_VERBOSE, "(%p) switch to: (rt=%d, prio=%d)...\n", this, rt, priority); 
    183212    if (priority > 98) priority = 98; // cap the priority 
    184213    m_realtime = rt; 
     
    193222    } 
    194223    return true; 
    195 } 
    196  
    197 bool 
    198 IsoHandler::iterate() { 
    199     debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "IsoHandler (%p) iterate...\n",this); 
    200     if(raw1394_loop_iterate(m_handle)) { 
    201         debugOutput( DEBUG_LEVEL_VERBOSE, 
    202                      "IsoHandler (%p): Failed to iterate handler: %s\n", 
    203                      this,strerror(errno)); 
    204         return false; 
    205     } else { 
    206         return true; 
    207     } 
    208224} 
    209225 
     
    259275} 
    260276 
    261 bool IsoHandler::prepare() 
    262 { 
    263     debugOutput( DEBUG_LEVEL_VERBOSE, "IsoHandler (%p) prepare...\n", this); 
    264     // check the state 
    265     if(m_State != E_Initialized) { 
    266         debugError("Incorrect state, expected E_Initialized, got %d\n",(int)m_State); 
    267         return false; 
    268     } 
    269     // Don't call until libraw1394's raw1394_new_handle() function has been 
    270     // fixed to correctly initialise the iso_packet_infos field.  Bug is 
    271     // confirmed present in libraw1394 1.2.1. 
    272 //     raw1394_iso_shutdown(m_handle); 
    273     m_State = E_Prepared; 
    274     return true; 
    275 } 
    276  
    277 bool IsoHandler::enable(int cycle) 
    278 { 
    279     debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    280     m_poll_fd.events = POLLIN; 
    281     m_State = E_Running; 
    282     return true; 
    283 } 
    284  
    285277bool IsoHandler::disable() 
    286278{ 
     
    311303 */ 
    312304 
    313 int IsoHandler::handleBusReset(unsigned int generation) { 
     305int 
     306IsoHandler::handleBusReset(unsigned int generation) 
     307
    314308    debugOutput( DEBUG_LEVEL_VERBOSE, "bus reset...\n"); 
    315309 
     
    330324 
    331325    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Handler type................: %s\n", 
    332             (this->getType()==EHT_Receive ? "Receive" : "Transmit")); 
     326            (this->getType() == eHT_Receive ? "Receive" : "Transmit")); 
    333327    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Port, Channel...............: %2d, %2d\n", 
    334328            m_manager.get1394Service().getPort(), channel); 
    335329    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Buffer, MaxPacketSize, IRQ..: %4d, %4d, %4d\n", 
    336330            m_buf_packets, m_max_packet_size, m_irq_interval); 
     331    if (this->getType() == eHT_Transmit) { 
     332        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Speed, PreBuffers...........: %2d, %2d\n", 
     333                                            m_speed, m_prebuffers); 
     334    } 
    337335    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Packet count................: %10d (%5d dropped)\n", 
    338336            this->getPacketCount(), this->getDroppedCount()); 
     
    371369} 
    372370 
    373 /* Child class implementations */ 
    374  
    375 IsoRecvHandler::IsoRecvHandler(IsoHandlerManager& manager) 
    376                 : IsoHandler(manager) 
    377 
    378     debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    379 
    380 IsoRecvHandler::IsoRecvHandler(IsoHandlerManager& manager, unsigned int buf_packets, 
    381                                unsigned int max_packet_size, int irq) 
    382                 : IsoHandler(manager, buf_packets,max_packet_size,irq) 
    383 
    384     debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    385  
    386 
    387 IsoRecvHandler::~IsoRecvHandler() 
    388 
    389  
    390 
    391  
    392 void IsoRecvHandler::flush() 
    393 
    394     raw1394_iso_recv_flush(m_handle); 
    395 
    396  
    397 bool 
    398 IsoRecvHandler::init() { 
    399     debugOutput( DEBUG_LEVEL_VERBOSE, "init recv handler %p\n",this); 
    400  
    401     if(!(IsoHandler::init())) { 
    402         return false; 
    403     } 
    404     return true; 
    405  
    406 
    407  
    408 enum raw1394_iso_disposition IsoRecvHandler::putPacket( 
     371void IsoHandler::flush() 
     372
     373    if(m_type == eHT_Receive) { 
     374        raw1394_iso_recv_flush(m_handle); 
     375    } else { 
     376        // do nothing 
     377    } 
     378
     379 
     380// ISO packet interface 
     381enum raw1394_iso_disposition IsoHandler::putPacket( 
    409382                    unsigned char *data, unsigned int length, 
    410383                    unsigned char channel, unsigned char tag, unsigned char sy, 
     
    415388                 length, channel, cycle ); 
    416389    m_packetcount++; 
    417     m_dropped+=dropped; 
     390    m_dropped += dropped; 
    418391 
    419392    if(m_Client) { 
     
    424397} 
    425398 
    426 bool IsoRecvHandler::prepare() 
    427 
    428     debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing iso receive handler (%p, client=%p)\n", this, m_Client); 
    429     // prepare the generic IsoHandler 
    430     if(!IsoHandler::prepare()) { 
    431         return false; 
    432     } 
    433     debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing iso receive handler (%p)\n",this); 
    434     debugOutput( DEBUG_LEVEL_VERBOSE, " Buffers         : %d \n", m_buf_packets); 
    435     debugOutput( DEBUG_LEVEL_VERBOSE, " Max Packet size : %d \n", m_max_packet_size); 
    436     debugOutput( DEBUG_LEVEL_VERBOSE, " Channel         : %d \n", m_Client->getChannel()); 
    437     debugOutput( DEBUG_LEVEL_VERBOSE, " Irq interval    : %d \n", m_irq_interval); 
    438     debugOutput( DEBUG_LEVEL_VERBOSE, " Mode            : %s \n",  
    439                                (m_irq_interval > 1)?"DMA_BUFFERFILL":"PACKET_PER_BUFFER"); 
    440  
    441     if(m_irq_interval > 1) { 
    442         if(raw1394_iso_recv_init(m_handle, 
    443                                 iso_receive_handler, 
     399 
     400enum raw1394_iso_disposition IsoHandler::getPacket( 
     401                    unsigned char *data, unsigned int *length, 
     402                    unsigned char *tag, unsigned char *sy, 
     403                    int cycle, unsigned int dropped) { 
     404 
     405    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
     406                    "sending packet: length=%d, cycle=%d\n", 
     407                    *length, cycle ); 
     408    m_packetcount++; 
     409    m_dropped += dropped; 
     410 
     411    if(m_Client) { 
     412        return m_Client->getPacket(data, length, tag, sy, cycle, dropped, m_max_packet_size); 
     413    } 
     414    return RAW1394_ISO_OK; 
     415
     416 
     417bool IsoHandler::prepare() 
     418
     419    // check the state 
     420    if(m_State != E_Initialized) { 
     421        debugError("Incorrect state, expected E_Initialized, got %d\n",(int)m_State); 
     422        return false; 
     423    } 
     424 
     425    // Don't call until libraw1394's raw1394_new_handle() function has been 
     426    // fixed to correctly initialise the iso_packet_infos field.  Bug is 
     427    // confirmed present in libraw1394 1.2.1. 
     428    //     raw1394_iso_shutdown(m_handle); 
     429    m_State = E_Prepared; 
     430 
     431    debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing iso handler (%p, client=%p)\n", this, m_Client); 
     432    dumpInfo(); 
     433    if (getType() == eHT_Receive) { 
     434        if(m_irq_interval > 1) { 
     435            if(raw1394_iso_recv_init(m_handle, 
     436                                    iso_receive_handler, 
     437                                    m_buf_packets, 
     438                                    m_max_packet_size, 
     439                                    m_Client->getChannel(), 
     440                                    RAW1394_DMA_BUFFERFILL, 
     441                                    m_irq_interval)) { 
     442                debugFatal("Could not do receive initialisation (DMA_BUFFERFILL)!\n" ); 
     443                debugFatal("  %s\n",strerror(errno)); 
     444                return false; 
     445            } 
     446        } else { 
     447            if(raw1394_iso_recv_init(m_handle, 
     448                                    iso_receive_handler, 
     449                                    m_buf_packets, 
     450                                    m_max_packet_size, 
     451                                    m_Client->getChannel(), 
     452                                    RAW1394_DMA_PACKET_PER_BUFFER, 
     453                                    m_irq_interval)) { 
     454                debugFatal("Could not do receive initialisation (PACKET_PER_BUFFER)!\n" ); 
     455                debugFatal("  %s\n",strerror(errno)); 
     456                return false; 
     457            } 
     458        } 
     459        return true; 
     460    } else { 
     461        if(raw1394_iso_xmit_init(m_handle, 
     462                                iso_transmit_handler, 
    444463                                m_buf_packets, 
    445464                                m_max_packet_size, 
    446465                                m_Client->getChannel(), 
    447                                 RAW1394_DMA_BUFFERFILL
     466                                m_speed
    448467                                m_irq_interval)) { 
    449             debugFatal("Could not do receive initialisation!\n" ); 
    450             debugFatal("  %s\n",strerror(errno)); 
    451  
    452             return false; 
    453         } 
    454     } else { 
    455         if(raw1394_iso_recv_init(m_handle, 
    456                                 iso_receive_handler, 
    457                                 m_buf_packets, 
    458                                 m_max_packet_size, 
    459                                 m_Client->getChannel(), 
    460                                 RAW1394_DMA_PACKET_PER_BUFFER, 
    461                                 m_irq_interval)) { 
    462             debugFatal("Could not do receive initialisation!\n" ); 
    463             debugFatal("  %s\n",strerror(errno)); 
    464  
    465             return false; 
    466         } 
    467     } 
    468     return true; 
    469 
    470  
    471 bool IsoRecvHandler::enable(int cycle) 
     468            debugFatal("Could not do xmit initialisation!\n" ); 
     469            return false; 
     470        } 
     471        return true; 
     472    } 
     473
     474 
     475bool IsoHandler::enable(int cycle) 
    472476{ 
    473477    debugOutput( DEBUG_LEVEL_VERBOSE, "start on cycle %d\n", cycle); 
     
    475479    if(m_State != E_Prepared) { 
    476480        if(!prepare()) { 
    477             debugFatal("Could not prepare recv handler\n"); 
    478             return false; 
    479         } 
    480     } 
    481     if(raw1394_iso_recv_start(m_handle, cycle, -1, 0)) { 
    482         debugFatal("Could not start receive handler (%s)\n",strerror(errno)); 
    483         dumpInfo(); 
    484         return false; 
    485     } 
    486     // start the generic IsoHandler 
    487     if(!IsoHandler::enable(cycle)) { 
    488         return false; 
    489     } 
    490     return true; 
    491 
    492  
    493 int IsoRecvHandler::handleBusReset(unsigned int generation) { 
    494     debugOutput( DEBUG_LEVEL_VERBOSE, "handle bus reset...\n"); 
    495  
    496     //TODO: implement busreset 
    497  
    498     // pass on the busreset signal 
    499     if(IsoHandler::handleBusReset(generation)) { 
    500         return -1; 
    501     } 
    502     return 0; 
    503 
    504  
    505 /* ----------------- XMIT --------------- */ 
    506  
    507 IsoXmitHandler::IsoXmitHandler(IsoHandlerManager& manager) 
    508                 : IsoHandler(manager), m_prebuffers(0) 
    509 
    510     debugOutput( DEBUG_LEVEL_VERBOSE, "IsoXmitHandler enter...\n"); 
    511  
    512 
    513 IsoXmitHandler::IsoXmitHandler(IsoHandlerManager& manager, unsigned int buf_packets, 
    514                                unsigned int max_packet_size, int irq) 
    515                 : IsoHandler(manager, buf_packets, max_packet_size,irq), 
    516                   m_speed(RAW1394_ISO_SPEED_400), m_prebuffers(0) 
    517 
    518     debugOutput( DEBUG_LEVEL_VERBOSE, "IsoXmitHandler enter...\n"); 
    519  
    520 
    521 IsoXmitHandler::IsoXmitHandler(IsoHandlerManager& manager, unsigned int buf_packets, 
    522                                unsigned int max_packet_size, int irq, 
    523                                enum raw1394_iso_speed speed) 
    524                 : IsoHandler(manager, buf_packets,max_packet_size,irq), 
    525                   m_speed(speed), m_prebuffers(0) 
    526 
    527     debugOutput( DEBUG_LEVEL_VERBOSE, "IsoXmitHandler enter...\n"); 
    528  
    529 
    530  
    531 IsoXmitHandler::~IsoXmitHandler() 
    532 
    533     // handle cleanup is done in the IsoHanlder destructor 
    534 
    535  
    536 bool 
    537 IsoXmitHandler::init() { 
    538  
    539     debugOutput( DEBUG_LEVEL_VERBOSE, "init xmit handler %p\n",this); 
    540  
    541     if(!(IsoHandler::init())) { 
    542         return false; 
    543     } 
    544  
    545     return true; 
    546 
    547  
    548 bool IsoXmitHandler::prepare() 
    549 
    550     debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing iso transmit handler (%p, client=%p)\n", this, m_Client); 
    551     if(!(IsoHandler::prepare())) { 
    552         return false; 
    553     } 
    554  
    555     debugOutput( DEBUG_LEVEL_VERBOSE, " Buffers         : %d \n",m_buf_packets); 
    556     debugOutput( DEBUG_LEVEL_VERBOSE, " Max Packet size : %d \n",m_max_packet_size); 
    557     debugOutput( DEBUG_LEVEL_VERBOSE, " Channel         : %d \n",m_Client->getChannel()); 
    558     debugOutput( DEBUG_LEVEL_VERBOSE, " Speed           : %d \n",m_speed); 
    559     debugOutput( DEBUG_LEVEL_VERBOSE, " Irq interval    : %d \n",m_irq_interval); 
    560     if(raw1394_iso_xmit_init(m_handle, 
    561                              iso_transmit_handler, 
    562                              m_buf_packets, 
    563                              m_max_packet_size, 
    564                              m_Client->getChannel(), 
    565                              m_speed, 
    566                              m_irq_interval)) { 
    567         debugFatal("Could not do xmit initialisation!\n" ); 
    568  
    569         return false; 
    570     } 
    571     return true; 
    572 
    573  
    574 bool IsoXmitHandler::enable(int cycle) 
    575 
    576     debugOutput( DEBUG_LEVEL_VERBOSE, "start on cycle %d, %d prebuffers\n",  
    577         cycle, m_prebuffers); 
    578     // check the state 
    579     if(m_State != E_Prepared) { 
    580         if(!prepare()) { 
    581             debugFatal("Could not prepare xmit handler\n"); 
    582             return false; 
    583         } 
    584     } 
    585     if(raw1394_iso_xmit_start(m_handle, cycle, m_prebuffers)) { 
    586         debugFatal("Could not start xmit handler (%s)\n",strerror(errno)); 
    587         dumpInfo(); 
    588         return false; 
    589     } 
    590     if(!(IsoHandler::enable(cycle))) { 
    591         return false; 
    592     } 
    593     return true; 
    594 
    595  
    596 enum raw1394_iso_disposition IsoXmitHandler::getPacket( 
    597                     unsigned char *data, unsigned int *length, 
    598                     unsigned char *tag, unsigned char *sy, 
    599                     int cycle, unsigned int dropped) { 
    600  
    601     debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
    602                     "sending packet: length=%d, cycle=%d\n", 
    603                     *length, cycle ); 
    604     m_packetcount++; 
    605     m_dropped+=dropped; 
    606  
    607     if(m_Client) { 
    608         return m_Client->getPacket(data, length, tag, sy, cycle, dropped, m_max_packet_size); 
    609     } 
    610     return RAW1394_ISO_OK; 
    611 
    612  
    613 int IsoXmitHandler::handleBusReset(unsigned int generation) { 
    614     debugOutput( DEBUG_LEVEL_VERBOSE, "bus reset...\n"); 
    615     //TODO: implement busreset 
    616     // pass on the busreset signal 
    617     if(IsoHandler::handleBusReset(generation)) { 
    618             return -1; 
    619     } 
    620     return 0; 
    621 
    622  
    623 void IsoXmitHandler::dumpInfo() 
    624 
    625     IsoHandler::dumpInfo(); 
    626     debugOutputShort( DEBUG_LEVEL_NORMAL, "  Speed, PreBuffers...........: %2d, %2d\n", 
    627                                           m_speed, m_prebuffers); 
    628 
     481            debugFatal("Could not prepare handler\n"); 
     482            return false; 
     483        } 
     484    } 
     485 
     486    if (getType() == eHT_Receive) { 
     487        if(raw1394_iso_recv_start(m_handle, cycle, -1, 0)) { 
     488            debugFatal("Could not start receive handler (%s)\n",strerror(errno)); 
     489            dumpInfo(); 
     490            return false; 
     491        } 
     492    } else { 
     493        if(raw1394_iso_xmit_start(m_handle, cycle, m_prebuffers)) { 
     494            debugFatal("Could not start xmit handler (%s)\n",strerror(errno)); 
     495            dumpInfo(); 
     496            return false; 
     497        } 
     498    } 
     499 
     500    m_poll_fd.events = POLLIN; 
     501    m_State = E_Running; 
     502    return true; 
     503
  • trunk/libffado/src/libieee1394/IsoHandler.h

    r753 r754  
    4949public: 
    5050    enum EHandlerType { 
    51             EHT_Receive, 
    52             EHT_Transmit 
     51            eHT_Receive, 
     52            eHT_Transmit 
    5353    }; 
    54     IsoHandler(IsoHandlerManager& manager); 
    55     IsoHandler(IsoHandlerManager& manager, unsigned int buf_packets, unsigned int max_packet_size, int irq); 
    56     virtual ~IsoHandler(); 
     54    IsoHandler(IsoHandlerManager& manager, enum EHandlerType t); 
     55    IsoHandler(IsoHandlerManager& manager, enum EHandlerType t, 
     56               unsigned int buf_packets, unsigned int max_packet_size, int irq); 
     57    IsoHandler(IsoHandlerManager& manager, enum EHandlerType t, 
     58               unsigned int buf_packets, unsigned int max_packet_size, int irq, enum raw1394_iso_speed speed); 
     59    ~IsoHandler(); 
    5760 
     61private: // the ISO callback interface 
     62    static enum raw1394_iso_disposition 
     63    iso_receive_handler(raw1394handle_t handle, unsigned char *data, 
     64                        unsigned int length, unsigned char channel, 
     65                        unsigned char tag, unsigned char sy, unsigned int cycle, 
     66                        unsigned int dropped); 
     67 
     68    enum raw1394_iso_disposition 
     69            putPacket(unsigned char *data, unsigned int length, 
     70                        unsigned char channel, unsigned char tag, unsigned char sy, 
     71                        unsigned int cycle, unsigned int dropped); 
     72 
     73    static enum raw1394_iso_disposition iso_transmit_handler(raw1394handle_t handle, 
     74                    unsigned char *data, unsigned int *length, 
     75                    unsigned char *tag, unsigned char *sy, 
     76                    int cycle, unsigned int dropped); 
     77    enum raw1394_iso_disposition 
     78            getPacket(unsigned char *data, unsigned int *length, 
     79                    unsigned char *tag, unsigned char *sy, 
     80                    int cycle, unsigned int dropped); 
     81 
     82public: 
    5883    // runnable interface 
    59     virtual bool Init(); 
    60     virtual bool Execute(); 
     84    bool Init(); 
     85    bool Execute(); 
    6186    int getFileDescriptor() { return raw1394_get_fd(m_handle);}; 
    6287    bool setThreadParameters(bool rt, int priority); 
    6388 
    64     virtual bool init(); 
    65     virtual bool prepare(); 
     89    bool init(); 
     90    bool prepare(); 
    6691 
    6792    bool iterate(); 
    6893    void setVerboseLevel(int l); 
    6994 
    70     virtual bool enable() {return enable(-1);}; 
    71     virtual bool enable(int cycle); 
    72     virtual bool disable(); 
     95    bool enable() {return enable(-1);}; 
     96    bool enable(int cycle); 
     97    bool disable(); 
    7398 
    74     virtual void flush() = 0; 
     99    void flush(); 
     100    enum EHandlerType getType() {return m_type;}; 
    75101 
    76102    bool isEnabled() 
     
    88114    void resetDroppedCount() {m_dropped=0;}; 
    89115 
    90     virtual enum EHandlerType getType() = 0; 
     116    unsigned int getPreBuffers() {return m_prebuffers;}; 
     117    void setPreBuffers(unsigned int n) {m_prebuffers=n;}; 
    91118 
    92     virtual void dumpInfo(); 
     119    void dumpInfo(); 
    93120 
    94121    bool inUse() {return (m_Client != 0) ;}; 
    95     virtual bool isStreamRegistered(Streaming::StreamProcessor *s) {return (m_Client == s);}; 
     122    bool isStreamRegistered(Streaming::StreamProcessor *s) {return (m_Client == s);}; 
    96123 
    97     virtual bool registerStream(Streaming::StreamProcessor *); 
    98     virtual bool unregisterStream(Streaming::StreamProcessor *); 
     124    bool registerStream(Streaming::StreamProcessor *); 
     125    bool unregisterStream(Streaming::StreamProcessor *); 
    99126 
    100     protected: 
    101         IsoHandlerManager& m_manager; 
    102         raw1394handle_t m_handle; 
    103         unsigned int    m_buf_packets; 
    104         unsigned int    m_max_packet_size; 
    105         int             m_irq_interval; 
     127private: 
     128    IsoHandlerManager& m_manager; 
     129    enum EHandlerType m_type; 
     130    raw1394handle_t m_handle; 
     131    unsigned int    m_buf_packets; 
     132    unsigned int    m_max_packet_size; 
     133    int             m_irq_interval; 
    106134 
    107         int m_packetcount; 
    108         int m_dropped; 
    109         Streaming::StreamProcessor *m_Client; 
     135    int m_packetcount; 
     136    int m_dropped; 
     137    Streaming::StreamProcessor *m_Client; 
    110138 
    111         virtual int handleBusReset(unsigned int generation); 
    112         DECLARE_DEBUG_MODULE; 
    113     private: 
    114         static int busreset_handler(raw1394handle_t handle, unsigned int generation); 
     139    int handleBusReset(unsigned int generation); 
    115140 
    116         struct pollfd   m_poll_fd; 
    117         int             m_poll_timeout; 
    118         // threading 
    119         bool            m_realtime; 
    120         int             m_priority; 
    121         Util::Thread *  m_Thread; 
     141    static int busreset_handler(raw1394handle_t handle, unsigned int generation); 
     142 
     143    struct pollfd   m_poll_fd; 
     144    int             m_poll_timeout; 
     145    // threading 
     146    bool            m_realtime; 
     147    int             m_priority; 
     148    Util::Thread *  m_Thread; 
     149 
     150    enum raw1394_iso_speed m_speed; 
     151    unsigned int m_prebuffers; 
    122152 
    123153    // the state machine 
    124     protected: 
    125         enum EHandlerStates { 
    126             E_Created, 
    127             E_Initialized, 
    128             E_Prepared, 
    129             E_Running, 
    130             E_Error 
    131         }; 
    132         enum EHandlerStates m_State; 
    133 }; 
    134  
    135 /*! 
    136 \brief ISO receive handler class (not multichannel) 
    137 */ 
    138  
    139 class IsoRecvHandler : public IsoHandler 
    140 
    141  
    142     public: 
    143         IsoRecvHandler(IsoHandlerManager& manager); 
    144         IsoRecvHandler(IsoHandlerManager& manager, unsigned int buf_packets, unsigned int max_packet_size, int irq); 
    145         virtual ~IsoRecvHandler(); 
    146  
    147         bool init(); 
    148         enum EHandlerType getType() { return EHT_Receive;}; 
    149         bool enable(int cycle); 
    150         virtual bool prepare(); 
    151         virtual void flush(); 
    152  
    153     protected: 
    154         int handleBusReset(unsigned int generation); 
    155     private: 
    156         static enum raw1394_iso_disposition 
    157         iso_receive_handler(raw1394handle_t handle, unsigned char *data, 
    158                             unsigned int length, unsigned char channel, 
    159                             unsigned char tag, unsigned char sy, unsigned int cycle, 
    160                             unsigned int dropped); 
    161  
    162         enum raw1394_iso_disposition 
    163                 putPacket(unsigned char *data, unsigned int length, 
    164                           unsigned char channel, unsigned char tag, unsigned char sy, 
    165                           unsigned int cycle, unsigned int dropped); 
    166 }; 
    167  
    168 /*! 
    169 \brief ISO transmit handler class 
    170 */ 
    171  
    172 class IsoXmitHandler  : public IsoHandler 
    173 
    174     public: 
    175         IsoXmitHandler(IsoHandlerManager& manager); 
    176         IsoXmitHandler(IsoHandlerManager& manager, unsigned int buf_packets, 
    177                         unsigned int max_packet_size, int irq); 
    178         IsoXmitHandler(IsoHandlerManager& manager, unsigned int buf_packets, 
    179                         unsigned int max_packet_size, int irq, 
    180                         enum raw1394_iso_speed speed); 
    181         virtual ~IsoXmitHandler(); 
    182  
    183         bool init(); 
    184         enum EHandlerType getType() { return EHT_Transmit;}; 
    185         unsigned int getPreBuffers() {return m_prebuffers;}; 
    186         void setPreBuffers(unsigned int n) {m_prebuffers=n;}; 
    187         virtual bool enable(int cycle); 
    188         virtual bool prepare(); 
    189         virtual void flush() {}; 
    190  
    191         void dumpInfo(); 
    192     protected: 
    193         int handleBusReset(unsigned int generation); 
    194  
    195     private: 
    196         static enum raw1394_iso_disposition iso_transmit_handler(raw1394handle_t handle, 
    197                         unsigned char *data, unsigned int *length, 
    198                         unsigned char *tag, unsigned char *sy, 
    199                         int cycle, unsigned int dropped); 
    200         enum raw1394_iso_disposition 
    201                 getPacket(unsigned char *data, unsigned int *length, 
    202                         unsigned char *tag, unsigned char *sy, 
    203                         int cycle, unsigned int dropped); 
    204  
    205         enum raw1394_iso_speed m_speed; 
    206         unsigned int m_prebuffers; 
     154    enum EHandlerStates { 
     155        E_Created, 
     156        E_Initialized, 
     157        E_Prepared, 
     158        E_Running, 
     159        E_Error 
     160    }; 
     161    enum EHandlerStates m_State; 
     162    DECLARE_DEBUG_MODULE; 
    207163}; 
    208164 
  • trunk/libffado/src/libieee1394/IsoHandlerManager.cpp

    r753 r754  
    5656bool 
    5757IsoHandlerManager::setThreadParameters(bool rt, int priority) { 
     58    debugOutput( DEBUG_LEVEL_VERBOSE, "(%p) switch to: (rt=%d, prio=%d)...\n", this, rt, priority); 
    5859    if (priority > 98) priority = 98; // cap the priority 
    5960    m_realtime = rt; 
     
    252253        //irq_interval=2; // HACK 
    253254        // create the actual handler 
    254         h = new IsoRecvHandler(*this, buffers
    255                                                max_packet_size, irq_interval); 
     255        h = new IsoHandler(*this, IsoHandler::eHT_Receive
     256                           buffers, max_packet_size, irq_interval); 
    256257        if(!h) { 
    257258            debugFatal("Could not create IsoRecvHandler\n"); 
     
    299300 
    300301        // create the actual handler 
    301         h = new IsoXmitHandler(*this, buffers
    302                                                max_packet_size, irq_interval); 
     302        h = new IsoHandler(*this, IsoHandler::eHT_Transmit
     303                           buffers, max_packet_size, irq_interval); 
    303304 
    304305        debugOutput( DEBUG_LEVEL_VERBOSE, " registering IsoXmitHandler\n"); 
  • trunk/libffado/src/libstreaming/StreamProcessorManager.cpp

    r753 r754  
    5252    , m_period( 0 ) 
    5353    , m_nominal_framerate ( 0 ) 
     54    , m_xrun_happened( false ) 
    5455    , m_xruns(0) 
    55     , m_xrun_happened( false ) 
    5656    , m_nbperiods(0) 
    5757{ 
     
    476476 
    477477            diff_between_streams[i] /= NB_PERIODS_FOR_ALIGN_AVERAGE; 
    478             diff_between_streams_frames[i] = roundf(diff_between_streams[i] / s->getTicksPerFrame()); 
     478            diff_between_streams_frames[i] = (int)roundf(diff_between_streams[i] / s->getTicksPerFrame()); 
    479479            debugOutput( DEBUG_LEVEL_VERBOSE, "   avg offset between SyncSP %p and SP %p is %lld ticks, %d frames...\n",  
    480480                m_SyncSource, s, diff_between_streams[i], diff_between_streams_frames[i]); 
  • trunk/libffado/src/libstreaming/util/cip.c

    r742 r754  
    213213                struct iec61883_packet *packet) 
    214214{ 
    215   int nevents; 
    216  
    217215  packet->eoh0 = 0; 
    218216 
     
    235233  ptz->dbc += ptz->syt_interval; 
    236234 
    237   return nevents
    238 } 
     235  return 0
     236}