static bool save_data( track_elem_t *p_track, const char *psz_name,
char *psz_value)
{
/* exit if setting is impossible */
if( !psz_name || !psz_value || !p_track )
return false;
/* re-convert xml special characters inside psz_value */
resolve_xml_special_chars( psz_value );
#define SAVE_INFO( name, value ) \
if( !strcmp( psz_name, name ) ) { p_track->value = strdup( psz_value ); }
SAVE_INFO( "Name", name )
else SAVE_INFO( "Artist", artist )
else SAVE_INFO( "Album", album )
else SAVE_INFO( "Genre", genre )
else SAVE_INFO( "Track Number", trackNum )
else SAVE_INFO( "Location", location )
else if( !strcmp( psz_name, "Total Time" ) )
{
long i_num = atol( psz_value );
p_track->duration = (mtime_t) i_num*1000;
}
#undef SAVE_INFO
return true;
}
static int Demux( demux_t *p_demux )
{
char *psz_line;
input_item_t *p_current_input = GetCurrentItem(p_demux);
input_item_node_t *p_subitems = input_item_node_Create( p_current_input );
while( (psz_line = stream_ReadLine( p_demux->s )) )
{
char *psz_parse = psz_line;
/* Skip leading tabs and spaces */
while( *psz_parse == ' ' || *psz_parse == '\t' ||
*psz_parse == '\n' || *psz_parse == '\r' )
psz_parse++;
/* if the line is the uri of the media item */
if( !strncasecmp( psz_parse, "<media src=\"", strlen( "<media src=\"" ) ) )
{
char *psz_uri = psz_parse + strlen( "<media src=\"" );
psz_parse = strchr( psz_uri, '"' );
if( psz_parse != NULL )
{
*psz_parse = '\0';
resolve_xml_special_chars( psz_uri );
psz_uri = ProcessMRL( psz_uri, p_demux->p_sys->psz_prefix );
if( psz_uri != NULL )
{
input_item_t *p_input;
p_input = input_item_NewExt( psz_uri, psz_uri,
0, NULL, 0, -1 );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
free( psz_uri );
}
}
}
/* Fetch another line */
free( psz_line );
}
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref(p_current_input);
var_Destroy( p_demux, "wpl-extvlcopt" );
return 0; /* Needed for correct operation of go back */
}
static int vlclua_resolve_xml_special_chars( lua_State *L )
{
int i_top = lua_gettop( L );
int i;
for( i = 1; i <= i_top; i++ )
{
const char *psz_cstring = luaL_checkstring( L, 1 );
char *psz_string = strdup( psz_cstring );
lua_remove( L, 1 ); /* remove elements to prevent being limited by
* the stack's size (this function will work with
* up to (stack size - 1) arguments */
resolve_xml_special_chars( psz_string );
lua_pushstring( L, psz_string );
free( psz_string );
}
return i_top;
}
static void ReadElement( xml_reader_t *p_xml_reader, char **ppsz_txt )
{
const char *psz_node = NULL;
/* Read the text node */
xml_ReaderNextNode( p_xml_reader, &psz_node );
free( *ppsz_txt );
*ppsz_txt = strdup( psz_node );
resolve_xml_special_chars( *ppsz_txt );
/* Read the end element */
xml_ReaderNextNode( p_xml_reader, &psz_node );
/* TODO :
* Currently we don't check the agreement of start and end element
* This function is only used to read the element that cannot have child
* according to the reference.
*/
}
static int Demux( demux_t *p_demux )
{
const char *psz_node = NULL;
char *psz_txt = NULL;
char *psz_base = FindPrefix( p_demux );
char *psz_title_asx = NULL;
char *psz_entryref = NULL;
xml_reader_t *p_xml_reader = NULL;
input_item_t *p_current_input = GetCurrentItem( p_demux );
input_item_node_t *p_subitems = NULL;
bool b_first_node = false;
int i_type;
int i_n_entry = 0;
p_xml_reader = xml_ReaderCreate( p_demux, p_demux->s );
if( !p_xml_reader )
{
msg_Err( p_demux, "Cannot parse ASX input file as XML");
goto error;
}
p_subitems = input_item_node_Create( p_current_input );
do
{
i_type = xml_ReaderNextNode( p_xml_reader, &psz_node );
if( i_type == XML_READER_STARTELEM )
{
if( !b_first_node )
{
if(!strncasecmp( psz_node, "ASX", 3 ) )
b_first_node = true;
else
{
msg_Err( p_demux, "invalid root node" );
goto error;
}
}
/* Metadata Node Handler */
if( !strncasecmp( psz_node, "TITLE", 5 ) )
{
ReadElement( p_xml_reader, &psz_title_asx );
input_item_SetTitle( p_current_input, psz_title_asx );
}
else if( !strncasecmp( psz_node, "AUTHOR", 6 ) )
{
ReadElement( p_xml_reader, &psz_txt );
input_item_SetArtist( p_current_input, psz_txt );
}
else if( !strncasecmp( psz_node, "COPYRIGHT", 9 ) )
{
ReadElement( p_xml_reader, &psz_txt );
input_item_SetCopyright( p_current_input, psz_txt );
}
else if( !strncasecmp( psz_node, "MOREINFO", 8 ) )
{
const char *psz_tmp;
do
{
psz_tmp = xml_ReaderNextAttr( p_xml_reader, &psz_node );
}
while( psz_tmp && strncasecmp( psz_tmp, "HREF", 4 ) );
if( !psz_tmp ) // If HREF attribute doesn't exist
ReadElement( p_xml_reader, &psz_txt );
else
psz_txt = strdup( psz_node );
resolve_xml_special_chars( psz_txt );
input_item_SetURL( p_current_input, psz_txt );
}
else if( !strncasecmp( psz_node, "ABSTRACT", 8 ) )
{
ReadElement( p_xml_reader, &psz_txt );
input_item_SetDescription( p_current_input, psz_txt );
}
else
/* Base Node handler */
if( !strncasecmp( psz_node, "BASE", 4 ) )
ReadElement( p_xml_reader, &psz_base );
else
/* Entry Ref Handler */
if( !strncasecmp( psz_node, "ENTRYREF", 7 ) )
{
const char *psz_tmp;
do
{
psz_tmp = xml_ReaderNextAttr( p_xml_reader, &psz_node );
}
while( psz_tmp && !strncasecmp( psz_tmp, "HREF", 4 ) );
/* Create new input item */
input_item_t *p_input;
psz_txt = strdup( psz_node );
resolve_xml_special_chars( psz_txt );
p_input = input_item_New( psz_txt, psz_title_asx );
input_item_CopyOptions( p_current_input, p_input );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
}
else
/* Entry Handler */
if( !strncasecmp( psz_node, "ENTRY", 5 ) )
{
ProcessEntry( &i_n_entry, p_xml_reader, p_subitems,
p_current_input, psz_base);
}
/* FIXME Unsupported elements
PARAM
EVENT
REPEAT
ENDMARK
STARTMARK
*/
}
}
while( i_type != XML_READER_ENDELEM || strncasecmp( psz_node, "ASX", 3 ) );
input_item_node_PostAndDelete( p_subitems );
p_subitems = NULL;
error:
free( psz_base );
free( psz_title_asx );
free( psz_entryref );
free( psz_txt );
if( p_xml_reader)
xml_ReaderDelete( p_xml_reader );
if( p_subitems )
input_item_node_Delete( p_subitems );
vlc_gc_decref( p_current_input );
return 0;
}
static void ProcessEntry( int *pi_n_entry, xml_reader_t *p_xml_reader,
input_item_node_t *p_subitems,
input_item_t *p_current_input, char *psz_prefix )
{
const char *psz_node = NULL;
const char *psz_txt = NULL;
int i_type;
char *psz_title = NULL;
char *psz_artist = NULL;
char *psz_copyright = NULL;
char *psz_moreinfo = NULL;
char *psz_description = NULL;
char *psz_name = NULL;
char *psz_mrl = NULL;
char *psz_href = NULL;
input_item_t *p_entry = NULL;
int i_options;
mtime_t i_start = 0;
mtime_t i_duration = 0;
char *ppsz_options[2];
do
{
i_type = xml_ReaderNextNode( p_xml_reader, &psz_node );
if( i_type == XML_READER_STARTELEM )
{
/* Metadata Node */
if( !strncasecmp( psz_node, "TITLE", 5 ) )
ReadElement( p_xml_reader, &psz_title );
else if( !strncasecmp( psz_node, "AUTHOR", 6 ) )
ReadElement( p_xml_reader, &psz_artist );
else if( !strncasecmp( psz_node, "COPYRIGHT", 9 ) )
ReadElement( p_xml_reader, &psz_copyright );
else if( !strncasecmp( psz_node,"MOREINFO", 8 ) )
{
do
{
psz_txt = xml_ReaderNextAttr( p_xml_reader, &psz_node );
}
while(psz_txt && strncasecmp( psz_txt, "HREF", 4 ) );
if( !psz_txt )
ReadElement( p_xml_reader, &psz_moreinfo );
else
psz_moreinfo = strdup( psz_node );
resolve_xml_special_chars( psz_moreinfo );
}
else if( !strncasecmp( psz_node, "ABSTRACT", 8 ) )
ReadElement( p_xml_reader, &psz_description );
else if( !strncasecmp( psz_node, "DURATION", 8 ) )
i_duration = ParseTime( p_xml_reader );
else if( !strncasecmp( psz_node, "STARTTIME", 9 ) )
i_start = ParseTime( p_xml_reader );
else
/* Reference Node */
/* All ref node will be converted into an entry */
if( !strncasecmp( psz_node, "REF", 3 ) )
{
*pi_n_entry = *pi_n_entry + 1;
if( !psz_title )
psz_title = input_item_GetTitle( p_current_input );
if( !psz_artist )
psz_artist = input_item_GetArtist( p_current_input );
if( !psz_copyright )
psz_copyright = input_item_GetCopyright( p_current_input );
if( !psz_description )
psz_description = input_item_GetDescription( p_current_input );
do
{
psz_txt = xml_ReaderNextAttr( p_xml_reader, &psz_node );
}
while( strncasecmp( psz_txt, "HREF", 4) );
psz_href = strdup( psz_node );
if( asprintf( &psz_name, "%d. %s", *pi_n_entry, psz_title ) == -1)
psz_name = strdup( psz_title );
resolve_xml_special_chars( psz_href );
psz_mrl = ProcessMRL( psz_href, psz_prefix );
/* Add Time information */
i_options = 0;
if( i_start )
{
if( asprintf( ppsz_options, ":start-time=%d" ,(int) i_start/1000000 ) != -1)
i_options++;
}
if( i_duration)
{
if( asprintf( ppsz_options + i_options, ":stop-time=%d",
(int) (i_start+i_duration)/1000000 ) != -1)
i_options++;
}
/* Create the input item */
p_entry = input_item_NewExt( psz_mrl, psz_name, i_options,
(const char* const*) ppsz_options, VLC_INPUT_OPTION_TRUSTED, i_duration );
input_item_CopyOptions( p_current_input, p_entry );
/* Add the metadata */
if( psz_name )
input_item_SetTitle( p_entry, psz_name );
if( psz_artist )
input_item_SetArtist( p_entry, psz_artist );
if( psz_copyright )
input_item_SetCopyright( p_entry, psz_copyright );
if( psz_moreinfo )
input_item_SetURL( p_entry, psz_moreinfo );
if( psz_description )
input_item_SetDescription( p_entry, psz_description );
if( i_duration > 0)
input_item_SetDuration( p_entry, i_duration );
input_item_node_AppendItem( p_subitems, p_entry );
while( i_options )
free( ppsz_options[--i_options] );
free( psz_name );
free( psz_mrl );
}
}
}
while( i_type != XML_READER_ENDELEM || strncasecmp( psz_node, "ENTRY", 5 ) );
free( psz_href );
free( psz_title );
free( psz_artist );
free( psz_copyright );
free( psz_moreinfo );
free( psz_description );
}
/* "specs" : http://phobos.apple.com/static/iTunesRSS.html */
static int Demux( demux_t *p_demux )
{
bool b_item = false;
bool b_image = false;
xml_reader_t *p_xml_reader;
char *psz_elname = NULL;
char *psz_item_mrl = NULL;
char *psz_item_size = NULL;
char *psz_item_type = NULL;
char *psz_item_name = NULL;
char *psz_item_date = NULL;
char *psz_item_author = NULL;
char *psz_item_category = NULL;
char *psz_item_duration = NULL;
char *psz_item_keywords = NULL;
char *psz_item_subtitle = NULL;
char *psz_item_summary = NULL;
char *psz_art_url = NULL;
const char *node;
int i_type;
input_item_t *p_input;
input_item_node_t *p_subitems = NULL;
input_item_t *p_current_input = GetCurrentItem(p_demux);
p_xml_reader = xml_ReaderCreate( p_demux, p_demux->s );
if( !p_xml_reader )
goto error;
/* xml */
/* check root node */
if( xml_ReaderNextNode( p_xml_reader, &node ) != XML_READER_STARTELEM )
{
msg_Err( p_demux, "invalid file (no root node)" );
goto error;
}
if( strcmp( node, "rss" ) )
{
msg_Err( p_demux, "invalid root node <%s>", node );
goto error;
}
p_subitems = input_item_node_Create( p_current_input );
while( (i_type = xml_ReaderNextNode( p_xml_reader, &node )) > 0 )
{
switch( i_type )
{
case XML_READER_STARTELEM:
{
free( psz_elname );
psz_elname = strdup( node );
if( unlikely(!node) )
goto error;
if( !strcmp( node, "item" ) )
b_item = true;
else if( !strcmp( node, "image" ) )
b_image = true;
// Read the attributes
const char *attr, *value;
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) )
{
if( !strcmp( node, "enclosure" ) )
{
char **p = NULL;
if( !strcmp( attr, "url" ) )
p = &psz_item_mrl;
else if( !strcmp( attr, "length" ) )
p = &psz_item_size;
else if( !strcmp( attr, "type" ) )
p = &psz_item_type;
if( p != NULL )
{
free( *p );
*p = strdup( value );
}
else
msg_Dbg( p_demux,"unhandled attribute %s in <%s>",
attr, node );
}
else
msg_Dbg( p_demux,"unhandled attribute %s in <%s>",
attr, node );
}
break;
}
case XML_READER_TEXT:
{
if(!psz_elname) break;
/* item specific meta data */
if( b_item )
{
char **p;
if( !strcmp( psz_elname, "title" ) )
p = &psz_item_name;
else if( !strcmp( psz_elname, "itunes:author" ) ||
!strcmp( psz_elname, "author" ) )
/* <author> isn't standard iTunes podcast stuff */
p = &psz_item_author;
else if( !strcmp( psz_elname, "itunes:summary" ) ||
!strcmp( psz_elname, "description" ) )
/* <description> isn't standard iTunes podcast stuff */
p = &psz_item_summary;
else if( !strcmp( psz_elname, "pubDate" ) )
p = &psz_item_date;
else if( !strcmp( psz_elname, "itunes:category" ) )
p = &psz_item_category;
else if( !strcmp( psz_elname, "itunes:duration" ) )
p = &psz_item_duration;
else if( !strcmp( psz_elname, "itunes:keywords" ) )
p = &psz_item_keywords;
else if( !strcmp( psz_elname, "itunes:subtitle" ) )
p = &psz_item_subtitle;
else
break;
free( *p );
*p = strdup( node );
}
/* toplevel meta data */
else if( !b_image )
{
if( !strcmp( psz_elname, "title" ) )
input_item_SetName( p_current_input, node );
#define ADD_GINFO( info, name ) \
else if( !strcmp( psz_elname, name ) ) \
input_item_AddInfo( p_current_input, _("Podcast Info"), \
info, "%s", node );
ADD_GINFO( _("Podcast Link"), "link" )
ADD_GINFO( _("Podcast Copyright"), "copyright" )
ADD_GINFO( _("Podcast Category"), "itunes:category" )
ADD_GINFO( _("Podcast Keywords"), "itunes:keywords" )
ADD_GINFO( _("Podcast Subtitle"), "itunes:subtitle" )
#undef ADD_GINFO
else if( !strcmp( psz_elname, "itunes:summary" ) ||
!strcmp( psz_elname, "description" ) )
{ /* <description> isn't standard iTunes podcast stuff */
input_item_AddInfo( p_current_input,
_( "Podcast Info" ), _( "Podcast Summary" ),
"%s", node );
}
}
else
{
if( !strcmp( psz_elname, "url" ) )
{
free( psz_art_url );
psz_art_url = strdup( node );
}
else
msg_Dbg( p_demux, "unhandled text in element <%s>",
psz_elname );
}
break;
}
// End element
case XML_READER_ENDELEM:
{
FREENULL( psz_elname );
if( !strcmp( node, "item" ) )
{
if( psz_item_mrl == NULL )
{
if (psz_item_name)
msg_Warn( p_demux, "invalid XML item, skipping %s",
psz_item_name );
else
msg_Warn( p_demux, "invalid XML item, skipped" );
FREENULL( psz_item_name );
FREENULL( psz_item_size );
FREENULL( psz_item_type );
FREENULL( psz_item_date );
FREENULL( psz_item_author );
FREENULL( psz_item_category );
FREENULL( psz_item_duration );
FREENULL( psz_item_keywords );
FREENULL( psz_item_subtitle );
FREENULL( psz_item_summary );
FREENULL( psz_art_url );
FREENULL( psz_elname );
continue;
}
resolve_xml_special_chars( psz_item_mrl );
resolve_xml_special_chars( psz_item_name );
p_input = input_item_New( psz_item_mrl, psz_item_name );
FREENULL( psz_item_mrl );
FREENULL( psz_item_name );
if( p_input == NULL )
break; /* FIXME: meta data memory leaks? */
/* Set the duration if available */
if( psz_item_duration )
input_item_SetDuration( p_input, strTimeToMTime( psz_item_duration ) );
#define ADD_INFO( info, field ) \
if( field ) { \
input_item_AddInfo( p_input, _( "Podcast Info" ), (info), "%s", \
(field) ); \
FREENULL( field ); }
ADD_INFO( _("Podcast Publication Date"), psz_item_date );
ADD_INFO( _("Podcast Author"), psz_item_author );
ADD_INFO( _("Podcast Subcategory"), psz_item_category );
ADD_INFO( _("Podcast Duration"), psz_item_duration );
ADD_INFO( _("Podcast Keywords"), psz_item_keywords );
ADD_INFO( _("Podcast Subtitle"), psz_item_subtitle );
ADD_INFO( _("Podcast Summary"), psz_item_summary );
ADD_INFO( _("Podcast Type"), psz_item_type );
#undef ADD_INFO
/* Add the global art url to this item, if any */
if( psz_art_url )
{
resolve_xml_special_chars( psz_art_url );
input_item_SetArtURL( p_input, psz_art_url );
}
if( psz_item_size )
{
input_item_AddInfo( p_input,
_( "Podcast Info" ),
_( "Podcast Size" ),
_("%s bytes"),
psz_item_size );
FREENULL( psz_item_size );
}
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
b_item = false;
}
else if( !strcmp( node, "image" ) )
{
b_image = false;
}
break;
}
}
}
