Changeset 1721

Show
Ignore:
Timestamp:
11/22/09 07:26:31 (14 years ago)
Author:
ppalmers
Message:

fix all format string warnings

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libffado-2.0/src/debugmodule/debugmodule.cpp

    r1720 r1721  
    186186    int chars_written=0; 
    187187    int retval=0; 
    188     retval = snprintf(msg, MB_BUFFERSIZE, "%011lu: %s (%s)[%4d] %s: ",  
     188    retval = snprintf(msg, MB_BUFFERSIZE, "%011lu: %s (%s)[%4u] %s: ",  
    189189                      ts_usec, getPreSequence( level ), 
    190190                      fname,  line,  function ); 
  • branches/libffado-2.0/src/libavc/descriptors/avc_descriptor.cpp

    r1720 r1721  
    249249        // copy the payload 
    250250         
    251         if (bytes_read+readDescCmd.m_data_length>m_descriptor_length) { 
     251        if (bytes_read + readDescCmd.m_data_length > m_descriptor_length) { 
    252252            debugWarning("Device returned too much data, truncating\n"); 
    253253            readDescCmd.m_data_length=m_descriptor_length-bytes_read; 
    254254        } 
    255255         
    256         debugOutput(DEBUG_LEVEL_VERBOSE, " copying %u bytes to internal buffer offset %lu\n",readDescCmd.m_data_length, bytes_read); 
     256        debugOutput(DEBUG_LEVEL_VERBOSE, 
     257                    " copying %u bytes to internal buffer offset %lu\n",  
     258                    readDescCmd.m_data_length, bytes_read); 
    257259         
    258260        memcpy(m_data+bytes_read,readDescCmd.m_data, readDescCmd.m_data_length); 
  • branches/libffado-2.0/src/libieee1394/CycleTimerHelper.cpp

    r1720 r1721  
    291291    cycle_timer_ticks = CYCLE_TIMER_TO_TICKS(cycle_timer); 
    292292 
    293     debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, " read : CTR: %11lu, local: %17llu\n", 
     293    debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, " read : CTR: %11u, local: %17lu\n", 
    294294                        cycle_timer, local_time); 
    295295    debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    296                        "  ctr   : 0x%08X %11llu (%03us %04ucy %04uticks)\n", 
     296                       "  ctr   : 0x%08X %11lu (%03us %04ucy %04uticks)\n", 
    297297                       (uint32_t)cycle_timer, (uint64_t)cycle_timer_ticks, 
    298298                       (unsigned int)TICKS_TO_SECS( (uint64_t)cycle_timer_ticks ), 
     
    409409    // // simulate a random scheduling delay between (0-10ms) 
    410410    // ffado_microsecs_t tmp = Util::SystemTimeSource::SleepUsecRandom(10000); 
    411     // debugOutput( DEBUG_LEVEL_VERBOSE, " (%p) random sleep of %lu usecs...\n", this, tmp); 
     411    // debugOutput( DEBUG_LEVEL_VERBOSE, " (%p) random sleep of %u usecs...\n", this, tmp); 
    412412 
    413413    if(m_unhandled_busreset) { 
     
    419419    } 
    420420 
    421     debugOutputExtreme( DEBUG_LEVEL_ULTRA_VERBOSE, " read : CTR: %11lu, local: %17llu\n", 
     421    debugOutputExtreme( DEBUG_LEVEL_ULTRA_VERBOSE, " read : CTR: %11u, local: %17lu\n", 
    422422                        cycle_timer, local_time); 
    423423    debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    424                        "  ctr   : 0x%08X %11llu (%03us %04ucy %04uticks)\n", 
     424                       "  ctr   : 0x%08X %11lu (%03us %04ucy %04uticks)\n", 
    425425                       (uint32_t)cycle_timer, (uint64_t)cycle_timer_ticks, 
    426426                       (unsigned int)TICKS_TO_SECS( (uint64_t)cycle_timer_ticks ), 
     
    462462            diff_ticks_corr = diff_ticks - ticks_late; 
    463463            debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    464                                "diff_ticks_corr=%ld, diff_ticks = %ld, ticks_late = %ld\n", 
     464                               "diff_ticks_corr=%d, diff_ticks = %ld, ticks_late = %ld\n", 
    465465                               diff_ticks_corr, diff_ticks, ticks_late); 
    466466        } else { 
     
    526526 
    527527        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE,  
    528                            " usecs: current: %f next: %f usecs_late=%ld ticks_late=%ld\n", 
     528                           " usecs: current: %f next: %f usecs_late=%d ticks_late=%ld\n", 
    529529                           m_current_time_usecs, m_next_time_usecs, usecs_late, ticks_late); 
    530530        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    531                            " ticks: current: %f next: %f diff=%ld\n", 
     531                           " ticks: current: %f next: %f diff=%d\n", 
    532532                           m_current_time_ticks, m_next_time_ticks, diff_ticks); 
    533533        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    534                            " ticks: current: %011llu (%03us %04ucy %04uticks)\n", 
     534                           " ticks: current: %011lu (%03us %04ucy %04uticks)\n", 
    535535                           (uint64_t)m_current_time_ticks, 
    536536                           (unsigned int)TICKS_TO_SECS( (uint64_t)m_current_time_ticks ), 
     
    538538                           (unsigned int)TICKS_TO_OFFSET( (uint64_t)m_current_time_ticks ) ); 
    539539        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    540                            " ticks: next   : %011llu (%03us %04ucy %04uticks)\n", 
     540                           " ticks: next   : %011lu (%03us %04ucy %04uticks)\n", 
    541541                           (uint64_t)m_next_time_ticks, 
    542542                           (unsigned int)TICKS_TO_SECS( (uint64_t)m_next_time_ticks ), 
     
    545545 
    546546        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    547                            " state: local: %11llu, dll_e2: %f, rate: %f\n", 
     547                           " state: local: %11lu, dll_e2: %f, rate: %f\n", 
    548548                           local_time, m_dll_e2, getRate()); 
    549549    } 
     
    625625    if (y_step_in_ticks_int > 0) { 
    626626        retval = addTicks(offset_in_ticks_int, y_step_in_ticks_int); 
    627 /*        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, "y_step_in_ticks_int > 0: %ld, time_diff: %f, rate: %f, retval: %lu\n",  
     627/*        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, "y_step_in_ticks_int > 0: %d, time_diff: %f, rate: %f, retval: %u\n",  
    628628                    y_step_in_ticks_int, time_diff, my_vars.rate, retval);*/ 
    629629    } else { 
     
    631631 
    632632        // this can happen if the update thread was woken up earlier than it should have been 
    633 /*        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, "y_step_in_ticks_int <= 0: %ld, time_diff: %f, rate: %f, retval: %lu\n",  
     633/*        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, "y_step_in_ticks_int <= 0: %d, time_diff: %f, rate: %f, retval: %u\n",  
    634634                    y_step_in_ticks_int, time_diff, my_vars.rate, retval);*/ 
    635635    } 
  • branches/libffado-2.0/src/libieee1394/ieee1394service.cpp

    r1571 r1721  
    509509        #ifdef DEBUG 
    510510        debugOutput(DEBUG_LEVEL_VERY_VERBOSE, 
    511             "read: node 0x%hX, addr = 0x%016llX, length = %u\n", 
     511            "read: node 0x%hX, addr = 0x%016lX, length = %lu\n", 
    512512            nodeId, addr, length); 
    513513        printBuffer( DEBUG_LEVEL_VERY_VERBOSE, length, buffer ); 
     
    518518        #ifdef DEBUG 
    519519        debugOutput(DEBUG_LEVEL_NORMAL, 
    520                     "raw1394_read failed: node 0x%hX, addr = 0x%016llX, length = %u\n", 
     520                    "raw1394_read failed: node 0x%hX, addr = 0x%016lX, length = %lu\n", 
    521521                    nodeId, addr, length); 
    522522        #endif 
     
    564564 
    565565    #ifdef DEBUG 
    566     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"write: node 0x%hX, addr = 0x%016llX, length = %d\n", 
     566    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"write: node 0x%hX, addr = 0x%016lX, length = %lu\n", 
    567567                nodeId, addr, length); 
    568568    printBuffer( DEBUG_LEVEL_VERY_VERBOSE, length, data ); 
     
    601601    } 
    602602    #ifdef DEBUG 
    603     debugOutput(DEBUG_LEVEL_VERBOSE,"lockCompareSwap64: node 0x%X, addr = 0x%016llX\n", 
     603    debugOutput(DEBUG_LEVEL_VERBOSE,"lockCompareSwap64: node 0x%X, addr = 0x%016lX\n", 
    604604                nodeId, addr); 
    605     debugOutput(DEBUG_LEVEL_VERBOSE,"  if (*(addr)==0x%016llX) *(addr)=0x%016llX\n", 
     605    debugOutput(DEBUG_LEVEL_VERBOSE,"  if (*(addr)==0x%016lX) *(addr)=0x%016lX\n", 
    606606                compare_value, swap_value); 
    607607    fb_octlet_t buffer; 
     
    609609        debugWarning("Could not read register\n"); 
    610610    } else { 
    611         debugOutput(DEBUG_LEVEL_VERBOSE,"before = 0x%016llX\n", buffer); 
     611        debugOutput(DEBUG_LEVEL_VERBOSE,"before = 0x%016lX\n", buffer); 
    612612    } 
    613613    #endif 
     
    633633        debugWarning("Could not read register\n"); 
    634634    } else { 
    635         debugOutput(DEBUG_LEVEL_VERBOSE,"after = 0x%016llX\n", buffer); 
     635        debugOutput(DEBUG_LEVEL_VERBOSE,"after = 0x%016lX\n", buffer); 
    636636    } 
    637637    #endif 
     
    827827    fb_quadlet_t *data_quads = (fb_quadlet_t *)data; 
    828828    #ifdef DEBUG 
    829     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"fcp response: node 0x%hX, response = %d, length = %d bytes\n", 
     829    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"fcp response: node 0x%hX, response = %d, length = %lu bytes\n", 
    830830                nodeid, response, length); 
    831831    printBuffer(DEBUG_LEVEL_VERY_VERBOSE, (length+3)/4, data_quads ); 
     
    857857            } else if(FCP_MASK_SUBUNIT_AND_OPCODE(first_quadlet)  
    858858                      != FCP_MASK_SUBUNIT_AND_OPCODE(CondSwapFromBus32(m_fcp_block.request[0]))) { 
    859                 debugOutput(DEBUG_LEVEL_VERBOSE, "FCP response not for this request: %08lX != %08lX\n", 
     859                debugOutput(DEBUG_LEVEL_VERBOSE, "FCP response not for this request: %08X != %08X\n", 
    860860                             FCP_MASK_SUBUNIT_AND_OPCODE(first_quadlet), 
    861861                             FCP_MASK_SUBUNIT_AND_OPCODE(CondSwapFromBus32(m_fcp_block.request[0]))); 
     
    921921        return 0; 
    922922    } 
    923     debugOutput(DEBUG_LEVEL_VERBOSE, " READ HI: 0x%08lX\n", split_timeout_hi); 
     923    debugOutput(DEBUG_LEVEL_VERBOSE, " READ HI: 0x%08X\n", split_timeout_hi); 
    924924 
    925925    if(!readNoLock( 0xffc0 | nodeId, CSR_REGISTER_BASE + CSR_SPLIT_TIMEOUT_LO, 1, 
     
    928928        return 0; 
    929929    } 
    930     debugOutput(DEBUG_LEVEL_VERBOSE, " READ LO: 0x%08lX\n", split_timeout_low); 
     930    debugOutput(DEBUG_LEVEL_VERBOSE, " READ LO: 0x%08X\n", split_timeout_low); 
    931931 
    932932    split_timeout_hi = CondSwapFromBus32(split_timeout_hi); 
     
    13811381    debugOutput( DEBUG_LEVEL_VERBOSE, " CycleTimerHelper: %p, IsoManager: %p, WatchDog: %p\n", 
    13821382                 m_pCTRHelper, m_pIsoManager, m_pWatchdog ); 
    1383     debugOutput( DEBUG_LEVEL_VERBOSE, " Time: %011llu (%03us %04ucy %04uticks)\n", 
     1383    debugOutput( DEBUG_LEVEL_VERBOSE, " Time: %011lu (%03us %04ucy %04uticks)\n", 
    13841384                ctr, 
    13851385                (unsigned int)TICKS_TO_SECS( ctr ), 
  • branches/libffado-2.0/src/libieee1394/IsoHandler.cpp

    r1561 r1721  
    397397    if((pkt_ctr & ~0x0FFFL) != pkt_ctr_ref) { 
    398398        debugWarning("reconstructed CTR counter discrepancy\n"); 
    399         debugWarning(" ingredients: %X, %lX, %lX, %lX, %lX, %ld, %ld, %ld, %lld\n", 
     399        debugWarning(" ingredients: %X, %X, %X, %X, %X, %d, %ld, %ld, %ld\n", 
    400400                       cycle, pkt_ctr_ref, pkt_ctr, now, m_last_now, now_secs_ref, CYCLE_TIMER_GET_SECS(now), CYCLE_TIMER_GET_SECS(m_last_now), tmp); 
    401401        debugWarning(" diffcy = %ld \n", diff_cycles); 
     
    490490        if(((pkt_ctr & ~0x0FFFL) != pkt_ctr_ref) && (m_packets > m_buf_packets)) { 
    491491            debugWarning("reconstructed CTR counter discrepancy\n"); 
    492             debugWarning(" ingredients: %X, %lX, %lX, %lX, %lX, %ld, %ld, %ld, %lld\n", 
     492            debugWarning(" ingredients: %X, %X, %X, %X, %X, %d, %ld, %ld, %ld\n", 
    493493                        cycle, pkt_ctr_ref, pkt_ctr, now, m_last_now, now_secs_ref, CYCLE_TIMER_GET_SECS(now), CYCLE_TIMER_GET_SECS(m_last_now), tmp); 
    494494            debugWarning(" diffcy = %ld \n", diff_cycles); 
  • branches/libffado-2.0/src/libieee1394/IsoHandlerManager.cpp

    r1536 r1721  
    113113 
    114114        if (!h->handleBusReset()) { 
    115             debugWarning("Failed to handle busreset on %p\n"); 
     115            debugWarning("Failed to handle busreset on %p\n", h); 
    116116            retval = false; 
    117117        } 
     
    331331 
    332332        debugOutputExtreme(DEBUG_LEVEL_VERBOSE, 
    333                            "(%p, %s) check handler %d: diff = %lld, max = %lld, now: %08lX, last: %08lX\n", 
     333                           "(%p, %s) check handler %d: diff = %ld, max = %lld, now: %08lX, last: %08lX\n", 
    334334                           this, (m_handlerType == IsoHandler::eHT_Transmit? "Transmit": "Receive"),  
    335335                           i, measured_diff_ticks, max_diff_ticks, ctr_at_poll_return, last_packet_seen); 
    336336        if(measured_diff_ticks > max_diff_ticks) { 
    337             debugFatal("(%p, %s) Handler died: now: %08lX, last: %08lX, diff: %lld (max: %lld)\n", 
     337            debugFatal("(%p, %s) Handler died: now: %08X, last: %08X, diff: %ld (max: %ld)\n", 
    338338                       this, (m_handlerType == IsoHandler::eHT_Transmit? "Transmit": "Receive"), 
    339339                       ctr_at_poll_return, last_packet_seen, measured_diff_ticks, max_diff_ticks); 
     
    416416            debugError("(%p) sem_timedwait error (result=%d errno=EINVAL)\n",  
    417417                        this, result); 
    418             debugError("(%p) timeout_nsec=%lld ts.sec=%d ts.nsec=%lld\n",  
     418            debugError("(%p) timeout_nsec=%lld ts.sec=%ld ts.nsec=%ld\n",  
    419419                       this, m_activity_wait_timeout_nsec, ts.tv_sec, ts.tv_nsec); 
    420420            return eAR_Error; 
     
    422422            debugError("(%p) sem_timedwait error (result=%d errno=%d)\n",  
    423423                        this, result, errno); 
    424             debugError("(%p) timeout_nsec=%lld ts.sec=%d ts.nsec=%lld\n",  
     424            debugError("(%p) timeout_nsec=%lld ts.sec=%ld ts.nsec=%ld\n",  
    425425                       this, m_activity_wait_timeout_nsec, ts.tv_sec, ts.tv_nsec); 
    426426            return eAR_Error; 
     
    888888 
    889889    m_StreamProcessors.push_back(stream); 
    890     debugOutput( DEBUG_LEVEL_VERBOSE, " %d streams, %d handlers registered\n", 
     890    debugOutput( DEBUG_LEVEL_VERBOSE, " %lu streams, %lu handlers registered\n", 
    891891                                      m_StreamProcessors.size(), m_IsoHandlers.size()); 
    892892    return true; 
  • branches/libffado-2.0/src/libstreaming/amdtp/AmdtpReceiveStreamProcessor.cpp

    r1544 r1721  
    148148    if(isRunning()) { 
    149149        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    150                            "STMP: %lluticks | syt_interval=%d, tpf=%f\n", 
     150                           "STMP: %luticks | syt_interval=%d, tpf=%f\n", 
    151151                           m_last_timestamp, m_syt_interval, getTicksPerFrame()); 
    152152/*        debugOutput(DEBUG_LEVEL_NORMAL, 
    153                            "STMP: %12llu ticks | delta_t: %5lld | bufferfill: %5d\n", 
     153                           "STMP: %12lu ticks | delta_t: %5ld | bufferfill: %5d\n", 
    154154                           m_last_timestamp, now_t-last_t, m_data_buffer->getBufferFill());*/ 
    155155    } 
  • branches/libffado-2.0/src/libstreaming/amdtp/AmdtpTransmitStreamProcessor.cpp

    r1546 r1721  
    141141        { 
    142142            debugOutput( DEBUG_LEVEL_NORMAL, 
    143                          "Insufficient frames (P): N=%02d, CY=%04u, TC=%04u, CUT=%04d\n", 
     143                         "Insufficient frames (P): N=%02d, CY=%04lu, TC=%04u, CUT=%04d\n", 
    144144                         fc, CYCLE_TIMER_GET_CYCLES(pkt_ctr),  
    145145                         transmit_at_cycle, cycles_until_transmit ); 
     
    200200            // we are too late 
    201201            debugOutput(DEBUG_LEVEL_VERBOSE, 
    202                         "Too late: CY=%04u, TC=%04u, CUT=%04d, TSP=%011llu (%04u)\n", 
     202                        "Too late: CY=%04lu, TC=%04u, CUT=%04d, TSP=%011lu (%04u)\n", 
    203203                        CYCLE_TIMER_GET_CYCLES(pkt_ctr), 
    204204                        transmit_at_cycle, cycles_until_transmit, 
     
    229229            // for timestamp tracing 
    230230            debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    231                                "XMIT PKT: TSP= %011llu (%04u) (%04u) (%04u)\n", 
     231                               "XMIT PKT: TSP= %011lu (%04u) (%04u) (%04u)\n", 
    232232                               presentation_time, 
    233233                               (unsigned int)CYCLE_TIMER_GET_CYCLES(pkt_ctr), 
     
    239239        { 
    240240            debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    241                                "Too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011llu (%04u), TSP=%011llu (%04u)\n", 
     241                               "Too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011lu (%04u), TSP=%011llu (%04u)\n", 
    242242                               CYCLE_TIMER_GET_CYCLES(pkt_ctr), 
    243243                               transmit_at_cycle, cycles_until_transmit, 
     
    248248            { 
    249249                debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    250                                    "Way too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011llu (%04u), TSP=%011llu (%04u)\n", 
     250                                   "Way too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011lu (%04u), TSP=%011llu (%04u)\n", 
    251251                                   CYCLE_TIMER_GET_CYCLES(pkt_ctr), 
    252252                                   transmit_at_cycle, cycles_until_transmit, 
     
    269269    { 
    270270        debugOutputExtreme(DEBUG_LEVEL_VERBOSE, 
    271                            "XMIT DATA: TSP= %011llu (%04u)\n", 
     271                           "XMIT DATA: TSP= %011lu (%04u)\n", 
    272272                           m_last_timestamp, 
    273273                           (unsigned int)TICKS_TO_CYCLES(m_last_timestamp)); 
     
    301301    struct iec61883_packet *packet = ( struct iec61883_packet * ) data; 
    302302    debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    303                        "XMIT SILENT (cy %04d): CY=%04u, TSP=%011llu (%04u)\n", 
     303                       "XMIT SILENT (cy %04d): CY=%04u, TSP=%011lu (%04u)\n", 
    304304                       CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp, 
    305305                       (unsigned int)TICKS_TO_CYCLES(m_last_timestamp)); 
     
    338338    struct iec61883_packet *packet = ( struct iec61883_packet * ) data; 
    339339    debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    340                        "XMIT EMPTY (cy %04d): CY=%04u, TSP=%011llu (%04u)\n", 
     340                       "XMIT EMPTY (cy %04d): CY=%04u, TSP=%011lu (%04u)\n", 
    341341                       CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp, 
    342342                       (unsigned int)TICKS_TO_CYCLES(m_last_timestamp) ); 
  • branches/libffado-2.0/src/libstreaming/generic/StreamProcessor.cpp

    r1536 r1721  
    378378        if (m_last_timestamp > 0 && m_last_timestamp2 > 0) { 
    379379            int64_t tsp_diff = diffTicks(m_last_timestamp, m_last_timestamp2); 
    380             debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "TSP diff: %lld\n", tsp_diff); 
     380            debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "TSP diff: %ld\n", tsp_diff); 
    381381            double tsp_diff_d = tsp_diff; 
    382382            double fs_syt = 1.0/tsp_diff_d; 
     
    399399                if(diff-ticks_per_packet > 50 || diff-ticks_per_packet < -50) { 
    400400                    debugOutput(DEBUG_LEVEL_VERBOSE, 
    401                                 "cy %04u rather large TSP difference TS=%011llu => TS=%011llu (%d, nom %d)\n", 
     401                                "cy %04lu rather large TSP difference TS=%011lu => TS=%011lu (%d, nom %d)\n", 
    402402                                CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp2, 
    403403                                m_last_timestamp, diff, ticks_per_packet); 
     
    410410                    diff = diffTicks(last_timestamp_fixed, m_last_timestamp2); 
    411411                    if(diff-ticks_per_packet < 50 && diff-ticks_per_packet > -50) { 
    412                         debugWarning("cy %04u rather large TSP difference TS=%011llu => TS=%011llu (%d, nom %d)\n", 
     412                        debugWarning("cy %04lu rather large TSP difference TS=%011lu => TS=%011lu (%d, nom %d)\n", 
    413413                                    CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp2, 
    414414                                    m_last_timestamp, diff, ticks_per_packet); 
     
    420420                        diff = diffTicks(last_timestamp_fixed, m_last_timestamp2); 
    421421                        if(diff-ticks_per_packet < 50 && diff-ticks_per_packet > -50) { 
    422                             debugWarning("cy %04u rather large TSP difference TS=%011llu => TS=%011llu (%d, nom %d)\n", 
     422                            debugWarning("cy %04lu rather large TSP difference TS=%011lu => TS=%011lu (%d, nom %d)\n", 
    423423                                        CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp2, 
    424424                                        m_last_timestamp, diff, ticks_per_packet); 
     
    429429                } 
    430430                debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    431                                 "%04u %011llu %011llu %d %d\n", 
     431                                "%04u %011lu %011lu %d %d\n", 
    432432                                CYCLE_TIMER_GET_CYCLES(pkt_ctr), 
    433433                                m_last_timestamp2, m_last_timestamp,  
     
    437437 
    438438        debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    439                           "RECV: CY=%04u TS=%011llu\n", 
     439                          "RECV: CY=%04u TS=%011lu\n", 
    440440                          CYCLE_TIMER_GET_CYCLES(pkt_ctr), 
    441441                          m_last_timestamp); 
     
    606606        if (result == eCRV_Packet) { 
    607607            debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    608                                "XMIT SILENT: CY=%04u TS=%011llu\n", 
     608                               "XMIT SILENT: CY=%04u TS=%011lu\n", 
    609609                               CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp); 
    610610 
     
    657657        if (result == eCRV_Packet || result == eCRV_Defer) { 
    658658            debugOutputExtreme(DEBUG_LEVEL_VERBOSE, 
    659                                "XMIT: CY=%04u TS=%011llu\n", 
     659                               "XMIT: CY=%04u TS=%011lu\n", 
    660660                               CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp); 
    661661 
     
    694694            if (m_last_timestamp > 0 && m_last_timestamp2 > 0) { 
    695695                int64_t tsp_diff = diffTicks(m_last_timestamp, m_last_timestamp2); 
    696                 debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "TSP diff: %lld\n", tsp_diff); 
     696                debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "TSP diff: %ld\n", tsp_diff); 
    697697                double tsp_diff_d = tsp_diff; 
    698698                double fs_syt = 1.0/tsp_diff_d; 
     
    703703                debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "Nom fs: %12f, Instantanous fs: %12f, diff: %12f (%12f)\n", 
    704704                           fs_nom, fs_syt, fs_diff, fs_diff_norm); 
    705 //                 debugOutput(DEBUG_LEVEL_VERBOSE, "Diff fs: %12f, m_last_timestamp: %011llu, m_last_timestamp2: %011llu\n", 
     705//                 debugOutput(DEBUG_LEVEL_VERBOSE, "Diff fs: %12f, m_last_timestamp: %011lu, m_last_timestamp2: %011lu\n", 
    706706//                            fs_diff, m_last_timestamp, m_last_timestamp2); 
    707707                if (fs_diff_norm > 0.01 || fs_diff_norm < -0.01) { 
     
    716716                if(diff-ticks_per_packet > 50 || diff-ticks_per_packet < -50) { 
    717717                    debugOutput(DEBUG_LEVEL_VERBOSE, 
    718                                 "cy %04d, rather large TSP difference TS=%011llu => TS=%011llu (%d, nom %d)\n", 
     718                                "cy %04ld, rather large TSP difference TS=%011lu => TS=%011lu (%d, nom %d)\n", 
    719719                                CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp2, 
    720720                                m_last_timestamp, diff, ticks_per_packet); 
    721721                } 
    722722                debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    723                                 "%04d %011llu %011llu %d %d\n", 
     723                                "%04ld %011lu %011lu %d %d\n", 
    724724                                CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp2, 
    725725                                m_last_timestamp, diff, ticks_per_packet); 
     
    757757            goto send_empty_packet; 
    758758        } else if (result == eCRV_Again) { 
    759             debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "have to retry cycle %d\n", CYCLE_TIMER_GET_CYCLES(pkt_ctr)); 
     759            debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "have to retry cycle %ld\n", CYCLE_TIMER_GET_CYCLES(pkt_ctr)); 
    760760            if(m_state != m_next_state) { 
    761761                debugOutput(DEBUG_LEVEL_VERBOSE, "Should update state from %s to %s\n", 
     
    809809    bool result; 
    810810    debugOutputExtreme( DEBUG_LEVEL_VERBOSE, 
    811                         "(%p, %s) getFrames(%d, %11llu)\n", 
     811                        "(%p, %s) getFrames(%d, %11lu)\n", 
    812812                        this, getTypeString(), nbframes, ts); 
    813813    assert( getType() == ePT_Receive ); 
     
    840840    lag_frames = (((float)lag_ticks) / srate); 
    841841    debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    842                        "stream (%p): drifts %6d ticks = %10.5f frames (rate=%10.5f), %lld, %llu, %d\n", 
     842                       "stream (%p): drifts %6d ticks = %10.5f frames (rate=%10.5f), %ld, %lu, %d\n", 
    843843                       this, lag_ticks, lag_frames, srate, ts, ts_expected, fc); 
    844844    if (lag_frames >= 1.0) { 
    845845        // the stream lags 
    846         debugOutput(DEBUG_LEVEL_VERBOSE, "stream (%p): lags  with %6d ticks = %10.5f frames (rate=%10.5f), %lld, %llu, %d\n", 
     846        debugOutput(DEBUG_LEVEL_VERBOSE, "stream (%p): lags  with %6d ticks = %10.5f frames (rate=%10.5f), %ld, %lu, %d\n", 
    847847                      this, lag_ticks, lag_frames, srate, ts, ts_expected, fc); 
    848848    } else if (lag_frames <= -1.0) { 
    849849        // the stream leads 
    850         debugOutput(DEBUG_LEVEL_VERBOSE, "stream (%p): leads with %6d ticks = %10.5f frames (rate=%10.5f), %lld, %llu, %d\n", 
     850        debugOutput(DEBUG_LEVEL_VERBOSE, "stream (%p): leads with %6d ticks = %10.5f frames (rate=%10.5f), %ld, %lu, %d\n", 
    851851                      this, lag_ticks, lag_frames, srate, ts, ts_expected, fc); 
    852852    } 
     
    862862{ 
    863863    debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    864                        "stream (%p): dry run %d frames (@ ts=%lld)\n", 
     864                       "stream (%p): dry run %d frames (@ ts=%ld)\n", 
    865865                       this, nbframes, ts); 
    866866    // dry run on this side means that we put silence in all enabled ports 
     
    873873{ 
    874874    bool result; 
    875     debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "StreamProcessor::dropFrames(%d, %lld)\n", nbframes, ts); 
     875    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "StreamProcessor::dropFrames(%d, %ld)\n", nbframes, ts); 
    876876    result = m_data_buffer->dropFrames(nbframes); 
    877877    SIGNAL_ACTIVITY_ISO_RECV; 
     
    883883    bool result; 
    884884    debugOutputExtreme( DEBUG_LEVEL_VERBOSE, 
    885                         "(%p, %s) putFrames(%d, %11llu)\n", 
     885                        "(%p, %s) putFrames(%d, %11lu)\n", 
    886886                        this, getTypeString(), nbframes, ts); 
    887887    assert( getType() == ePT_Transmit ); 
     
    896896{ 
    897897    debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    898                        "StreamProcessor::putFramesWet(%d, %llu)\n", 
     898                       "StreamProcessor::putFramesWet(%d, %lu)\n", 
    899899                       nbframes, ts); 
    900900    // transfer the data 
    901901    m_data_buffer->blockProcessWriteFrames(nbframes, ts); 
    902902    debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    903                        " New timestamp: %llu\n", ts); 
     903                       " New timestamp: %lu\n", ts); 
    904904    return true; // FIXME: what about failure? 
    905905} 
     
    909909{ 
    910910    debugOutputExtreme(DEBUG_LEVEL_ULTRA_VERBOSE, 
    911                        "StreamProcessor::putFramesDry(%d, %llu)\n", 
     911                       "StreamProcessor::putFramesDry(%d, %lu)\n", 
    912912                       nbframes, ts); 
    913913    // do nothing 
     
    919919{ 
    920920    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, 
    921                        "StreamProcessor::putSilenceFrames(%d, %llu)\n", 
     921                       "StreamProcessor::putSilenceFrames(%d, %lu)\n", 
    922922                       nbframes, ts); 
    923923 
     
    10701070    // make the scratch buffer one period of frames long 
    10711071    m_scratch_buffer_size_bytes = m_StreamProcessorManager.getPeriodSize() * getEventsPerFrame() * getEventSize(); 
    1072     debugOutput( DEBUG_LEVEL_VERBOSE, " Allocate scratch buffer of %d quadlets\n"); 
     1072    debugOutput( DEBUG_LEVEL_VERBOSE, " Allocate scratch buffer of %ld quadlets\n", m_scratch_buffer_size_bytes); 
    10731073    if(m_scratch_buffer) delete[] m_scratch_buffer; 
    10741074    m_scratch_buffer = new byte_t[m_scratch_buffer_size_bytes]; 
     
    11591159    #ifdef DEBUG 
    11601160    uint64_t now = m_1394service.getCycleTimerTicks(); 
    1161     debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
     1161    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011lu (%03us %04uc %04ut)\n", 
    11621162                          now, 
    11631163                          (unsigned int)TICKS_TO_SECS(now), 
    11641164                          (unsigned int)TICKS_TO_CYCLES(now), 
    11651165                          (unsigned int)TICKS_TO_OFFSET(now)); 
    1166     debugOutput(DEBUG_LEVEL_VERBOSE,"  Start at              : %011llu (%03us %04uc %04ut)\n", 
     1166    debugOutput(DEBUG_LEVEL_VERBOSE,"  Start at              : %011lu (%03us %04uc %04ut)\n", 
    11671167                          tx, 
    11681168                          (unsigned int)TICKS_TO_SECS(tx), 
     
    12051205    #ifdef DEBUG 
    12061206    uint64_t now = m_1394service.getCycleTimerTicks(); 
    1207     debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
     1207    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011lu (%03us %04uc %04ut)\n", 
    12081208                          now, 
    12091209                          (unsigned int)TICKS_TO_SECS(now), 
    12101210                          (unsigned int)TICKS_TO_CYCLES(now), 
    12111211                          (unsigned int)TICKS_TO_OFFSET(now)); 
    1212     debugOutput(DEBUG_LEVEL_VERBOSE,"  Start at              : %011llu (%03us %04uc %04ut)\n", 
     1212    debugOutput(DEBUG_LEVEL_VERBOSE,"  Start at              : %011lu (%03us %04uc %04ut)\n", 
    12131213                          tx, 
    12141214                          (unsigned int)TICKS_TO_SECS(tx), 
     
    12291229    #ifdef DEBUG 
    12301230    uint64_t now = m_1394service.getCycleTimerTicks(); 
    1231     debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
     1231    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011lu (%03us %04uc %04ut)\n", 
    12321232                          now, 
    12331233                          (unsigned int)TICKS_TO_SECS(now), 
    12341234                          (unsigned int)TICKS_TO_CYCLES(now), 
    12351235                          (unsigned int)TICKS_TO_OFFSET(now)); 
    1236     debugOutput(DEBUG_LEVEL_VERBOSE,"  Stop at              : %011llu (%03us %04uc %04ut)\n", 
     1236    debugOutput(DEBUG_LEVEL_VERBOSE,"  Stop at              : %011lu (%03us %04uc %04ut)\n", 
    12371237                          tx, 
    12381238                          (unsigned int)TICKS_TO_SECS(tx), 
     
    12541254    #ifdef DEBUG 
    12551255    uint64_t now = m_1394service.getCycleTimerTicks(); 
    1256     debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011llu (%03us %04uc %04ut)\n", 
     1256    debugOutput(DEBUG_LEVEL_VERBOSE,"  Now                   : %011lu (%03us %04uc %04ut)\n", 
    12571257                          now, 
    12581258                          (unsigned int)TICKS_TO_SECS(now), 
    12591259                          (unsigned int)TICKS_TO_CYCLES(now), 
    12601260                          (unsigned int)TICKS_TO_OFFSET(now)); 
    1261     debugOutput(DEBUG_LEVEL_VERBOSE,"  Stop at              : %011llu (%03us %04uc %04ut)\n", 
     1261    debugOutput(DEBUG_LEVEL_VERBOSE,"  Stop at              : %011lu (%03us %04uc %04ut)\n", 
    12621262                          tx, 
    12631263                          (unsigned int)TICKS_TO_SECS(tx), 
     
    19011901    } 
    19021902    uint64_t now = m_1394service.getCycleTimerTicks(); 
    1903     debugOutputShort( DEBUG_LEVEL_NORMAL, "  Now                   : %011llu (%03us %04uc %04ut)\n", 
     1903    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Now                   : %011lu (%03us %04uc %04ut)\n", 
    19041904                        now, 
    19051905                        (unsigned int)TICKS_TO_SECS(now), 
  • branches/libffado-2.0/src/libstreaming/motu/MotuReceiveStreamProcessor.cpp

    r1488 r1721  
    182182    #ifdef DEBUG 
    183183    if(isRunning()) { 
    184         debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"STMP: %lluticks | tpf=%f\n", 
     184        debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"STMP: %luticks | tpf=%f\n", 
    185185            m_last_timestamp, getTicksPerFrame()); 
    186186    } 
  • branches/libffado-2.0/src/libstreaming/motu/MotuTransmitStreamProcessor.cpp

    r1489 r1721  
    197197            // we are too late 
    198198            debugOutput(DEBUG_LEVEL_VERBOSE, 
    199                         "Too late: CY=%04u, TC=%04u, CUT=%04d, TSP=%011llu (%04u)\n", 
     199                        "Too late: CY=%04u, TC=%04u, CUT=%04d, TSP=%011lu (%04u)\n", 
    200200                        cycle, 
    201201                        transmit_at_cycle, cycles_until_transmit, 
     
    232232        { 
    233233            debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    234                         "Too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011llu (%04u), TSP=%011llu (%04u)\n", 
     234                        "Too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011lu (%04u), TSP=%011lu (%04u)\n", 
    235235                        cycle, 
    236236                        transmit_at_cycle, cycles_until_transmit, 
     
    241241            { 
    242242                debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    243                             "Way too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011llu (%04u), TSP=%011llu (%04u)\n", 
     243                            "Way too early: CY=%04u, TC=%04u, CUT=%04d, TST=%011lu (%04u), TSP=%011lu (%04u)\n", 
    244244                            cycle, 
    245245                            transmit_at_cycle, cycles_until_transmit, 
     
    289289    uint32_t pkt_ctr ) 
    290290{ 
    291     debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, "XMIT EMPTY: CY=%04u, TSP=%011llu (%04u)\n", 
     291    debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, "XMIT EMPTY: CY=%04lu, TSP=%011lu (%04u)\n", 
    292292                CYCLE_TIMER_GET_CYCLES(pkt_ctr), m_last_timestamp,  
    293293                ( unsigned int ) TICKS_TO_CYCLES ( m_last_timestamp ) ); 
     
    318318    unsigned int cycle = CYCLE_TIMER_GET_CYCLES(pkt_ctr); 
    319319 
    320     debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "XMIT SILENT: CY=%04u, TSP=%011llu (%04u)\n", 
     320    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "XMIT SILENT: CY=%04u, TSP=%011lu (%04u)\n", 
    321321                 cycle, m_last_timestamp, 
    322322                 ( unsigned int ) TICKS_TO_CYCLES ( m_last_timestamp ) ); 
  • branches/libffado-2.0/src/libstreaming/StreamProcessorManager.cpp

    r1544 r1721  
    192192            debugError("(%p) sem_[timed]wait error (result=%d errno=EINVAL)\n",  
    193193                        this, result); 
    194             debugError("(%p) timeout_nsec=%lld ts.sec=%d ts.nsec=%lld\n",  
     194            debugError("(%p) timeout_nsec=%ld ts.sec=%ld ts.nsec=%ld\n",  
    195195                       this, m_activity_wait_timeout_nsec, ts.tv_sec, ts.tv_nsec); 
    196196            return eAR_Error; 
     
    198198            debugError("(%p) sem_[timed]wait error (result=%d errno=%d)\n",  
    199199                        this, result, errno); 
    200             debugError("(%p) timeout_nsec=%lld ts.sec=%d ts.nsec=%lld\n",  
     200            debugError("(%p) timeout_nsec=%ld ts.sec=%ld ts.nsec=%ld\n",  
    201201                       this, m_activity_wait_timeout_nsec, ts.tv_sec, ts.tv_nsec); 
    202202            return eAR_Error; 
     
    540540        #ifdef DEBUG 
    541541        int64_t now = Util::SystemTimeSource::getCurrentTime(); 
    542         debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "CTR  pred: %lld, syncdelay: %lld, diff: %lld\n", ticks_at_period, ticks_at_period_margin, ticks_at_period_margin-ticks_at_period ); 
    543         debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "PREWAIT  pred: %lld, now: %lld, wait: %lld\n", pred_system_time_at_xfer, now, pred_system_time_at_xfer-now ); 
     542        debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "CTR  pred: %ld, syncdelay: %lld, diff: %lld\n", ticks_at_period, ticks_at_period_margin, ticks_at_period_margin-ticks_at_period ); 
     543        debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "PREWAIT  pred: %ld, now: %lld, wait: %lld\n", pred_system_time_at_xfer, now, pred_system_time_at_xfer-now ); 
    544544        #endif 
    545545     
     
    549549        #ifdef DEBUG 
    550550        now = Util::SystemTimeSource::getCurrentTime(); 
    551         debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "POSTWAIT pred: %lld, now: %lld, excess: %lld\n", pred_system_time_at_xfer, now, now-pred_system_time_at_xfer ); 
     551        debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "POSTWAIT pred: %ld, now: %lld, excess: %lld\n", pred_system_time_at_xfer, now, now-pred_system_time_at_xfer ); 
    552552        #endif 
    553553    } 
     
    570570    // figure out where we are now 
    571571    uint64_t time_of_first_sample = m_SyncSource->getTimeAtPeriod(); 
    572     debugOutput( DEBUG_LEVEL_VERBOSE, " sync at TS=%011llu (%03us %04uc %04ut)...\n",  
     572    debugOutput( DEBUG_LEVEL_VERBOSE, " sync at TS=%011lu (%03us %04uc %04ut)...\n",  
    573573        time_of_first_sample, 
    574574        (unsigned int)TICKS_TO_SECS(time_of_first_sample), 
     
    587587    time_of_first_sample = addTicks(time_of_first_sample, 
    588588                                    time_for_startup_ticks); 
    589     debugOutput( DEBUG_LEVEL_VERBOSE, "  add %d frames (%011llu ticks)...\n",  
     589    debugOutput( DEBUG_LEVEL_VERBOSE, "  add %d frames (%011lu ticks)...\n",  
    590590        time_for_startup_frames, time_for_startup_ticks); 
    591591 
    592     debugOutput( DEBUG_LEVEL_VERBOSE, "  => first sample at TS=%011llu (%03us %04uc %04ut)...\n",  
     592    debugOutput( DEBUG_LEVEL_VERBOSE, "  => first sample at TS=%011lu (%03us %04uc %04ut)...\n",  
    593593        time_of_first_sample, 
    594594        (unsigned int)TICKS_TO_SECS(time_of_first_sample), 
     
    603603    uint64_t time_to_start_recv = substractTicks(time_of_first_sample, 
    604604                                                 prestart_cycles_for_recv * TICKS_PER_CYCLE); 
    605     debugOutput( DEBUG_LEVEL_VERBOSE, "  => xmit starts at  TS=%011llu (%03us %04uc %04ut)...\n",  
     605    debugOutput( DEBUG_LEVEL_VERBOSE, "  => xmit starts at  TS=%011lu (%03us %04uc %04ut)...\n",  
    606606        time_to_start_xmit, 
    607607        (unsigned int)TICKS_TO_SECS(time_to_start_xmit), 
    608608        (unsigned int)TICKS_TO_CYCLES(time_to_start_xmit), 
    609609        (unsigned int)TICKS_TO_OFFSET(time_to_start_xmit)); 
    610     debugOutput( DEBUG_LEVEL_VERBOSE, "  => recv starts at  TS=%011llu (%03us %04uc %04ut)...\n",  
     610    debugOutput( DEBUG_LEVEL_VERBOSE, "  => recv starts at  TS=%011lu (%03us %04uc %04ut)...\n",  
    611611        time_to_start_recv, 
    612612        (unsigned int)TICKS_TO_SECS(time_to_start_recv), 
     
    660660        signed int fc; 
    661661        (*it)->getBufferHeadTimestamp ( &ts, &fc ); 
    662         debugOutput( DEBUG_LEVEL_VERBOSE, " transmit buffer tail %010lld => head TS %010lld, fc=%d...\n", 
     662        debugOutput( DEBUG_LEVEL_VERBOSE, " transmit buffer tail %010ld => head TS %010lu, fc=%d...\n", 
    663663                    time_of_first_sample, (uint64_t)ts, fc); 
    664664    } 
     
    690690    } 
    691691    if(!m_SyncSource->scheduleStartRunning(time_to_start_sync)) { 
    692         debugError("m_SyncSource->scheduleStartRunning(%11llu) failed\n", time_to_start_sync); 
     692        debugError("m_SyncSource->scheduleStartRunning(%11lu) failed\n", time_to_start_sync); 
    693693        return false; 
    694694    } 
     
    700700        if(*it != m_SyncSource) { 
    701701            if(!(*it)->scheduleStartRunning(time_to_start_recv)) { 
    702                 debugError("%p->scheduleStartRunning(%11llu) failed\n", *it, time_to_start_recv); 
     702                debugError("%p->scheduleStartRunning(%11lu) failed\n", *it, time_to_start_recv); 
    703703                return false; 
    704704            } 
     
    710710        if(*it != m_SyncSource) { 
    711711            if(!(*it)->scheduleStartRunning(time_to_start_xmit)) { 
    712                 debugError("%p->scheduleStartRunning(%11llu) failed\n", *it, time_to_start_xmit); 
     712                debugError("%p->scheduleStartRunning(%11lu) failed\n", *it, time_to_start_xmit); 
    713713                return false; 
    714714            } 
     
    743743    #endif 
    744744 
    745     debugOutput( DEBUG_LEVEL_VERBOSE, "  initial time of transfer %010lld, rate %f...\n", 
     745    debugOutput( DEBUG_LEVEL_VERBOSE, "  initial time of transfer %010ld, rate %f...\n", 
    746746                m_time_of_transfer, rate); 
    747747 
     
    762762 
    763763    int64_t transmit_tail_timestamp = addTicks(m_time_of_transfer, delay_in_ticks); 
    764     debugOutput( DEBUG_LEVEL_VERBOSE, "  preset transmit tail TS %010lld, rate %f...\n", 
     764    debugOutput( DEBUG_LEVEL_VERBOSE, "  preset transmit tail TS %010ld, rate %f...\n", 
    765765                transmit_tail_timestamp, rate); 
    766766 
     
    773773        signed int fc; 
    774774        (*it)->getBufferHeadTimestamp ( &ts, &fc ); 
    775         debugOutput( DEBUG_LEVEL_VERBOSE, "   => transmit head TS %010lld, fc=%d...\n", 
     775        debugOutput( DEBUG_LEVEL_VERBOSE, "   => transmit head TS %010ld, fc=%d...\n", 
    776776                    (uint64_t)ts, fc); 
    777777    } 
     
    830830                StreamProcessor *s = m_ReceiveProcessors.at(i); 
    831831                diff = diffTicks(m_SyncSource->getTimeAtPeriod(), s->getTimeAtPeriod()); 
    832                 debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "  offset between SyncSP %p and SP %p is %lld ticks...\n",  
     832                debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "  offset between SyncSP %p and SP %p is %ld ticks...\n",  
    833833                    m_SyncSource, s, diff); 
    834834                if ( nb_sync_runs == periods_per_align_try ) { 
     
    850850            diff_between_streams[i] /= periods_per_align_try; 
    851851            diff_between_streams_frames[i] = (int)roundf(diff_between_streams[i] / s->getTicksPerFrame()); 
    852             debugOutput( DEBUG_LEVEL_VERBOSE, "   avg offset between SyncSP %p and SP %p is %lld ticks, %d frames...\n",  
     852            debugOutput( DEBUG_LEVEL_VERBOSE, "   avg offset between SyncSP %p and SP %p is %ld ticks, %d frames...\n",  
    853853                m_SyncSource, s, diff_between_streams[i], diff_between_streams_frames[i]); 
    854854 
     
    11001100    #ifdef DEBUG 
    11011101    int64_t now = Util::SystemTimeSource::getCurrentTime(); 
    1102     debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "CTR  pred: %lld, syncdelay: %lld, diff: %lld\n", ticks_at_period, ticks_at_period_margin, ticks_at_period_margin-ticks_at_period ); 
    1103     debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "PREWAIT  pred: %lld, now: %lld, wait: %lld\n", pred_system_time_at_xfer, now, pred_system_time_at_xfer-now ); 
     1102    debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "CTR  pred: %ld, syncdelay: %lld, diff: %lld\n", ticks_at_period, ticks_at_period_margin, ticks_at_period_margin-ticks_at_period ); 
     1103    debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "PREWAIT  pred: %ld, now: %lld, wait: %lld\n", pred_system_time_at_xfer, now, pred_system_time_at_xfer-now ); 
    11041104    #endif 
    11051105 
     
    11091109    #ifdef DEBUG 
    11101110    now = Util::SystemTimeSource::getCurrentTime(); 
    1111     debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "POSTWAIT pred: %lld, now: %lld, excess: %lld\n", pred_system_time_at_xfer, now, now-pred_system_time_at_xfer ); 
     1111    debugOutputExtreme(DEBUG_LEVEL_VERBOSE, "POSTWAIT pred: %ld, now: %lld, excess: %lld\n", pred_system_time_at_xfer, now, now-pred_system_time_at_xfer ); 
    11121112    #endif 
    11131113 
     
    12391239    // so 50 ticks = 10%, which is a rather large jitter value. 
    12401240    if(diff-ticks_per_period > 50 || diff-ticks_per_period < -50) { 
    1241         debugOutput(DEBUG_LEVEL_VERBOSE, "rather large TSP difference TS=%011llu => TS=%011llu (%d, nom %d)\n", 
     1241        debugOutput(DEBUG_LEVEL_VERBOSE, "rather large TSP difference TS=%011lu => TS=%011lu (%d, nom %d)\n", 
    12421242                                            m_time_of_transfer2, m_time_of_transfer, diff, ticks_per_period); 
    12431243    } 
     
    12461246 
    12471247    debugOutputExtreme(DEBUG_LEVEL_VERBOSE, 
    1248                         "transfer period %d at %llu ticks...\n", 
     1248                        "transfer period %d at %lu ticks...\n", 
    12491249                        m_nbperiods, m_time_of_transfer); 
    12501250 
     
    12621262    } 
    12631263    debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE,  
    1264                         "XF at %011llu ticks, RBF=%d, XBF=%d, SUM=%d...\n", 
     1264                        "XF at %011lu ticks, RBF=%d, XBF=%d, SUM=%d...\n", 
    12651265                        m_time_of_transfer, rcv_bf, xmt_bf, rcv_bf+xmt_bf); 
    12661266 
     
    13351335    if(m_SyncSource == NULL) return false; 
    13361336    debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, 
    1337         "transfer(%d) at TS=%011llu (%03us %04uc %04ut)...\n",  
     1337        "transfer(%d) at TS=%011lu (%03us %04uc %04ut)...\n",  
    13381338        t, m_time_of_transfer, 
    13391339        (unsigned int)TICKS_TO_SECS(m_time_of_transfer), 
     
    13491349                ++it ) { 
    13501350            if(!(*it)->getFrames(m_period, m_time_of_transfer)) { 
    1351                     debugWarning("could not getFrames(%u, %11llu) from stream processor (%p)\n", 
     1351                    debugWarning("could not getFrames(%u, %11lu) from stream processor (%p)\n", 
    13521352                            m_period, m_time_of_transfer,*it); 
    13531353                retval &= false; // buffer underrun 
     
    13721372 
    13731373            if(!(*it)->putFrames(m_period, transmit_timestamp)) { 
    1374                 debugWarning("could not putFrames(%u,%llu) to stream processor (%p)\n", 
     1374                debugWarning("could not putFrames(%u,%lu) to stream processor (%p)\n", 
    13751375                        m_period, transmit_timestamp, *it); 
    13761376                retval &= false; // buffer underrun 
     
    14131413    if(m_SyncSource == NULL) return false; 
    14141414    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
    1415         "transferSilence(%d) at TS=%011llu (%03us %04uc %04ut)...\n",  
     1415        "transferSilence(%d) at TS=%011lu (%03us %04uc %04ut)...\n",  
    14161416        t, m_time_of_transfer, 
    14171417        (unsigned int)TICKS_TO_SECS(m_time_of_transfer), 
     
    14271427                ++it ) { 
    14281428            if(!(*it)->dropFrames(m_period, m_time_of_transfer)) { 
    1429                     debugWarning("could not dropFrames(%u, %11llu) from stream processor (%p)\n", 
     1429                    debugWarning("could not dropFrames(%u, %11lu) from stream processor (%p)\n", 
    14301430                            m_period, m_time_of_transfer,*it); 
    14311431                retval &= false; // buffer underrun 
     
    14501450 
    14511451            if(!(*it)->putSilenceFrames(m_period, transmit_timestamp)) { 
    1452                 debugWarning("could not putSilenceFrames(%u,%llu) to stream processor (%p)\n", 
     1452                debugWarning("could not putSilenceFrames(%u,%lu) to stream processor (%p)\n", 
    14531453                        m_period, transmit_timestamp, *it); 
    14541454                retval &= false; // buffer underrun 
     
    16231623        #ifdef DEBUG 
    16241624        if(idx >= (int)m_CapturePorts_shadow.size()) { 
    1625             debugError("Capture port %d out of range (%d)\n", idx, m_CapturePorts_shadow.size()); 
     1625            debugError("Capture port %d out of range (%lu)\n", idx, m_CapturePorts_shadow.size()); 
    16261626            return NULL; 
    16271627        } 
     
    16311631        #ifdef DEBUG 
    16321632        if(idx >= (int)m_PlaybackPorts_shadow.size()) { 
    1633             debugError("Playback port %d out of range (%d)\n", idx, m_PlaybackPorts_shadow.size()); 
     1633            debugError("Playback port %d out of range (%lu)\n", idx, m_PlaybackPorts_shadow.size()); 
    16341634            return NULL; 
    16351635        } 
  • branches/libffado-2.0/src/libutil/Configuration.cpp

    r1566 r1721  
    182182            int32_t i = s; 
    183183            debugOutput(DEBUG_LEVEL_NORMAL, 
    184                         "  %s%s = %ld (0x%08lX)\n", 
     184                        "  %s%s = %d (0x%08X)\n", 
    185185                        prefix.c_str(), s.getName(), i, i); 
    186186        } 
     
    190190            int64_t i = s; 
    191191            debugOutput(DEBUG_LEVEL_NORMAL, 
    192                         "  %s%s = %lld (0x%016llX)\n", 
     192                        "  %s%s = %ld (0x%016lX)\n", 
    193193                        prefix.c_str(), s.getName(), i, i); 
    194194        } 
     
    259259        if(t == Setting::TypeInt64) { 
    260260            ref = *s; 
    261             debugOutput(DEBUG_LEVEL_VERBOSE, "path '%s' has value %d\n", path.c_str(), ref); 
     261            debugOutput(DEBUG_LEVEL_VERBOSE, "path '%s' has value %ld\n", path.c_str(), ref); 
    262262            return true; 
    263263        } else { 
  • branches/libffado-2.0/src/libutil/PosixThread.cpp

    r1432 r1721  
    142142        if ((res = pthread_create(&fThread, &attributes, ThreadHandler, this))) { 
    143143            debugError("Cannot create realtime thread (%d: %s)\n", res, strerror(res)); 
    144             debugError(" priority: %d %s\n", fPriority); 
     144            debugError(" priority: %d\n", fPriority); 
    145145            return -1; 
    146146        } 
     
    162162{ 
    163163    if (fThread) { // If thread has been started 
    164         debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Kill %p (thread: %p)\n", m_id.c_str(), this, fThread); 
     164        debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Kill %p (thread: %p)\n", m_id.c_str(), this, (void *)fThread); 
    165165        void* status; 
    166166        pthread_cancel(fThread); 
    167167        pthread_join(fThread, &status); 
    168         debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Killed %p (thread: %p)\n", m_id.c_str(), this, fThread); 
     168        debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Killed %p (thread: %p)\n", m_id.c_str(), this, (void *)fThread); 
    169169        return 0; 
    170170    } else { 
     
    176176{ 
    177177    if (fThread) { // If thread has been started 
    178         debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Stop %p (thread: %p)\n", m_id.c_str(), this, fThread); 
     178        debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Stop %p (thread: %p)\n", m_id.c_str(), this, (void *)fThread); 
    179179        void* status; 
    180180        fRunning = false; // Request for the thread to stop 
    181181        pthread_join(fThread, &status); 
    182         debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Stopped %p (thread: %p)\n", m_id.c_str(), this, fThread); 
     182        debugOutput( DEBUG_LEVEL_VERBOSE, "(%s) Stopped %p (thread: %p)\n", m_id.c_str(), this, (void *)fThread); 
    183183        return 0; 
    184184    } else { 
  • branches/libffado-2.0/src/libutil/serialize_expat.cpp

    r1154 r1721  
    117117            Xml::Node& n = pNode->add( Xml::Node(tokens[tokens.size() - 1].c_str(), NULL) ); 
    118118            char* valstr; 
    119             asprintf( &valstr, "%lld", value ); 
     119            asprintf( &valstr, "%ld", value ); 
    120120            n.set_child_text( valstr ); 
    121121            free( valstr ); 
  • branches/libffado-2.0/src/libutil/serialize_libxml.cpp

    r1566 r1721  
    8989 
    9090{ 
    91     debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "write %s = %d\n", 
     91    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "write %s = %lld\n", 
    9292                 strMemberName.c_str(), value ); 
    9393 
     
    266266            value = strtoll( pElement->get_child_text()->get_content().c_str(), 
    267267                             &tail, 0 ); 
    268             debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "found %s = %d\n", 
     268            debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "found %s = %lld\n", 
    269269                         strMemberName.c_str(), value ); 
    270270            return true; 
  • branches/libffado-2.0/src/libutil/StreamStatistics.cpp

    r864 r1721  
    5555void StreamStatistics::dumpInfo() { 
    5656    debugOutputShort( DEBUG_LEVEL_VERBOSE,  
    57                       "--- Stats for %s: min=%ld avg=%f max=%ld cnt=%ld sum=%ld\n", 
     57                      "--- Stats for %s: min=%d avg=%f max=%ld cnt=%ld sum=%ld\n", 
    5858                      m_name.c_str(), m_min, m_average, m_max, m_count, m_sum); 
    5959    debugOutputShort( DEBUG_LEVEL_VERBOSE, "    Signal stats\n"); 
  • branches/libffado-2.0/src/libutil/SystemTimeSource.cpp

    r1165 r1721  
    5555    ts.tv_nsec = (wake_at_usec % (1000000LL)) * 1000LL; 
    5656    debugOutputExtreme(DEBUG_LEVEL_VERBOSE, 
    57                 "clock_nanosleep until %lld sec, %lld nanosec\n", 
     57                "clock_nanosleep until %ld sec, %lld nanosec\n", 
    5858                (int64_t)ts.tv_sec, (int64_t)ts.tv_nsec); 
    5959    int err = clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, NULL); 
  • branches/libffado-2.0/src/libutil/TimestampedBuffer.cpp

    r1536 r1721  
    505505        if (written < write_size) 
    506506        { 
    507             debugWarning("ringbuffer full, %u, %u\n", write_size, written); 
     507            debugWarning("ringbuffer full, %u, %lu\n", write_size, written); 
    508508            return false; 
    509509        } 
     
    534534    if (written < write_size) 
    535535    { 
    536         debugWarning("ringbuffer full, request: %u, actual: %u\n", write_size, written); 
     536        debugWarning("ringbuffer full, request: %u, actual: %lu\n", write_size, written); 
    537537        return false; 
    538538    } 
     
    645645 
    646646        if(vec[0].len + vec[1].len < m_process_block_size) { // this indicates a full event buffer 
    647             debugError("Event buffer overrun in buffer %p, fill: %u, bytes2write: %u \n", 
     647            debugError("Event buffer overrun in buffer %p, fill: %lu, bytes2write: %u \n", 
    648648                       this, ffado_ringbuffer_read_space(m_event_buffer), bytes2write); 
    649649            debugShowBackLog(); 
  • branches/libffado-2.0/support/firmware/fireworks-downloader.cpp

    r1454 r1721  
    213213 
    214214    if (node_id < 0) { 
    215         printMessage("Could not find device with GUID 0x%016llX\n", guid); 
     215        printMessage("Could not find device with GUID 0x%016lX\n", guid); 
    216216        return -1; 
    217217    } 
  • branches/libffado-2.0/tests/streaming/teststreaming3.cpp

    r1566 r1721  
    264264    } 
    265265 
    266     debugOutput(DEBUG_LEVEL_NORMAL, "verbose level = %d\n", arguments.verbose); 
     266    debugOutput(DEBUG_LEVEL_NORMAL, "verbose level = %ld\n", arguments.verbose); 
    267267    setDebugLevel(arguments.verbose); 
    268268 
  • branches/libffado-2.0/tests/systemtests/test-isoxmit-1.cpp

    r1146 r1721  
    232232    } 
    233233 
    234     debugOutput(DEBUG_LEVEL_NORMAL, "verbose level = %d\n", arguments.verbose); 
     234    debugOutput(DEBUG_LEVEL_NORMAL, "verbose level = %ld\n", arguments.verbose); 
    235235    setDebugLevel(arguments.verbose); 
    236236 
     
    243243    } 
    244244 
    245     debugOutput(DEBUG_LEVEL_INFO, "Select 1394 port %d...\n", arguments.port); 
     245    debugOutput(DEBUG_LEVEL_INFO, "Select 1394 port %ld...\n", arguments.port); 
    246246    do 
    247247    { 
     
    270270    raw1394_set_bus_reset_handler(handle, myResetHandler); 
    271271 
    272     debugOutput(DEBUG_LEVEL_INFO, "Setting RT priority (%d)...\n", arguments.rtprio); 
     272    debugOutput(DEBUG_LEVEL_INFO, "Setting RT priority (%ld)...\n", arguments.rtprio); 
    273273    set_realtime_priority(arguments.rtprio); 
    274274 
  • branches/libffado-2.0/tests/test-ffado.cpp

    r1461 r1721  
    511511        uint64_t result_rcv = sytRecvToFullTicks(syt_timestamp, rcv_cycle, ctr_now); 
    512512        uint64_t result_xmt = sytXmitToFullTicks(syt_timestamp, rcv_cycle, ctr_now); 
    513         printf("RCV: 0x%010llX %010llu  XMT: 0x%010llX %010llu CTR: %010llu\n", 
     513        printf("RCV: 0x%010lX %010lu  XMT: 0x%010lX %010lu CTR: %010lu\n", 
    514514               result_rcv, result_rcv, result_xmt, result_xmt, CYCLE_TIMER_TO_TICKS(ctr_now)); 
    515515