static int Demux( demux_t *p_demux )
{
char *psz_line;
char *psz_uri = NULL;
char *psz_parse;
input_item_t *p_input;
INIT_PLAYLIST_STUFF;
psz_line = stream_ReadLine( p_demux->s );
while( psz_line )
{
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=\"" ) ) )
{
psz_uri = ParseUriValue( psz_parse );
if( !EMPTY_STR(psz_uri) )
{
psz_uri = ProcessMRL( psz_uri, p_demux->p_sys->psz_prefix );
MaybeFromLocaleRep( &psz_uri );
p_input = input_item_NewExt( p_demux, psz_uri, psz_uri,
0, NULL, 0, -1 );
input_item_AddSubItem( p_current_input, p_input );
}
free( psz_uri );
}
/* Fetch another line */
free( psz_line );
psz_line = stream_ReadLine( p_demux->s );
}
HANDLE_PLAY_AND_RELEASE;
var_Destroy( p_demux, "wpl-extvlcopt" );
return 0; /* Needed for correct operation of go back */
}
/*****************************************************************************
* Demux: reads and demuxes data packets
*****************************************************************************
* Returns -1 in case of error, 0 in case of EOF, 1 otherwise
*****************************************************************************/
static int Demux ( demux_t *p_demux )
{
char *psz_line;
while( ( psz_line = stream_ReadLine( p_demux->s ) ) )
{
ParseLine( p_demux, psz_line );
free( psz_line );
}
return VLC_SUCCESS;
}
static int vlclua_stream_readline( lua_State *L )
{
stream_t **pp_stream = (stream_t **)luaL_checkudata( L, 1, "stream" );
char *psz_line = stream_ReadLine( *pp_stream );
if( psz_line )
{
lua_pushstring( L, psz_line );
free( psz_line );
}
else
lua_pushnil( L );
return 1;
}
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_demux_readline( lua_State *L )
{
demux_t *p_demux = (demux_t *)vlclua_get_this( L );
char *psz_line = stream_ReadLine( p_demux->s );
if( psz_line )
{
lua_pushstring( L, psz_line );
free( psz_line );
}
else
{
lua_pushnil( L );
}
return 1;
}
/*****************************************************************************
* Demux: The important stuff
*****************************************************************************/
static int Demux( demux_t *p_demux )
{
char *psz_line;
input_item_t *p_input;
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 **ppsz_options = NULL;
int i_options = 0;
char *psz_name = NULL;
if( !ParseLine( psz_line, &psz_name, &ppsz_options, &i_options ) )
{
free( psz_line );
continue;
}
EnsureUTF8( psz_name );
for( int i = 0; i< i_options; i++ )
EnsureUTF8( ppsz_options[i] );
p_input = input_item_NewExt( "dvb://", psz_name,
i_options, (const char**)ppsz_options, VLC_INPUT_OPTION_TRUSTED, -1 );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
while( i_options-- )
free( ppsz_options[i_options] );
free( ppsz_options );
free( psz_line );
}
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref(p_current_input);
return 0; /* Needed for correct operation of go back */
}
/** Parses the whole channels.conf file */
static int Demux(demux_t *demux)
{
input_item_t *input = GetCurrentItem(demux);
input_item_node_t *subitems = input_item_node_Create(input);
char *line;
while ((line = stream_ReadLine(demux->s)) != NULL)
{
input_item_t *item = ParseLine(line);
if (item == NULL)
continue;
input_item_node_AppendItem(subitems, item);
vlc_gc_decref(item);
}
input_item_node_PostAndDelete(subitems);
vlc_gc_decref(input);
return 0; /* Needed for correct operation of go back */
}
static int Demux( demux_t *p_demux)
{
char *psz_line;
/* Attach playlist and start reading data */
playlist_t *p_playlist;
p_playlist = (playlist_t*)vlc_object_find( p_demux,
VLC_OBJECT_PLAYLIST, FIND_PARENT );
if( !p_playlist )
{
msg_Err( p_demux, "cannot attach playlist" );
return VLC_EGENERIC;
}
p_playlist->pp_items[p_playlist->i_index]->b_autodeletion = VLC_TRUE;
while( ( psz_line = stream_ReadLine( p_demux->s) ) != NULL )
{
if( ( psz_line[0] == '#' ) || (psz_line[0] == '\r') ||
( psz_line[0] == '\n') || (psz_line[0] == (char)0) )
{
continue;
}
/* Remove end of line */
if( psz_line[strlen(psz_line) -1 ] == '\n' ||
psz_line[strlen(psz_line) -1 ] == '\r' )
{
psz_line[ strlen(psz_line) -1 ] = (char)0;
if( psz_line[strlen(psz_line) - 1 ] == '\r' )
psz_line[strlen(psz_line) - 1 ] = (char)0;
}
playlist_Add( p_playlist, psz_line, psz_line, PLAYLIST_APPEND,
PLAYLIST_END );
free( psz_line );
}
p_demux->b_die = VLC_TRUE;
vlc_object_release( p_playlist );
return VLC_SUCCESS;
}
static int Demux( demux_t *p_demux )
{
char *psz_name = NULL;
char *psz_line;
char *psz_mrl = NULL;
char *psz_mrl_orig = NULL;
char *psz_key;
char *psz_value;
int i_item = -1;
input_item_t *p_input;
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 ) ) )
{
if( !strncasecmp( psz_line, "[playlist]", sizeof("[playlist]")-1 ) ||
!strncasecmp( psz_line, "[Reference]", sizeof("[Reference]")-1 ) )
{
free( psz_line );
continue;
}
psz_key = psz_line;
psz_value = strchr( psz_line, '=' );
if( psz_value )
{
*psz_value='\0';
psz_value++;
}
else
{
free( psz_line );
continue;
}
if( !strcasecmp( psz_key, "version" ) )
{
msg_Dbg( p_demux, "pls file version: %s", psz_value );
free( psz_line );
continue;
}
if( !strcasecmp( psz_key, "numberofentries" ) )
{
msg_Dbg( p_demux, "pls should have %d entries", atoi(psz_value) );
free( psz_line);
continue;
}
/* find the number part of of file1, title1 or length1 etc */
int i_new_item;
if( sscanf( psz_key, "%*[^0-9]%d", &i_new_item ) != 1 )
{
msg_Warn( p_demux, "couldn't find number of items" );
free( psz_line );
continue;
}
if( i_item == -1 )
i_item = i_new_item;
else if( i_item != i_new_item )
{
/* we found a new item, insert the previous */
if( psz_mrl )
{
p_input = input_item_New( psz_mrl, psz_name );
input_item_CopyOptions( p_current_input, p_input );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
free( psz_mrl_orig );
psz_mrl_orig = psz_mrl = NULL;
}
else
{
msg_Warn( p_demux, "no file= part found for item %d", i_item );
}
free( psz_name );
psz_name = NULL;
i_item = i_new_item;
}
if( !strncasecmp( psz_key, "file", sizeof("file") -1 ) ||
!strncasecmp( psz_key, "Ref", sizeof("Ref") -1 ) )
{
free( psz_mrl_orig );
psz_mrl_orig =
psz_mrl = ProcessMRL( psz_value, p_demux->p_sys->psz_prefix );
if( !strncasecmp( psz_key, "Ref", sizeof("Ref") -1 ) )
{
if( !strncasecmp( psz_mrl, "http://", sizeof("http://") -1 ) )
memcpy( psz_mrl, "mmsh", 4 );
}
}
else if( !strncasecmp( psz_key, "title", sizeof("title") -1 ) )
{
free( psz_name );
psz_name = strdup( psz_value );
}
else if( !strncasecmp( psz_key, "length", sizeof("length") -1 ) )
/* duration in seconds */;
else
{
msg_Warn( p_demux, "unknown key found in pls file: %s", psz_key );
}
free( psz_line );
}
/* Add last object */
if( psz_mrl )
{
p_input = input_item_New( psz_mrl, psz_name );
input_item_CopyOptions( p_current_input, p_input );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
free( psz_mrl_orig );
}
else
{
msg_Warn( p_demux, "no file= part found for item %d", i_item );
}
free( psz_name );
psz_name = NULL;
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref(p_current_input);
return 0; /* Needed for correct operation of go back */
}
/*****************************************************************************
* Demux: The important stuff
*****************************************************************************/
static int Demux( demux_t *p_demux )
{
playlist_t *p_playlist;
char *psz_line;
playlist_item_t *p_current;
vlc_bool_t b_play;
p_playlist = (playlist_t *) vlc_object_find( p_demux, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( !p_playlist )
{
msg_Err( p_demux, "can't find playlist" );
return -1;
}
b_play = E_(FindItem)( p_demux, p_playlist, &p_current );
playlist_ItemToNode( p_playlist, p_current );
p_current->input.i_type = ITEM_TYPE_PLAYLIST;
while( (psz_line = stream_ReadLine( p_demux->s )) )
{
playlist_item_t *p_item;
char **ppsz_options = NULL;
int i, i_options = 0;
char *psz_name = NULL;
if( !ParseLine( psz_line, &psz_name, &ppsz_options, &i_options ) )
{
free( psz_line );
continue;
}
EnsureUTF8( psz_name );
p_item = playlist_ItemNew( p_playlist, "dvb:", psz_name );
for( i = 0; i< i_options; i++ )
{
EnsureUTF8( ppsz_options[i] );
playlist_ItemAddOption( p_item, ppsz_options[i] );
}
playlist_NodeAddItem( p_playlist, p_item,
p_current->pp_parents[0]->i_view,
p_current, PLAYLIST_APPEND, PLAYLIST_END );
/* We need to declare the parents of the node as the
* * same of the parent's ones */
playlist_CopyParents( p_current, p_item );
vlc_input_item_CopyOptions( &p_current->input, &p_item->input );
while( i_options-- ) free( ppsz_options[i_options] );
if( ppsz_options ) free( ppsz_options );
free( psz_line );
}
/* Go back and play the playlist */
if( b_play && p_playlist->status.p_item &&
p_playlist->status.p_item->i_children > 0 )
{
playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
p_playlist->status.i_view,
p_playlist->status.p_item,
p_playlist->status.p_item->pp_children[0] );
}
vlc_object_release( p_playlist );
return VLC_SUCCESS;
}
static int Demux( demux_t *p_demux )
{
int i_ret = -1;
xml_reader_t *p_xml_reader = NULL;
char *psz_elname = NULL;
input_item_t *p_input;
char *psz_mrl = NULL, *psz_title = NULL, *psz_genre = NULL;
char *psz_now = NULL, *psz_listeners = NULL, *psz_bitrate = NULL;
input_item_node_t *p_subitems = NULL;
input_item_t *p_current_input = GetCurrentItem(p_demux);
psz_elname = stream_ReadLine( p_demux->s );
free( psz_elname );
psz_elname = NULL;
p_xml_reader = xml_ReaderCreate( p_demux, p_demux->s );
if( !p_xml_reader )
goto end;
/* xml */
/* check root node */
if( xml_ReaderRead( p_xml_reader ) != 1 )
{
msg_Err( p_demux, "invalid file (no root node)" );
goto end;
}
if( xml_ReaderNodeType( p_xml_reader ) != XML_READER_STARTELEM ||
( psz_elname = xml_ReaderName( p_xml_reader ) ) == NULL ||
strcmp( psz_elname, "WinampXML" ) )
{
msg_Err( p_demux, "invalid root node %i, %s",
xml_ReaderNodeType( p_xml_reader ), psz_elname );
goto end;
}
FREENULL( psz_elname );
/* root node should not have any attributes, and should only
* contain the "playlist node */
/* Skip until 1st child node */
while( (i_ret = xml_ReaderRead( p_xml_reader )) == 1 &&
xml_ReaderNodeType( p_xml_reader ) != XML_READER_STARTELEM );
if( i_ret != 1 )
{
msg_Err( p_demux, "invalid file (no child node)" );
goto end;
}
if( ( psz_elname = xml_ReaderName( p_xml_reader ) ) == NULL ||
strcmp( psz_elname, "playlist" ) )
{
msg_Err( p_demux, "invalid child node %s", psz_elname );
goto end;
}
FREENULL( psz_elname );
// Read the attributes
while( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
{
char *psz_name = xml_ReaderName( p_xml_reader );
char *psz_value = xml_ReaderValue( p_xml_reader );
if( !psz_name || !psz_value )
{
free( psz_name );
free( psz_value );
goto end;
}
if( !strcmp( psz_name, "num_entries" ) )
{
msg_Dbg( p_demux, "playlist has %d entries", atoi(psz_value) );
}
else if( !strcmp( psz_name, "label" ) )
{
input_item_SetName( p_current_input, psz_value );
}
else
{
msg_Warn( p_demux, "stray attribute %s with value %s in element"
" 'playlist'", psz_name, psz_value );
}
free( psz_name );
free( psz_value );
}
p_subitems = input_item_node_Create( p_current_input );
while( (i_ret = xml_ReaderRead( p_xml_reader )) == 1 )
{
// Get the node type
switch( xml_ReaderNodeType( p_xml_reader ) )
{
// Error
case -1:
goto end;
case XML_READER_STARTELEM:
{
// Read the element name
free( psz_elname );
psz_elname = xml_ReaderName( p_xml_reader );
if( !psz_elname )
goto end;
// Read the attributes
while( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
{
char *psz_name = xml_ReaderName( p_xml_reader );
char *psz_value = xml_ReaderValue( p_xml_reader );
if( !psz_name || !psz_value )
{
free( psz_name );
free( psz_value );
goto end;
}
if( !strcmp( psz_elname, "entry" ) &&
!strcmp( psz_name, "Playstring" ) )
{
psz_mrl = psz_value;
}
else
{
msg_Warn( p_demux, "unexpected attribute %s in element %s",
psz_name, psz_elname );
free( psz_value );
}
free( psz_name );
}
break;
}
case XML_READER_TEXT:
{
char *psz_text = xml_ReaderValue( p_xml_reader );
if( IsWhitespace( psz_text ) )
{
free( psz_text );
break;
}
if( !strcmp( psz_elname, "Name" ) )
{
psz_title = psz_text;
}
else if( !strcmp( psz_elname, "Genre" ) )
{
psz_genre = psz_text;
}
else if( !strcmp( psz_elname, "Nowplaying" ) )
{
psz_now = psz_text;
}
else if( !strcmp( psz_elname, "Listeners" ) )
{
psz_listeners = psz_text;
}
else if( !strcmp( psz_elname, "Bitrate" ) )
{
psz_bitrate = psz_text;
}
else if( !strcmp( psz_elname, "" ) )
{
free( psz_text );
}
else
{
msg_Warn( p_demux, "unexpected text in element '%s'",
psz_elname );
free( psz_text );
}
break;
}
// End element
case XML_READER_ENDELEM:
{
// Read the element name
free( psz_elname );
psz_elname = xml_ReaderName( p_xml_reader );
if( !psz_elname )
goto end;
if( !strcmp( psz_elname, "entry" ) )
{
p_input = input_item_New( p_demux, psz_mrl, psz_title );
if( psz_now )
input_item_SetNowPlaying( p_input, psz_now );
if( psz_genre )
input_item_SetGenre( p_input, psz_genre );
if( psz_listeners )
msg_Err( p_demux, "Unsupported meta listeners" );
if( psz_bitrate )
msg_Err( p_demux, "Unsupported meta bitrate" );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
FREENULL( psz_title );
FREENULL( psz_mrl );
FREENULL( psz_genre );
FREENULL( psz_bitrate );
FREENULL( psz_listeners );
FREENULL( psz_now );
}
free( psz_elname );
psz_elname = strdup( "" );
break;
}
}
}
if( i_ret != 0 )
{
msg_Warn( p_demux, "error while parsing data" );
i_ret = 0; /* Needed for correct operation of go back */
}
end:
free( psz_elname );
if( p_subitems )
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref( p_current_input );
if( p_xml_reader )
xml_ReaderDelete( p_xml_reader );
return i_ret;
}
static int Demux( demux_t *p_demux )
{
char *psz_line;
char *psz_name = NULL;
char *psz_artist = NULL;
char *psz_album_art = NULL;
int i_parsed_duration = 0;
mtime_t i_duration = -1;
const char**ppsz_options = NULL;
char * (*pf_dup) (const char *) = p_demux->p_sys->pf_dup;
int i_options = 0;
bool b_cleanup = false;
input_item_t *p_input;
input_item_t *p_current_input = GetCurrentItem(p_demux);
input_item_node_t *p_subitems = input_item_node_Create( p_current_input );
psz_line = stream_ReadLine( p_demux->s );
while( psz_line )
{
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( *psz_parse == '#' )
{
/* Parse extra info */
/* Skip leading tabs and spaces */
while( *psz_parse == ' ' || *psz_parse == '\t' ||
*psz_parse == '\n' || *psz_parse == '\r' ||
*psz_parse == '#' ) psz_parse++;
if( !*psz_parse ) goto error;
if( !strncasecmp( psz_parse, "EXTINF:", sizeof("EXTINF:") -1 ) )
{
/* Extended info */
psz_parse += sizeof("EXTINF:") - 1;
FREENULL( psz_name );
FREENULL( psz_artist );
parseEXTINF( psz_parse, &psz_artist, &psz_name, &i_parsed_duration );
if( i_parsed_duration >= 0 )
i_duration = i_parsed_duration * INT64_C(1000000);
if( psz_name )
psz_name = pf_dup( psz_name );
if( psz_artist )
psz_artist = pf_dup( psz_artist );
}
else if( !strncasecmp( psz_parse, "EXTVLCOPT:",
sizeof("EXTVLCOPT:") -1 ) )
{
/* VLC Option */
char *psz_option;
psz_parse += sizeof("EXTVLCOPT:") -1;
if( !*psz_parse ) goto error;
psz_option = pf_dup( psz_parse );
if( psz_option )
INSERT_ELEM( ppsz_options, i_options, i_options,
psz_option );
}
/* Special case for jamendo which provide the albumart */
else if( !strncasecmp( psz_parse, "EXTALBUMARTURL:",
sizeof( "EXTALBUMARTURL:" ) -1 ) )
{
psz_parse += sizeof( "EXTALBUMARTURL:" ) - 1;
free( psz_album_art );
psz_album_art = pf_dup( psz_parse );
}
}
else if( !strncasecmp( psz_parse, "RTSPtext", sizeof("RTSPtext") -1 ) )
{
;/* special case to handle QuickTime RTSPtext redirect files */
}
else if( *psz_parse )
{
char *psz_mrl;
psz_parse = pf_dup( psz_parse );
if( !psz_name && psz_parse )
/* Use filename as name for relative entries */
psz_name = strdup( psz_parse );
psz_mrl = ProcessMRL( psz_parse, p_demux->p_sys->psz_prefix );
b_cleanup = true;
if( !psz_mrl )
{
free( psz_parse );
goto error;
}
p_input = input_item_NewExt( psz_mrl, psz_name,
i_options, ppsz_options, 0, i_duration );
free( psz_parse );
free( psz_mrl );
if( !EMPTY_STR(psz_artist) )
input_item_SetArtist( p_input, psz_artist );
if( psz_name ) input_item_SetTitle( p_input, psz_name );
if( !EMPTY_STR(psz_album_art) )
input_item_SetArtURL( p_input, psz_album_art );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
}
error:
/* Fetch another line */
free( psz_line );
psz_line = stream_ReadLine( p_demux->s );
if( !psz_line ) b_cleanup = true;
if( b_cleanup )
{
/* Cleanup state */
while( i_options-- ) free( (char*)ppsz_options[i_options] );
FREENULL( ppsz_options );
i_options = 0;
FREENULL( psz_name );
FREENULL( psz_artist );
FREENULL( psz_album_art );
i_parsed_duration = 0;
i_duration = -1;
b_cleanup = false;
}
}
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref(p_current_input);
var_Destroy( p_demux, "m3u-extvlcopt" );
return 0; /* Needed for correct operation of go back */
}
static int Demux( demux_t *p_demux )
{
mtime_t i_duration = -1;
char *psz_name = NULL;
char *psz_line;
char *psz_mrl = NULL;
char *psz_key;
char *psz_value;
playlist_t *p_playlist;
int i_position;
int i_item = -1;
int i_new_item = 0;
int i_key_length;
playlist_item_t *p_parent;
vlc_bool_t b_play;
p_playlist = (playlist_t *) vlc_object_find( p_demux, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( !p_playlist )
{
msg_Err( p_demux, "can't find playlist" );
return -1;
}
b_play = E_(FindItem)( p_demux, p_playlist, &p_parent );
p_parent->input.i_type = ITEM_TYPE_PLAYLIST;
/* Change the item to a node */
if( p_parent->i_children == -1)
{
playlist_ItemToNode( p_playlist,p_parent );
}
while( ( psz_line = stream_ReadLine( p_demux->s ) ) )
{
if( !strncasecmp( psz_line, "[playlist]", sizeof("[playlist]")-1 ) )
{
free( psz_line );
continue;
}
psz_key = psz_line;
psz_value = strchr( psz_line, '=' );
if( psz_value )
{
*psz_value='\0';
psz_value++;
}
else
{
msg_Warn( p_demux, "invalid line in pls file" );
free( psz_line );
continue;
}
if( !strcasecmp( psz_key, "version" ) )
{
msg_Dbg( p_demux, "pls file version: %s", psz_value );
free( psz_line );
continue;
}
/* find the number part of of file1, title1 or length1 etc */
i_key_length = strlen( psz_key );
if( i_key_length >= 5 ) /* file1 type case */
{
i_new_item = atoi( psz_key + 4 );
if( i_new_item == 0 && i_key_length >= 6 ) /* title1 type case */
{
i_new_item = atoi( psz_key + 5 );
if( i_new_item == 0 && i_key_length >= 7 ) /* length1 type case */
{
i_new_item = atoi( psz_key + 6 );
}
}
}
if( i_new_item == 0 )
{
msg_Warn( p_demux, "couldn't find number of items" );
free( psz_line );
continue;
}
if( i_item == -1 )
{
i_item = i_new_item;
}
/* we found a new item, insert the previous */
if( i_item != i_new_item )
{
if( psz_mrl )
{
playlist_item_t *p_item = playlist_ItemNew( p_playlist, psz_mrl,
psz_name );
playlist_NodeAddItem( p_playlist,p_item,
p_parent->pp_parents[0]->i_view,
p_parent,
PLAYLIST_APPEND, PLAYLIST_END );
playlist_CopyParents( p_parent, p_item );
if( i_duration != -1 )
{
//playlist_SetDuration( p_playlist, i_position, i_duration );
}
i_position++;
free( psz_mrl );
psz_mrl = NULL;
vlc_input_item_CopyOptions( &p_parent->input,
&p_item->input );
}
else
{
msg_Warn( p_demux, "no file= part found for item %d", i_item );
}
if( psz_name )
{
free( psz_name );
psz_name = NULL;
}
i_duration = -1;
i_item = i_new_item;
i_new_item = 0;
}
if( !strncasecmp( psz_key, "file", sizeof("file") -1 ) )
{
psz_mrl = E_(ProcessMRL)( psz_value, p_demux->p_sys->psz_prefix );
}
else if( !strncasecmp( psz_key, "title", sizeof("title") -1 ) )
{
psz_name = strdup( psz_value );
}
else if( !strncasecmp( psz_key, "length", sizeof("length") -1 ) )
{
i_duration = atoi( psz_value );
if( i_duration != -1 )
{
i_duration *= 1000000;
}
}
else
{
msg_Warn( p_demux, "unknown key found in pls file: %s", psz_key );
}
free( psz_line );
}
/* Add last object */
if( psz_mrl )
{
playlist_item_t *p_item = playlist_ItemNew( p_playlist, psz_mrl,
psz_name );
playlist_NodeAddItem( p_playlist,p_item,
p_parent->pp_parents[0]->i_view,
p_parent,
PLAYLIST_APPEND, PLAYLIST_END );
playlist_CopyParents( p_parent, p_item );
if( i_duration != -1 )
{
//playlist_SetDuration( p_playlist, i_position, i_duration );
}
free( psz_mrl );
psz_mrl = NULL;
vlc_input_item_CopyOptions( &p_parent->input,
&p_item->input );
}
else
{
msg_Warn( p_demux, "no file= part found for item %d", i_item );
}
if( psz_name )
{
free( psz_name );
psz_name = NULL;
}
if( b_play && p_playlist->status.p_item &&
p_playlist->status.p_item->i_children > 0 )
{
playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
p_playlist->status.i_view,
p_playlist->status.p_item,
p_playlist->status.p_item->pp_children[0] );
}
vlc_object_release( p_playlist );
return VLC_SUCCESS;
}
static int Demux( demux_t *p_demux )
{
char *psz_line;
mtime_t i_duration = -1;
char *psz_title = NULL, *psz_genre = NULL, *psz_tracknum = NULL,
*psz_language = NULL, *psz_artist = NULL, *psz_album = NULL,
*psz_date = NULL, *psz_publisher = NULL, *psz_encodedby = NULL,
*psz_description = NULL, *psz_url = NULL, *psz_copyright = NULL,
*psz_mrl = NULL;
input_item_t *p_current_input = GetCurrentItem(p_demux);
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 1st line is "AC", skip it */
/* TODO: using this information ? */
if( !strncasecmp( psz_parse, "AC", strlen( "AC" ) ) )
{
free( psz_line );
psz_line = stream_ReadLine( p_demux->s );
}
input_item_node_t *p_subitems = input_item_node_Create( p_current_input );
/* Loop on all lines */
while( psz_line )
{
psz_parse = psz_line;
/* Skip leading tabs and spaces */
while( *psz_parse == ' ' || *psz_parse == '\t' ||
*psz_parse == '\n' || *psz_parse == '\r' )
psz_parse++;
/* filename */
if( !strncasecmp( psz_parse, "NM", strlen( "NM" ) ) )
{
char *psz_tabvalue = ParseTabValue( psz_parse );
if( !EMPTY_STR(psz_tabvalue) )
{
psz_mrl = ProcessMRL( psz_tabvalue, p_demux->p_sys->psz_prefix );
}
free( psz_tabvalue );
}
/* duration */
else if( !strncasecmp( psz_parse, "DR", strlen( "DR" ) ) )
{
char *psz_tabvalue = ParseTabValue( psz_parse );
if( !EMPTY_STR(psz_tabvalue) )
{
int i_parsed_duration = atoi( psz_tabvalue );
if( i_parsed_duration >= 0 )
i_duration = i_parsed_duration * INT64_C(1000);
}
free( psz_tabvalue );
}
#define PARSE(tag,variable) \
else if( !strncasecmp( psz_parse, tag, strlen( tag ) ) ) \
variable = ParseTabValue( psz_parse );
PARSE( "TT", psz_title )
PARSE( "TG", psz_genre )
PARSE( "TR", psz_tracknum )
PARSE( "TL", psz_language )
PARSE( "TA", psz_artist )
PARSE( "TB", psz_album )
PARSE( "TY", psz_date )
PARSE( "TH", psz_publisher )
PARSE( "TE", psz_encodedby )
PARSE( "TC", psz_description )
PARSE( "TU", psz_url )
PARSE( "TO", psz_copyright )
#undef PARSE
/* force a duration ? */
else if( !strncasecmp( psz_parse, "FD", strlen( "FD" ) ) )
{}
/* end of file entry */
else if( !strncasecmp( psz_parse, "BR!", strlen( "BR!" ) ) )
{
/* create the input item */
input_item_t *p_input = input_item_NewExt( p_demux, psz_mrl,
psz_title, 0, NULL, 0, i_duration );
input_item_node_AppendItem( p_subitems, p_input );
FREENULL( psz_mrl );
FREENULL( psz_title );
i_duration = -1;
#define SET(variable, type) \
if( !EMPTY_STR(variable) ) \
{ \
input_item_Set##type( p_input, variable ); \
FREENULL( variable ); \
}
/* set the meta */
SET( psz_genre, Genre );
SET( psz_tracknum, TrackNum );
SET( psz_language, Language );
SET( psz_artist, Artist );
SET( psz_album, Album );
SET( psz_date, Date );
SET( psz_encodedby, EncodedBy );
SET( psz_description, Description );
SET( psz_copyright, Copyright );
#undef SET
vlc_gc_decref( p_input );
}
else
msg_Warn( p_demux, "invalid line '%s'", psz_parse );
/* Fetch another line */
free( psz_line );
psz_line = stream_ReadLine( p_demux->s );
}
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref(p_current_input);
var_Destroy( p_demux, "zpl-extvlcopt" );
return 0; /* Needed for correct operation of go back */
}
static int Demux( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
char *psz_line;
char *psz_attrvalue;
char *psz_version = NULL;
char *psz_url = NULL;
char *psz_docid = NULL;
int i_duration = -1;
char *psz_title = NULL;
char *psz_description = NULL;
input_item_t *p_input;
input_item_t *p_current_input = GetCurrentItem(p_demux);
input_item_node_t *p_subitems = input_item_node_Create( p_current_input );
p_sys->p_current_input = p_current_input;
while( ( psz_line = stream_ReadLine( p_demux->s ) ) )
{
if( *psz_line == '#' )
{
/* This is a comment */
free( psz_line );
continue;
}
psz_attrvalue = strchr( psz_line, ':' );
if( !psz_attrvalue )
{
msg_Dbg( p_demux, "Unable to parse line (%s)", psz_line );
free( psz_line );
continue;
}
*psz_attrvalue = '\0';
psz_attrvalue++;
if( !strcmp( psz_line, "gvp_version" ) )
{
psz_version = strdup( psz_attrvalue );
}
else if( !strcmp( psz_line, "url" ) )
{
psz_url = strdup( psz_attrvalue );
}
else if( !strcmp( psz_line, "docid" ) )
{
psz_docid = strdup( psz_attrvalue );
}
else if( !strcmp( psz_line, "duration" ) )
{
i_duration = atoi( psz_attrvalue );
}
else if( !strcmp( psz_line, "title" ) )
{
psz_title = strdup( psz_attrvalue );
}
else if( !strcmp( psz_line, "description" ) )
{
char *buf;
if( !psz_description )
{
psz_description = strdup( psz_attrvalue );
}
else
{
/* handle multi-line descriptions */
if( asprintf( &buf, "%s\n%s", psz_description, psz_attrvalue ) == -1 )
buf = NULL;
free( psz_description );
psz_description = buf;
}
/* remove ^M char at the end of the line (if any) */
buf = psz_description + strlen( psz_description );
if( buf != psz_description )
{
buf--;
if( *buf == '\r' ) *buf = '\0';
}
}
free( psz_line );
}
if( !psz_url )
{
msg_Err( p_demux, "URL not found" );
}
else
{
p_input = input_item_New( psz_url, psz_title );
#define SADD_INFO( type, field ) if( field ) { input_item_AddInfo( \
p_input, _("Google Video"), type, "%s", field ) ; }
SADD_INFO( "gvp_version", psz_version );
SADD_INFO( "docid", psz_docid );
SADD_INFO( "description", psz_description );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
}
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref(p_current_input);
free( psz_version );
free( psz_url );
free( psz_docid );
free( psz_title );
free( psz_description );
return 0; /* Needed for correct operation of go back */
}
static int Demux( demux_t *p_demux )
{
playlist_t *p_playlist;
char *psz_line;
int i_position;
char *psz_name = NULL;
mtime_t i_duration = -1;
char **ppsz_options = NULL;
int i_options = 0;
vlc_bool_t b_cleanup = VLC_FALSE;
p_playlist = (playlist_t *) vlc_object_find( p_demux, VLC_OBJECT_PLAYLIST,
FIND_PARENT );
if( !p_playlist )
{
msg_Err( p_demux, "can't find playlist" );
return -1;
}
vlc_mutex_lock( &p_playlist->object_lock );
p_playlist->pp_items[p_playlist->i_index]->b_autodeletion = VLC_TRUE;
i_position = p_playlist->i_index + 1;
vlc_mutex_unlock( &p_playlist->object_lock );
psz_line = stream_ReadLine( p_demux->s );
while( psz_line )
{
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( *psz_parse == '#' )
{
/* Parse extra info */
/* Skip leading tabs and spaces */
while( *psz_parse == ' ' || *psz_parse == '\t' ||
*psz_parse == '\n' || *psz_parse == '\r' ||
*psz_parse == '#' ) psz_parse++;
if( !*psz_parse ) goto error;
if( !strncasecmp( psz_parse, "EXTINF:", sizeof("EXTINF:") -1 ) )
{
/* Extended info */
char *psz_duration;
psz_parse += sizeof("EXTINF:") - 1;
while( *psz_parse == '\t' || *psz_parse == ' ' ) psz_parse++;
psz_duration = psz_parse;
psz_parse = strchr( psz_parse, ',' );
if( psz_parse )
{
*psz_parse = '\0';
psz_parse++;
psz_name = strdup( psz_parse );
i_duration = atoi( psz_duration );
if( i_duration != -1 ) i_duration *= 1000000;
}
}
else if( !strncasecmp( psz_parse, "EXTVLCOPT:",
sizeof("EXTVLCOPT:") -1 ) )
{
/* VLC Option */
char *psz_option;
psz_parse += sizeof("EXTVLCOPT:") -1;
if( !*psz_parse ) goto error;
psz_option = strdup( psz_parse );
if( psz_option )
INSERT_ELEM( ppsz_options, i_options, i_options,
psz_option );
}
}
else if( *psz_parse )
{
char *psz_mrl =
ProcessMRL( psz_parse, p_demux->p_sys->psz_prefix );
b_cleanup = VLC_TRUE;
if( !psz_mrl ) goto error;
playlist_AddExt( p_playlist, psz_mrl, psz_name,
PLAYLIST_INSERT, i_position, i_duration,
(const char **)ppsz_options, i_options );
i_position++;
free( psz_mrl );
}
error:
/* Fetch another line */
free( psz_line );
psz_line = stream_ReadLine( p_demux->s );
if( !psz_line ) b_cleanup = VLC_TRUE;
if( b_cleanup )
{
/* Cleanup state */
while( i_options-- ) free( ppsz_options[i_options] );
if( ppsz_options ) free( ppsz_options );
ppsz_options = NULL; i_options = 0;
if( psz_name ) free( psz_name );
psz_name = NULL;
i_duration = -1;
b_cleanup = VLC_FALSE;
}
}
vlc_object_release( p_playlist );
return VLC_SUCCESS;
}
static int Demux( demux_t *p_demux )
{
int i_ret = -1;
xml_reader_t *p_xml_reader = NULL;
char *psz_elname = NULL;
const char *node;
input_item_t *p_input;
char *psz_mrl = NULL, *psz_title = NULL, *psz_genre = NULL;
char *psz_now = NULL, *psz_listeners = NULL, *psz_bitrate = NULL;
input_item_node_t *p_subitems = NULL;
input_item_t *p_current_input = GetCurrentItem(p_demux);
free( stream_ReadLine( p_demux->s ) );
p_xml_reader = xml_ReaderCreate( p_demux, p_demux->s );
if( !p_xml_reader )
return -1;
/* xml */
/* check root node */
if( xml_ReaderNextNode( p_xml_reader, &node ) != XML_READER_STARTELEM )
{
msg_Err( p_demux, "invalid file (no root node)" );
goto end;
}
if( strcmp( node, "WinampXML" ) )
{
msg_Err( p_demux, "invalid root node: %s", node );
goto end;
}
/* root node should not have any attributes, and should only
* contain the "playlist node */
/* Skip until 1st child node */
while( (i_ret = xml_ReaderNextNode( p_xml_reader, &node )) != XML_READER_STARTELEM )
if( i_ret <= 0 )
{
msg_Err( p_demux, "invalid file (no child node)" );
goto end;
}
if( strcmp( node, "playlist" ) )
{
msg_Err( p_demux, "invalid child node %s", node );
goto end;
}
// Read the attributes
const char *attr, *value;
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) != NULL )
{
if( !strcmp( attr, "num_entries" ) )
msg_Dbg( p_demux, "playlist has %d entries", atoi(value) );
else if( !strcmp( attr, "label" ) )
input_item_SetName( p_current_input, value );
else
msg_Warn( p_demux, "stray attribute %s with value %s in element"
" <playlist>", attr, value );
}
p_subitems = input_item_node_Create( p_current_input );
while( (i_ret = xml_ReaderNextNode( p_xml_reader, &node )) > 0 )
{
// Get the node type
switch( i_ret )
{
case XML_READER_STARTELEM:
{
// Read the element name
free( psz_elname );
psz_elname = strdup( node );
if( unlikely(!psz_elname) )
goto end;
// Read the attributes
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) )
{
if( !strcmp( psz_elname, "entry" ) &&
!strcmp( attr, "Playstring" ) )
{
free( psz_mrl );
psz_mrl = strdup( value );
}
else
{
msg_Warn( p_demux, "unexpected attribute %s in <%s>",
attr, psz_elname );
}
}
break;
}
case XML_READER_TEXT:
{
char **p;
if( psz_elname == NULL )
break;
if( IsWhitespace( node ) )
break;
if( !strcmp( psz_elname, "Name" ) )
p = &psz_title;
else if( !strcmp( psz_elname, "Genre" ) )
p = &psz_genre;
else if( !strcmp( psz_elname, "Nowplaying" ) )
p = &psz_now;
else if( !strcmp( psz_elname, "Listeners" ) )
p = &psz_listeners;
else if( !strcmp( psz_elname, "Bitrate" ) )
p = &psz_bitrate;
else
{
msg_Warn( p_demux, "unexpected text in element <%s>",
psz_elname );
break;
}
free( *p );
*p = strdup( node );
break;
}
// End element
case XML_READER_ENDELEM:
{
// Read the element name
if( !strcmp( node, "entry" ) )
{
p_input = input_item_New( p_demux, psz_mrl, psz_title );
if( psz_now )
input_item_SetNowPlaying( p_input, psz_now );
if( psz_genre )
input_item_SetGenre( p_input, psz_genre );
if( psz_listeners )
msg_Err( p_demux, "Unsupported meta listeners" );
if( psz_bitrate )
msg_Err( p_demux, "Unsupported meta bitrate" );
input_item_node_AppendItem( p_subitems, p_input );
vlc_gc_decref( p_input );
FREENULL( psz_title );
FREENULL( psz_mrl );
FREENULL( psz_genre );
FREENULL( psz_bitrate );
FREENULL( psz_listeners );
FREENULL( psz_now );
}
FREENULL( psz_elname );
break;
}
}
}
if( i_ret < 0 )
{
msg_Warn( p_demux, "error while parsing data" );
i_ret = 0; /* Needed for correct operation of go back */
}
end:
free( psz_elname );
if( p_subitems )
input_item_node_PostAndDelete( p_subitems );
vlc_gc_decref( p_current_input );
if( p_xml_reader )
xml_ReaderDelete( p_xml_reader );
return i_ret;
}
/*****************************************************************************
* Open: initializes raw DV demux structures
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
int i_width=-1, i_height=-1;
unsigned u_fps_num, u_fps_den;
vlc_fourcc_t i_chroma = 0;
unsigned int i_sar_num;
unsigned int i_sar_den;
const struct preset_t *p_preset = NULL;
const uint8_t *p_peek;
bool b_y4m = false;
if( stream_Peek( p_demux->s, &p_peek, 9 ) == 9 )
{
/* http://wiki.multimedia.cx/index.php?title=YUV4MPEG2 */
if( !strncmp( (char *)p_peek, "YUV4MPEG2", 9 ) )
{
b_y4m = true;
goto valid;
}
}
if( !p_demux->b_force )
{
/* guess preset based on file extension */
if( !p_demux->psz_file )
return VLC_EGENERIC;
const char *psz_ext = strrchr( p_demux->psz_file, '.' );
if( !psz_ext )
return VLC_EGENERIC;
psz_ext++;
for( unsigned i = 0; p_presets[i].psz_ext ; i++ )
{
if( !strcasecmp( psz_ext, p_presets[i].psz_ext ) )
{
p_preset = &p_presets[i];
goto valid;
}
}
return VLC_EGENERIC;
}
valid:
p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
p_sys->b_y4m = b_y4m;
/* guess the parameters based on the preset */
if( p_preset )
{
i_width = p_preset->i_width;
i_height = p_preset->i_height;
u_fps_num = p_preset->u_fps_num;
u_fps_den = p_preset->u_fps_den;
i_sar_num = p_preset->u_ar_num * p_preset->i_height;
i_sar_den = p_preset->u_ar_den * p_preset->i_width;
i_chroma = p_preset->i_chroma;
}
/* override presets if yuv4mpeg2 */
if( b_y4m )
{
/* The string should start with "YUV4MPEG2" */
char *psz = stream_ReadLine( p_demux->s );
char *psz_buf;
int a = 1;
int b = 1;
if( unlikely(psz == NULL) )
goto error;
/* NB, it is not possible to handle interlaced here, since the
* interlaced picture flags are in picture_t not block_t */
#define READ_FRAC( key, num, den ) do { \
psz_buf = strstr( psz+9, key );\
if( psz_buf )\
{\
char *end = strchr( psz_buf+1, ' ' );\
char *sep;\
if( end ) *end = '\0';\
sep = strchr( psz_buf+1, ':' );\
if( sep )\
{\
*sep = '\0';\
den = atoi( sep+1 );\
}\
else\
{\
den = 1;\
}\
num = atoi( psz_buf+2 );\
if( sep ) *sep = ':';\
if( end ) *end = ' ';\
} } while(0)
READ_FRAC( " W", i_width, a );
READ_FRAC( " H", i_height, a );
READ_FRAC( " F", u_fps_num, u_fps_den );
READ_FRAC( " A", a, b );
#undef READ_FRAC
if( b != 0 )
{
i_sar_num = a;
i_sar_den = b;
}
psz_buf = strstr( psz+9, " C" );
if( psz_buf )
{
static const struct { const char *psz_name; vlc_fourcc_t i_fcc; } formats[] =
{
{ "420jpeg", VLC_CODEC_I420 },
{ "420paldv", VLC_CODEC_I420 },
{ "420", VLC_CODEC_I420 },
{ "422", VLC_CODEC_I422 },
{ "444", VLC_CODEC_I444 },
{ "mono", VLC_CODEC_GREY },
{ NULL, 0 }
};
bool b_found = false;
char *psz_end = strchr( psz_buf+1, ' ' );
if( psz_end )
*psz_end = '\0';
psz_buf += 2;
for( int i = 0; formats[i].psz_name != NULL; i++ )
{
if( !strncmp( psz_buf, formats[i].psz_name, strlen(formats[i].psz_name) ) )
{
i_chroma = formats[i].i_fcc;
b_found = true;
break;
}
}
if( !b_found )
msg_Warn( p_demux, "Unknown YUV4MPEG2 chroma type \"%s\"", psz_buf );
if( psz_end )
*psz_end = ' ';
}
free( psz );
}
/* allow the user to override anything guessed from the input */
int i_tmp;
i_tmp = var_CreateGetInteger( p_demux, "rawvid-width" );
if( i_tmp ) i_width = i_tmp;
i_tmp = var_CreateGetInteger( p_demux, "rawvid-height" );
if( i_tmp ) i_height = i_tmp;
char *psz_tmp;
psz_tmp = var_CreateGetNonEmptyString( p_demux, "rawvid-chroma" );
if( psz_tmp )
{
if( strlen( psz_tmp ) != 4 )
{
msg_Err( p_demux, "Invalid fourcc format/chroma specification %s"
" expecting four characters eg, UYVY", psz_tmp );
free( psz_tmp );
goto error;
}
memcpy( &i_chroma, psz_tmp, 4 );
msg_Dbg( p_demux, "Forcing chroma to 0x%.8x (%4.4s)", i_chroma, (char*)&i_chroma );
free( psz_tmp );
}
if( var_InheritURational( p_demux, &u_fps_num, &u_fps_den, "rawvid-fps" ) )
{
u_fps_num = 0;
u_fps_den = 1;
}
if( var_InheritURational( p_demux, &i_sar_num, &i_sar_den,
"rawvid-aspect-ratio" ) )
i_sar_num = i_sar_den = 1;
/* moan about anything wrong */
if( i_width <= 0 || i_height <= 0 )
{
msg_Err( p_demux, "width and height must be strictly positive." );
goto error;
}
if( !u_fps_num || !u_fps_den )
{
msg_Err( p_demux, "invalid or no framerate specified." );
goto error;
}
if( i_chroma == 0 )
{
msg_Err( p_demux, "invalid or no chroma specified." );
goto error;
}
/* fixup anything missing with sensible assumptions */
if( i_sar_num <= 0 || i_sar_den <= 0 )
{
/* assume 1:1 sar */
i_sar_num = 1;
i_sar_den = 1;
}
es_format_Init( &p_sys->fmt_video, VIDEO_ES, i_chroma );
video_format_Setup( &p_sys->fmt_video.video, i_chroma,
i_width, i_height, i_width, i_height,
i_sar_num, i_sar_den );
vlc_ureduce( &p_sys->fmt_video.video.i_frame_rate,
&p_sys->fmt_video.video.i_frame_rate_base,
u_fps_num, u_fps_den, 0);
date_Init( &p_sys->pcr, p_sys->fmt_video.video.i_frame_rate,
p_sys->fmt_video.video.i_frame_rate_base );
date_Set( &p_sys->pcr, 0 );
if( !p_sys->fmt_video.video.i_bits_per_pixel )
{
msg_Err( p_demux, "Unsupported chroma 0x%.8x (%4.4s)", i_chroma,
(char*)&i_chroma );
goto error;
}
p_sys->frame_size = i_width * i_height
* p_sys->fmt_video.video.i_bits_per_pixel / 8;
p_sys->p_es_video = es_out_Add( p_demux->out, &p_sys->fmt_video );
p_demux->pf_demux = Demux;
p_demux->pf_control = Control;
return VLC_SUCCESS;
error:
stream_Seek( p_demux->s, 0 ); // Workaround, but y4m uses stream_ReadLines
free( p_sys );
return VLC_EGENERIC;
}
/**
* Main demux callback function
* @param p_demux: this demux object
*/
static int Demux( demux_t *p_demux )
{
char *psz_line;
char *psz_artist = NULL, *psz_album = NULL, *psz_genre = NULL, *psz_year = NULL;
char *psz_author = NULL, *psz_title = NULL, *psz_copyright = NULL, *psz_cdnum = NULL, *psz_comments = NULL;
int i_parsed_duration = 0;
mtime_t i_duration = -1;
const char **ppsz_options = NULL;
int i_options = 0, i_start = 0, i_stop = 0;
bool b_cleanup = false;
input_item_t *p_input;
input_item_t *p_current_input = GetCurrentItem(p_demux);
psz_line = stream_ReadLine( p_demux->s );
while( psz_line )
{
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( *psz_parse == '#' )
{
/* Ignore comments */
}
else if( *psz_parse )
{
char *psz_mrl, *psz_option_next, *psz_option;
char *psz_param, *psz_value;
/* Get the MRL from the file. Note that this might contain parameters of form ?param1=value1¶m2=value2 in a RAM file */
psz_mrl = ProcessMRL( psz_parse, p_demux->p_sys->psz_prefix );
b_cleanup = true;
if ( !psz_mrl ) goto error;
/* We have the MRL, now we have to check for options and parse them from MRL */
psz_option = strchr( psz_mrl, '?' ); /* Look for start of options */
if( psz_option )
{
/* Remove options from MRL
because VLC can't get the file otherwise */
*psz_option = '\0';
psz_option++;
psz_option_next = psz_option;
while( 1 ) /* Process each option */
{
/* Look for end of first option which maybe a & or \0 */
psz_option = psz_option_next;
psz_option_next = strchr( psz_option, '&' );
if( psz_option_next )
{
*psz_option_next = '\0';
psz_option_next++;
}
else
psz_option_next = strchr( psz_option, '\0' );
/* Quit if options are over */
if( psz_option_next == psz_option )
break;
/* Parse out param and value */
psz_param = psz_option;
psz_value = strchr( psz_option, '=' );
if( psz_value == NULL )
break;
*psz_value = '\0';
psz_value++;
/* Take action based on parameter value in the below if else structure */
/* TODO: Remove any quotes surrounding values if required */
if( !strcmp( psz_param, "clipinfo" ) )
{
ParseClipInfo( psz_value, &psz_artist, &psz_title,
&psz_album, &psz_genre, &psz_year,
&psz_cdnum, &psz_comments ); /* clipinfo has various sub parameters, which is parsed by this function */
}
else if( !strcmp( psz_param, "author" ) )
psz_author = decode_URI(psz_value);
else if( !strcmp( psz_param, "start" ) )
{
i_start = ParseTime( psz_value, strlen( psz_value ) );
char *temp;
if( i_start )
{
if( asprintf( &temp, ":start-time=%d", i_start ) != -1 )
INSERT_ELEM( ppsz_options, i_options, i_options, temp );
}
}
else if( !strcmp( psz_param, "end" ) )
{
i_stop = ParseTime( psz_value, strlen( psz_value ) );
char *temp;
if( i_stop )
{
if( asprintf( &temp, ":stop-time=%d", i_stop ) != -1 )
INSERT_ELEM( ppsz_options, i_options, i_options, temp );
}
}
else if( !strcmp( psz_param, "title" ) )
psz_title = decode_URI(psz_value);
else if( !strcmp( psz_param, "copyright" ) )
psz_copyright = decode_URI(psz_value);
else
{ /* TODO: insert option anyway? Currently ignores*/
/* INSERT_ELEM( ppsz_options, i_options, i_options, psz_option ); */
}
}
}
/* Create the input item and pump in all the options into playlist item */
p_input = input_item_NewExt( p_demux, psz_mrl, psz_title, i_options, ppsz_options, 0, i_duration );
if( !EMPTY_STR( psz_artist ) ) input_item_SetArtist( p_input, psz_artist );
if( !EMPTY_STR( psz_author ) ) input_item_SetPublisher( p_input, psz_author );
if( !EMPTY_STR( psz_title ) ) input_item_SetTitle( p_input, psz_title );
if( !EMPTY_STR( psz_copyright ) ) input_item_SetCopyright( p_input, psz_copyright );
if( !EMPTY_STR( psz_album ) ) input_item_SetAlbum( p_input, psz_album );
if( !EMPTY_STR( psz_genre ) ) input_item_SetGenre( p_input, psz_genre );
if( !EMPTY_STR( psz_year ) ) input_item_SetDate( p_input, psz_copyright );
if( !EMPTY_STR( psz_cdnum ) ) input_item_SetTrackNum( p_input, psz_cdnum );
if( !EMPTY_STR( psz_comments ) ) input_item_SetDescription( p_input, psz_comments );
input_item_AddSubItem( p_current_input, p_input );
vlc_gc_decref( p_input );
free( psz_mrl );
}
error:
/* Fetch another line */
free( psz_line );
psz_line = stream_ReadLine( p_demux->s );
if( !psz_line ) b_cleanup = true;
if( b_cleanup )
{
/* Cleanup state */
while( i_options-- ) free( (char*)ppsz_options[i_options] );
FREENULL( ppsz_options );
FREENULL( psz_artist );
FREENULL( psz_title );
FREENULL( psz_author );
FREENULL( psz_copyright );
FREENULL( psz_album );
FREENULL( psz_genre );
FREENULL( psz_year );
FREENULL( psz_cdnum );
FREENULL( psz_comments );
i_options = 0;
i_parsed_duration = 0;
i_duration = -1;
i_start = 0;
i_stop = 0;
b_cleanup = false;
}
}
vlc_gc_decref(p_current_input);
var_Destroy( p_demux, "m3u-extvlcopt" );
return 0; /* Needed for correct operation of go back */
}
/*****************************************************************************
* Demux: reads and demuxes data packets
*****************************************************************************
* Returns -1 in case of error, 0 in case of EOF, 1 otherwise
*****************************************************************************/
static int Demux ( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
input_item_t *p_child = NULL;
char *psz_line;
input_item_t *p_current_input = GetCurrentItem(p_demux);
while( ( psz_line = stream_ReadLine( p_demux->s ) ) )
{
ParseLine( p_demux, psz_line );
free( psz_line );
}
if( p_sys->psz_mcast_ip )
{
/* Definetly schedules multicast session */
/* We don't care if it's live or not */
free( p_sys->psz_uri );
if( asprintf( &p_sys->psz_uri, "udp://@" "%s:%i", p_sys->psz_mcast_ip, p_sys->i_mcast_port ) == -1 )
{
p_sys->psz_uri = NULL;
return -1;
}
}
if( p_sys->psz_uri == NULL )
{
if( p_sys->psz_server && p_sys->psz_location )
{
if( asprintf( &p_sys->psz_uri, "rtsp://" "%s:%i%s",
p_sys->psz_server, p_sys->i_port > 0 ? p_sys->i_port : 554, p_sys->psz_location ) == -1 )
{
p_sys->psz_uri = NULL;
return -1;
}
}
}
if( p_sys->b_concert )
{
/* It's definetly a simulcasted scheduled stream */
/* We don't care if it's live or not */
if( p_sys->psz_uri == NULL )
{
msg_Err( p_demux, "no URI was found" );
return -1;
}
char *uri;
if( asprintf( &uri, "%s%%3FMeDiAbAsEshowingId=%d%%26MeDiAbAsEconcert"
"%%3FMeDiAbAsE", p_sys->psz_uri, p_sys->i_sid ) == -1 )
return -1;
free( p_sys->psz_uri );
p_sys->psz_uri = uri;
}
p_child = input_item_NewWithType( p_sys->psz_uri,
p_sys->psz_name ? p_sys->psz_name : p_sys->psz_uri,
0, NULL, 0, p_sys->i_duration, ITEM_TYPE_NET );
if( !p_child )
{
msg_Err( p_demux, "A valid playlistitem could not be created" );
return -1;
}
input_item_CopyOptions( p_current_input, p_child );
if( p_sys->i_packet_size && p_sys->psz_mcast_ip )
{
char *psz_option;
p_sys->i_packet_size += 1000;
if( asprintf( &psz_option, "mtu=%i", p_sys->i_packet_size ) != -1 )
{
input_item_AddOption( p_child, psz_option, VLC_INPUT_OPTION_TRUSTED );
free( psz_option );
}
}
if( !p_sys->psz_mcast_ip )
input_item_AddOption( p_child, "rtsp-caching=5000", VLC_INPUT_OPTION_TRUSTED );
if( !p_sys->psz_mcast_ip && p_sys->b_rtsp_kasenna )
input_item_AddOption( p_child, "rtsp-kasenna", VLC_INPUT_OPTION_TRUSTED );
input_item_PostSubItem( p_current_input, p_child );
vlc_gc_decref( p_child );
vlc_gc_decref(p_current_input);
return 0; /* Needed for correct operation of go back */
}
