X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Faccess%2Fvcdx%2Faccess.c;h=5c1dafad5b05373eb4453bca0b1144db10036155;hb=79053042f17a929d8fd175cc51d989f1f6abdba9;hp=7c5835fbee7faab16d98527295f609e58481b69b;hpb=8b492795fec291bd5dff480610306e8b95e20e58;p=vlc diff --git a/modules/access/vcdx/access.c b/modules/access/vcdx/access.c index 7c5835fbee..5c1dafad5b 100644 --- a/modules/access/vcdx/access.c +++ b/modules/access/vcdx/access.c @@ -87,11 +87,11 @@ static access_t *p_vcd_access = NULL; 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: @@ -113,11 +113,11 @@ cdio_log_handler (cdio_log_level_t level, const char message[]) 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: @@ -142,16 +142,16 @@ vcd_log_handler (vcd_log_level_t level, const char message[]) 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 ) ) ) @@ -213,7 +213,7 @@ VCDReadBlock( access_t * p_access ) 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 @@ -235,16 +235,17 @@ VCDReadBlock( access_t * p_access ) 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) ); } } } @@ -262,30 +263,30 @@ VCDSeek( access_t * p_access, int64_t i_pos ) 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" ); @@ -297,15 +298,15 @@ VCDSeek( access_t * p_access, int64_t i_pos ) 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 */ @@ -340,11 +341,12 @@ VCDEntryPoints( access_t * p_access ) 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) { @@ -352,43 +354,43 @@ VCDEntryPoints( access_t * p_access ) 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; } } @@ -399,19 +401,19 @@ VCDEntryPoints( access_t * p_access ) 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")); @@ -419,18 +421,19 @@ VCDSegments( access_t * p_access ) /* 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 ); @@ -440,9 +443,10 @@ VCDSegments( access_t * p_access ) 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; } @@ -465,15 +469,17 @@ VCDTitles( access_t * p_access ) 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 ); @@ -484,7 +490,7 @@ VCDTitles( access_t * p_access ) 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; @@ -497,21 +503,21 @@ VCDTitles( access_t * p_access ) 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 /* @@ -520,8 +526,8 @@ VCDLIDs( access_t * p_access ) 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 } @@ -530,8 +536,8 @@ VCDLIDs( access_t * p_access ) 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(); @@ -547,10 +553,10 @@ VCDLIDs( access_t * p_access ) } #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; @@ -563,7 +569,7 @@ static char * 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; @@ -683,7 +689,7 @@ void 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, @@ -691,18 +697,18 @@ VCDSetOrigin( access_t *p_access, lsn_t i_lsn, track_t i_track, 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; @@ -713,21 +719,21 @@ VCDSetOrigin( access_t *p_access, lsn_t i_lsn, track_t i_track, 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 ); } @@ -743,7 +749,7 @@ static vcdinfo_obj_t * 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; @@ -764,41 +770,43 @@ vcd_Open( vlc_object_t *p_this, const char *psz_dev ) 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; ii_tracks; i++) { + for (i=0; ii_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; ii_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; ii_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; ii_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; ii_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; @@ -815,7 +823,7 @@ VCDUpdateVar( access_t *p_access, int i_num, int i_action, 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) { @@ -844,7 +852,7 @@ int 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; @@ -861,15 +869,15 @@ VCDOpen ( vlc_object_t *p_this ) 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; @@ -880,43 +888,45 @@ VCDOpen ( vlc_object_t *p_this ) 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; } @@ -928,7 +938,7 @@ VCDOpen ( vlc_object_t *p_this ) 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 */ @@ -938,8 +948,9 @@ VCDOpen ( vlc_object_t *p_this ) } /* 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; @@ -956,12 +967,12 @@ VCDOpen ( vlc_object_t *p_this ) 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 ); @@ -969,7 +980,7 @@ VCDOpen ( vlc_object_t *p_this ) return VLC_SUCCESS; err_exit: free( psz_source ); - free( p_vcd ); + free( p_vcdplayer ); return VLC_EGENERIC; } @@ -980,20 +991,20 @@ void 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; } @@ -1005,7 +1016,7 @@ VCDClose ( vlc_object_t *p_this ) *****************************************************************************/ 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; @@ -1023,8 +1034,8 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) 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" ); @@ -1050,7 +1061,7 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) /* */ 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; @@ -1073,7 +1084,7 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) 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 ); @@ -1082,33 +1093,34 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) 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; @@ -1122,7 +1134,7 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) 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 */ @@ -1130,14 +1142,14 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) 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 ); @@ -1152,27 +1164,28 @@ static int VCDControl( access_t *p_access, int i_query, va_list args ) 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; }