static int Control( stream_t *p_stream, int i_query, va_list args )
{
stream_sys_t *p_sys = p_stream->p_sys;
switch( i_query )
{
case STREAM_CAN_FASTSEEK:
if( !p_sys->b_fastseek || !p_sys->b_seek )
{
*va_arg( args, bool* ) = false;
return VLC_SUCCESS;
}
break;
case STREAM_CAN_SEEK:
if( !p_sys->b_seek )
{
*va_arg( args, bool* ) = false;
return VLC_SUCCESS;
}
break;
default:
break;
}
return vlc_stream_vaControl( p_stream->p_source, i_query, args );
}
static int Control( stream_extractor_t* p_extractor, int i_query, va_list args )
{
private_sys_t* p_sys = p_extractor->p_sys;
switch( i_query )
{
case STREAM_CAN_FASTSEEK:
*va_arg( args, bool* ) = false;
break;
case STREAM_CAN_SEEK:
*va_arg( args, bool* ) = p_sys->b_seekable_source;
break;
case STREAM_GET_SIZE:
if( p_sys->p_entry == NULL )
return VLC_EGENERIC;
if( !archive_entry_size_is_set( p_sys->p_entry ) )
return VLC_EGENERIC;
*va_arg( args, uint64_t* ) = archive_entry_size( p_sys->p_entry );
break;
default:
return vlc_stream_vaControl( p_extractor->source, i_query, args );
}
return VLC_SUCCESS;
}
/** *************************************************************************
* Control
****************************************************************************/
static int Control( stream_t *s, int i_query, va_list args )
{
stream_sys_t *p_sys = s->p_sys;
switch( i_query )
{
case STREAM_GET_SIZE:
{
uint64_t *pi_size = va_arg( args, uint64_t* );
*pi_size = p_sys->i_len;
return VLC_SUCCESS;
}
case STREAM_GET_CONTENT_TYPE:
return VLC_EGENERIC;
case STREAM_CAN_SEEK:
case STREAM_CAN_FASTSEEK:
case STREAM_SET_RECORD_STATE:
return vlc_stream_vaControl( s->p_source, i_query, args );
default:
return VLC_EGENERIC;
}
}
static int Control( stream_t *s, int i_query, va_list args )
{
if( i_query != STREAM_SET_RECORD_STATE )
return vlc_stream_vaControl( s->p_source, i_query, args );
stream_sys_t *sys = s->p_sys;
bool b_active = (bool)va_arg( args, int );
const char *psz_extension = NULL;
if( b_active )
psz_extension = (const char*)va_arg( args, const char* );
if( !sys->f == !b_active )
return VLC_SUCCESS;
if( b_active )
return Start( s, psz_extension );
else
return Stop( s );
}
static int Control(access_t *p_access, int i_query, va_list args)
{
access_sys_t *p_sys = p_access->p_sys;
switch (i_query)
{
case STREAM_CAN_SEEK:
*va_arg(args, bool *)= p_sys->b_seekable;
break;
case STREAM_CAN_FASTSEEK:
if (!p_sys->b_seekable || !p_sys->p_stream)
{
*va_arg( args, bool* ) = false;
break;
}
else
return vlc_stream_vaControl( p_sys->p_stream, i_query, args );
case STREAM_SET_PAUSE_STATE:
break;
case STREAM_CAN_PAUSE:
case STREAM_CAN_CONTROL_PACE:
*va_arg(args, bool *) = true;
break;
case STREAM_GET_SIZE:
*va_arg(args, uint64_t *) = archive_entry_size(p_sys->p_entry);
break;
case STREAM_GET_PTS_DELAY:
*va_arg(args, int64_t *) = DEFAULT_PTS_DELAY;
break;
default:
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
static int Control(demux_t *demux, int query, va_list args)
{
demux_sys_t *sys = demux->p_sys;
switch(query) {
case DEMUX_CAN_SEEK:
return vlc_stream_vaControl(demux->s, query, args);
case DEMUX_GET_LENGTH: {
int64_t *l = va_arg(args, int64_t *);
*l = sys->count > 0 ? sys->index[sys->count-1].stop : 0;
return VLC_SUCCESS;
}
case DEMUX_GET_TIME: {
int64_t *t = va_arg(args, int64_t *);
*t = sys->current < sys->count ? sys->index[sys->count-1].start : 0;
return VLC_SUCCESS;
}
case DEMUX_SET_NEXT_DEMUX_TIME: {
sys->next_date = va_arg(args, int64_t);
return VLC_SUCCESS;
}
case DEMUX_SET_TIME: {
int64_t t = va_arg(args, int64_t);
sys->current = 0;
while (sys->current < sys->count) {
if (sys->index[sys->current].stop > t) {
vlc_stream_Seek(demux->s, 1024 + 128LL * sys->index[sys->current].index);
break;
}
sys->current++;
}
return VLC_SUCCESS;
}
case DEMUX_SET_POSITION:
case DEMUX_GET_POSITION:
default:
return VLC_EGENERIC;
}
}
static int Control(demux_t *demux, int query, va_list args)
{
(void) demux;
switch( query )
{
case DEMUX_IS_PLAYLIST:
{
bool *pb_bool = va_arg( args, bool * );
*pb_bool = true;
return VLC_SUCCESS;
}
case DEMUX_GET_META:
{
return vlc_stream_vaControl(demux->s, STREAM_GET_META, args);
}
case DEMUX_HAS_UNSUPPORTED_META:
{
*(va_arg( args, bool * )) = false;
return VLC_SUCCESS;
}
}
return VLC_EGENERIC;
}
/*****************************************************************************
* Control:
*****************************************************************************/
static int Control( demux_t *p_demux, int i_query, va_list args )
{
demux_sys_t *p_sys = p_demux->p_sys;
double f, *pf;
int64_t i64;
int i_ret;
switch( i_query )
{
case DEMUX_CAN_SEEK:
*va_arg( args, bool * ) = p_sys->b_seekable;
return VLC_SUCCESS;
case DEMUX_GET_TITLE:
*va_arg( args, int * ) = p_sys->current_title;
return VLC_SUCCESS;
case DEMUX_GET_SEEKPOINT:
*va_arg( args, int * ) = p_sys->current_seekpoint;
return VLC_SUCCESS;
case DEMUX_GET_POSITION:
pf = va_arg( args, double * );
i64 = stream_Size( p_demux->s ) - p_sys->i_start_byte;
if( i64 > 0 )
{
double current = vlc_stream_Tell( p_demux->s ) - p_sys->i_start_byte;
*pf = current / (double)i64;
}
else
{
*pf = 0.0;
}
return VLC_SUCCESS;
case DEMUX_SET_POSITION:
f = va_arg( args, double );
i64 = stream_Size( p_demux->s ) - p_sys->i_start_byte;
p_sys->i_current_pts = VLC_TICK_INVALID;
p_sys->i_scr = VLC_TICK_INVALID;
if( p_sys->format == CDXA_PS )
{
i64 = (int64_t)(i64 * f); /* Align to sector payload */
i64 = p_sys->i_start_byte + i64 - (i64 % CDXA_SECTOR_SIZE) + CDXA_SECTOR_HEADER_SIZE;
}
else
{
i64 = p_sys->i_start_byte + (int64_t)(i64 * f);
}
i_ret = vlc_stream_Seek( p_demux->s, i64 );
if( i_ret == VLC_SUCCESS )
{
NotifyDiscontinuity( p_sys->tk, p_demux->out );
return i_ret;
}
break;
case DEMUX_GET_TIME:
if( p_sys->i_time_track_index >= 0 && p_sys->i_current_pts != VLC_TICK_INVALID )
{
*va_arg( args, vlc_tick_t * ) = p_sys->i_current_pts - p_sys->tk[p_sys->i_time_track_index].i_first_pts;
return VLC_SUCCESS;
}
if( p_sys->i_first_scr != VLC_TICK_INVALID && p_sys->i_scr != VLC_TICK_INVALID )
{
vlc_tick_t i_time = p_sys->i_scr - p_sys->i_first_scr;
/* H.222 2.5.2.2 */
if( p_sys->i_mux_rate > 0 && p_sys->b_have_pack )
{
uint64_t i_offset = vlc_stream_Tell( p_demux->s ) - p_sys->i_lastpack_byte;
i_time += vlc_tick_from_samples(i_offset, p_sys->i_mux_rate * 50);
}
*va_arg( args, vlc_tick_t * ) = i_time;
return VLC_SUCCESS;
}
*va_arg( args, vlc_tick_t * ) = 0;
break;
case DEMUX_GET_LENGTH:
if( p_sys->i_length > VLC_TICK_0 )
{
*va_arg( args, vlc_tick_t * ) = p_sys->i_length;
return VLC_SUCCESS;
}
else if( p_sys->i_mux_rate > 0 )
{
*va_arg( args, vlc_tick_t * ) = vlc_tick_from_samples( stream_Size( p_demux->s ) - p_sys->i_start_byte / 50,
p_sys->i_mux_rate );
return VLC_SUCCESS;
}
*va_arg( args, vlc_tick_t * ) = 0;
break;
case DEMUX_SET_TIME:
{
if( p_sys->i_time_track_index >= 0 && p_sys->i_current_pts != VLC_TICK_INVALID &&
p_sys->i_length > VLC_TICK_0)
{
vlc_tick_t i_time = va_arg( args, vlc_tick_t );
i_time -= p_sys->tk[p_sys->i_time_track_index].i_first_pts;
return demux_Control( p_demux, DEMUX_SET_POSITION, (double) i_time / p_sys->i_length );
}
break;
}
case DEMUX_GET_TITLE_INFO:
{
struct input_title_t ***v = va_arg( args, struct input_title_t*** );
int *c = va_arg( args, int * );
*va_arg( args, int* ) = 0; /* Title offset */
*va_arg( args, int* ) = 0; /* Chapter offset */
return vlc_stream_Control( p_demux->s, STREAM_GET_TITLE_INFO, v,
c );
}
case DEMUX_SET_TITLE:
return vlc_stream_vaControl( p_demux->s, STREAM_SET_TITLE, args );
case DEMUX_SET_SEEKPOINT:
return vlc_stream_vaControl( p_demux->s, STREAM_SET_SEEKPOINT,
args );
case DEMUX_TEST_AND_CLEAR_FLAGS:
{
unsigned *restrict flags = va_arg(args, unsigned *);
*flags &= p_sys->updates;
p_sys->updates &= ~*flags;
return VLC_SUCCESS;
}
case DEMUX_GET_META:
return vlc_stream_vaControl( p_demux->s, STREAM_GET_META, args );
case DEMUX_GET_FPS:
break;
case DEMUX_CAN_PAUSE:
case DEMUX_SET_PAUSE_STATE:
case DEMUX_CAN_CONTROL_PACE:
case DEMUX_GET_PTS_DELAY:
return demux_vaControlHelper( p_demux->s, 0, -1, 0, 1, i_query, args );
default:
break;
}
return VLC_EGENERIC;
}
/*****************************************************************************
* Control:
*****************************************************************************/
static int Control( demux_t *p_demux, int i_query, va_list args )
{
demux_sys_t *p_sys = p_demux->p_sys;
int64_t *pi64, i64;
double *pf, f;
int i_skp;
size_t i_idx;
bool b;
vlc_meta_t *p_meta;
input_attachment_t ***ppp_attach;
int *pi_int;
switch( i_query )
{
case DEMUX_CAN_SEEK:
return vlc_stream_vaControl( p_demux->s, i_query, args );
case DEMUX_GET_ATTACHMENTS:
ppp_attach = va_arg( args, input_attachment_t*** );
pi_int = va_arg( args, int * );
if( p_sys->stored_attachments.size() <= 0 )
return VLC_EGENERIC;
*pi_int = p_sys->stored_attachments.size();
*ppp_attach = static_cast<input_attachment_t**>( malloc( sizeof(input_attachment_t*) *
p_sys->stored_attachments.size() ) );
if( !(*ppp_attach) )
return VLC_ENOMEM;
for( size_t i = 0; i < p_sys->stored_attachments.size(); i++ )
{
attachment_c *a = p_sys->stored_attachments[i];
(*ppp_attach)[i] = vlc_input_attachment_New( a->fileName(), a->mimeType(), NULL,
a->p_data, a->size() );
if( !(*ppp_attach)[i] )
{
free(*ppp_attach);
return VLC_ENOMEM;
}
}
return VLC_SUCCESS;
case DEMUX_GET_META:
p_meta = va_arg( args, vlc_meta_t* );
vlc_meta_Merge( p_meta, p_sys->meta );
return VLC_SUCCESS;
case DEMUX_GET_LENGTH:
pi64 = va_arg( args, int64_t * );
if( p_sys->f_duration > 0.0 )
{
*pi64 = static_cast<int64_t>( p_sys->f_duration * 1000 );
return VLC_SUCCESS;
}
return VLC_EGENERIC;
case DEMUX_GET_POSITION:
pf = va_arg( args, double * );
if ( p_sys->f_duration > 0.0 )
*pf = static_cast<double> (p_sys->i_pcr >= p_sys->i_start_pts ? p_sys->i_pcr : p_sys->i_start_pts ) / (1000.0 * p_sys->f_duration);
return VLC_SUCCESS;
case DEMUX_SET_POSITION:
if( p_sys->f_duration > 0.0 )
{
f = va_arg( args, double );
b = va_arg( args, int ); /* precise? */
Seek( p_demux, -1, f, NULL, b );
return VLC_SUCCESS;
}
return VLC_EGENERIC;
case DEMUX_GET_TIME:
pi64 = va_arg( args, int64_t * );
*pi64 = p_sys->i_pcr;
return VLC_SUCCESS;
case DEMUX_GET_TITLE_INFO:
if( p_sys->titles.size() > 1 || ( p_sys->titles.size() == 1 && p_sys->titles[0]->i_seekpoint > 0 ) )
{
input_title_t ***ppp_title = va_arg( args, input_title_t*** );
int *pi_int = va_arg( args, int* );
*pi_int = p_sys->titles.size();
*ppp_title = static_cast<input_title_t**>( malloc( sizeof( input_title_t* ) * p_sys->titles.size() ) );
for( size_t i = 0; i < p_sys->titles.size(); i++ )
(*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->titles[i] );
return VLC_SUCCESS;
}
static int Control( stream_t *p_stream, int i_query, va_list args )
{
return vlc_stream_vaControl( p_stream->s, i_query, args );
}
