Skip to content

V
vlc-2-2
Commit 3a9b48da authored by Clément Stenac's avatar Clément Stenac
Browse files
Options

CDDAX: 

    - coding style fixes
    - adapted to new playlist API
    - only put generic things in Meta-information

wxWidgets:
    - Fixed playlist updating

core:
    - added playlist_ItemGetByInput
    - implemented input_item_t.b_fixed name : if this is set, the interface should not try to "improve" the display string.
parent 180ca722
Hide whitespace changes
Inline Side-by-side
Showing with 880 additions and 743 deletions
include/vlc_input.h
View file @ 3a9b48da
...@@ -62,6 +62,8 @@ struct input_item_t ...@@ -62,6 +62,8 @@ struct input_item_t
int i_es; /**< Number of es format descriptions */ int i_es; /**< Number of es format descriptions */
es_format_t **es; /**< Pointer to an array of es formats */ es_format_t **es; /**< Pointer to an array of es formats */
vlc_bool_t b_fixed_name; /**< Can the interface change the name ?*/
vlc_mutex_t lock; /**< Item cannot be changed without this lock */ vlc_mutex_t lock; /**< Item cannot be changed without this lock */
}; };
...@@ -85,6 +87,7 @@ static inline void vlc_input_item_Init( vlc_object_t *p_o, input_item_t *p_i ) ...@@ -85,6 +87,7 @@ static inline void vlc_input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
p_i->pp_categories = 0; p_i->pp_categories = 0;
p_i->es = 0; p_i->es = 0;
p_i->i_type = ITEM_TYPE_UNKNOWN; p_i->i_type = ITEM_TYPE_UNKNOWN;
p_i->b_fixed_name = VLC_TRUE;
vlc_mutex_init( p_o, &p_i->lock ); vlc_mutex_init( p_o, &p_i->lock );
} }
......
modules/access/cdda/access.c
View file @ 3a9b48da
...@@ -63,8 +63,8 @@ access_t *p_cdda_input = NULL; ...@@ -63,8 +63,8 @@ access_t *p_cdda_input = NULL;
*****************************************************************************/ *****************************************************************************/
static block_t *CDDAReadBlocks( access_t * p_access ); static block_t *CDDAReadBlocks( access_t * p_access );
static int CDDASeek( access_t * p_access, int64_t i_pos ); static int CDDASeek( access_t * p_access, int64_t i_pos );
static int CDDAControl( access_t *p_access, int i_query, static int CDDAControl( access_t *p_access, int i_query,
va_list args ); va_list args );
static int CDDAInit( access_t *p_access, cdda_data_t *p_cdda ) ; static int CDDAInit( access_t *p_access, cdda_data_t *p_cdda ) ;
...@@ -111,15 +111,17 @@ cdio_log_handler (cdio_log_level_t level, const char message[]) ...@@ -111,15 +111,17 @@ cdio_log_handler (cdio_log_level_t level, const char message[])
static void static void
cddb_log_handler (cddb_log_level_t level, const char message[]) cddb_log_handler (cddb_log_level_t level, const char message[])
{ {
cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_sys; cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
switch (level) { switch (level)
case CDDB_LOG_DEBUG: {
case CDDB_LOG_INFO: case CDDB_LOG_DEBUG:
if (!(p_cdda->i_debug & INPUT_DBG_CDDB)) return; case CDDB_LOG_INFO:
/* Fall through if to warn case */ if (!(p_cdda->i_debug & INPUT_DBG_CDDB)) return;
default:
cdio_log_handler (level, message); /* Fall through if to warn case */
} default:
cdio_log_handler (level, message);
}
} }
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
...@@ -130,34 +132,35 @@ cddb_log_handler (cddb_log_level_t level, const char message[]) ...@@ -130,34 +132,35 @@ cddb_log_handler (cddb_log_level_t level, const char message[])
static void static void
uninit_log_handler (cdio_log_level_t level, const char message[]) uninit_log_handler (cdio_log_level_t level, const char message[])
{ {
cdda_data_t *p_cdda = NULL; cdda_data_t *p_cdda = NULL;
if (p_cdda_input) if (p_cdda_input)
p_cdda = (cdda_data_t *)p_cdda_input->p_sys; p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
switch (level) { switch (level)
case CDIO_LOG_DEBUG: {
case CDIO_LOG_INFO: case CDIO_LOG_DEBUG:
if (!p_cdda || !(p_cdda->i_debug & (INPUT_DBG_CDIO|INPUT_DBG_CDDB))) case CDIO_LOG_INFO:
return; if (!p_cdda || !(p_cdda->i_debug & (INPUT_DBG_CDIO|INPUT_DBG_CDDB)))
/* Fall through if to warn case */ return;
case CDIO_LOG_WARN:
fprintf(stderr, "WARN: %s\n", message); /* Fall through if to warn case */
break; case CDIO_LOG_WARN:
case CDIO_LOG_ERROR: fprintf(stderr, "WARN: %s\n", message);
fprintf(stderr, "ERROR: %s\n", message); break;
break; case CDIO_LOG_ERROR:
case CDIO_LOG_ASSERT: fprintf(stderr, "ERROR: %s\n", message);
fprintf(stderr, "ASSERT ERROR: %s\n", message); break;
break; case CDIO_LOG_ASSERT:
default: fprintf(stderr, "ASSERT ERROR: %s\n", message);
fprintf(stderr, "UNKNOWN ERROR: %s\n%s %d\n", break;
message, default:
"The above message had unknown cdio log level", fprintf(stderr, "UNKNOWN ERROR: %s\n%s %d\n", message,
level); "The above message had unknown cdio log level",
} level);
}
/* gl_default_cdio_log_handler (level, message); */ /* gl_default_cdio_log_handler (level, message); */
} }
/***************************************************************************** /*****************************************************************************
...@@ -166,15 +169,14 @@ uninit_log_handler (cdio_log_level_t level, const char message[]) ...@@ -166,15 +169,14 @@ uninit_log_handler (cdio_log_level_t level, const char message[])
* read. It is also possible if we haven't read a RIFF header in which * read. It is also possible if we haven't read a RIFF header in which
* case one that we creaded during Open/Initialization is returned. * case one that we creaded during Open/Initialization is returned.
*****************************************************************************/ *****************************************************************************/
static block_t * static block_t * CDDAReadBlocks( access_t * p_access )
CDDAReadBlocks( access_t * p_access )
{ {
block_t *p_block; block_t *p_block;
cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys; cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
int i_blocks = p_cdda->i_blocks_per_read; int i_blocks = p_cdda->i_blocks_per_read;
dbg_print((INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_LSN), "called %d", dbg_print((INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_LSN), "called %d",
p_cdda->i_lsn); p_cdda->i_lsn);
/* Check end of file */ /* Check end of file */
if( p_access->info.b_eof ) return NULL; if( p_access->info.b_eof ) return NULL;
...@@ -199,10 +201,10 @@ CDDAReadBlocks( access_t * p_access ) ...@@ -199,10 +201,10 @@ CDDAReadBlocks( access_t * p_access )
p_access->info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SIZE; p_access->info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SIZE;
p_access->info.i_title++; p_access->info.i_title++;
p_access->info.i_size = p_access->info.i_size =
p_cdda->p_title[p_access->info.i_title]->i_size; p_cdda->p_title[p_access->info.i_title]->i_size;
p_access->info.i_pos = 0; p_access->info.i_pos = 0;
p_cdda->i_track++; p_cdda->i_track++;
} }
/* Possibly adjust i_blocks so we don't read past the end of a track. */ /* Possibly adjust i_blocks so we don't read past the end of a track. */
...@@ -216,26 +218,26 @@ CDDAReadBlocks( access_t * p_access ) ...@@ -216,26 +218,26 @@ CDDAReadBlocks( access_t * p_access )
if( !p_block) if( !p_block)
{ {
msg_Err( p_access, "Cannot get a new block of size: %i", msg_Err( p_access, "Cannot get a new block of size: %i",
i_blocks * CDIO_CD_FRAMESIZE_RAW ); i_blocks * CDIO_CD_FRAMESIZE_RAW );
return NULL; return NULL;
} }
if( cdio_read_audio_sectors( p_cdda->p_cdio, p_block->p_buffer, if( cdio_read_audio_sectors( p_cdda->p_cdio, p_block->p_buffer,
p_cdda->i_lsn, i_blocks) != 0 ) p_cdda->i_lsn, i_blocks) != 0 )
{ {
msg_Err( p_access, "could not read sector %lu", msg_Err( p_access, "could not read sector %lu",
(long unsigned int) p_cdda->i_lsn ); (long unsigned int) p_cdda->i_lsn );
block_Release( p_block ); block_Release( p_block );
/* If we had problems above, assume the problem is with /* If we had problems above, assume the problem is with
the first sector of the read and set to skip it. In the first sector of the read and set to skip it. In
the future libcdio may have cdparanoia support. the future libcdio may have cdparanoia support.
*/ */
p_cdda->i_lsn++; p_cdda->i_lsn++;
p_access->info.i_pos += CDIO_CD_FRAMESIZE_RAW; p_access->info.i_pos += CDIO_CD_FRAMESIZE_RAW;
return NULL; return NULL;
} }
p_cdda->i_lsn += i_blocks; p_cdda->i_lsn += i_blocks;
p_access->info.i_pos += p_block->i_buffer; p_access->info.i_pos += p_block->i_buffer;
...@@ -246,8 +248,7 @@ CDDAReadBlocks( access_t * p_access ) ...@@ -246,8 +248,7 @@ CDDAReadBlocks( access_t * p_access )
* CDDASeek - change position for subsequent reads. For example, this * CDDASeek - change position for subsequent reads. For example, this
* can happen if the user moves a position slider bar in a GUI. * can happen if the user moves a position slider bar in a GUI.
****************************************************************************/ ****************************************************************************/
static int static int CDDASeek( access_t * p_access, int64_t i_pos )
CDDASeek( access_t * p_access, int64_t i_pos )
{ {
cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys; cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
...@@ -256,8 +257,8 @@ CDDASeek( access_t * p_access, int64_t i_pos ) ...@@ -256,8 +257,8 @@ CDDASeek( access_t * p_access, int64_t i_pos )
p_access->info.i_pos = i_pos; p_access->info.i_pos = i_pos;
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_SEEK), dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_SEEK),
"lsn %lu, offset: %lld", "lsn %lu, offset: %lld",
(long unsigned int) p_cdda->i_lsn, i_pos ); (long unsigned int) p_cdda->i_lsn, i_pos );
return VLC_SUCCESS; return VLC_SUCCESS;
} }
...@@ -266,11 +267,10 @@ CDDASeek( access_t * p_access, int64_t i_pos ) ...@@ -266,11 +267,10 @@ CDDASeek( access_t * p_access, int64_t i_pos )
****************************************************************************/ ****************************************************************************/
/***************************************************************************** /*****************************************************************************
* Open: open cdda device or image file and initialize structures * Open: open cdda device or image file and initialize structures
* for subsequent operations. * for subsequent operations.
*****************************************************************************/ *****************************************************************************/
int int E_(CDDAOpen)( vlc_object_t *p_this )
E_(CDDAOpen)( vlc_object_t *p_this )
{ {
access_t *p_access = (access_t*)p_this; access_t *p_access = (access_t*)p_this;
char * psz_source = NULL; char * psz_source = NULL;
...@@ -289,51 +289,53 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -289,51 +289,53 @@ E_(CDDAOpen)( vlc_object_t *p_this )
if( p_access->psz_path && *p_access->psz_path ) if( p_access->psz_path && *p_access->psz_path )
{ {
char *psz_parser = psz_source = strdup( p_access->psz_path ); char *psz_parser = psz_source = strdup( p_access->psz_path );
while( *psz_parser && *psz_parser != '@' ) while( *psz_parser && *psz_parser != '@' )
{ {
psz_parser++; psz_parser++;
} }
if( *psz_parser == '@' ) if( *psz_parser == '@' )
{ {
/* Found options */ /* Found options */
*psz_parser = '\0'; *psz_parser = '\0';
++psz_parser; ++psz_parser;
if ('T' == *psz_parser || 't' == *psz_parser ) if ('T' == *psz_parser || 't' == *psz_parser )
++psz_parser; ++psz_parser;
i_track = (int)strtol( psz_parser, NULL, 10 ); i_track = (int)strtol( psz_parser, NULL, 10 );
i_track = i_track ? i_track : 1; i_track = i_track ? i_track : 1;
b_single_track = true; b_single_track = true;
} }
} }
if (!psz_source || !*psz_source) if (!psz_source || !*psz_source)
{ {
/* No device/track given. Continue only when this plugin was /* No device/track given. Continue only when this plugin was
selected */ selected */
if( !p_this->b_force ) return VLC_EGENERIC; if( !p_this->b_force ) return VLC_EGENERIC;
psz_source = var_CreateGetString( p_this, "cd-audio" ); psz_source = var_CreateGetString( p_this, "cd-audio" );
if( !psz_source || !*psz_source ) { if( !psz_source || !*psz_source )
/* Scan for a CD-ROM drive with a CD-DA in it. */ {
char **cd_drives = /* Scan for a CD-ROM drive with a CD-DA in it. */
cdio_get_devices_with_cap(NULL, CDIO_FS_AUDIO, false); char **cd_drives =
cdio_get_devices_with_cap(NULL, CDIO_FS_AUDIO, false);
if (NULL == cd_drives || NULL == cd_drives[0] ) {
msg_Err( p_access, if (NULL == cd_drives || NULL == cd_drives[0] )
"libcdio couldn't find something with a CD-DA in it" ); {
if (cd_drives) cdio_free_device_list(cd_drives); msg_Err( p_access,
return VLC_EGENERIC; "libcdio couldn't find something with a CD-DA in it" );
} if (cd_drives) cdio_free_device_list(cd_drives);
return VLC_EGENERIC;
psz_source = strdup(cd_drives[0]); }
cdio_free_device_list(cd_drives);
} psz_source = strdup(cd_drives[0]);
cdio_free_device_list(cd_drives);
}
} }
cdio_log_set_handler ( cdio_log_handler ); cdio_log_set_handler ( cdio_log_handler );
...@@ -342,7 +344,7 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -342,7 +344,7 @@ E_(CDDAOpen)( vlc_object_t *p_this )
if( !(p_cdio = cdio_open( psz_source, DRIVER_UNKNOWN )) ) if( !(p_cdio = cdio_open( psz_source, DRIVER_UNKNOWN )) )
{ {
msg_Warn( p_access, "could not open %s", psz_source ); msg_Warn( p_access, "could not open %s", psz_source );
goto error2; goto error2;
} }
p_cdda = malloc( sizeof(cdda_data_t) ); p_cdda = malloc( sizeof(cdda_data_t) );
...@@ -375,23 +377,23 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -375,23 +377,23 @@ E_(CDDAOpen)( vlc_object_t *p_this )
p_cdda->i_blocks_per_read p_cdda->i_blocks_per_read
= config_GetInt(p_this, MODULE_STRING "-blocks-per-read"); = config_GetInt(p_this, MODULE_STRING "-blocks-per-read");
p_cdda->p_input = vlc_object_find( p_access, VLC_OBJECT_INPUT, p_cdda->p_input = vlc_object_find( p_access, VLC_OBJECT_INPUT,
FIND_PARENT ); FIND_PARENT );
if (0 == p_cdda->i_blocks_per_read) if (0 == p_cdda->i_blocks_per_read)
p_cdda->i_blocks_per_read = DEFAULT_BLOCKS_PER_READ; p_cdda->i_blocks_per_read = DEFAULT_BLOCKS_PER_READ;
if ( p_cdda->i_blocks_per_read < MIN_BLOCKS_PER_READ
|| p_cdda->i_blocks_per_read > MAX_BLOCKS_PER_READ ) {
msg_Warn( p_cdda_input,
"Number of blocks (%d) has to be between %d and %d. "
"Using %d.",
p_cdda->i_blocks_per_read,
MIN_BLOCKS_PER_READ, MAX_BLOCKS_PER_READ,
DEFAULT_BLOCKS_PER_READ );
p_cdda->i_blocks_per_read = DEFAULT_BLOCKS_PER_READ;
}
if ( p_cdda->i_blocks_per_read < MIN_BLOCKS_PER_READ
|| p_cdda->i_blocks_per_read > MAX_BLOCKS_PER_READ )
{
msg_Warn( p_cdda_input,
"Number of blocks (%d) has to be between %d and %d. "
"Using %d.",
p_cdda->i_blocks_per_read,
MIN_BLOCKS_PER_READ, MAX_BLOCKS_PER_READ,
DEFAULT_BLOCKS_PER_READ );
p_cdda->i_blocks_per_read = DEFAULT_BLOCKS_PER_READ;
}
dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "%s", psz_source ); dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "%s", psz_source );
...@@ -415,8 +417,8 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -415,8 +417,8 @@ E_(CDDAOpen)( vlc_object_t *p_this )
if ( VLC_SUCCESS != i_rc ) goto error; if ( VLC_SUCCESS != i_rc ) goto error;
CDDAFixupPlaylist( p_access, p_cdda, psz_source, b_single_track ); CDDAFixupPlaylist( p_access, p_cdda, psz_source, b_single_track );
/* Build a WAV header to put in front of the output data. /* Build a WAV header to put in front of the output data.
This gets sent back in the Block (read) routine. This gets sent back in the Block (read) routine.
*/ */
memset( &p_cdda->waveheader, 0, sizeof(WAVEHEADER) ); memset( &p_cdda->waveheader, 0, sizeof(WAVEHEADER) );
...@@ -432,13 +434,14 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -432,13 +434,14 @@ E_(CDDAOpen)( vlc_object_t *p_this )
SetWLE( &p_cdda->waveheader.BytesPerSample, SetWLE( &p_cdda->waveheader.BytesPerSample,
2 /*Modus*/ * 16 /*BitsPerSample*/ / 8 ); 2 /*Modus*/ * 16 /*BitsPerSample*/ / 8 );
SetDWLE( &p_cdda->waveheader.BytesPerSec, SetDWLE( &p_cdda->waveheader.BytesPerSec,
2*16/8 /*BytesPerSample*/ * CDDA_FREQUENCY_SAMPLE ); 2*16/8 /*BytesPerSample*/ * CDDA_FREQUENCY_SAMPLE );
p_cdda->waveheader.DataChunkID = VLC_FOURCC('d', 'a', 't', 'a'); p_cdda->waveheader.DataChunkID = VLC_FOURCC('d', 'a', 't', 'a');
p_cdda->waveheader.DataLength = 0; /* we just don't know */ p_cdda->waveheader.DataLength = 0; /* we just don't know */
/* PTS delay */ /* PTS delay */
var_Create( p_access, MODULE_STRING "-caching", var_Create( p_access, MODULE_STRING "-caching",
VLC_VAR_INTEGER|VLC_VAR_DOINHERIT ); VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
vlc_object_release( p_cdda->p_input );
return VLC_SUCCESS; return VLC_SUCCESS;
error: error:
...@@ -446,6 +449,7 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -446,6 +449,7 @@ E_(CDDAOpen)( vlc_object_t *p_this )
free( p_cdda ); free( p_cdda );
error2: error2:
free( psz_source ); free( psz_source );
vlc_object_release( p_cdda->p_input );
return i_rc; return i_rc;
} }
...@@ -453,8 +457,7 @@ E_(CDDAOpen)( vlc_object_t *p_this ) ...@@ -453,8 +457,7 @@ E_(CDDAOpen)( vlc_object_t *p_this )
/***************************************************************************** /*****************************************************************************
* CDDAClose: closes cdda and frees any resources associded with it. * CDDAClose: closes cdda and frees any resources associded with it.
*****************************************************************************/ *****************************************************************************/
void void E_(CDDAClose)( vlc_object_t *p_this )
E_(CDDAClose)( vlc_object_t *p_this )
{ {
access_t *p_access = (access_t *) p_this; access_t *p_access = (access_t *) p_this;
cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys; cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
...@@ -500,73 +503,83 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args ) ...@@ -500,73 +503,83 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args )
switch( i_query ) switch( i_query )
{ {
/* Pass back a copy of meta information that was gathered when we /* Pass back a copy of meta information that was gathered when we
during the Open/Initialize call. during the Open/Initialize call.
*/ */
case ACCESS_GET_META: case ACCESS_GET_META:
{ {
vlc_meta_t **pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** ); vlc_meta_t **pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
if ( p_cdda->p_meta ) { if ( p_cdda->p_meta )
*pp_meta = vlc_meta_Duplicate( p_cdda->p_meta ); {
dbg_print( INPUT_DBG_META, "%s", "Meta copied" ); *pp_meta = vlc_meta_Duplicate( p_cdda->p_meta );
} else dbg_print( INPUT_DBG_META, "%s", "Meta copied" );
msg_Warn( p_access, "tried to copy NULL meta info" ); }
else
return VLC_SUCCESS; msg_Warn( p_access, "tried to copy NULL meta info" );
}
return VLC_EGENERIC; return VLC_SUCCESS;
}
case ACCESS_CAN_SEEK: case ACCESS_CAN_SEEK:
case ACCESS_CAN_FASTSEEK: case ACCESS_CAN_FASTSEEK:
case ACCESS_CAN_PAUSE: case ACCESS_CAN_PAUSE:
case ACCESS_CAN_CONTROL_PACE: case ACCESS_CAN_CONTROL_PACE:
{ {
vlc_bool_t *pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* ); vlc_bool_t *pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
*pb_bool = VLC_TRUE; *pb_bool = VLC_TRUE;
break; return VLC_SUCCESS;;
} }
/* */ /* */
case ACCESS_GET_MTU: case ACCESS_GET_MTU:
{
pi_int = (int*)va_arg( args, int * ); pi_int = (int*)va_arg( args, int * );
*pi_int = p_cdda-> i_blocks_per_read * CDIO_CD_FRAMESIZE_RAW; *pi_int = p_cdda-> i_blocks_per_read * CDIO_CD_FRAMESIZE_RAW;
break; break;
}
case ACCESS_GET_PTS_DELAY: case ACCESS_GET_PTS_DELAY:
{ {
int64_t *pi_64 = (int64_t*)va_arg( args, int64_t * ); int64_t *pi_64 = (int64_t*)va_arg( args, int64_t * );
*pi_64 = var_GetInteger( p_access, MODULE_STRING "-caching" ) *pi_64 = var_GetInteger( p_access, MODULE_STRING "-caching" )
* MILLISECONDS_PER_SEC; * MILLISECONDS_PER_SEC;
break; break;
} }
/* */ /* */
case ACCESS_SET_PAUSE_STATE: case ACCESS_SET_PAUSE_STATE:
break; break;
case ACCESS_GET_TITLE_INFO: case ACCESS_GET_TITLE_INFO:
{ input_title_t ***ppp_title; {
input_title_t ***ppp_title;
ppp_title = (input_title_t***)va_arg( args, input_title_t*** ); ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
pi_int = (int*)va_arg( args, int* ); pi_int = (int*)va_arg( args, int* );
*((int*)va_arg( args, int* )) = 1; /* Title offset */ *((int*)va_arg( args, int* )) = 1; /* Title offset */
/* Duplicate title info */ /* Duplicate title info */
/*** printf("+++ i_tracks %d, i_titles %d\n", printf("+++ i_tracks %d, i_titles %d\n",
p_cdda->i_tracks, p_cdda->i_titles); ***/ p_cdda->i_tracks, p_cdda->i_titles);
if( p_cdda->i_titles == 0 )
{
*pi_int = 0; ppp_title = NULL;
return VLC_SUCCESS;
}
*pi_int = p_cdda->i_titles; *pi_int = p_cdda->i_titles;
*ppp_title = malloc(sizeof( input_title_t **) * p_cdda->i_titles ); *ppp_title = malloc(sizeof( input_title_t **) * p_cdda->i_titles );
if (!*ppp_title) return VLC_ENOMEM; if (!*ppp_title) return VLC_ENOMEM;
for( i = 0; i < p_cdda->i_titles; i++ ) for( i = 0; i < p_cdda->i_titles; i++ )
{ {
if ( p_cdda->p_title[i] ) if ( p_cdda->p_title[i] )
(*ppp_title)[i] = (*ppp_title)[i] =
vlc_input_title_Duplicate( p_cdda->p_title[i] ); vlc_input_title_Duplicate( p_cdda->p_title[i] );
} }
} break;
break; }
case ACCESS_SET_TITLE: case ACCESS_SET_TITLE:
{
i = (int)va_arg( args, int ); i = (int)va_arg( args, int );
if( i != p_access->info.i_title ) if( i != p_access->info.i_title )
{ {
...@@ -581,13 +594,14 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args ) ...@@ -581,13 +594,14 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args )
p_cdda->i_lsn = p_cdda->lsn[p_cdda->i_first_track+i]; p_cdda->i_lsn = p_cdda->lsn[p_cdda->i_first_track+i];
} }
break; break;
}
case ACCESS_SET_SEEKPOINT: case ACCESS_SET_SEEKPOINT:
case ACCESS_SET_PRIVATE_ID_STATE: case ACCESS_SET_PRIVATE_ID_STATE:
return VLC_EGENERIC; return VLC_EGENERIC;
default: default:
msg_Warn( p_access, "unimplemented query in control" ); msg_Warn( p_access, "unimplemented query in control" );
return VLC_EGENERIC; return VLC_EGENERIC;
} }
...@@ -595,7 +609,7 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args ) ...@@ -595,7 +609,7 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args )
} }
/***************************************************************************** /*****************************************************************************
CDDAInit: CDDAInit:
Initialize information pertaining to the CD: the number of tracks, Initialize information pertaining to the CD: the number of tracks,
first track number, LSNs for each track and the leadout. The leadout first track number, LSNs for each track and the leadout. The leadout
...@@ -607,8 +621,7 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args ) ...@@ -607,8 +621,7 @@ static int CDDAControl( access_t *p_access, int i_query, va_list args )
We return the VLC-type status, e.g. VLC_SUCCESS, VLC_ENOMEM, etc. We return the VLC-type status, e.g. VLC_SUCCESS, VLC_ENOMEM, etc.
*****************************************************************************/ *****************************************************************************/
static int static int CDDAInit( access_t *p_access, cdda_data_t *p_cdda )
CDDAInit( access_t *p_access, cdda_data_t *p_cdda )
{ {
track_t i; track_t i;
discmode_t discmode = CDIO_DISC_MODE_NO_INFO; discmode_t discmode = CDIO_DISC_MODE_NO_INFO;
...@@ -620,26 +633,26 @@ CDDAInit( access_t *p_access, cdda_data_t *p_cdda ) ...@@ -620,26 +633,26 @@ CDDAInit( access_t *p_access, cdda_data_t *p_cdda )
switch(discmode) { switch(discmode) {
case CDIO_DISC_MODE_CD_DA: case CDIO_DISC_MODE_CD_DA:
case CDIO_DISC_MODE_CD_MIXED: case CDIO_DISC_MODE_CD_MIXED:
/* These are possible for CD-DA */ /* These are possible for CD-DA */
break; break;
default: default:
/* These are not possible for CD-DA */ /* These are not possible for CD-DA */
msg_Err( p_access, msg_Err( p_access,
"Disc seems not to be CD-DA. libcdio reports it is %s", "Disc seems not to be CD-DA. libcdio reports it is %s",
discmode2str[discmode] discmode2str[discmode]
); );
return VLC_EGENERIC; return VLC_EGENERIC;
} }
/* Fill the lsn array with the track/sector matches. /* Fill the lsn array with the track/sector matches.
Note cdio_get_track_lsn when given num_tracks + 1 will return Note cdio_get_track_lsn when given num_tracks + 1 will return
the leadout LSN. the leadout LSN.
*/ */
for( i = 0 ; i <= p_cdda->i_tracks ; i++ ) for( i = 0 ; i <= p_cdda->i_tracks ; i++ )
{ {
track_t i_track = p_cdda->i_first_track + i; track_t i_track = p_cdda->i_first_track + i;
(p_cdda->lsn)[ i_track ] = cdio_get_track_lsn(p_cdda->p_cdio, i_track); (p_cdda->lsn)[ i_track ] = cdio_get_track_lsn(p_cdda->p_cdio, i_track);
} }
/* Set reading start LSN. */ /* Set reading start LSN. */
p_cdda->i_lsn = p_cdda->lsn[p_cdda->i_track]; p_cdda->i_lsn = p_cdda->lsn[p_cdda->i_track];
......
modules/access/cdda/callback.c
View file @ 3a9b48da
...@@ -26,20 +26,21 @@ ...@@ -26,20 +26,21 @@
int int
E_(CDDADebugCB) ( vlc_object_t *p_this, const char *psz_name, E_(CDDADebugCB) ( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oldval, vlc_value_t val, void *p_data ) vlc_value_t oldval, vlc_value_t val, void *p_data )
{ {
cdda_data_t *p_cdda; cdda_data_t *p_cdda;
if (NULL == p_cdda_input) return VLC_EGENERIC; if (NULL == p_cdda_input) return VLC_EGENERIC;
p_cdda = (cdda_data_t *)p_cdda_input->p_sys; p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) { if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT))
msg_Dbg( p_cdda_input, "Old debug (x%0x) %d, new debug (x%0x) %d", {
p_cdda->i_debug, p_cdda->i_debug, val.i_int, val.i_int); msg_Dbg( p_cdda_input, "Old debug (x%0x) %d, new debug (x%0x) %d",
} p_cdda->i_debug, p_cdda->i_debug, val.i_int, val.i_int);
p_cdda->i_debug = val.i_int; }
return VLC_SUCCESS; p_cdda->i_debug = val.i_int;
return VLC_SUCCESS;
} }
/* FIXME: could probably shorten some of the below boilerplate code... /* FIXME: could probably shorten some of the below boilerplate code...
...@@ -48,86 +49,90 @@ int ...@@ -48,86 +49,90 @@ int
E_(CDDBEnabledCB) ( vlc_object_t *p_this, const char *psz_name, E_(CDDBEnabledCB) ( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oldval, vlc_value_t val, void *p_data ) vlc_value_t oldval, vlc_value_t val, void *p_data )
{ {
cdda_data_t *p_cdda; cdda_data_t *p_cdda;
if (NULL == p_cdda_input) return VLC_EGENERIC; if (NULL == p_cdda_input) return VLC_EGENERIC;
p_cdda = (cdda_data_t *)p_cdda_input->p_sys; p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) { if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT))
msg_Dbg( p_cdda_input, "Old CDDB Enabled (x%0x) %d, new (x%0x) %d", {
p_cdda->b_cddb_enabled, p_cdda->b_cddb_enabled, msg_Dbg( p_cdda_input, "Old CDDB Enabled (x%0x) %d, new (x%0x) %d",
val.b_bool, val.b_bool); p_cdda->b_cddb_enabled, p_cdda->b_cddb_enabled,
} val.b_bool, val.b_bool);
p_cdda->b_cddb_enabled = val.b_bool; }
p_cdda->b_cddb_enabled = val.b_bool;
#endif #endif
return VLC_SUCCESS; return VLC_SUCCESS;
} }
int int
E_(CDTextEnabledCB) ( vlc_object_t *p_this, const char *psz_name, E_(CDTextEnabledCB) ( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oldval, vlc_value_t val, void *p_data ) vlc_value_t oldval, vlc_value_t val, void *p_data )
{ {
cdda_data_t *p_cdda; cdda_data_t *p_cdda;
if (NULL == p_cdda_input) return VLC_EGENERIC; if (NULL == p_cdda_input) return VLC_EGENERIC;
p_cdda = (cdda_data_t *)p_cdda_input->p_sys; p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) { if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT))
msg_Dbg( p_cdda_input, "Old CDText Enabled (x%0x) %d, new (x%0x) %d", {
p_cdda->b_cdtext_enabled, p_cdda->b_cdtext_enabled, msg_Dbg( p_cdda_input, "Old CDText Enabled (x%0x) %d, new (x%0x) %d",
val.b_bool, val.b_bool); p_cdda->b_cdtext_enabled, p_cdda->b_cdtext_enabled,
} val.b_bool, val.b_bool);
p_cdda->b_cdtext_enabled = val.b_bool; }
return VLC_SUCCESS; p_cdda->b_cdtext_enabled = val.b_bool;
return VLC_SUCCESS;
} }
int int
E_(CDTextPreferCB) ( vlc_object_t *p_this, const char *psz_name, E_(CDTextPreferCB) ( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oldval, vlc_value_t val, void *p_data ) vlc_value_t oldval, vlc_value_t val, void *p_data )
{ {
cdda_data_t *p_cdda; cdda_data_t *p_cdda;
if (NULL == p_cdda_input) return VLC_EGENERIC; if (NULL == p_cdda_input) return VLC_EGENERIC;
p_cdda = (cdda_data_t *)p_cdda_input->p_sys; p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) { if ( p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT))
msg_Dbg( p_cdda_input, "Old CDText Prefer (x%0x) %d, new (x%0x) %d", {
p_cdda->b_cdtext_prefer, p_cdda->b_cdtext_prefer, msg_Dbg( p_cdda_input, "Old CDText Prefer (x%0x) %d, new (x%0x) %d",
val.b_bool, val.b_bool); p_cdda->b_cdtext_prefer, p_cdda->b_cdtext_prefer,
} val.b_bool, val.b_bool);
p_cdda->b_cdtext_prefer = val.b_bool; }
p_cdda->b_cdtext_prefer = val.b_bool;
#endif #endif
return VLC_SUCCESS; return VLC_SUCCESS;
} }
int int
E_(CDDABlocksPerReadCB) ( vlc_object_t *p_this, const char *psz_name, E_(CDDABlocksPerReadCB) ( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oldval, vlc_value_t val, void *p_data ) vlc_value_t oldval, vlc_value_t val, void *p_data )
{ {
cdda_data_t *p_cdda; cdda_data_t *p_cdda;
if (NULL == p_cdda_input) return VLC_EGENERIC; if (NULL == p_cdda_input) return VLC_EGENERIC;
p_cdda = (cdda_data_t *)p_cdda_input->p_sys; p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) { if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT))
msg_Dbg( p_cdda_input, "Old blocks per read: %d, new %d", {
p_cdda->i_blocks_per_read, val.i_int); msg_Dbg( p_cdda_input, "Old blocks per read: %d, new %d",
} p_cdda->i_blocks_per_read, val.i_int);
}
if (0 == val.i_int) val.i_int = DEFAULT_BLOCKS_PER_READ;
if ( val.i_int >= MIN_BLOCKS_PER_READ && val.i_int <= MAX_BLOCKS_PER_READ ) if (0 == val.i_int) val.i_int = DEFAULT_BLOCKS_PER_READ;
p_cdda->i_blocks_per_read = val.i_int; if ( val.i_int >= MIN_BLOCKS_PER_READ && val.i_int <= MAX_BLOCKS_PER_READ )
else { p_cdda->i_blocks_per_read = val.i_int;
msg_Warn( p_cdda_input, else
"Number of blocks (%d) has to be between %d and %d. No change.", {
val.i_int, MIN_BLOCKS_PER_READ, MAX_BLOCKS_PER_READ ); msg_Warn( p_cdda_input,
} "Number of blocks (%d) has to be between %d and %d. No change.",
val.i_int, MIN_BLOCKS_PER_READ, MAX_BLOCKS_PER_READ );
return VLC_SUCCESS; }
return VLC_SUCCESS;
} }
modules/access/cdda/info.c
View file @ 3a9b48da
...@@ -47,156 +47,165 @@ ...@@ -47,156 +47,165 @@
if (val) var=strdup(val); if (val) var=strdup(val);
static void static void GetCDDBInfo( access_t *p_access, cdda_data_t *p_cdda )
GetCDDBInfo( access_t *p_access, cdda_data_t *p_cdda )
{ {
int i, i_matches;
cddb_conn_t *conn = cddb_new();
const CdIo *p_cdio = p_cdda->p_cdio;
int i, i_matches; dbg_print( (INPUT_DBG_CALL), "" );
cddb_conn_t *conn = cddb_new();
const CdIo *p_cdio = p_cdda->p_cdio;
dbg_print( (INPUT_DBG_CALL), "" );
#ifdef FIXME_NOW #ifdef FIXME_NOW
cddb_log_set_handler (uninit_log_handler); cddb_log_set_handler (uninit_log_handler);
#endif #endif
if (!conn) { if (!conn)
msg_Warn( p_access, "Unable to initialize libcddb" ); {
goto cddb_destroy; msg_Warn( p_access, "Unable to initialize libcddb" );
} goto cddb_destroy;
}
cddb_set_email_address( conn,
config_GetPsz( p_access, cddb_set_email_address( conn,
MODULE_STRING "-cddb-email") ); config_GetPsz( p_access,
MODULE_STRING "-cddb-email") );
cddb_set_server_name( conn, cddb_set_server_name( conn,
config_GetPsz( p_access, config_GetPsz( p_access,
MODULE_STRING "-cddb-server") ); MODULE_STRING "-cddb-server") );
cddb_set_server_port(conn,
cddb_set_server_port(conn, config_GetInt( p_access,
config_GetInt( p_access, MODULE_STRING "-cddb-port") );
MODULE_STRING "-cddb-port") );
/* Set the location of the local CDDB cache directory. /* Set the location of the local CDDB cache directory.
The default location of this directory is */ The default location of this directory is */
if (!config_GetInt( p_access, MODULE_STRING "-cddb-enable-cache" ))
cddb_cache_disable(conn);
cddb_cache_set_dir(conn,
config_GetPsz( p_access,
MODULE_STRING "-cddb-cachedir") );
cddb_set_timeout(conn,
config_GetInt( p_access, MODULE_STRING "-cddb-timeout") );
if (config_GetInt( p_access, MODULE_STRING "-cddb-httpd" )) {
cddb_http_enable(conn);
} else
cddb_http_disable(conn);
p_cdda->cddb.disc = cddb_disc_new();
if (!p_cdda->cddb.disc) {
msg_Err( p_access, "Unable to create CDDB disc structure." );
goto cddb_end;
}
for(i = 0; i < p_cdda->i_tracks; i++) {
track_t i_track = p_cdda->i_first_track + i;
cddb_track_t *t = cddb_track_new();
t->frame_offset = cdio_get_track_lba(p_cdio, i_track);
cddb_disc_add_track(p_cdda->cddb.disc, t);
}
p_cdda->cddb.disc->length =
cdio_get_track_lba(p_cdio, CDIO_CDROM_LEADOUT_TRACK)
/ CDIO_CD_FRAMES_PER_SEC;
if (!cddb_disc_calc_discid(p_cdda->cddb.disc)) {
msg_Err( p_access, "CDDB disc ID calculation failed" );
goto cddb_destroy;
}
i_matches = cddb_query(conn, p_cdda->cddb.disc);
if (i_matches > 0) {
if (i_matches > 1)
msg_Warn( p_access, "Found %d matches in CDDB. Using first one.",
i_matches);
cddb_read(conn, p_cdda->cddb.disc);
if (p_cdda->i_debug & INPUT_DBG_CDDB)
cddb_disc_print(p_cdda->cddb.disc);
} else {
msg_Warn( p_access, "CDDB error: %s", cddb_error_str(errno));
}
cddb_destroy: if (!config_GetInt( p_access, MODULE_STRING "-cddb-enable-cache" ))
cddb_destroy(conn); cddb_cache_disable(conn);
cddb_cache_set_dir(conn,
config_GetPsz( p_access,
MODULE_STRING "-cddb-cachedir") );
cddb_set_timeout(conn,
config_GetInt( p_access, MODULE_STRING "-cddb-timeout") );
if (config_GetInt( p_access, MODULE_STRING "-cddb-httpd" ) )
{
cddb_http_enable(conn);
}
else
{
cddb_http_disable(conn);
}
p_cdda->cddb.disc = cddb_disc_new();
if (!p_cdda->cddb.disc)
{
msg_Err( p_access, "Unable to create CDDB disc structure." );
goto cddb_end;
}
for(i = 0; i < p_cdda->i_tracks; i++)
{
track_t i_track = p_cdda->i_first_track + i;
cddb_track_t *t = cddb_track_new();
t->frame_offset = cdio_get_track_lba(p_cdio, i_track);
cddb_disc_add_track(p_cdda->cddb.disc, t);
}
p_cdda->cddb.disc->length =
cdio_get_track_lba(p_cdio, CDIO_CDROM_LEADOUT_TRACK)
/ CDIO_CD_FRAMES_PER_SEC;
if (!cddb_disc_calc_discid(p_cdda->cddb.disc))
{
msg_Err( p_access, "CDDB disc ID calculation failed" );
goto cddb_destroy;
}
i_matches = cddb_query(conn, p_cdda->cddb.disc);
if (i_matches > 0)
{
if (i_matches > 1)
msg_Warn( p_access, "Found %d matches in CDDB. Using first one.",
i_matches);
cddb_read(conn, p_cdda->cddb.disc);
if (p_cdda->i_debug & INPUT_DBG_CDDB)
cddb_disc_print(p_cdda->cddb.disc);
}
else
{
msg_Warn( p_access, "CDDB error: %s", cddb_error_str(errno));
}
cddb_end: ; cddb_destroy:
cddb_destroy(conn);
cddb_end: ;
} }
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
#define add_meta_val(FIELD, VLC_META, VAL) \ #define add_meta_val(FIELD, VLC_META, VAL) \
if ( p_cdda->p_meta && VAL) { \ if ( p_cdda->p_meta && VAL) { \
vlc_meta_Add( p_cdda->p_meta, VLC_META, VAL ); \ vlc_meta_Add( p_cdda->p_meta, VLC_META, VAL ); \
dbg_print( INPUT_DBG_META, "field %s: %s\n", VLC_META, VAL ); \ dbg_print( INPUT_DBG_META, "field %s: %s\n", VLC_META, VAL ); \
} \ } \
#define add_cddb_meta(FIELD, VLC_META) \ #define add_cddb_meta(FIELD, VLC_META) \
add_meta_val(FIELD, VLC_META, p_cdda->cddb.disc->FIELD); add_meta_val(FIELD, VLC_META, p_cdda->cddb.disc->FIELD);
#define add_cddb_meta_fmt(FIELD, FORMAT_SPEC, VLC_META) \ #define add_cddb_meta_fmt(FIELD, FORMAT_SPEC, VLC_META) \
{ \ { \
char psz_buf[100]; \ char psz_buf[100]; \
snprintf( psz_buf, sizeof(psz_buf)-1, FORMAT_SPEC, \ snprintf( psz_buf, sizeof(psz_buf)-1, FORMAT_SPEC, \
p_cdda->cddb.disc->FIELD ); \ p_cdda->cddb.disc->FIELD ); \
psz_buf[sizeof(psz_buf)-1] = '\0'; \ psz_buf[sizeof(psz_buf)-1] = '\0'; \
add_meta_val(FIELD, VLC_META, psz_buf); \ add_meta_val(FIELD, VLC_META, psz_buf); \
} }
/* Adds a string-valued entry to the stream and media information if /* Adds a string-valued entry to the stream and media information if
the string is not null or the null string. the string is not null or the null string.
*/ */
#define add_info_str(CATEGORY, TITLE, FIELD) \ #define add_info_str(CATEGORY, TITLE, FIELD) \
if (FIELD && strlen(FIELD)) { \ if (FIELD && strlen(FIELD)) { \
input_Control( p_cdda->p_input, INPUT_ADD_INFO, CATEGORY, \ input_Control( p_cdda->p_input, INPUT_ADD_INFO, CATEGORY, \
_(TITLE), "%s", FIELD ); \ _(TITLE), "%s", FIELD ); \
} }
/* Adds a numeric-valued entry to the stream and media information /* Adds a numeric-valued entry to the stream and media information
if the number is not zero. */ if the number is not zero. */
#define add_info_val(CATEGORY, TITLE, FMT, FIELD) \ #define add_info_val(CATEGORY, TITLE, FMT, FIELD) \
if (FIELD) { \ if (FIELD) { \
input_Control( p_cdda->p_input, INPUT_ADD_INFO, CATEGORY, \ input_Control( p_cdda->p_input, INPUT_ADD_INFO, CATEGORY, \
_(TITLE), FMT, FIELD ); \ _(TITLE), FMT, FIELD ); \
} }
/* Adds a CDDB string-valued entry to the stream and media information /* Adds a CDDB string-valued entry to the stream and media information
under category "Disc" if the string is not null or the null string. under category "Disc" if the string is not null or the null string.
*/ */
#define add_cddb_disc_info_str(TITLE, FIELD) \ #define add_cddb_disc_info_str(TITLE, FIELD) \
add_info_str("Disc", TITLE, p_cdda->cddb.disc->FIELD) add_info_str("Disc", TITLE, p_cdda->cddb.disc->FIELD)
/* Adds a CDDB numeric-valued entry to the stream and media information /* Adds a CDDB numeric-valued entry to the stream and media information
under category "Disc" if the string is not null or the null string. under category "Disc" if the string is not null or the null string.
*/ */
#define add_cddb_disc_info_val(TITLE, FMT, FIELD) \ #define add_cddb_disc_info_val(TITLE, FMT, FIELD) \
add_info_val("Disc", TITLE, FMT, p_cdda->cddb.disc->FIELD) add_info_val("Disc", TITLE, FMT, p_cdda->cddb.disc->FIELD)
/* Adds a CD-Text string-valued entry to the stream and media information /* Adds a CD-Text string-valued entry to the stream and media information
under category "Disc" if the string is not null or the null string. under category "Disc" if the string is not null or the null string.
*/ */
#define add_cdtext_info_str(CATEGORY, TITLE, INDEX, FIELD) \ #define add_cdtext_info_str(CATEGORY, TITLE, INDEX, FIELD) \
add_info_str(CATEGORY, TITLE, p_cdda->p_cdtext[INDEX]->field[FIELD]) add_info_str(CATEGORY, TITLE, p_cdda->p_cdtext[INDEX]->field[FIELD])
/* Adds a CD-Text string-valued entry to the stream and media information /* Adds a CD-Text string-valued entry to the stream and media information
under category "Disc" if the string is not null or the null string. under category "Disc" if the string is not null or the null string.
*/ */
#define add_cdtext_disc_info_str(TITLE, FIELD) \ #define add_cdtext_disc_info_str(TITLE, FIELD) \
add_cdtext_info_str("Disc", TITLE, 0, FIELD) add_cdtext_info_str("Disc", TITLE, 0, FIELD)
...@@ -209,120 +218,146 @@ GetCDDBInfo( access_t *p_access, cdda_data_t *p_cdda ) ...@@ -209,120 +218,146 @@ GetCDDBInfo( access_t *p_access, cdda_data_t *p_cdda )
Meta information is also used elsewhere such as in "stream and Meta information is also used elsewhere such as in "stream and
media info" or in playlist info. The intialization of CD-Text or CDDB media info" or in playlist info. The intialization of CD-Text or CDDB
is done here though. is done here though.
*/ */
void void CDDAMetaInfo( access_t *p_access, int i_track )
CDDAMetaInfo( access_t *p_access )
{ {
cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys; cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
if ( ! p_cdda ) return; if ( ! p_cdda ) return;
p_cdda->psz_mcn = cdio_get_mcn(p_cdda->p_cdio);
p_cdda->psz_mcn = cdio_get_mcn(p_cdda->p_cdio);
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
if ( p_cdda->b_cddb_enabled ) { if ( p_cdda->b_cddb_enabled )
{
GetCDDBInfo(p_access, p_cdda); GetCDDBInfo(p_access, p_cdda);
if ( p_cdda->cddb.disc )
if ( p_cdda->cddb.disc ) { {
p_cdda->p_meta = vlc_meta_New();
p_cdda->p_meta = vlc_meta_New(); if( i_track == -1 )
{
add_cddb_meta(title, VLC_META_CDDB_TITLE); add_cddb_meta(title, VLC_META_TITLE);
add_cddb_meta(artist, VLC_META_CDDB_ARTIST); add_cddb_meta(artist, VLC_META_ARTIST);
add_cddb_meta(genre, VLC_META_CDDB_GENRE); input_Control( p_cdda->p_input, INPUT_SET_NAME,
add_cddb_meta(ext_data, VLC_META_CDDB_EXT_DATA); p_cdda->cddb.disc->artist );
}
add_cddb_meta_fmt(year, "%d", VLC_META_CDDB_YEAR); else
add_cddb_meta_fmt(discid, "%x", VLC_META_CDDB_DISCID); {
cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
i_track-1);
if (t != NULL )
{
if( t->title != NULL )
{
add_meta_val( NULL, VLC_META_TITLE, t->title );
}
if( t->artist != NULL )
{
add_meta_val( NULL, VLC_META_ARTIST, t->artist );
}
}
}
add_cddb_meta(genre, VLC_META_GENRE);
add_cddb_meta_fmt(year, "%d", VLC_META_DATE );
}
} }
}
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
#define TITLE_MAX 30 #define TITLE_MAX 30
{
{ track_t i = p_cdda->i_tracks;
track_t i = p_cdda->i_tracks; const int i_first_track = p_cdda->i_first_track;
const int i_first_track = p_cdda->i_first_track; char psz_buffer[MSTRTIME_MAX_SIZE];
char psz_buffer[MSTRTIME_MAX_SIZE]; mtime_t i_duration =
mtime_t i_duration = (p_cdda->lsn[i_first_track+i] - p_cdda->lsn[i_first_track])
(p_cdda->lsn[i_first_track+i] - p_cdda->lsn[i_first_track]) / CDIO_CD_FRAMES_PER_SEC;
/ CDIO_CD_FRAMES_PER_SEC;
dbg_print( INPUT_DBG_META, "Duration %ld", (long int) i_duration );
dbg_print( INPUT_DBG_META, "Duration %ld", (long int) i_duration ); input_Control( p_cdda->p_input, INPUT_ADD_INFO,
input_Control( p_cdda->p_input, INPUT_ADD_INFO, _("Disc"), _("Duration"), "%s",
_("Disc"), _("Duration"), "%s", secstotimestr( psz_buffer, i_duration ) );
secstotimestr( psz_buffer, i_duration ) );
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc) { if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc)
add_cddb_disc_info_str("Artist (CDDB)", artist); {
add_cddb_disc_info_str("Genre (CDDB)", genre); add_cddb_disc_info_str("Artist (CDDB)", artist);
add_cddb_disc_info_str("Extended Data (CDDB)", ext_data); add_cddb_disc_info_str("Genre (CDDB)", genre);
add_cddb_disc_info_val("Year (CDDB)", "%d", year); add_cddb_disc_info_str("Extended Data (CDDB)", ext_data);
add_cddb_disc_info_val("Disc ID (CDDB)", "%x", discid); add_cddb_disc_info_val("Year (CDDB)", "%d", year);
add_cddb_disc_info_str("Title (CDDB)", title); add_cddb_disc_info_val("Disc ID (CDDB)", "%x", discid);
add_info_str("Disc", "Category (CDDB)", add_cddb_disc_info_str("Title (CDDB)", title);
CDDB_CATEGORY[p_cdda->cddb.disc->category]); add_info_str("Disc", "Category (CDDB)",
} CDDB_CATEGORY[p_cdda->cddb.disc->category]);
}
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
p_cdda->p_cdtext[0] = cdio_get_cdtext(p_cdda->p_cdio, 0); p_cdda->p_cdtext[0] = cdio_get_cdtext(p_cdda->p_cdio, 0);
if (p_cdda->p_cdtext[0]) { if (p_cdda->p_cdtext[0])
add_cdtext_disc_info_str("Arranger (CD-Text)", CDTEXT_ARRANGER); {
add_cdtext_disc_info_str("Composer (CD-Text)", CDTEXT_COMPOSER); add_cdtext_disc_info_str("Arranger (CD-Text)", CDTEXT_ARRANGER);
add_cdtext_disc_info_str("Disc ID (CD-Text)", CDTEXT_DISCID); add_cdtext_disc_info_str("Composer (CD-Text)", CDTEXT_COMPOSER);
add_cdtext_disc_info_str("Genre (CD-Text)", CDTEXT_GENRE); add_cdtext_disc_info_str("Disc ID (CD-Text)", CDTEXT_DISCID);
add_cdtext_disc_info_str("Message (CD-Text)", CDTEXT_MESSAGE); add_cdtext_disc_info_str("Genre (CD-Text)", CDTEXT_GENRE);
add_cdtext_disc_info_str("Performer (CD-Text)", CDTEXT_PERFORMER); add_cdtext_disc_info_str("Message (CD-Text)", CDTEXT_MESSAGE);
add_cdtext_disc_info_str("Songwriter (CD-Text)", CDTEXT_SONGWRITER); add_cdtext_disc_info_str("Performer (CD-Text)", CDTEXT_PERFORMER);
add_cdtext_disc_info_str("Title (CD-Text)", CDTEXT_TITLE); add_cdtext_disc_info_str("Songwriter (CD-Text)", CDTEXT_SONGWRITER);
} add_cdtext_disc_info_str("Title (CD-Text)", CDTEXT_TITLE);
}
for( i = 0 ; i < p_cdda->i_tracks ; i++ ) {
char psz_track[TITLE_MAX]; if( i_track == -1 )
const track_t i_track = i_first_track + i; {
mtime_t i_duration = (p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track]) for( i = 0 ; i < p_cdda->i_tracks ; i++ )
/ CDIO_CD_FRAMES_PER_SEC; {
snprintf(psz_track, TITLE_MAX, "%s %02d", _("Track"), i_track); char psz_track[TITLE_MAX];
input_Control( p_cdda->p_input, INPUT_ADD_INFO, psz_track, const track_t i_track = i_first_track + i;
_("Duration"), "%s", mtime_t i_duration = (p_cdda->lsn[i_track+1] -
secstotimestr( psz_buffer, i_duration ) ); p_cdda->lsn[i_track])
/ CDIO_CD_FRAMES_PER_SEC;
p_cdda->p_cdtext[i_track] = cdio_get_cdtext(p_cdda->p_cdio, i_track); snprintf(psz_track, TITLE_MAX, "%s %02d", _("Track"), i_track);
input_Control( p_cdda->p_input, INPUT_ADD_INFO, psz_track,
if (p_cdda->p_cdtext[i_track]) { _("Duration"), "%s",
add_cdtext_info_str(psz_track, "Arranger (CD-Text)", i_track, secstotimestr( psz_buffer, i_duration ) );
CDTEXT_ARRANGER);
add_cdtext_info_str(psz_track, "Composer (CD-Text)", i_track, p_cdda->p_cdtext[i_track] =
CDTEXT_COMPOSER); cdio_get_cdtext(p_cdda->p_cdio, i_track);
add_cdtext_info_str(psz_track, "Disc ID (CD-Text)", i_track,
CDTEXT_DISCID); if (p_cdda->p_cdtext[i_track])
add_cdtext_info_str(psz_track, "Genre (CD-Text)", i_track, {
CDTEXT_GENRE); add_cdtext_info_str( psz_track, "Arranger (CD-Text)",
add_cdtext_info_str(psz_track, "Message (CD-Text)", i_track, i_track, CDTEXT_ARRANGER);
CDTEXT_MESSAGE); add_cdtext_info_str( psz_track, "Composer (CD-Text)",
add_cdtext_info_str(psz_track, "Performer (CD-Text)", i_track, i_track, CDTEXT_COMPOSER);
CDTEXT_PERFORMER); add_cdtext_info_str( psz_track, "Disc ID (CD-Text)",
add_cdtext_info_str(psz_track, "Songwriter (CD-Text)", i_track, i_track, CDTEXT_DISCID);
CDTEXT_SONGWRITER); add_cdtext_info_str( psz_track, "Genre (CD-Text)",
add_cdtext_info_str(psz_track, "Title (CD-Text)", i_track, i_track, CDTEXT_GENRE);
CDTEXT_TITLE); add_cdtext_info_str( psz_track, "Message (CD-Text)",
} i_track, CDTEXT_MESSAGE);
add_cdtext_info_str( psz_track, "Performer (CD-Text)",
i_track, CDTEXT_PERFORMER);
add_cdtext_info_str( psz_track, "Songwriter (CD-Text)",
i_track, CDTEXT_SONGWRITER);
add_cdtext_info_str( psz_track, "Title (CD-Text)",
i_track, CDTEXT_TITLE);
}
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
if (p_cdda->b_cddb_enabled) { if (p_cdda->b_cddb_enabled)
cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, i); {
if (t != NULL) { cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, i);
add_info_str(psz_track, "Artist (CDDB)", t->artist); if (t != NULL)
add_info_str(psz_track, "Title (CDDB)", t->title); {
add_info_str(psz_track, "Extended Data (CDDB)", t->ext_data); add_info_str(psz_track, "Artist (CDDB)", t->artist);
} add_info_str(psz_track, "Title (CDDB)", t->title);
} add_info_str(psz_track, "Extended Data (CDDB)",
t->ext_data);
}
}
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
}
}
} }
}
} }
#define add_format_str_info(val) \ #define add_format_str_info(val) \
...@@ -374,333 +409,410 @@ CDDAMetaInfo( access_t *p_access ) ...@@ -374,333 +409,410 @@ CDDAMetaInfo( access_t *p_access )
*/ */
static char * static char *
CDDAFormatStr( const access_t *p_access, cdda_data_t *p_cdda, CDDAFormatStr( const access_t *p_access, cdda_data_t *p_cdda,
const char format_str[], const char *mrl, track_t i_track) const char format_str[], const char *mrl, track_t i_track)
{ {
#define TEMP_STR_SIZE 256 #define TEMP_STR_SIZE 256
#define TEMP_STR_LEN (TEMP_STR_SIZE-1) #define TEMP_STR_LEN (TEMP_STR_SIZE-1)
static char temp_str[TEMP_STR_SIZE]; static char temp_str[TEMP_STR_SIZE];
size_t i; size_t i;
char * tp = temp_str; char * tp = temp_str;
vlc_bool_t saw_control_prefix = false; vlc_bool_t saw_control_prefix = false;
size_t format_len = strlen(format_str); size_t format_len = strlen(format_str);
memset(temp_str, 0, TEMP_STR_SIZE); memset(temp_str, 0, TEMP_STR_SIZE);
for (i=0; i<format_len; i++) { for (i=0; i<format_len; i++)
{
if (!saw_control_prefix && format_str[i] != '%') { if (!saw_control_prefix && format_str[i] != '%')
*tp++ = format_str[i]; {
saw_control_prefix = false; *tp++ = format_str[i];
continue; saw_control_prefix = false;
} continue;
}
switch(format_str[i]) { switch(format_str[i])
case '%': {
if (saw_control_prefix) { case '%':
*tp++ = '%'; if (saw_control_prefix)
} {
saw_control_prefix = !saw_control_prefix; *tp++ = '%';
break; }
saw_control_prefix = !saw_control_prefix;
break;
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
case 'a': case 'a':
if (!p_cdda->b_cddb_enabled) goto not_special; if (!p_cdda->b_cddb_enabled) goto not_special;
if (p_cdda->cddb.disc) if (p_cdda->cddb.disc)
add_format_str_info(p_cdda->cddb.disc->artist); add_format_str_info(p_cdda->cddb.disc->artist);
break; break;
case 'A': case 'A':
if (!p_cdda->b_cddb_enabled) goto not_special; if (!p_cdda->b_cddb_enabled) goto not_special;
if (p_cdda->cddb.disc) if (p_cdda->cddb.disc)
add_format_str_info(p_cdda->cddb.disc->title); add_format_str_info(p_cdda->cddb.disc->title);
break; break;
case 'C': case 'C':
if (!p_cdda->b_cddb_enabled) goto not_special; if (!p_cdda->b_cddb_enabled) goto not_special;
if (p_cdda->cddb.disc) if (p_cdda->cddb.disc)
add_format_str_info(CDDB_CATEGORY[p_cdda->cddb.disc->category]); add_format_str_info(
break; CDDB_CATEGORY[p_cdda->cddb.disc->category]);
case 'G': break;
if (!p_cdda->b_cddb_enabled) goto not_special; case 'G':
if (p_cdda->cddb.disc) if (!p_cdda->b_cddb_enabled) goto not_special;
add_format_str_info(p_cdda->cddb.disc->genre); if (p_cdda->cddb.disc)
break; add_format_str_info(p_cdda->cddb.disc->genre);
case 'I': break;
if (!p_cdda->b_cddb_enabled) goto not_special; case 'I':
if (p_cdda->cddb.disc) if (!p_cdda->b_cddb_enabled) goto not_special;
add_format_num_info(p_cdda->cddb.disc->discid, "%x"); if (p_cdda->cddb.disc)
break; add_format_num_info(p_cdda->cddb.disc->discid, "%x");
case 'Y': break;
if (!p_cdda->b_cddb_enabled) goto not_special; case 'Y':
if (p_cdda->cddb.disc) if (!p_cdda->b_cddb_enabled) goto not_special;
add_format_num_info(p_cdda->cddb.disc->year, "%5d"); if (p_cdda->cddb.disc)
break; add_format_num_info(p_cdda->cddb.disc->year, "%5d");
case 't': break;
if (p_cdda && p_cdda->b_cddb_enabled && p_cdda->cddb.disc) { case 't':
cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, if (p_cdda && p_cdda->b_cddb_enabled && p_cdda->cddb.disc)
i_track-1); {
if (t != NULL && t->title != NULL) cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
add_format_str_info(t->title); i_track-1);
} else goto not_special; if (t != NULL && t->title != NULL)
break; add_format_str_info(t->title);
case 'p': }
if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc) { else goto not_special;
cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, break;
i_track-1); case 'p':
if (t != NULL && t->artist != NULL) if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc)
add_format_str_info(t->artist); {
} else goto not_special; cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
break; i_track-1);
case 'e': if (t != NULL && t->artist != NULL)
if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc) { add_format_str_info(t->artist);
cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, } else goto not_special;
i_track-1); break;
if (t != NULL && t->ext_data != NULL) case 'e':
add_format_str_info(t->ext_data); if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc)
} else goto not_special; {
break; cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
case 's': i_track-1);
if (p_cdda->b_cddb_enabled) { if (t != NULL && t->ext_data != NULL)
char psz_buffer[MSTRTIME_MAX_SIZE]; add_format_str_info(t->ext_data);
mtime_t i_duration = (p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track]) } else goto not_special;
/ CDIO_CD_FRAMES_PER_SEC; break;
add_format_str_info(secstotimestr( psz_buffer, i_duration ) ); case 's':
} else if (p_cdda->b_cddb_enabled)
goto not_special; {
break; char psz_buffer[MSTRTIME_MAX_SIZE];
mtime_t i_duration = (p_cdda->lsn[i_track+1] -
p_cdda->lsn[i_track])
/ CDIO_CD_FRAMES_PER_SEC;
add_format_str_info(secstotimestr( psz_buffer,
i_duration ) );
} else goto not_special;
break;
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
case 'M': case 'M':
add_format_str_info(mrl); add_format_str_info(mrl);
break; break;
case 'm': case 'm':
add_format_str_info(p_cdda->psz_mcn); add_format_str_info(p_cdda->psz_mcn);
break; break;
case 'n': case 'n':
add_format_num_info(p_cdda->i_tracks, "%d"); add_format_num_info(p_cdda->i_tracks, "%d");
break; break;
case 'T': case 'T':
add_format_num_info(i_track, "%02d"); add_format_num_info(i_track, "%02d");
break; break;
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
not_special: not_special:
#endif #endif
default: default:
*tp++ = '%'; *tp++ = '%';
*tp++ = format_str[i]; *tp++ = format_str[i];
saw_control_prefix = false; saw_control_prefix = false;
}
} }
} return strdup(temp_str);
return strdup(temp_str);
} }
/* Adds a string-valued entry to the playlist information under "Track" /* Adds a string-valued entry to the playlist information under "Track"
if the string is not null or the null string. if the string is not null or the null string.
*/ */
#define add_playlist_track_info_str(TITLE, FIELD) \ #define add_playlist_track_info_str(TITLE, FIELD) \
if (FIELD && strlen(FIELD)) { \ if (FIELD && strlen(FIELD)) \
playlist_ItemAddInfo( p_item, _("Track"), _(TITLE), \ { \
"%s", FIELD); \ playlist_ItemAddInfo( p_item, _("Track"), _(TITLE), \
} "%s", FIELD); \
}
void
CDDACreatePlaylistItem(const access_t *p_access, cdda_data_t *p_cdda, playlist_item_t *
playlist_t *p_playlist, track_t i_track, CDDACreatePlaylistItem( const access_t *p_access, cdda_data_t *p_cdda,
char *psz_mrl, int psz_mrl_max, playlist_t *p_playlist, playlist_item_t *p_item,
const char *psz_source, int playlist_operation, track_t i_track, char *psz_mrl, int psz_mrl_max,
int i_pos) const char *psz_source )
{ {
mtime_t i_duration = (p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track]) mtime_t i_duration = (p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track])
* (1000000 / CDIO_CD_FRAMES_PER_SEC) ; * (1000000 / CDIO_CD_FRAMES_PER_SEC) ;
char *psz_title; char *psz_title;
char *config_varname = MODULE_STRING "-title-format"; char *config_varname = MODULE_STRING "-title-format";
playlist_item_t *p_item;
playlist_item_t *p_child = NULL;
if( !p_item )
{
return NULL;
}
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
if (p_cdda->b_cddb_enabled) { if (p_cdda->b_cddb_enabled)
config_varname = MODULE_STRING "-cddb-title-format"; {
} config_varname = MODULE_STRING "-cddb-title-format";
}
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
snprintf(psz_mrl, psz_mrl_max, "%s%s@T%u",
CDDA_MRL_PREFIX, psz_source, i_track);
psz_title = CDDAFormatStr(p_access, p_cdda,
config_GetPsz( p_access, config_varname ),
psz_mrl, i_track);
dbg_print( INPUT_DBG_META, "mrl: %s, title: %s, duration, %ld, pos %d",
psz_mrl, psz_title, (long int) i_duration / 1000000 , i_pos );
playlist_AddExt( p_playlist, psz_mrl, psz_title, playlist_operation,
i_pos, i_duration , NULL, 0);
if( i_pos == PLAYLIST_END ) i_pos = p_playlist->i_size - 1;
vlc_mutex_lock( &p_playlist->object_lock );
p_item = playlist_ItemGetByPos( p_playlist, i_pos );
vlc_mutex_unlock( &p_playlist->object_lock );
if( !p_item )
return;
vlc_mutex_lock( &p_item->input.lock );
add_playlist_track_info_str("Source", psz_source);
playlist_ItemAddInfo( p_item, _("Track"), _("Track Number"), "%d", i_track );
if (p_cdda->p_cdtext[0]) {
const cdtext_t *p = p_cdda->p_cdtext[0];
add_playlist_track_info_str("Disc Arranger (CD-Text)",
p->field[CDTEXT_ARRANGER]);
add_playlist_track_info_str("Disc Composer (CD-Text)",
p->field[CDTEXT_COMPOSER]);
add_playlist_track_info_str("Disc ID (CD-Text)",
p->field[CDTEXT_DISCID]);
add_playlist_track_info_str("Disc Genre (CD-Text)",
p->field[CDTEXT_GENRE]);
add_playlist_track_info_str("Disc Message (CD-Text)",
p->field[CDTEXT_MESSAGE]);
add_playlist_track_info_str("Disc Performer (CD-Text)",
p->field[CDTEXT_PERFORMER]);
add_playlist_track_info_str("Disc Songwriter (CD-Text)",
p->field[CDTEXT_SONGWRITER]);
add_playlist_track_info_str("Disc Title (CD-Text)",
p->field[CDTEXT_TITLE]);
}
if (p_cdda->p_cdtext[i_track]) { psz_title = CDDAFormatStr( p_access, p_cdda,
const cdtext_t *p = p_cdda->p_cdtext[i_track]; config_GetPsz( p_access, config_varname ),
add_playlist_track_info_str("Arranger (CD-Text)", psz_mrl, i_track);
p->field[CDTEXT_ARRANGER]);
add_playlist_track_info_str("Composer (CD-Text)",
p->field[CDTEXT_COMPOSER]);
add_playlist_track_info_str("Genre (CD-Text)",
p->field[CDTEXT_GENRE]);
add_playlist_track_info_str("Message (CD-Text)",
p->field[CDTEXT_MESSAGE]);
add_playlist_track_info_str("Performer (CD-Text)",
p->field[CDTEXT_PERFORMER]);
add_playlist_track_info_str("Songwriter (CD-Text)",
p->field[CDTEXT_SONGWRITER]);
add_playlist_track_info_str("Title (CD-Text)",
p->field[CDTEXT_TITLE]);
}
#ifdef HAVE_LIBCDDB snprintf(psz_mrl, psz_mrl_max, "%s%s@T%u",
if (p_cdda->b_cddb_enabled) { CDDA_MRL_PREFIX, psz_source, i_track);
cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
i_track-p_cdda->i_first_track); dbg_print( INPUT_DBG_META, "mrl: %s, title: %s, duration, %ld",
psz_mrl, psz_title, (long int) i_duration / 1000000 );
add_playlist_track_info_str("Disc Album (CDDB)",
p_cdda->cddb.disc->title); p_child = playlist_ItemNew( p_playlist, psz_mrl, psz_title );
add_playlist_track_info_str("Disc Artist(s) (CDDB)", p_child->input.b_fixed_name = VLC_TRUE;
p_cdda->cddb.disc->artist);
add_playlist_track_info_str("Disc Category (CDDB)", if( !p_child ) return NULL;
CDDB_CATEGORY[p_cdda->cddb.disc->category]);
add_playlist_track_info_str("Disc Genre (CDDB)", playlist_NodeAddItem( p_playlist, p_child,
p_cdda->cddb.disc->genre); p_item->pp_parents[0]->i_view,
if ( p_cdda->cddb.disc->discid ) { p_item, PLAYLIST_APPEND, PLAYLIST_END );
playlist_ItemAddInfo( p_item, _("Track"), _("Disc ID (CDDB)"), playlist_CopyParents( p_item, p_child );
"%x", p_cdda->cddb.disc->discid );
return p_child;
}
int CDDAAddMetaToItem( access_t *p_access, cdda_data_t *p_cdda,
playlist_item_t *p_item, const char *psz_source,
int i_track, vlc_bool_t b_single )
{
vlc_mutex_lock( &p_item->input.lock );
add_playlist_track_info_str("Source", psz_source);
playlist_ItemAddInfo( p_item, _("Track"), _("Track Number"),
"%d", i_track );
if (p_cdda->p_cdtext[0])
{
const cdtext_t *p = p_cdda->p_cdtext[0];
add_playlist_track_info_str("Disc Arranger (CD-Text)",
p->field[CDTEXT_ARRANGER]);
add_playlist_track_info_str("Disc Composer (CD-Text)",
p->field[CDTEXT_COMPOSER]);
add_playlist_track_info_str("Disc ID (CD-Text)",
p->field[CDTEXT_DISCID]);
add_playlist_track_info_str("Disc Genre (CD-Text)",
p->field[CDTEXT_GENRE]);
add_playlist_track_info_str("Disc Message (CD-Text)",
p->field[CDTEXT_MESSAGE]);
add_playlist_track_info_str("Disc Performer (CD-Text)",
p->field[CDTEXT_PERFORMER]);
add_playlist_track_info_str("Disc Songwriter (CD-Text)",
p->field[CDTEXT_SONGWRITER]);
add_playlist_track_info_str("Disc Title (CD-Text)",
p->field[CDTEXT_TITLE]);
} }
if (p_cdda->cddb.disc->year != 0) {
playlist_ItemAddInfo( p_item, _("Track"), _("Year (CDDB)"), if (p_cdda->p_cdtext[i_track])
"%5d", p_cdda->cddb.disc->year ); {
const cdtext_t *p = p_cdda->p_cdtext[i_track];
add_playlist_track_info_str("Arranger (CD-Text)",
p->field[CDTEXT_ARRANGER]);
add_playlist_track_info_str("Composer (CD-Text)",
p->field[CDTEXT_COMPOSER]);
add_playlist_track_info_str("Genre (CD-Text)",
p->field[CDTEXT_GENRE]);
add_playlist_track_info_str("Message (CD-Text)",
p->field[CDTEXT_MESSAGE]);
add_playlist_track_info_str("Performer (CD-Text)",
p->field[CDTEXT_PERFORMER]);
add_playlist_track_info_str("Songwriter (CD-Text)",
p->field[CDTEXT_SONGWRITER]);
add_playlist_track_info_str("Title (CD-Text)",
p->field[CDTEXT_TITLE]);
} }
if (t) { #ifdef HAVE_LIBCDDB
if (t->artist) if (p_cdda->b_cddb_enabled)
add_playlist_track_info_str("Track Artist (CDDB)", {
t->artist); cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
if (t->title) i_track-p_cdda->i_first_track);
add_playlist_track_info_str("Track Title (CDDB)",
t->title); add_playlist_track_info_str("Disc Album (CDDB)",
p_cdda->cddb.disc->title);
add_playlist_track_info_str("Disc Artist(s) (CDDB)",
p_cdda->cddb.disc->artist);
add_playlist_track_info_str("Disc Category (CDDB)",
CDDB_CATEGORY[p_cdda->cddb.disc->category]);
add_playlist_track_info_str("Disc Genre (CDDB)",
p_cdda->cddb.disc->genre);
if ( p_cdda->cddb.disc->discid )
{
playlist_ItemAddInfo( p_item, _("Track"), _("Disc ID (CDDB)"),
"%x", p_cdda->cddb.disc->discid );
}
if (p_cdda->cddb.disc->year != 0)
{
playlist_ItemAddInfo( p_item, _("Track"), _("Year (CDDB)"),
"%5d", p_cdda->cddb.disc->year );
}
if (t)
{
if (t->artist)
add_playlist_track_info_str("Track Artist (CDDB)",
t->artist);
if (t->title)
add_playlist_track_info_str("Track Title (CDDB)",
t->title);
}
} }
}
#endif /*HAVE_LIBCDDB*/ #endif /*HAVE_LIBCDDB*/
vlc_mutex_unlock( &p_item->input.lock ); vlc_mutex_unlock( &p_item->input.lock );
return VLC_SUCCESS;
} }
int int
CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda, CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda,
const char *psz_source, vlc_bool_t b_single_track ) const char *psz_source, vlc_bool_t b_single_track )
{ {
int i; int i;
playlist_t * p_playlist; playlist_t * p_playlist;
char * psz_mrl; char * psz_mrl;
unsigned int psz_mrl_max = strlen(CDDA_MRL_PREFIX) + strlen(psz_source) + unsigned int psz_mrl_max = strlen(CDDA_MRL_PREFIX) + strlen(psz_source) +
strlen("@T") + strlen("100") + 1; strlen("@T") + strlen("100") + 1;
const track_t i_first_track = p_cdda->i_first_track; const track_t i_first_track = p_cdda->i_first_track;
playlist_item_t *p_item;
vlc_bool_t b_play = VLC_FALSE;
#ifdef HAVE_LIBCDDB #ifdef HAVE_LIBCDDB
p_cdda->b_cddb_enabled = p_cdda->b_cddb_enabled =
config_GetInt( p_access, MODULE_STRING "-cddb-enabled" ); config_GetInt( p_access, MODULE_STRING "-cddb-enabled" );
if( b_single_track && !p_cdda->b_cddb_enabled ) return VLC_SUCCESS; if( b_single_track && !p_cdda->b_cddb_enabled )
return VLC_SUCCESS;
#else #else
if( b_single_track ) return VLC_SUCCESS; if( b_single_track )
return VLC_SUCCESS;
#endif #endif
psz_mrl = malloc( psz_mrl_max ); psz_mrl = malloc( psz_mrl_max );
if( psz_mrl == NULL ) if( psz_mrl == NULL )
{ {
msg_Warn( p_access, "out of memory" ); msg_Warn( p_access, "out of memory" );
return VLC_ENOMEM; return VLC_ENOMEM;
} }
p_playlist = (playlist_t *) vlc_object_find( p_access, VLC_OBJECT_PLAYLIST, p_playlist = (playlist_t *) vlc_object_find( p_access, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE ); FIND_ANYWHERE );
if( !p_playlist ) if( !p_playlist )
{ {
msg_Warn( p_access, "can't find playlist" ); msg_Warn( p_access, "can't find playlist" );
free(psz_mrl); free(psz_mrl);
return VLC_EGENERIC; return VLC_EGENERIC;
} }
CDDAMetaInfo(p_access); if( b_single_track )
{
if (b_single_track) { CDDAMetaInfo( p_access, p_cdda->i_track );
/* May fill out more information when the playlist user interface becomes }
more mature. else
*/ {
track_t i_track = p_cdda->i_track; CDDAMetaInfo( p_access, -1 );
}
input_title_t *t = p_cdda->p_title[i_track-i_first_track] =
vlc_input_title_New(); p_item = playlist_ItemGetByInput( p_playlist,
((input_thread_t *)p_access->p_parent)->input.p_item );
asprintf( &t->psz_name, _("Track %i"), i_track );
t->i_size = p_access->info.i_size = if( p_item == p_playlist->status.p_item && !b_single_track )
( p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track] ) * {
(int64_t) CDIO_CD_FRAMESIZE_RAW; b_play = VLC_TRUE;
}
t->i_length = I64C(1000000) * t->i_size / CDDA_FREQUENCY_SAMPLE / 4; else
CDDACreatePlaylistItem(p_access, p_cdda, p_playlist, i_track, {
psz_mrl, psz_mrl_max, psz_source, PLAYLIST_REPLACE, b_play = VLC_FALSE;
p_playlist->i_index); }
p_cdda->i_titles = 1;
} else { if( b_single_track )
{
for( i = 0 ; i < p_cdda->i_tracks ; i++ ) /*May fill out more information when the playlist user interface becomes
{ more mature.
const track_t i_track = i_first_track + i; */
input_title_t *t = p_cdda->p_title[i] = vlc_input_title_New(); track_t i_track = p_cdda->i_track;
asprintf( &t->psz_name, _("Track %i"), i_track ); input_title_t *t = p_cdda->p_title[0] = //i_track-i_first_track] =
t->i_size = ( p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track] ) * vlc_input_title_New();
(int64_t) CDIO_CD_FRAMESIZE_RAW;
asprintf( &t->psz_name, _("Track %i"), i_track );
t->i_length = I64C(1000000) * t->i_size / CDDA_FREQUENCY_SAMPLE / 4; t->i_size = p_access->info.i_size =
CDDACreatePlaylistItem(p_access, p_cdda, p_playlist, i_track, ( p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track] ) *
psz_mrl, psz_mrl_max, psz_source, (int64_t) CDIO_CD_FRAMESIZE_RAW;
PLAYLIST_APPEND, PLAYLIST_END);
} t->i_length = I64C(1000000) * t->i_size / CDDA_FREQUENCY_SAMPLE / 4;
p_cdda->i_titles = p_cdda->i_tracks; /* should be +1 */
p_access->info.i_size =
(p_cdda->lsn[i_first_track + p_cdda->i_tracks] CDDAAddMetaToItem( p_access, p_cdda, p_item, psz_source, i_track,
- p_cdda->lsn[i_first_track]) * (int64_t) CDIO_CD_FRAMESIZE_RAW; VLC_FALSE );
}
p_cdda->i_titles = 1;
}
else
{
playlist_ItemToNode( p_playlist, p_item );
for( i = 0 ; i < p_cdda->i_tracks ; i++ )
{
playlist_item_t *p_child;
const track_t i_track = i_first_track + i;
input_title_t *t = p_cdda->p_title[i] = vlc_input_title_New();
asprintf( &t->psz_name, _("Track %i"), i_track );
t->i_size = ( p_cdda->lsn[i_track+1] - p_cdda->lsn[i_track] ) *
(int64_t) CDIO_CD_FRAMESIZE_RAW;
t->i_length = I64C(1000000) * t->i_size / CDDA_FREQUENCY_SAMPLE / 4;
p_child = CDDACreatePlaylistItem( p_access, p_cdda, p_playlist,
p_item,
i_track, psz_mrl,
psz_mrl_max, psz_source );
CDDAAddMetaToItem( p_access, p_cdda, p_child, psz_source,
i_track, VLC_TRUE );
}
p_cdda->i_titles = p_cdda->i_tracks; /* should be +1 */
p_access->info.i_size =
(p_cdda->lsn[i_first_track + p_cdda->i_tracks]
- p_cdda->lsn[i_first_track]) * (int64_t) CDIO_CD_FRAMESIZE_RAW;
}
if( b_play )
{
playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
p_playlist->status.i_view,
p_playlist->status.p_item, NULL );
}
vlc_object_release( p_playlist );
return VLC_SUCCESS; return VLC_SUCCESS;
} }
modules/access/cdda/info.h
View file @ 3a9b48da
...@@ -23,27 +23,25 @@ ...@@ -23,27 +23,25 @@
/* /*
Fills out playlist information. Fills out playlist information.
*/ */
int CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda, int CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda,
const char *psz_source, const char *psz_source,
vlc_bool_t b_single_track ); vlc_bool_t b_single_track );
/* /*
Gets and saves CDDA Meta Information. In the Control routine, Gets and saves CDDA Meta Information. In the Control routine,
we handle Meta Information requests and basically copy what we've we handle Meta Information requests and basically copy what we've
saved here. saved here.
*/ */
void CDDAMetaInfo( access_t *p_access ); void CDDAMetaInfo( access_t *p_access, int );
/* /*
Creates a playlist item filling the meta information about that playlist Creates a playlist item filling the meta information about that playlist
item. item.
*/ */
void CDDACreatePlaylistItem(const access_t *p_access, playlist_item_t *
cdda_data_t *p_cdda, CDDACreatePlaylistItem( const access_t *p_access, cdda_data_t *p_cdda,
playlist_t *p_playlist, playlist_t *p_playlist, playlist_item_t *p_item,
track_t i_track, track_t i_track, char *psz_mrl, int psz_mrl_max,
char *psz_mrl, int psz_mrl_max, const char *psz_source );
const char *psz_source,
int playlist_operation,
int i_pos);
src/input/input.c
View file @ 3a9b48da
...@@ -1560,7 +1560,8 @@ static int UpdateMeta( input_thread_t *p_input ) ...@@ -1560,7 +1560,8 @@ static int UpdateMeta( input_thread_t *p_input )
msg_Dbg( p_input, " - '%s' = '%s'", msg_Dbg( p_input, " - '%s' = '%s'",
_(p_meta->name[i]), p_meta->value[i] ); _(p_meta->name[i]), p_meta->value[i] );
if( !strcmp(p_meta->name[i], VLC_META_TITLE) && p_meta->value[i] ) if( !strcmp(p_meta->name[i], VLC_META_TITLE) && p_meta->value[i] &&
!p_input->input.p_item->b_fixed_name )
input_Control( p_input, INPUT_SET_NAME, p_meta->value[i] ); input_Control( p_input, INPUT_SET_NAME, p_meta->value[i] );
if( !strcmp( p_meta->name[i], VLC_META_AUTHOR ) ) if( !strcmp( p_meta->name[i], VLC_META_AUTHOR ) )
......
src/playlist/item-ext.c
View file @ 3a9b48da
...@@ -436,6 +436,11 @@ playlist_item_t * playlist_ItemGetByInput( playlist_t * p_playlist , ...@@ -436,6 +436,11 @@ playlist_item_t * playlist_ItemGetByInput( playlist_t * p_playlist ,
input_item_t *p_item ) input_item_t *p_item )
{ {
int i; int i;
if( &p_playlist->status.p_item->input == p_item )
{
return p_playlist->status.p_item;
}
for( i = 0 ; i < p_playlist->i_size ; i++ ) for( i = 0 ; i < p_playlist->i_size ; i++ )
{ {
if( &p_playlist->pp_items[i]->input == p_item ) if( &p_playlist->pp_items[i]->input == p_item )
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment