i_pts /= 10; /* Dshow works with 100 nano-seconds resolution */
#if 0
- msg_Dbg( p_demux, "Read() stream: %i, size: %i, PTS: "I64Fd,
+ msg_Dbg( p_demux, "Read() stream: %i, size: %i, PTS: %"PRId64,
i_stream, i_data_size, i_pts );
#endif
msg_Dbg( p_demux, "DVDNAV_CELL_CHANGE" );
msg_Dbg( p_demux, " - cellN=%d", event->cellN );
msg_Dbg( p_demux, " - pgN=%d", event->pgN );
- msg_Dbg( p_demux, " - cell_length="I64Fd, event->cell_length );
- msg_Dbg( p_demux, " - pg_length="I64Fd, event->pg_length );
- msg_Dbg( p_demux, " - pgc_length="I64Fd, event->pgc_length );
- msg_Dbg( p_demux, " - cell_start="I64Fd, event->cell_start );
- msg_Dbg( p_demux, " - pg_start="I64Fd, event->pg_start );
+ msg_Dbg( p_demux, " - cell_length=%"PRId64, event->cell_length );
+ msg_Dbg( p_demux, " - pg_length=%"PRId64, event->pg_length );
+ msg_Dbg( p_demux, " - pgc_length=%"PRId64, event->pgc_length );
+ msg_Dbg( p_demux, " - cell_start=%"PRId64, event->cell_start );
+ msg_Dbg( p_demux, " - pg_start=%"PRId64, event->pg_start );
/* Store the lenght in time of the current PGC */
p_sys->i_pgc_length = event->pgc_length / 90 * 1000;
}
p_access->info.i_size = atoll( &psz_arg[4] );
free( psz_arg );
- msg_Dbg( p_access, "file size: "I64Fd, p_access->info.i_size );
+ msg_Dbg( p_access, "file size: %"PRId64, p_access->info.i_size );
/* Start the 'stream' */
if( ftp_StartStream( p_this, p_sys, 0 ) < 0 )
if( i_pos < 0 )
return VLC_EGENERIC;
- msg_Dbg( p_access, "seeking to "I64Fd, i_pos );
+ msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
ftp_StopStream( (vlc_object_t *)p_access, p_sys );
if( ftp_StartStream( (vlc_object_t *)p_access, p_sys, i_pos ) < 0 )
if( i_start > 0 )
{
- if( ftp_SendCommand( p_access, p_sys, "REST "I64Fu, i_start ) < 0 ||
+ if( ftp_SendCommand( p_access, p_sys, "REST %"PRIu64, i_start ) < 0 ||
ftp_ReadCommand( p_access, p_sys, &i_answer, NULL ) > 3 )
{
msg_Err( p_access, "cannot set restart offset" );
*****************************************************************************/
static int Seek( access_t *p_access, int64_t i_pos )
{
- msg_Dbg( p_access, "trying to seek to "I64Fd, i_pos );
+ msg_Dbg( p_access, "trying to seek to %"PRId64, i_pos );
Disconnect( p_access );
if( p_sys->i_version == 1 )
{
net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs,
- "Range: bytes="I64Fd"-\r\n", i_tell );
+ "Range: bytes=%"PRId64"-\r\n", i_tell );
}
/* Cookies */
else
{
p_access->info.i_size = i_tell + atoll( p );
- msg_Dbg( p_access, "stream size="I64Fd, p_access->info.i_size );
+ msg_Dbg( p_access, "stream size=%"PRId64, p_access->info.i_size );
}
}
else if( !strcasecmp( psz, "Location" ) )
off_t i_offset;
off_t i_packet;
- msg_Dbg( p_access, "seeking to "I64Fd, i_pos );
+ msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
i_packet = ( i_pos - p_sys->i_header ) / p_sys->asfh.i_min_data_packet_size;
i_offset = ( i_pos - p_sys->i_header ) % p_sys->asfh.i_min_data_packet_size;
E_( asf_HeaderParse )( &p_sys->asfh,
p_sys->p_header, p_sys->i_header );
- msg_Dbg( p_access, "packet count="I64Fd" packet size=%d",
+ msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
p_sys->asfh.i_data_packets_count,
p_sys->asfh.i_min_data_packet_size );
* and bitrate mutual exclusion(optional) */
E_( asf_HeaderParse )( &p_sys->asfh,
p_sys->p_header, p_sys->i_header );
- msg_Dbg( p_access, "packet count="I64Fd" packet size=%d",
+ msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
p_sys->asfh.i_data_packets_count,
p_sys->asfh.i_min_data_packet_size );
i_packet = ( i_pos - p_sys->i_header ) / p_sys->i_packet_length;
i_offset = ( i_pos - p_sys->i_header ) % p_sys->i_packet_length;
}
- msg_Dbg( p_access, "seeking to "I64Fd " (packet:%d)", i_pos, i_packet );
+ msg_Dbg( p_access, "seeking to %"PRId64 " (packet:%d)", i_pos, i_packet );
MMSStop( p_access );
msg_Dbg( p_access, "stream stopped (seek)" );
if( i_pos < 0 ) return VLC_EGENERIC;
- msg_Dbg( p_access, "seeking to "I64Fd, i_pos );
+ msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
#ifdef USE_CTX
i_ret = p_sys->p_smb->lseek(p_sys->p_smb, p_sys->p_file, i_pos, SEEK_SET);
{
if( p_sys->f )
{
- msg_Dbg( p_access, "dumped "I64Fd" kb (%s)",
+ msg_Dbg( p_access, "dumped %"PRId64" kb (%s)",
p_sys->i_size/1024, p_sys->psz_file );
Notify( p_access, false );
{
if( p_sys->p_buffer->i_dts + p_sys->p_thread->i_caching < now )
{
- msg_Dbg( p_access, "late packet for UDP input (" I64Fd ")",
+ msg_Dbg( p_access, "late packet for UDP input (%"PRId64 ")",
now - p_sys->p_buffer->i_dts
- p_sys->p_thread->i_caching );
}
/* Flush */
if( p_sys->p_buffer->i_dts + p_sys->p_thread->i_caching < now )
{
- msg_Dbg( p_access, "late packet for udp input (" I64Fd ")",
+ msg_Dbg( p_access, "late packet for udp input (%"PRId64 ")",
mdate() - p_sys->p_buffer->i_dts
- p_sys->p_thread->i_caching );
}
if( i_date - i_date_last > 2000000 )
{
if( !i_dropped_packets )
- msg_Dbg( p_thread, "mmh, hole ("I64Fd" > 2s) -> drop",
+ msg_Dbg( p_thread, "mmh, hole (%"PRId64" > 2s) -> drop",
i_date - i_date_last );
block_FifoPut( p_thread->p_empty_blocks, p_pk );
else if( i_date - i_date_last < -1000 )
{
if( !i_dropped_packets )
- msg_Dbg( p_thread, "mmh, packets in the past ("I64Fd")",
+ msg_Dbg( p_thread, "mmh, packets in the past (%"PRId64")",
i_date_last - i_date );
}
}
i_sent = mdate();
if ( i_sent > i_date + 20000 )
{
- msg_Dbg( p_thread, "packet has been sent too late (" I64Fd ")",
+ msg_Dbg( p_thread, "packet has been sent too late (%"PRId64 ")",
i_sent - i_date );
}
#endif
eqz_preset_10b[i]->f_amp[j] );
div = lldiv( eqz_preset_10b[i]->f_amp[j] * 10000000,
10000000 );
- sprintf( psz_newbands, "%s "I64Fd".%07u", psz_newbands,
+ sprintf( psz_newbands, "%s %"PRId64".%07u", psz_newbands,
(int64_t)div.quot, (unsigned int) div.rem );
}
if( p_sys->b_first == false )
latency = 0;
}
- PULSE_DEBUG( "Pulse stream request latency="I64Fd"", latency);
+ PULSE_DEBUG( "Pulse stream request latency=%"PRId64"", latency);
next_date = mdate() + latency;
if( p_aout->b_die )
return;
- msg_Dbg( p_aout, "will start to play in "I64Fd" us",
+ msg_Dbg( p_aout, "will start to play in %"PRId64" us",
(p_sys->start_date - AOUT_PTS_TOLERANCE/4)-mdate());
// than wait a short time... before grabbing first frames
{
/* No output generated */
#ifdef DMO_DEBUG
- msg_Dbg( p_enc, "ProcessInput(): no output generated "I64Fd, i_pts );
+ msg_Dbg( p_enc, "ProcessInput(): no output generated %"PRId64, i_pts );
#endif
return NULL;
}
if( db.dwStatus & DMO_OUTPUT_DATA_BUFFERF_TIME )
{
#ifdef DMO_DEBUG
- msg_Dbg( p_enc, "ProcessOutput(): pts: "I64Fd", "I64Fd,
+ msg_Dbg( p_enc, "ProcessOutput(): pts: %"PRId64", %"PRId64,
i_pts, db.rtTimestamp / 10 );
#endif
i_pts = db.rtTimestamp / 10;
{
p_block_out->i_length = db.rtTimelength / 10;
#ifdef DMO_DEBUG
- msg_Dbg( p_enc, "ProcessOutput(): length: "I64Fd,
+ msg_Dbg( p_enc, "ProcessOutput(): length: %"PRId64,
p_block_out->i_length );
#endif
}
}
#ifdef DEBUG_DVBSUB
- msg_Dbg( p_dec, "subtitle packet received: "I64Fd, p_sys->i_pts );
+ msg_Dbg( p_dec, "subtitle packet received: %"PRId64, p_sys->i_pts );
#endif
p_sys->b_page = false;
msg_Dbg( p_demux, "AVFormat supported stream" );
msg_Dbg( p_demux, " - format = %s (%s)",
p_sys->fmt->name, p_sys->fmt->long_name );
- msg_Dbg( p_demux, " - start time = "I64Fd,
+ msg_Dbg( p_demux, " - start time = %"PRId64,
( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE ) ?
p_sys->ic->start_time * 1000000 / AV_TIME_BASE : -1 );
- msg_Dbg( p_demux, " - duration = "I64Fd,
+ msg_Dbg( p_demux, " - duration = %"PRId64,
( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE ) ?
p_sys->ic->duration * 1000000 / AV_TIME_BASE : -1 );
p_sys->ic->streams[pkt.stream_index]->time_base.den;
#ifdef AVFORMAT_DEBUG
- msg_Dbg( p_demux, "tk[%d] dts="I64Fd" pts="I64Fd,
+ msg_Dbg( p_demux, "tk[%d] dts=%"PRId64" pts=%"PRId64,
pkt.stream_index, p_frame->i_dts, p_frame->i_pts );
#endif
if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
i64 += p_sys->ic->start_time;
- msg_Warn( p_demux, "DEMUX_SET_POSITION: "I64Fd, i64 );
+ msg_Warn( p_demux, "DEMUX_SET_POSITION: %"PRId64, i64 );
/* If we have a duration, we prefer to seek by time
but if we don't, or if the seek fails, try BYTE seeking */
int64_t i_size = stream_Size( p_demux->s );
i64 = (int64_t)i_size * f;
- msg_Warn( p_demux, "DEMUX_SET_BYTE_POSITION: "I64Fd, i64 );
+ msg_Warn( p_demux, "DEMUX_SET_BYTE_POSITION: %"PRId64, i64 );
if( av_seek_frame( p_sys->ic, -1, i64, AVSEEK_FLAG_BYTE ) < 0 )
return VLC_EGENERIC;
}
if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
i64 += p_sys->ic->start_time;
- msg_Warn( p_demux, "DEMUX_SET_TIME: "I64Fd, i64 );
+ msg_Warn( p_demux, "DEMUX_SET_TIME: %"PRId64, i64 );
if( av_seek_frame( p_sys->ic, -1, i64, 0 ) < 0 )
{
int64_t i_size = stream_Size( p_demux->s );
#ifdef AVFORMAT_DEBUG
- msg_Warn( p_demux, "IOSeek offset: "I64Fd", whence: %i", offset, whence );
+ msg_Warn( p_demux, "IOSeek offset: %"PRId64", whence: %i", offset, whence );
#endif
switch( whence )
if ( p_sys->i_last_pts == frame.pts )
{
msg_Warn( p_enc, "almost fed libavcodec with two frames with the "
- "same PTS (" I64Fd ")", frame.pts );
+ "same PTS (%"PRId64 ")", frame.pts );
return NULL;
}
else if ( p_sys->i_last_pts > frame.pts )
{
msg_Warn( p_enc, "almost fed libavcodec with a frame in the "
- "past (current: " I64Fd ", last: "I64Fd")",
+ "past (current: %"PRId64 ", last: %"PRId64")",
frame.pts, p_sys->i_last_pts );
return NULL;
}
if( av_write_frame( p_sys->oc, &pkt ) < 0 )
{
- msg_Err( p_mux, "could not write frame (pts: "I64Fd", dts: "I64Fd") "
- "(pkt pts: "I64Fd", dts: "I64Fd")",
+ msg_Err( p_mux, "could not write frame (pts: %"PRId64", dts: %"PRId64") "
+ "(pkt pts: %"PRId64", dts: %"PRId64")",
p_data->i_pts, p_data->i_dts, pkt.pts, pkt.dts );
block_Release( p_data );
return VLC_EGENERIC;
int64_t i_absolute;
#ifdef AVFORMAT_DEBUG
- msg_Dbg( p_mux, "IOSeek offset: "I64Fd", whence: %i", offset, whence );
+ msg_Dbg( p_mux, "IOSeek offset: %"PRId64", whence: %i", offset, whence );
#endif
switch( whence )
( p_block->i_pts <= 0 || p_block->i_buffer < 4 ) )
{
msg_Dbg( p_dec, "invalid starting packet (size < 4 or pts <=0)" );
- msg_Dbg( p_dec, "spu size: %d, i_pts: "I64Fd" i_buffer: %d",
+ msg_Dbg( p_dec, "spu size: %d, i_pts: %"PRId64" i_buffer: %d",
p_sys->i_spu_size, p_block->i_pts, p_block->i_buffer );
block_Release( p_block );
return NULL;
var_Get( p_sys->p_input, "position", &val);
sprintf( position, "%d" , (int)((val.f_float) * 100.0));
var_Get( p_sys->p_input, "time", &val);
- sprintf( time, I64Fi, (int64_t)val.i_time / I64C(1000000) );
+ sprintf( time, "%"PRIi64, (int64_t)val.i_time / I64C(1000000) );
var_Get( p_sys->p_input, "length", &val);
- sprintf( length, I64Fi, (int64_t)val.i_time / I64C(1000000) );
+ sprintf( length, "%"PRIi64, (int64_t)val.i_time / I64C(1000000) );
var_Get( p_sys->p_input, "state", &val );
if( val.i_int == PLAYING_S )
E_(mvar_AppendNewVar)( f, "type", "unknown" );
}
- sprintf( psz_ctime, I64Fd, (int64_t)stat_info.st_size );
+ sprintf( psz_ctime, "%"PRId64, (int64_t)stat_info.st_size );
E_(mvar_AppendNewVar)( f, "size", psz_ctime );
/* FIXME memory leak FIXME */
(struct sockaddr *)&from, i_struct_size );
#if 0
- msg_Dbg( p_intf, "Master clockref: "I64Fd" -> "I64Fd", from %s "
- "(date: "I64Fd")", i_clockref, i_master_clockref,
+ msg_Dbg( p_intf, "Master clockref: %"PRId64" -> %"PRId64", from %s "
+ "(date: %"PRId64")", i_clockref, i_master_clockref,
from.ss_family == AF_INET
? inet_ntoa(((struct sockaddr_in *)&from)->sin_addr)
: "non-IPv4", i_date );
}
#if 0
- msg_Dbg( p_intf, "Slave clockref: "I64Fd" -> "I64Fd" -> "I64Fd", "
- "clock diff: "I64Fd" drift: "I64Fd,
+ msg_Dbg( p_intf, "Slave clockref: %"PRId64" -> %"PRId64" -> %"PRId64", "
+ "clock diff: %"PRId64" drift: %"PRId64,
i_clockref, i_master_clockref,
i_client_clockref, i_diff_date, i_drift );
#endif
#ifdef ASF_DEBUG
msg_Dbg( s,
- "found object guid: " GUID_FMT " size:"I64Fd,
+ "found object guid: " GUID_FMT " size:%"PRId64,
GUID_PRINT( p_common->i_object_id ),
p_common->i_object_size );
#endif
#ifdef ASF_DEBUG
msg_Dbg( s,
"read \"data object\" file_id:" GUID_FMT " total data packet:"
- I64Fd" reserved:%d",
+ "%"PRId64" reserved:%d",
GUID_PRINT( p_data->i_file_id ),
p_data->i_total_data_packets,
p_data->i_reserved );
#ifdef ASF_DEBUG
msg_Dbg( s,
"read \"index object\" file_id:" GUID_FMT
- " index_entry_time_interval:"I64Fd" max_packet_count:%d "
+ " index_entry_time_interval:%"PRId64" max_packet_count:%d "
"index_entry_count:%ld",
GUID_PRINT( p_index->i_file_id ),
p_index->i_index_entry_time_interval,
#ifdef ASF_DEBUG
msg_Dbg( s,
"read \"file properties object\" file_id:" GUID_FMT
- " file_size:"I64Fd" creation_date:"I64Fd" data_packets_count:"
- I64Fd" play_duration:"I64Fd" send_duration:"I64Fd" preroll:"I64Fd
+ " file_size:%"PRId64" creation_date:%"PRId64" data_packets_count:"
+ "%"PRId64" play_duration:%"PRId64" send_duration:%"PRId64" preroll:%"PRId64
" flags:%d min_data_packet_size:%d "
" max_data_packet_size:%d max_bitrate:%d",
GUID_PRINT( p_fp->i_file_id ), p_fp->i_file_size,
msg_Dbg( s, " - %s (%i bytes)",
p_rec->psz_name, p_rec->i_data );
else
- msg_Dbg( s, " - %s="I64Fd,
+ msg_Dbg( s, " - %s=%"PRId64,
p_rec->psz_name, p_rec->i_val );
}
#endif
#ifdef ASF_DEBUG
msg_Dbg( s,
"read \"stream Properties object\" stream_type:" GUID_FMT
- " error_correction_type:" GUID_FMT " time_offset:"I64Fd
+ " error_correction_type:" GUID_FMT " time_offset:%"PRId64
" type_specific_data_length:%d error_correction_data_length:%d"
" flags:0x%x stream_number:%d",
GUID_PRINT( p_sp->i_stream_type ),
#ifdef ASF_DEBUG
msg_Dbg( s, "read \"extended stream properties object\":" );
- msg_Dbg( s, " - start="I64Fd" end="I64Fd,
+ msg_Dbg( s, " - start=%"PRId64" end=%"PRId64,
p_esp->i_start_time, p_esp->i_end_time );
msg_Dbg( s, " - data bitrate=%d buffer=%d initial fullness=%d",
p_esp->i_data_bitrate,
msg_Dbg( s, " - flags=0x%x", p_esp->i_flags );
msg_Dbg( s, " - stream number=%d language=%d",
p_esp->i_stream_number, p_esp->i_language_index );
- msg_Dbg( s, " - average time per frame="I64Fd,
+ msg_Dbg( s, " - average time per frame=%"PRId64,
p_esp->i_average_time_per_frame );
msg_Dbg( s, " - stream name count=%d", p_esp->i_stream_name_count );
for( i = 0; i < p_esp->i_stream_name_count; i++ )
else if( i_type == 4 )
{
/* QWord */
- asprintf( &p_ec->ppsz_value[i], I64Fd, GetQWLE(p_data));
+ asprintf( &p_ec->ppsz_value[i], "%"PRId64, GetQWLE(p_data));
}
else if( i_type == 5 )
{
str[i * 5] = '|';
}
snprintf( str + 5*i_level, 1024,
- "+ '%s' GUID "GUID_FMT" size:"I64Fu"pos:"I64Fu,
+ "+ '%s' GUID "GUID_FMT" size:%"PRIu64"pos:%"PRIu64,
psz_name,
GUID_PRINT( p_node->i_object_id ),
p_node->i_object_size, p_node->i_object_pos );
demux_sys_t *p_sys = p_demux->p_sys;
unsigned int i_stream;
- msg_Dbg( p_demux, "seek requested: "I64Fd" seconds %d%%",
+ msg_Dbg( p_demux, "seek requested: %"PRId64" seconds %d%%",
i_date / 1000000, i_percent );
if( p_sys->b_seekable )
i_date = AVI_GetPTS( p_stream );
/* TODO better support for i_samplesize != 0 */
- msg_Dbg( p_demux, "estimate date "I64Fd, i_date );
+ msg_Dbg( p_demux, "estimate date %"PRId64, i_date );
}
/* */
AVI_TrackSeek( p_demux, i_stream, i_date );
}
p_sys->i_time = i_date;
- msg_Dbg( p_demux, "seek: "I64Fd" seconds", p_sys->i_time /1000000 );
+ msg_Dbg( p_demux, "seek: %"PRId64" seconds", p_sys->i_time /1000000 );
return VLC_SUCCESS;
}
else
}
msg_Dbg( p_demux,
- "old:"I64Fd" %s new "I64Fd,
+ "old:%"PRId64" %s new %"PRId64,
i_oldpts,
i_oldpts > i_date ? ">" : "<",
i_date );
i_length /= (mtime_t)1000000; /* in seconds */
msg_Dbg( p_demux,
- "stream[%d] length:"I64Fd" (based on index)",
+ "stream[%d] length:%"PRId64" (based on index)",
i,
i_length );
i_maxlength = __MAX( i_maxlength, i_length );
#ifdef AVI_DEBUG
msg_Dbg( (vlc_object_t*)s,
- "found Chunk fourcc:%8.8x (%4.4s) size:"I64Fd" pos:"I64Fd,
+ "found Chunk fourcc:%8.8x (%4.4s) size:%"PRId64" pos:%"PRId64,
p_chk->common.i_chunk_fourcc,
(char*)&p_chk->common.i_chunk_fourcc,
p_chk->common.i_chunk_size,
p_chk->common.i_chunk_fourcc == AVIFOURCC_LIST )
{
sprintf( str + i_level * 5,
- "%c %4.4s-%4.4s size:"I64Fu" pos:"I64Fu,
+ "%c %4.4s-%4.4s size:%"PRIu64" pos:%"PRIu64,
i_level ? '+' : '*',
(char*)&p_chk->common.i_chunk_fourcc,
(char*)&p_chk->list.i_type,
else
{
sprintf( str + i_level * 5,
- "+ %4.4s size:"I64Fu" pos:"I64Fu,
+ "+ %4.4s size:%"PRIu64" pos:%"PRIu64,
(char*)&p_chk->common.i_chunk_fourcc,
p_chk->common.i_chunk_size,
p_chk->common.i_chunk_pos );
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys = p_demux->p_sys;
- msg_Info( p_demux ,"closing %s ("I64Fd" Kbytes dumped)", p_sys->psz_file,
+ msg_Info( p_demux ,"closing %s (%"PRId64" Kbytes dumped)", p_sys->psz_file,
p_sys->i_write / 1024 );
if( p_sys->p_file != stdout )
tk->i_last_dts = p_block->i_dts;
#if 0
-msg_Dbg( p_demux, "block i_dts: "I64Fd" / i_pts: "I64Fd, p_block->i_dts, p_block->i_pts);
+msg_Dbg( p_demux, "block i_dts: %"PRId64" / i_pts: %"PRId64, p_block->i_dts, p_block->i_pts);
#endif
if( strcmp( tk->psz_codec, "S_VOBSUB" ) )
{
#if LIBMATROSKA_VERSION >= 0x000800
if (uint64(doc_read_version) > 2)
{
- msg_Err( p_demux, "This matroska file is needs version "I64Fd" and this VLC only supports version 1 & 2", uint64(doc_read_version));
+ msg_Err( p_demux, "This matroska file is needs version %"PRId64" and this VLC only supports version 1 & 2", uint64(doc_read_version));
return NULL;
}
#else
if (uint64(doc_read_version) != 1)
{
- msg_Err( p_demux, "This matroska file is needs version "I64Fd" and this VLC only supports version 1", uint64(doc_read_version));
+ msg_Err( p_demux, "This matroska file is needs version %"PRId64" and this VLC only supports version 1", uint64(doc_read_version));
return NULL;
}
#endif
int i_index;
- msg_Dbg( p_demux, "seek request to "I64Fd" (%f%%)", i_date, f_percent );
+ msg_Dbg( p_demux, "seek request to %"PRId64" (%f%%)", i_date, f_percent );
if( i_date < 0 && f_percent < 0 )
{
msg_Warn( p_demux, "cannot seek nowhere !" );
ep->Up();
#if 0
- msg_Dbg( &sys.demuxer, " * added time="I64Fd" pos="I64Fd
+ msg_Dbg( &sys.demuxer, " * added time=%"PRId64" pos=%"PRId64
" track=%d bnum=%d", idx.i_time, idx.i_position,
idx.i_track, idx.i_block_number );
#endif
{
if( id == KaxCues::ClassInfos.GlobalId )
{
- msg_Dbg( &sys.demuxer, "| | | = cues at "I64Fd, i_pos );
+ msg_Dbg( &sys.demuxer, "| | | = cues at %"PRId64, i_pos );
i_cues_position = segment->GetGlobalPosition( i_pos );
}
else if( id == KaxChapters::ClassInfos.GlobalId )
{
- msg_Dbg( &sys.demuxer, "| | | = chapters at "I64Fd, i_pos );
+ msg_Dbg( &sys.demuxer, "| | | = chapters at %"PRId64, i_pos );
i_chapters_position = segment->GetGlobalPosition( i_pos );
}
else if( id == KaxTags::ClassInfos.GlobalId )
{
- msg_Dbg( &sys.demuxer, "| | | = tags at "I64Fd, i_pos );
+ msg_Dbg( &sys.demuxer, "| | | = tags at %"PRId64, i_pos );
i_tags_position = segment->GetGlobalPosition( i_pos );
}
}
KaxTrackDefaultDuration &defd = *(KaxTrackDefaultDuration*)l;
tk->i_default_duration = uint64(defd);
- msg_Dbg( &sys.demuxer, "| | | + Track Default Duration="I64Fd, uint64(defd) );
+ msg_Dbg( &sys.demuxer, "| | | + Track Default Duration=%"PRId64, uint64(defd) );
}
else if( MKV_IS_ID( l, KaxTrackTimecodeScale ) )
{
tk->p_extra_data = (uint8_t*)malloc( tk->i_extra_data );
memcpy( tk->p_extra_data, cpriv.GetBuffer(), tk->i_extra_data );
}
- msg_Dbg( &sys.demuxer, "| | | + Track CodecPrivate size="I64Fd, cpriv.GetSize() );
+ msg_Dbg( &sys.demuxer, "| | | + Track CodecPrivate size=%"PRId64, cpriv.GetSize() );
}
else if( MKV_IS_ID( l, KaxCodecName ) )
{
i_timescale = uint64(tcs);
- msg_Dbg( &sys.demuxer, "| | + TimecodeScale="I64Fd,
+ msg_Dbg( &sys.demuxer, "| | + TimecodeScale=%"PRId64,
i_timescale );
}
else if( MKV_IS_ID( l, KaxDuration ) )
i_duration = mtime_t( double( dur ) );
- msg_Dbg( &sys.demuxer, "| | + Duration="I64Fd,
+ msg_Dbg( &sys.demuxer, "| | + Duration=%"PRId64,
i_duration );
}
else if( MKV_IS_ID( l, KaxMuxingApp ) )
i_seek_time = p_indexes[i_idx].i_time;
}
- msg_Dbg( &sys.demuxer, "seek got "I64Fd" (%d%%)",
+ msg_Dbg( &sys.demuxer, "seek got %"PRId64" (%d%%)",
i_seek_time, (int)( 100 * i_seek_position / stream_Size( sys.demuxer.s ) ) );
es.I_O().setFilePointer( i_seek_position, seek_beginning );
chapter_item_c *p_chapter = sys.FindChapter( i_chapter_uid, p_segment );
if ( p_chapter == NULL )
- msg_Dbg( &sys.demuxer, "Chapter "I64Fd" not found", i_chapter_uid);
+ msg_Dbg( &sys.demuxer, "Chapter %"PRId64" not found", i_chapter_uid);
else
{
if ( !p_chapter->EnterAndLeave( sys.p_current_segment->CurrentChapter() ) )
p_sys->i_time = 1;
p_sys->i_length = ModPlug_GetLength( p_sys->f ) * (int64_t)1000;
- msg_Dbg( p_demux, "MOD loaded name=%s lenght="I64Fd"ms",
+ msg_Dbg( p_demux, "MOD loaded name=%s lenght=%"PRId64"ms",
ModPlug_GetName( p_sys->f ),
p_sys->i_length );
if( p_box->i_size )
{
if MP4_BOX_TYPE_ASCII()
- msg_Dbg( p_stream, "found Box: %4.4s size "I64Fd,
+ msg_Dbg( p_stream, "found Box: %4.4s size %"PRId64,
(char*)&p_box->i_type, p_box->i_size );
else
- msg_Dbg( p_stream, "found Box: c%3.3s size "I64Fd,
+ msg_Dbg( p_stream, "found Box: c%3.3s size %"PRId64,
(char*)&p_box->i_type+1, p_box->i_size );
}
#endif
p_box->data.p_sample_soun->i_bytes_per_frame = 0;
p_box->data.p_sample_soun->i_bytes_per_sample = 0;
- msg_Dbg( p_stream, "read box: \"soun\" mp4 or qt1/2 (rest="I64Fd")",
+ msg_Dbg( p_stream, "read box: \"soun\" mp4 or qt1/2 (rest=%"PRId64")",
i_read );
stream_Seek( p_stream, p_box->i_pos +
MP4_BOX_HEADERSIZE( p_box ) + 28 );
}
#ifdef MP4_VERBOSE
- msg_Dbg( p_stream, "read box: \"stdp\" entry-count "I64Fd,
+ msg_Dbg( p_stream, "read box: \"stdp\" entry-count %"PRId64,
i_read / 2 );
#endif
}
#ifdef MP4_VERBOSE
- msg_Dbg( p_stream, "read box: \"stdp\" entry-count "I64Fd,
+ msg_Dbg( p_stream, "read box: \"stdp\" entry-count %"PRId64,
i_read / 2 );
#endif
}
}
- msg_Dbg( p_demux, "track[Id 0x%x] read %d samples length:"I64Fd"s",
+ msg_Dbg( p_demux, "track[Id 0x%x] read %d samples length:%"PRId64"s",
p_demux_track->i_track_ID, p_demux_track->i_sample_count,
i_last_dts / p_demux_track->i_timescale );
MP4_Box_data_sample_soun_t *p_soun =
p_sample->data.p_sample_soun;
- msg_Warn( p_demux, "i_timescale ("I64Fu") != i_sampleratehi "
+ msg_Warn( p_demux, "i_timescale (%"PRIu64") != i_sampleratehi "
"(%u), making both equal (report any problem).",
p_track->i_timescale, p_soun->i_sampleratehi );
i_start += elst->i_media_time[p_track->i_elst];
}
- msg_Dbg( p_demux, "elst (%d) gives "I64Fd"ms (movie)-> "I64Fd
+ msg_Dbg( p_demux, "elst (%d) gives %"PRId64"ms (movie)-> %"PRId64
"ms (track)", p_track->i_elst,
i_mvt * 1000 / p_sys->i_timescale,
i_start * 1000 / p_track->i_timescale );
msg_Warn( p_demux, "elst box found" );
for( i = 0; i < elst->i_entry_count; i++ )
{
- msg_Dbg( p_demux, " - [%d] duration="I64Fd"ms media time="I64Fd
+ msg_Dbg( p_demux, " - [%d] duration=%"PRId64"ms media time=%"PRId64
"ms) rate=%d.%d", i,
elst->i_segment_duration[i] * 1000 / p_sys->i_timescale,
elst->i_media_time[i] >= 0 ?
if( p_stream->fmt.i_codec == VLC_FOURCC( 't','a','r','k' ) )
{
/* FIXME: the biggest hack I've ever done */
- msg_Warn( p_demux, "tarkin pts: "I64Fd", granule: "I64Fd,
+ msg_Warn( p_demux, "tarkin pts: %"PRId64", granule: %"PRId64,
p_block->i_pts, p_block->i_dts );
msleep(10000);
}
content_type_string );
}
- msg_Dbg( p_this, "AnxData packet info: "I64Fd" / "I64Fd", %d, ``%s''",
+ msg_Dbg( p_this, "AnxData packet info: %"PRId64" / %"PRId64", %d, ``%s''",
granule_rate_numerator, granule_rate_denominator,
p_stream->secondary_header_packets, content_type_string );
{
p_sys->i_length = i_length;
p_sys->i_time_track = i;
- msg_Dbg( p_demux, "we found a length of: "I64Fd, p_sys->i_length );
+ msg_Dbg( p_demux, "we found a length of: %"PRId64, p_sys->i_length );
}
}
}
if( !b_new && !p_sys->b_have_pack && tk->fmt.i_cat == AUDIO_ES && p_pkt->i_pts > 0 )
{
/* A hack to sync the A/V on PES files. */
- msg_Dbg( p_demux, "force SCR: "I64Fd, p_pkt->i_pts );
+ msg_Dbg( p_demux, "force SCR: %"PRId64, p_pkt->i_pts );
es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_pkt->i_pts );
}
/* If in dump mode, then close the file */
if( p_sys->b_file_out )
{
- msg_Info( p_demux ,"closing %s ("I64Fd" Kbytes dumped)",
+ msg_Info( p_demux ,"closing %s (%"PRId64" Kbytes dumped)",
p_sys->psz_file, p_sys->i_write / 1024 );
if( p_sys->p_file != stdout )
//subrec_type, esOffset1);
p_sys->lastVideoPTS = get_pts(
&p_block_in->p_buffer[ esOffset1 + VIDEO_PTS_OFFSET ] );
- /*msg_Dbg(p_demux, "Video rec %d PTS "I64Fd, p_sys->i_cur_rec,
+ /*msg_Dbg(p_demux, "Video rec %d PTS %"PRId64, p_sys->i_cur_rec,
p_sys->lastVideoPTS );*/
if (subrec_type != 0x06) {
/* if we found a PES, and it's not type 6, then we're S2 */
/* seek within the chunk to get roughly to where we want */
p_sys->i_cur_rec = (int)
((double) ((seek_pos % CHUNK_SIZE) / (double) (CHUNK_SIZE)) * p_sys->i_num_recs);
- msg_Dbg(p_demux, "Seeked to file pos " I64Fd, seek_pos);
+ msg_Dbg(p_demux, "Seeked to file pos %"PRId64, seek_pos);
msg_Dbg(p_demux, " (chunk %d, record %d)",
p_sys->i_cur_chunk - 1, p_sys->i_cur_rec);
lldiv_t dout = lldiv( p_intf->p_libvlc->p_stats->f_output_bitrate * 1000000,
1000 );
fprintf( p_intf->p_sys->p_rrd,
- I64Fi":%lld.%03u:%lld.%03u:%lld.%03u\n",
+ "%"PRIi64":%lld.%03u:%lld.%03u:%lld.%03u\n",
p_intf->p_sys->last_update/1000000,
din.quot, (unsigned int)din.rem,
ddm.quot, (unsigned int)ddm.rem,
p = psz_sdp = malloc( i_size );
p += sprintf( p, "v=0\r\n" );
- p += sprintf( p, "o=- "I64Fd" %d IN IP%c %s\r\n",
+ p += sprintf( p, "o=- %"PRId64" %d IN IP%c %s\r\n",
p_media->i_sdp_id, p_media->i_sdp_version, ipv, ip );
if( *p_media->psz_session_name )
p += sprintf( p, "s=%s\r\n", p_media->psz_session_name );
(uint64_t)p_stream->i_totalsize /
(uint64_t)p_stream->i_duration;
}
- msg_Info( p_mux, "stream[%d] duration:"I64Fd" totalsize:"I64Fd
+ msg_Info( p_mux, "stream[%d] duration:%"PRId64" totalsize:%"PRId64
" frames:%d fps:%f kb/s:%d",
i_stream,
(int64_t)p_stream->i_duration / (int64_t)1000000,
if( p_sys->i_shaping_delay <= 0 )
{
msg_Err( p_mux,
- "invalid shaping ("I64Fd"ms) resetting to 200ms",
+ "invalid shaping (%"PRId64"ms) resetting to 200ms",
p_sys->i_shaping_delay / 1000 );
p_sys->i_shaping_delay = 200000;
}
p_sys->i_pcr_delay >= p_sys->i_shaping_delay )
{
msg_Err( p_mux,
- "invalid pcr delay ("I64Fd"ms) resetting to 70ms",
+ "invalid pcr delay (%"PRId64"ms) resetting to 70ms",
p_sys->i_pcr_delay / 1000 );
p_sys->i_pcr_delay = 70000;
}
var_Get( p_mux, SOUT_CFG_PREFIX "dts-delay", &val );
p_sys->i_dts_delay = (int64_t)val.i_int * 1000;
- msg_Dbg( p_mux, "shaping="I64Fd" pcr="I64Fd" dts_delay="I64Fd,
+ msg_Dbg( p_mux, "shaping=%"PRId64" pcr=%"PRId64" dts_delay=%"PRId64,
p_sys->i_shaping_delay, p_sys->i_pcr_delay, p_sys->i_dts_delay );
var_Get( p_mux, SOUT_CFG_PREFIX "use-key-frames", &val );
p_stream->i_pes_length ) )
{
msg_Warn( p_mux, "packet with too strange dts "
- "(dts="I64Fd",old="I64Fd",pcr="I64Fd")",
+ "(dts=%"PRId64",old=%"PRId64",pcr=%"PRId64")",
p_data->i_dts, p_stream->i_pes_dts,
p_pcr_stream->i_pes_dts );
block_Release( p_data );
i++;
i_new_dts = i_pcr_dts + i_pcr_length * i / i_packet_count;
}
- msg_Dbg( p_mux, "adjusting rate at "I64Fd"/"I64Fd" (%d/%d)",
+ msg_Dbg( p_mux, "adjusting rate at %"PRId64"/%"PRId64" (%d/%d)",
i_cut_dts - i_pcr_dts, i_pcr_length, new_chain.i_depth,
p_chain_ts->i_depth );
if ( new_chain.i_depth )
/ (uint64_t)(i_pcr_length / 1000);
if ( p_sys->i_bitrate_max && p_sys->i_bitrate_max < i_bitrate )
{
- msg_Warn( p_mux, "max bitrate exceeded at "I64Fd
- " (%d bi/s for %d pkt in "I64Fd" us)",
+ msg_Warn( p_mux, "max bitrate exceeded at %"PRId64
+ " (%d bi/s for %d pkt in %"PRId64" us)",
i_pcr_dts + p_sys->i_shaping_delay * 3 / 2 - mdate(),
i_bitrate, i_packet_count, i_pcr_length);
}
#if 0
else
{
- msg_Dbg( p_mux, "starting at "I64Fd
- " (%d bi/s for %d packets in "I64Fd" us)",
+ msg_Dbg( p_mux, "starting at %"PRId64
+ " (%d bi/s for %d packets in %"PRId64" us)",
i_pcr_dts + p_sys->i_shaping_delay * 3 / 2 - mdate(),
i_bitrate, i_packet_count, i_pcr_length);
}
break;
}
#if 0
- msg_Dbg( p_dec, "pts="I64Fd" dts="I64Fd,
+ msg_Dbg( p_dec, "pts=%"PRId64" dts=%"PRId64,
p_pic->i_pts, p_pic->i_dts );
#endif
p_pic->i_length = p_sys->i_interpolated_dts - p_pic->i_dts;
#if 0
- msg_Dbg( p_dec, "pic: type=%d dts="I64Fd" pts-dts="I64Fd,
+ msg_Dbg( p_dec, "pic: type=%d dts=%"PRId64" pts-dts=%"PRId64,
p_sys->i_picture_type, p_pic->i_dts, p_pic->i_pts - p_pic->i_dts);
#endif
/* We can interpolate dts/pts only if we have a frame rate */
if( p_dec->fmt_out.video.i_frame_rate != 0 && p_dec->fmt_out.video.i_frame_rate_base != 0 )
{
- //msg_Dbg( p_dec, "-------------- XXX0 dts="I64Fd" pts="I64Fd" interpolated="I64Fd, p_pic->i_dts, p_pic->i_pts, p_sys->i_interpolated_dts );
+ //msg_Dbg( p_dec, "-------------- XXX0 dts=%"PRId64" pts=%"PRId64" interpolated=%"PRId64, p_pic->i_dts, p_pic->i_pts, p_sys->i_interpolated_dts );
if( p_pic->i_dts <= 0 )
p_pic->i_dts = p_sys->i_interpolated_dts;
}
p_sys->i_interpolated_dts = p_pic->i_dts;
- //msg_Dbg( p_dec, "-------------- dts="I64Fd" pts="I64Fd, p_pic->i_dts, p_pic->i_pts );
+ //msg_Dbg( p_dec, "-------------- dts=%"PRId64" pts=%"PRId64, p_pic->i_dts, p_pic->i_pts );
/* Reset context */
p_sys->p_frame = NULL;
goto error;
}
- if ((sscanf (data, "%63s "I64Fu" "I64Fu" IN IP%u %1023s",
+ if ((sscanf (data, "%63s %"PRIu64" %"PRIu64" IN IP%u %1023s",
p_sdp->username, &p_sdp->session_id,
&p_sdp->session_version, &p_sdp->orig_ip_version,
p_sdp->orig_host) != 5)
< p_bridge->pp_es[i]->i_last) )
{
block_t *p_block = p_bridge->pp_es[i]->p_block;
- msg_Dbg( p_stream, "dropping a packet (" I64Fd ")",
+ msg_Dbg( p_stream, "dropping a packet (%"PRId64 ")",
mdate() - p_block->i_dts - p_sys->i_delay );
p_bridge->pp_es[i]->p_block
= p_bridge->pp_es[i]->p_block->p_next;
if( psz_session == NULL )
{
ses = RtspClientNew( rtsp );
- snprintf( psz_sesbuf, sizeof( psz_sesbuf ), I64Fx,
+ snprintf( psz_sesbuf, sizeof( psz_sesbuf ), "%"PRIx64,
ses->id );
psz_session = psz_sesbuf;
}
mtime_t current_date = mdate();
if( current_date + 50000 > p_pic->date )
{
- msg_Dbg( p_stream, "late picture skipped ("I64Fd")",
+ msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
current_date + 50000 - p_pic->date );
p_pic->pf_release( p_pic );
continue;
if( p_sys->i_shaping_delay <= 0 )
{
msg_Err( p_stream,
- "invalid shaping ("I64Fd"ms) reseting to 500ms",
+ "invalid shaping (%"PRId64"ms) reseting to 500ms",
p_sys->i_shaping_delay / 1000 );
p_sys->i_shaping_delay = 500000;
}
p_sys->b_mpeg4_matrix = 1;
}
- msg_Dbg( p_stream, "codec video %dkb/s max gop="I64Fd"us",
+ msg_Dbg( p_stream, "codec video %dkb/s max gop=%"PRId64"us",
p_sys->i_vbitrate / 1024, p_sys->i_shaping_delay );
if( !p_sys->p_out )
}
else
{
- msg_Dbg( p_filter, "too late picture for %s (" I64Fd ")",
+ msg_Dbg( p_filter, "too late picture for %s (%"PRId64 ")",
p_es->psz_id,
date - p_es->p_picture->date - p_sys->i_delay );
break;
case P_TYPE_DOUBLE:
div = lldiv( init_cond->init_val.double_val * 1000000,
1000000 );
- sprintf(string, "%s="I64Fd".%06u\n", init_cond->param->name, div.quot, (unsigned int) div.rem );
+ sprintf(string, "%s=%"PRId64".%06u\n", init_cond->param->name, div.quot, (unsigned int) div.rem );
break;
default:
return;
else if (init_cond->param->type == P_TYPE_DOUBLE)
{
lldiv_t div = lldiv( init_cond->init_val.double_val * 1000000,1000000 );
- sprintf(s, "%s="I64Fd".%06u\n", init_cond->param->name, div.quot,
+ sprintf(s, "%s=%"PRId64".%06u\n", init_cond->param->name, div.quot,
(unsigned int) div.rem );
}