static void
cdio_log_handler (cdio_log_level_t level, const char message[])
{
- const vcdplayer_t *p_vcd = (vcdplayer_t *)p_vcd_access->p_sys;
+ const vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_vcd_access->p_sys;
switch (level) {
case CDIO_LOG_DEBUG:
case CDIO_LOG_INFO:
- if (p_vcd->i_debug & INPUT_DBG_CDIO)
+ if (p_vcdplayer->i_debug & INPUT_DBG_CDIO)
msg_Dbg( p_vcd_access, message);
break;
case CDIO_LOG_WARN:
static void
vcd_log_handler (vcd_log_level_t level, const char message[])
{
- vcdplayer_t *p_vcd = (vcdplayer_t *)p_vcd_access->p_sys;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_vcd_access->p_sys;
switch (level) {
case VCD_LOG_DEBUG:
case VCD_LOG_INFO:
- if (p_vcd->i_debug & INPUT_DBG_VCDINFO)
+ if (p_vcdplayer->i_debug & INPUT_DBG_VCDINFO)
msg_Dbg( p_vcd_access, message);
break;
case VCD_LOG_WARN:
static block_t *
VCDReadBlock( access_t * p_access )
{
- vcdplayer_t *p_vcd= (vcdplayer_t *)p_access->p_sys;
+ vcdplayer_t *p_vcdplayer= (vcdplayer_t *)p_access->p_sys;
+ const int i_blocks = p_vcdplayer->i_blocks_per_read;
block_t *p_block;
- const int i_blocks = p_vcd->i_blocks_per_read;
- int i_read;
- uint8_t * p_buf;
+ int i_read;
+ uint8_t *p_buf;
i_read = 0;
dbg_print( (INPUT_DBG_LSN), "lsn: %lu",
- (long unsigned int) p_vcd->i_lsn );
+ (long unsigned int) p_vcdplayer->i_lsn );
/* Allocate a block for the reading */
if( !( p_block = block_New( p_access, i_blocks * M2F2_SECTOR_SIZE ) ) )
p_vcd->in_still = VLC_FALSE;
dbg_print(INPUT_DBG_STILL, "still wait time done");
#else
- vcdIntfStillTime(p_vcd->p_intf, *p_buf);
+ vcdIntfStillTime(p_vcdplayer->p_intf, *p_buf);
#endif
#if 1
p_buf += M2F2_SECTOR_SIZE;
/* Update seekpoint */
- if ( VCDINFO_ITEM_TYPE_ENTRY == p_vcd->play_item.type )
+ if ( VCDINFO_ITEM_TYPE_ENTRY == p_vcdplayer->play_item.type )
{
- unsigned int i_entry = p_vcd->play_item.num+1;
- lsn_t i_lsn = vcdinfo_get_entry_lba(p_vcd->vcd, i_entry);
- if ( p_vcd->i_lsn >= i_lsn && i_lsn != VCDINFO_NULL_LBA )
+ unsigned int i_entry = p_vcdplayer->play_item.num+1;
+ lsn_t i_lsn = vcdinfo_get_entry_lba(p_vcdplayer->vcd, i_entry);
+ if ( p_vcdplayer->i_lsn >= i_lsn && i_lsn != VCDINFO_NULL_LBA )
{
- const track_t i_track = p_vcd->i_track;
- p_vcd->play_item.num = i_entry;
+ const track_t i_track = p_vcdplayer->i_track;
+ p_vcdplayer->play_item.num = i_entry;
dbg_print( (INPUT_DBG_LSN|INPUT_DBG_PBC), "entry change" );
- VCDSetOrigin( p_access, i_lsn, i_track, &(p_vcd->play_item) );
+ VCDSetOrigin( p_access, i_lsn, i_track,
+ &(p_vcdplayer->play_item) );
}
}
}
if (!p_access || !p_access->p_sys) return VLC_EGENERIC;
{
- vcdplayer_t *p_vcd = (vcdplayer_t *)p_vcd_access->p_sys;
- const input_title_t *t = p_vcd->p_title[p_access->info.i_title];
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_vcd_access->p_sys;
+ const input_title_t *t = p_vcdplayer->p_title[p_access->info.i_title];
+ unsigned int i_entry = VCDINFO_INVALID_ENTRY;
int i_seekpoint;
- unsigned int i_entry=VCDINFO_INVALID_ENTRY;
/* Next sector to read */
p_access->info.i_pos = i_pos;
- p_vcd->i_lsn = (i_pos / (int64_t)M2F2_SECTOR_SIZE) +
- p_vcd->track_lsn;
+ p_vcdplayer->i_lsn = (i_pos / (int64_t)M2F2_SECTOR_SIZE) +
+ p_vcdplayer->track_lsn;
- switch (p_vcd->play_item.type) {
+ switch (p_vcdplayer->play_item.type) {
case VCDINFO_ITEM_TYPE_TRACK:
case VCDINFO_ITEM_TYPE_ENTRY:
break ;
default:
- p_vcd->b_valid_ep = VLC_FALSE;
+ p_vcdplayer->b_valid_ep = VLC_FALSE;
}
/* Find entry */
- if( p_vcd->b_valid_ep )
+ if( p_vcdplayer->b_valid_ep )
{
- for( i_entry = 0 ; i_entry < p_vcd->i_entries ; i_entry ++ )
+ for( i_entry = 0 ; i_entry < p_vcdplayer->i_entries ; i_entry ++ )
{
- if( p_vcd->i_lsn < p_vcd->p_entries[i_entry] )
+ if( p_vcdplayer->i_lsn < p_vcdplayer->p_entries[i_entry] )
{
VCDUpdateVar( p_access, i_entry, VLC_VAR_SETVALUE,
"chapter", _("Entry"), "Setting entry" );
vcdinfo_itemid_t itemid;
itemid.num = i_entry;
itemid.type = VCDINFO_ITEM_TYPE_ENTRY;
- VCDSetOrigin(p_access, p_vcd->i_lsn, p_vcd->i_track,
+ VCDSetOrigin(p_access, p_vcdplayer->i_lsn, p_vcdplayer->i_track,
&itemid);
}
}
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_SEEK),
"orig %lu, cur: %lu, offset: %lld, entry %d",
- (long unsigned int) p_vcd->origin_lsn,
- (long unsigned int) p_vcd->i_lsn, i_pos,
+ (long unsigned int) p_vcdplayer->origin_lsn,
+ (long unsigned int) p_vcdplayer->i_lsn, i_pos,
i_entry );
/* Find seekpoint */
if (!p_access || !p_access->p_sys) return VLC_FALSE;
{
- vcdplayer_t *p_vcd = (vcdplayer_t *) p_access->p_sys;
- const unsigned int i_entries = vcdinfo_get_num_entries(p_vcd->vcd);
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
+ const unsigned int i_entries =
+ vcdinfo_get_num_entries(p_vcdplayer->vcd);
const track_t i_last_track
- = cdio_get_num_tracks(vcdinfo_get_cd_image(p_vcd->vcd))
- + cdio_get_first_track_num(vcdinfo_get_cd_image(p_vcd->vcd));
+ = cdio_get_num_tracks(vcdinfo_get_cd_image(p_vcdplayer->vcd))
+ + cdio_get_first_track_num(vcdinfo_get_cd_image(p_vcdplayer->vcd));
unsigned int i;
if (0 == i_entries) {
return VLC_FALSE;
}
- p_vcd->p_entries = malloc( sizeof( lsn_t ) * i_entries );
+ p_vcdplayer->p_entries = malloc( sizeof( lsn_t ) * i_entries );
- if( p_vcd->p_entries == NULL )
+ if( p_vcdplayer->p_entries == NULL )
{
LOG_ERR ("not enough memory for entry points treatment" );
return VLC_FALSE;
}
- p_vcd->i_entries = i_entries;
+ p_vcdplayer->i_entries = i_entries;
for( i = 0 ; i < i_entries ; i++ )
{
- const track_t i_track = vcdinfo_get_track(p_vcd->vcd, i);
+ const track_t i_track = vcdinfo_get_track(p_vcdplayer->vcd, i);
if( i_track <= i_last_track ) {
seekpoint_t *s = vlc_seekpoint_New();
char psz_entry[100];
snprintf(psz_entry, sizeof(psz_entry), "%s%02d", _("Entry "), i );
- p_vcd->p_entries[i] = vcdinfo_get_entry_lba(p_vcd->vcd, i);
+ p_vcdplayer->p_entries[i] = vcdinfo_get_entry_lba(p_vcdplayer->vcd, i);
s->psz_name = strdup(psz_entry);
s->i_byte_offset =
- (p_vcd->p_entries[i] - vcdinfo_get_track_lba(p_vcd->vcd, i_track))
+ (p_vcdplayer->p_entries[i] - vcdinfo_get_track_lba(p_vcdplayer->vcd, i_track))
* M2F2_SECTOR_SIZE;
dbg_print( INPUT_DBG_MRL,
"%s, lsn %d, byte_offset %ld",
- s->psz_name, p_vcd->p_entries[i],
+ s->psz_name, p_vcdplayer->p_entries[i],
(unsigned long int) s->i_byte_offset);
- TAB_APPEND( p_vcd->p_title[i_track-1]->i_seekpoint,
- p_vcd->p_title[i_track-1]->seekpoint, s );
+ TAB_APPEND( p_vcdplayer->p_title[i_track-1]->i_seekpoint,
+ p_vcdplayer->p_title[i_track-1]->seekpoint, s );
} else
msg_Warn( p_access, "wrong track number found in entry points" );
}
- p_vcd->b_valid_ep = VLC_TRUE;
+ p_vcdplayer->b_valid_ep = VLC_TRUE;
return VLC_TRUE;
}
}
static vlc_bool_t
VCDSegments( access_t * p_access )
{
- vcdplayer_t *p_vcd = (vcdplayer_t *) p_access->p_sys;
- unsigned int i;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
+ unsigned int i;
input_title_t *t;
- p_vcd->i_segments = vcdinfo_get_num_segments(p_vcd->vcd);
+ p_vcdplayer->i_segments = vcdinfo_get_num_segments(p_vcdplayer->vcd);
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_MRL),
- "Segments: %d", p_vcd->i_segments);
+ "Segments: %d", p_vcdplayer->i_segments);
- if ( 0 == p_vcd->i_segments ) return VLC_FALSE;
+ if ( 0 == p_vcdplayer->i_segments ) return VLC_FALSE;
- t = p_vcd->p_title[p_vcd->i_titles] = vlc_input_title_New();
- p_vcd->i_titles++;
+ t = p_vcdplayer->p_title[p_vcdplayer->i_titles] = vlc_input_title_New();
+ p_vcdplayer->i_titles++;
t->i_size = 0; /* Not sure Segments have a size associated */
t->psz_name = strdup(_("Segments"));
/* We have one additional segment allocated so we can get the size
by subtracting seg[i+1] - seg[i].
*/
- p_vcd->p_segments = malloc( sizeof( lsn_t ) * (p_vcd->i_segments+1) );
- if( p_vcd->p_segments == NULL )
+ p_vcdplayer->p_segments =
+ malloc( sizeof( lsn_t ) * (p_vcdplayer->i_segments+1) );
+ if( p_vcdplayer->p_segments == NULL )
{
LOG_ERR ("not enough memory for segment treatment" );
return VLC_FALSE;
}
- for( i = 0 ; i < p_vcd->i_segments ; i++ )
+ for( i = 0 ; i < p_vcdplayer->i_segments ; i++ )
{
char psz_segment[100];
seekpoint_t *s = vlc_seekpoint_New();
- p_vcd->p_segments[i] = vcdinfo_get_seg_lsn(p_vcd->vcd, i);
+ p_vcdplayer->p_segments[i] = vcdinfo_get_seg_lsn(p_vcdplayer->vcd, i);
snprintf( psz_segment, sizeof(psz_segment), "%s%02d", _("Segment "),
i );
TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
}
- p_vcd->p_segments[p_vcd->i_segments] =
- p_vcd->p_segments[p_vcd->i_segments-1]+
- vcdinfo_get_seg_sector_count(p_vcd->vcd, p_vcd->i_segments-1);
+ p_vcdplayer->p_segments[p_vcdplayer->i_segments] =
+ p_vcdplayer->p_segments[p_vcdplayer->i_segments-1]+
+ vcdinfo_get_seg_sector_count(p_vcdplayer->vcd,
+ p_vcdplayer->i_segments-1);
return VLC_TRUE;
}
if (!p_access || !p_access->p_sys) return VLC_EGENERIC;
{
- vcdplayer_t *p_vcd = (vcdplayer_t *) p_access->p_sys;
- track_t i;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
+ track_t i;
- p_vcd->i_titles = 0;
- for( i = 1 ; i <= p_vcd->i_tracks ; i++ )
+ p_vcdplayer->i_titles = 0;
+ for( i = 1 ; i <= p_vcdplayer->i_tracks ; i++ )
{
- input_title_t *t = p_vcd->p_title[i-1] = vlc_input_title_New();
+ input_title_t *t = p_vcdplayer->p_title[i-1] =
+ vlc_input_title_New();
char psz_track[100];
- uint32_t i_secsize = vcdinfo_get_track_sect_count( p_vcd->vcd, i );
+ uint32_t i_secsize =
+ vcdinfo_get_track_sect_count( p_vcdplayer->vcd, i );
snprintf( psz_track, sizeof(psz_track), "%s%02d", _("Track "),
i );
dbg_print( INPUT_DBG_MRL, "track[%d] i_size: %lld",
i, t->i_size );
- p_vcd->i_titles++;
+ p_vcdplayer->i_titles++;
}
return VLC_SUCCESS;
static vlc_bool_t
VCDLIDs( access_t * p_access )
{
- vcdplayer_t *p_vcd = (vcdplayer_t *) p_access->p_sys;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
input_title_t *t;
- unsigned int i_lid, i_title;
+ unsigned int i_lid, i_title;
- p_vcd->i_lids = vcdinfo_get_num_LIDs(p_vcd->vcd);
- p_vcd->i_lid = VCDINFO_INVALID_ENTRY;
+ p_vcdplayer->i_lids = vcdinfo_get_num_LIDs(p_vcdplayer->vcd);
+ p_vcdplayer->i_lid = VCDINFO_INVALID_ENTRY;
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_MRL),
- "LIDs: %d", p_vcd->i_lids);
+ "LIDs: %d", p_vcdplayer->i_lids);
- if ( 0 == p_vcd->i_lids ) return VLC_FALSE;
+ if ( 0 == p_vcdplayer->i_lids ) return VLC_FALSE;
- if (vcdinfo_read_psd (p_vcd->vcd)) {
+ if (vcdinfo_read_psd (p_vcdplayer->vcd)) {
- vcdinfo_visit_lot (p_vcd->vcd, VLC_FALSE);
+ vcdinfo_visit_lot (p_vcdplayer->vcd, VLC_FALSE);
#if FIXED
/*
selection features in the extended PSD haven't been implemented,
it's best then to not try to read this at all.
*/
- if (vcdinfo_get_psd_x_size(p_vcd->vcd))
- vcdinfo_visit_lot (p_vcd->vcd, VLC_TRUE);
+ if (vcdinfo_get_psd_x_size(p_vcdplayer->vcd))
+ vcdinfo_visit_lot (p_vcdplayer->vcd, VLC_TRUE);
#endif
}
t->b_menu = VLC_TRUE;
t->psz_name = strdup( "LIDs" );
- i_title = p_vcd->i_tracks;
- for( i_lid = 1 ; i_lid <= p_vcd->i_lids ; i_lid++ )
+ i_title = p_vcdplayer->i_tracks;
+ for( i_lid = 1 ; i_lid <= p_vcdplayer->i_lids ; i_lid++ )
{
char psz_lid[100];
seekpoint_t *s = vlc_seekpoint_New();
}
#if DYNAMICALLY_ALLOCATED
- TAB_APPEND( p_vcd->i_titles, p_vcd->p_title, t );
+ TAB_APPEND( p_vcdplayer->i_titles, p_vcdplayer->p_title, t );
#else
- p_vcd->p_title[p_vcd->i_titles] = t;
- p_vcd->i_titles++;
+ p_vcdplayer->p_title[p_vcdplayer->i_titles] = t;
+ p_vcdplayer->i_titles++;
#endif
return VLC_TRUE;
VCDParse( access_t * p_access, /*out*/ vcdinfo_itemid_t * p_itemid,
/*out*/ vlc_bool_t *play_single_item )
{
- vcdplayer_t *p_vcd = (vcdplayer_t *)p_access->p_sys;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_access->p_sys;
char *psz_parser;
char *psz_source;
char *psz_next;
VCDSetOrigin( access_t *p_access, lsn_t i_lsn, track_t i_track,
const vcdinfo_itemid_t *p_itemid )
{
- vcdplayer_t *p_vcd= (vcdplayer_t *)p_access->p_sys;
+ vcdplayer_t *p_vcdplayer= (vcdplayer_t *)p_access->p_sys;
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_LSN),
"i_lsn: %lu, track: %d", (long unsigned int) i_lsn,
vcdplayer_set_origin(p_access, i_lsn, i_track, p_itemid);
- p_access->info.i_pos = ( i_lsn - p_vcd->track_lsn )
+ p_access->info.i_pos = ( i_lsn - p_vcdplayer->track_lsn )
* M2F2_SECTOR_SIZE;
- p_access->info.i_update |= INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE
- | INPUT_UPDATE_SEEKPOINT;
+ p_access->info.i_update |= INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE
+ | INPUT_UPDATE_SEEKPOINT;
- switch (p_vcd->play_item.type) {
+ switch (p_vcdplayer->play_item.type) {
case VCDINFO_ITEM_TYPE_ENTRY:
VCDUpdateVar( p_access, p_itemid->num, VLC_VAR_SETVALUE,
"chapter", _("Entry"), "Setting entry/segment");
p_access->info.i_title = i_track-1;
- p_access->info.i_size = p_vcd->p_title[i_track-1]->i_size;
+ p_access->info.i_size = p_vcdplayer->p_title[i_track-1]->i_size;
p_access->info.i_seekpoint = p_itemid->num;
break;
and they must here. The segment seekpoints are stored after
the entry seekpoints and (zeroed) lid seekpoints.
*/
- p_access->info.i_title = p_vcd->i_titles - 1;
+ p_access->info.i_title = p_vcdplayer->i_titles - 1;
p_access->info.i_size = 150 * M2F2_SECTOR_SIZE;
- p_access->info.i_seekpoint = p_vcd->i_entries
- + p_vcd->i_lids + p_itemid->num;
+ p_access->info.i_seekpoint = p_vcdplayer->i_entries
+ + p_vcdplayer->i_lids + p_itemid->num;
break;
case VCDINFO_ITEM_TYPE_TRACK:
p_access->info.i_title = i_track-1;
- p_access->info.i_size = p_vcd->p_title[i_track-1]->i_size;
- p_access->info.i_seekpoint = vcdinfo_track_get_entry(p_vcd->vcd,
+ p_access->info.i_size = p_vcdplayer->p_title[i_track-1]->i_size;
+ p_access->info.i_seekpoint = vcdinfo_track_get_entry(p_vcdplayer->vcd,
i_track);
break;
default:
msg_Warn( p_access, "can't set origin for play type %d",
- p_vcd->play_item.type );
+ p_vcdplayer->play_item.type );
}
vcd_Open( vlc_object_t *p_this, const char *psz_dev )
{
access_t *p_access = (access_t *)p_this;
- vcdplayer_t *p_vcd = (vcdplayer_t *) p_access->p_sys;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
vcdinfo_obj_t *p_vcdobj;
char *actual_dev;
unsigned int i;
Save summary info on tracks, segments and entries...
*/
- if ( 0 < (p_vcd->i_tracks = vcdinfo_get_num_tracks(p_vcdobj)) ) {
- p_vcd->track = (vcdplayer_play_item_info_t *)
- calloc(p_vcd->i_tracks, sizeof(vcdplayer_play_item_info_t));
+ if ( 0 < (p_vcdplayer->i_tracks = vcdinfo_get_num_tracks(p_vcdobj)) ) {
+ p_vcdplayer->track = (vcdplayer_play_item_info_t *)
+ calloc(p_vcdplayer->i_tracks, sizeof(vcdplayer_play_item_info_t));
- for (i=0; i<p_vcd->i_tracks; i++) {
+ for (i=0; i<p_vcdplayer->i_tracks; i++) {
unsigned int track_num=i+1;
- p_vcd->track[i].size =
+ p_vcdplayer->track[i].size =
vcdinfo_get_track_sect_count(p_vcdobj, track_num);
- p_vcd->track[i].start_LSN =
+ p_vcdplayer->track[i].start_LSN =
vcdinfo_get_track_lba(p_vcdobj, track_num);
}
} else
- p_vcd->track = NULL;
+ p_vcdplayer->track = NULL;
- if ( 0 < (p_vcd->i_entries = vcdinfo_get_num_entries(p_vcdobj)) ) {
- p_vcd->entry = (vcdplayer_play_item_info_t *)
- calloc(p_vcd->i_entries, sizeof(vcdplayer_play_item_info_t));
+ if ( 0 < (p_vcdplayer->i_entries = vcdinfo_get_num_entries(p_vcdobj)) ) {
+ p_vcdplayer->entry = (vcdplayer_play_item_info_t *)
+ calloc(p_vcdplayer->i_entries, sizeof(vcdplayer_play_item_info_t));
- for (i=0; i<p_vcd->i_entries; i++) {
- p_vcd->entry[i].size = vcdinfo_get_entry_sect_count(p_vcdobj, i);
- p_vcd->entry[i].start_LSN = vcdinfo_get_entry_lba(p_vcdobj, i);
+ for (i=0; i<p_vcdplayer->i_entries; i++) {
+ p_vcdplayer->entry[i].size =
+ vcdinfo_get_entry_sect_count(p_vcdobj, i);
+ p_vcdplayer->entry[i].start_LSN = vcdinfo_get_entry_lba(p_vcdobj, i);
}
} else
- p_vcd->entry = NULL;
+ p_vcdplayer->entry = NULL;
- if ( 0 < (p_vcd->i_segments = vcdinfo_get_num_segments(p_vcdobj)) ) {
- p_vcd->segment = (vcdplayer_play_item_info_t *)
- calloc(p_vcd->i_segments, sizeof(vcdplayer_play_item_info_t));
+ if ( 0 < (p_vcdplayer->i_segments = vcdinfo_get_num_segments(p_vcdobj)) ) {
+ p_vcdplayer->segment = (vcdplayer_play_item_info_t *)
+ calloc(p_vcdplayer->i_segments, sizeof(vcdplayer_play_item_info_t));
- for (i=0; i<p_vcd->i_segments; i++) {
- p_vcd->segment[i].size = vcdinfo_get_seg_sector_count(p_vcdobj, i);
- p_vcd->segment[i].start_LSN = vcdinfo_get_seg_lsn(p_vcdobj, i);
+ for (i=0; i<p_vcdplayer->i_segments; i++) {
+ p_vcdplayer->segment[i].size =
+ vcdinfo_get_seg_sector_count(p_vcdobj, i);
+ p_vcdplayer->segment[i].start_LSN = vcdinfo_get_seg_lsn(p_vcdobj, i);
}
} else
- p_vcd->segment = NULL;
+ p_vcdplayer->segment = NULL;
return p_vcdobj;
vlc_value_t val;
val.i_int = i_num;
if (p_access) {
- const vcdplayer_t *p_vcd = (vcdplayer_t *)p_vcd_access->p_sys;
+ const vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_vcd_access->p_sys;
dbg_print( INPUT_DBG_PBC, "%s %d", p_debug_label, i_num );
}
if (p_label) {
VCDOpen ( vlc_object_t *p_this )
{
access_t *p_access = (access_t *)p_this;
- vcdplayer_t *p_vcd;
+ vcdplayer_t *p_vcdplayer;
char *psz_source;
vcdinfo_itemid_t itemid;
vlc_bool_t play_single_item = VLC_FALSE;
p_access->info.i_title = 0;
p_access->info.i_seekpoint = 0;
- p_vcd = malloc( sizeof(vcdplayer_t) );
+ p_vcdplayer = malloc( sizeof(vcdplayer_t) );
- if( p_vcd == NULL )
+ if( p_vcdplayer == NULL )
{
LOG_ERR ("out of memory" );
return VLC_ENOMEM;
}
- p_access->p_sys = (access_sys_t *) p_vcd;
+ p_access->p_sys = (access_sys_t *) p_vcdplayer;
/* Set where to log errors messages from libcdio. */
p_vcd_access = p_access;
if ( NULL == psz_source )
{
- free( p_vcd );
+ free( p_vcdplayer );
return( VLC_EGENERIC );
}
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "source: %s: mrl: %s",
psz_source, p_access->psz_path );
- p_vcd->psz_source = strdup(psz_source);
- p_vcd->i_debug = config_GetInt( p_this,
+ p_vcdplayer->psz_source = strdup(psz_source);
+ p_vcdplayer->i_debug = config_GetInt( p_this,
MODULE_STRING "-debug" );
- p_vcd->i_blocks_per_read = config_GetInt( p_this, MODULE_STRING
+ p_vcdplayer->i_blocks_per_read = config_GetInt( p_this, MODULE_STRING
"-blocks-per-read" );
- p_vcd->in_still = VLC_FALSE;
- p_vcd->play_item.type = VCDINFO_ITEM_TYPE_NOTFOUND;
- p_vcd->p_input = vlc_object_find( p_access, VLC_OBJECT_INPUT,
- FIND_PARENT );
- p_vcd->p_demux = vlc_object_find( p_access, VLC_OBJECT_DEMUX,
- FIND_PARENT );
- p_vcd->p_meta = vlc_meta_New();
- p_vcd->p_segments = NULL;
- p_vcd->p_entries = NULL;
+ p_vcdplayer->in_still = VLC_FALSE;
+ p_vcdplayer->play_item.type = VCDINFO_ITEM_TYPE_NOTFOUND;
+ p_vcdplayer->p_input = vlc_object_find( p_access,
+ VLC_OBJECT_INPUT,
+ FIND_PARENT );
+ p_vcdplayer->p_demux = vlc_object_find( p_access,
+ VLC_OBJECT_DEMUX,
+ FIND_PARENT );
+ p_vcdplayer->p_meta = vlc_meta_New();
+ p_vcdplayer->p_segments = NULL;
+ p_vcdplayer->p_entries = NULL;
/* set up input */
- if( !(p_vcd->vcd = vcd_Open( p_this, psz_source )) )
+ if( !(p_vcdplayer->vcd = vcd_Open( p_this, psz_source )) )
{
msg_Warn( p_access, "could not open %s", psz_source );
goto err_exit;
}
- p_vcd->b_svd= (vlc_bool_t) vcdinfo_get_tracksSVD(p_vcd->vcd);;
+ p_vcdplayer->b_svd= (vlc_bool_t) vcdinfo_get_tracksSVD(p_vcdplayer->vcd);;
/* Get track information. */
- p_vcd->i_tracks = vcdinfo_get_num_tracks(p_vcd->vcd);
+ p_vcdplayer->i_tracks = vcdinfo_get_num_tracks(p_vcdplayer->vcd);
- if( p_vcd->i_tracks < 1 || CDIO_INVALID_TRACK == p_vcd->i_tracks ) {
- vcdinfo_close( p_vcd->vcd );
+ if( p_vcdplayer->i_tracks < 1 || CDIO_INVALID_TRACK == p_vcdplayer->i_tracks ) {
+ vcdinfo_close( p_vcdplayer->vcd );
LOG_ERR ("no movie tracks found" );
goto err_exit;
}
if( ! VCDEntryPoints( p_access ) )
{
msg_Warn( p_access, "could not read entry points, will not use them" );
- p_vcd->b_valid_ep = VLC_FALSE;
+ p_vcdplayer->b_valid_ep = VLC_FALSE;
}
/* Initialize LID info and add that as a menu item */
}
/* Do we set PBC (via LID) on? */
- p_vcd->i_lid =
- ( VCDINFO_ITEM_TYPE_LID == itemid.type && p_vcd->i_lids > itemid.num )
+ p_vcdplayer->i_lid =
+ ( VCDINFO_ITEM_TYPE_LID == itemid.type
+ && p_vcdplayer->i_lids > itemid.num )
? itemid.num
: VCDINFO_INVALID_ENTRY;
play_single_item );
#endif
- p_vcd->p_intf = intf_Create( p_access, "vcdx" );
- p_vcd->p_intf->b_block = VLC_FALSE;
- p_vcd->p_access = p_access;
+ p_vcdplayer->p_intf = intf_Create( p_access, "vcdx" );
+ p_vcdplayer->p_intf->b_block = VLC_FALSE;
+ p_vcdplayer->p_access = p_access;
#ifdef FIXED
- intf_RunThread( p_vcd->p_intf );
+ intf_RunThread( p_vcdplayer->p_intf );
#endif
free( psz_source );
return VLC_SUCCESS;
err_exit:
free( psz_source );
- free( p_vcd );
+ free( p_vcdplayer );
return VLC_EGENERIC;
}
VCDClose ( vlc_object_t *p_this )
{
access_t *p_access = (access_t *)p_this;
- vcdplayer_t *p_vcd = (vcdplayer_t *)p_access->p_sys;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_access->p_sys;
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "VCDClose" );
- vcdinfo_close( p_vcd->vcd );
+ vcdinfo_close( p_vcdplayer->vcd );
- FREE_AND_NULL( p_vcd->p_entries );
- FREE_AND_NULL( p_vcd->p_segments );
- FREE_AND_NULL( p_vcd->psz_source );
- FREE_AND_NULL( p_vcd->track );
- FREE_AND_NULL( p_vcd->segment );
- FREE_AND_NULL( p_vcd->entry );
+ FREE_AND_NULL( p_vcdplayer->p_entries );
+ FREE_AND_NULL( p_vcdplayer->p_segments );
+ FREE_AND_NULL( p_vcdplayer->psz_source );
+ FREE_AND_NULL( p_vcdplayer->track );
+ FREE_AND_NULL( p_vcdplayer->segment );
+ FREE_AND_NULL( p_vcdplayer->entry );
- free( p_vcd );
+ free( p_vcdplayer );
p_access->p_sys = NULL;
p_vcd_access = NULL;
}
*****************************************************************************/
static int VCDControl( access_t *p_access, int i_query, va_list args )
{
- vcdplayer_t *p_vcd= (vcdplayer_t *)p_access->p_sys;
+ vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_access->p_sys;
int *pi_int;
int i;
dbg_print( INPUT_DBG_EVENT, "get meta info" );
- if ( p_vcd->p_meta ) {
- *pp_meta = vlc_meta_Duplicate( p_vcd->p_meta );
+ if ( p_vcdplayer->p_meta ) {
+ *pp_meta = vlc_meta_Duplicate( p_vcdplayer->p_meta );
dbg_print( INPUT_DBG_META, "%s", "Meta copied" );
} else
msg_Warn( p_access, "tried to copy NULL meta info" );
/* */
case ACCESS_GET_MTU:
pi_int = (int*)va_arg( args, int * );
- *pi_int = (p_vcd->i_blocks_per_read * M2F2_SECTOR_SIZE);
+ *pi_int = (p_vcdplayer->i_blocks_per_read * M2F2_SECTOR_SIZE);
dbg_print( INPUT_DBG_EVENT, "GET MTU: %d", *pi_int );
break;
case ACCESS_GET_TITLE_INFO:
{
unsigned int psz_mrl_max = strlen(VCD_MRL_PREFIX)
- + strlen(p_vcd->psz_source) + sizeof("@E999")+3;
+ + strlen(p_vcdplayer->psz_source) + sizeof("@E999")+3;
input_title_t ***ppp_title
= (input_title_t***)va_arg( args, input_title_t*** );
char *psz_mrl = malloc( psz_mrl_max );
pi_int = (int*)va_arg( args, int* );
dbg_print( INPUT_DBG_EVENT, "GET TITLE: i_titles %d",
- p_vcd->i_titles );
+ p_vcdplayer->i_titles );
if( psz_mrl == NULL ) {
msg_Warn( p_access, "out of memory" );
} else {
snprintf(psz_mrl, psz_mrl_max, "%s%s",
- VCD_MRL_PREFIX, p_vcd->psz_source);
+ VCD_MRL_PREFIX, p_vcdplayer->psz_source);
VCDMetaInfo( p_access, psz_mrl );
free(psz_mrl);
}
/* Duplicate title info */
- if( p_vcd->i_titles == 0 )
+ if( p_vcdplayer->i_titles == 0 )
{
*pi_int = 0; ppp_title = NULL;
return VLC_SUCCESS;
}
- *pi_int = p_vcd->i_titles;
- *ppp_title = malloc(sizeof( input_title_t **) * p_vcd->i_titles );
-
+ *pi_int = p_vcdplayer->i_titles;
+ *ppp_title = malloc( sizeof( input_title_t **)
+ * p_vcdplayer->i_titles );
+
if (!*ppp_title) return VLC_ENOMEM;
- for( i = 0; i < p_vcd->i_titles; i++ )
+ for( i = 0; i < p_vcdplayer->i_titles; i++ )
{
- if ( p_vcd->p_title[i] )
+ if ( p_vcdplayer->p_title[i] )
(*ppp_title)[i] =
- vlc_input_title_Duplicate( p_vcd->p_title[i] );
+ vlc_input_title_Duplicate( p_vcdplayer->p_title[i] );
}
}
break;
vcdinfo_itemid_t itemid;
track_t i_track = i+1;
unsigned int i_entry =
- vcdinfo_track_get_entry( p_vcd->vcd, i_track);
+ vcdinfo_track_get_entry( p_vcdplayer->vcd, i_track);
/* FIXME! For now we are assuming titles are only
tracks and that track == title+1 */
itemid.type = VCDINFO_ITEM_TYPE_TRACK;
VCDSetOrigin(p_access,
- vcdinfo_get_entry_lba(p_vcd->vcd, i_entry),
+ vcdinfo_get_entry_lba(p_vcdplayer->vcd, i_entry),
i_track, &itemid );
}
break;
case ACCESS_SET_SEEKPOINT:
{
- input_title_t *t = p_vcd->p_title[p_access->info.i_title];
+ input_title_t *t = p_vcdplayer->p_title[p_access->info.i_title];
unsigned int i = (unsigned int)va_arg( args, unsigned int );
dbg_print( INPUT_DBG_EVENT, "set seekpoint %d", i );
We need to generalize all of this.
*/
- if (i < p_vcd->i_entries)
+ if (i < p_vcdplayer->i_entries)
{
- p_vcd->play_item.num = i;
- p_vcd->play_item.type = VCDINFO_ITEM_TYPE_ENTRY;
- lsn = vcdinfo_get_entry_lba(p_vcd->vcd, i);
- } else if ( i < p_vcd->i_entries + p_vcd->i_lids )
+ p_vcdplayer->play_item.num = i;
+ p_vcdplayer->play_item.type = VCDINFO_ITEM_TYPE_ENTRY;
+ lsn = vcdinfo_get_entry_lba(p_vcdplayer->vcd, i);
+ } else if ( i < p_vcdplayer->i_entries + p_vcdplayer->i_lids )
{
- p_vcd->play_item.num = i = i - p_vcd->i_entries;
- p_vcd->play_item.type = VCDINFO_ITEM_TYPE_LID;
+ p_vcdplayer->play_item.num = i
+ = i - p_vcdplayer->i_entries;
+ p_vcdplayer->play_item.type = VCDINFO_ITEM_TYPE_LID;
lsn = 0;
} else
{
- p_vcd->play_item.num = i = i - p_vcd->i_entries
- - p_vcd->i_lids;
- p_vcd->play_item.type = VCDINFO_ITEM_TYPE_SEGMENT;
- lsn = vcdinfo_get_seg_lsn(p_vcd->vcd, i);
+ p_vcdplayer->play_item.num = i
+ = i - p_vcdplayer->i_entries - p_vcdplayer->i_lids;
+ p_vcdplayer->play_item.type = VCDINFO_ITEM_TYPE_SEGMENT;
+ lsn = vcdinfo_get_seg_lsn(p_vcdplayer->vcd, i);
}
VCDSetOrigin( p_access,
- vcdinfo_get_entry_lba(p_vcd->vcd, i),
- i_track, &(p_vcd->play_item) );
+ vcdinfo_get_entry_lba(p_vcdplayer->vcd, i),
+ i_track, &(p_vcdplayer->play_item) );
}
return VLC_SUCCESS;
}
projects / vlc / blobdiff