*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
-#include <stdlib.h>
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include <vlc/vlc.h>
-#include <vlc/input.h>
#include "input_internal.h"
/* Method 1: */
static int AStreamReadBlock( stream_t *s, void *p_read, int i_read );
-static int AStreamPeekBlock( stream_t *s, uint8_t **p_peek, int i_read );
+static int AStreamPeekBlock( stream_t *s, const uint8_t **p_peek, int i_read );
static int AStreamSeekBlock( stream_t *s, int64_t i_pos );
static void AStreamPrebufferBlock( stream_t *s );
static block_t *AReadBlock( stream_t *s, vlc_bool_t *pb_eof );
/* Method 2 */
static int AStreamReadStream( stream_t *s, void *p_read, int i_read );
-static int AStreamPeekStream( stream_t *s, uint8_t **pp_peek, int i_read );
+static int AStreamPeekStream( stream_t *s, const uint8_t **pp_peek, int i_read );
static int AStreamSeekStream( stream_t *s, int64_t i_pos );
static void AStreamPrebufferStream( stream_t *s );
static int AReadStream( stream_t *s, void *p_read, int i_read );
****************************************************************************/
stream_t *__stream_UrlNew( vlc_object_t *p_parent, const char *psz_url )
{
- char *psz_access, *psz_demux, *psz_path, *psz_dup;
+ const char *psz_access, *psz_demux;
+ char *psz_path;
access_t *p_access;
stream_t *p_res;
if( !psz_url ) return 0;
- psz_dup = strdup( psz_url );
- MRLSplit( p_parent, psz_dup, &psz_access, &psz_demux, &psz_path );
+ char psz_dup[strlen (psz_url) + 1];
+ strcpy (psz_dup, psz_url);;
+ MRLSplit( psz_dup, &psz_access, &psz_demux, &psz_path );
/* Now try a real access */
p_access = access2_New( p_parent, psz_access, psz_demux, psz_path, 0 );
- free( psz_dup );
if( p_access == NULL )
{
stream_t *stream_AccessNew( access_t *p_access, vlc_bool_t b_quick )
{
- stream_t *s = vlc_object_create( p_access, VLC_OBJECT_STREAM );
+ stream_t *s = vlc_stream_create( VLC_OBJECT(p_access) );
stream_sys_t *p_sys;
- char *psz_list;
+ char *psz_list = NULL;
if( !s ) return NULL;
/* Attach it now, needed for b_die */
vlc_object_attach( s, p_access );
- s->pf_block = NULL;
s->pf_read = NULL; /* Set up later */
s->pf_peek = NULL;
- s->pf_control= AStreamControl;
+ s->pf_control = AStreamControl;
s->pf_destroy = AStreamDestroy;
s->p_sys = p_sys = malloc( sizeof( stream_sys_t ) );
+ if( p_sys == NULL )
+ {
+ msg_Err( s, "Out of memory when allocating stream_sys_t" );
+ goto error;
+ }
/* UTF16 and UTF32 text file conversion */
s->i_char_width = 1;
if( (psz_list = var_CreateGetString( s, "input-list" )) && *psz_list )
{
access_entry_t *p_entry = malloc( sizeof(access_entry_t) );
+ if( p_entry == NULL )
+ {
+ msg_Err( s, "Out of memory when allocating access_entry_t" );
+ goto error;
+ }
char *psz_name, *psz_parser = psz_name = psz_list;
p_sys->p_list_access = p_access;
p_entry->i_size = p_access->info.i_size;
p_entry->psz_path = strdup( p_access->psz_path );
+ if( p_entry->psz_path == NULL )
+ {
+ msg_Err( s, "Out of memory when duplicating p_access->psz_path" );
+ free( p_entry );
+ goto error;
+ }
TAB_APPEND( p_sys->i_list, p_sys->list, p_entry );
msg_Dbg( p_access, "adding file `%s', ("I64Fd" bytes)",
p_entry->psz_path, p_access->info.i_size );
if( psz_name )
{
access_t *p_tmp = access2_New( p_access, p_access->psz_access,
- 0, psz_name, 0 );
+ "", psz_name, 0 );
if( !p_tmp )
{
psz_name, p_tmp->info.i_size );
p_entry = malloc( sizeof(access_entry_t) );
+ if( p_entry == NULL )
+ {
+ msg_Err( p_access, "Out of memory when allocating access_entry_t" );
+ goto error;
+ }
p_entry->i_size = p_tmp->info.i_size;
p_entry->psz_path = psz_name;
TAB_APPEND( p_sys->i_list, p_sys->list, p_entry );
if( psz_name ) psz_name++;
}
}
- if( psz_list ) free( psz_list );
+ FREENULL( psz_list );
/* Peek */
p_sys->i_peek = 0;
p_sys->stream.i_offset = 0;
p_sys->stream.i_tk = 0;
p_sys->stream.p_buffer = malloc( STREAM_CACHE_SIZE );
+ if( p_sys->stream.p_buffer == NULL )
+ {
+ msg_Err( s, "Out of memory when allocating stream cache (%d bytes)",
+ STREAM_CACHE_SIZE );
+ goto error;
+ }
p_sys->stream.i_used = 0;
access2_Control( p_access, ACCESS_GET_MTU,
&p_sys->stream.i_read_size );
{
free( p_sys->stream.p_buffer );
}
+ while( p_sys->i_list > 0 )
+ free( p_sys->list[--(p_sys->i_list)] );
+ free( p_sys->list );
+ free( psz_list );
free( s->p_sys );
vlc_object_detach( s );
vlc_object_destroy( s );
}
return access2_vaControl( p_access, i_int, args );
+ case STREAM_GET_CONTENT_TYPE:
+ return access2_Control( p_access, ACCESS_GET_CONTENT_TYPE,
+ va_arg( args, char ** ) );
+
default:
msg_Err( s, "invalid stream_vaControl query=0x%x", i_query );
return VLC_EGENERIC;
return i_data;
}
-static int AStreamPeekBlock( stream_t *s, uint8_t **pp_peek, int i_read )
+static int AStreamPeekBlock( stream_t *s, const uint8_t **pp_peek, int i_read )
{
stream_sys_t *p_sys = s->p_sys;
uint8_t *p_data;
if( !b_aseek )
{
- msg_Err( s, "backward seek impossible (access non seekable)" );
+ msg_Err( s, "backward seeking impossible (access not seekable)" );
return VLC_EGENERIC;
}
/* Refill a block */
if( AStreamRefillBlock( s ) )
{
- msg_Err( s, "cannot re fill buffer" );
+ msg_Err( s, "cannot pre fill buffer" );
return VLC_EGENERIC;
}
/* Update stat */
return i_data;
}
-static int AStreamPeekStream( stream_t *s, uint8_t **pp_peek, int i_read )
+static int AStreamPeekStream( stream_t *s, const uint8_t **pp_peek, int i_read )
{
stream_sys_t *p_sys = s->p_sys;
stream_track_t *tk = &p_sys->stream.tk[p_sys->stream.i_tk];
( (p_access->info.i_title > 1 || p_access->info.i_seekpoint > 1) ?
STREAM_CACHE_PREBUFFER_SIZE : STREAM_CACHE_TRACK_SIZE / 3 );
- msg_Dbg( s, "pre buffering" );
+ msg_Dbg( s, "pre-buffering..." );
i_start = mdate();
for( ;; )
{
i_byterate = ( I64C(1000000) * p_sys->stat.i_bytes ) /
(p_sys->stat.i_read_time+1);
- msg_Dbg( s, "prebuffering done "I64Fd" bytes in "I64Fd"s - "
+ msg_Dbg( s, "pre-buffering done "I64Fd" bytes in "I64Fd"s - "
I64Fd" kbytes/s",
p_sys->stat.i_bytes,
p_sys->stat.i_read_time / I64C(1000000),
while( i_read < STREAM_LINE_MAX )
{
char *psz_eol;
- uint8_t *p_data;
+ const uint8_t *p_data;
int i_data;
int64_t i_pos;
{
int i_bom_size = 0;
char *psz_encoding = NULL;
-
+
if( p_data[0] == 0xEF && p_data[1] == 0xBB && p_data[2] == 0xBF )
{
psz_encoding = strdup( "UTF-8" );
/* Open the converter if we need it */
if( psz_encoding != NULL )
{
+ input_thread_t *p_input;
msg_Dbg( s, "%s BOM detected", psz_encoding );
+ p_input = (input_thread_t *)vlc_object_find( s, VLC_OBJECT_INPUT, FIND_PARENT );
if( s->i_char_width > 1 )
{
s->conv = vlc_iconv_open( "UTF-8", psz_encoding );
msg_Err( s, "iconv_open failed" );
}
}
- if( psz_encoding ) free( psz_encoding );
+ if( p_input != NULL)
+ {
+ var_Create( p_input, "subsdec-encoding", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
+ var_SetString( p_input, "subsdec-encoding", "UTF-8" );
+ vlc_object_release( p_input );
+ }
+ free( psz_encoding );
}
}
if( i_data % s->i_char_width )
{
+ /* keep i_char_width boundary */
+ i_data = i_data - ( i_data % s->i_char_width );
msg_Warn( s, "the read is not i_char_width compatible");
}
+ if( i_data == 0 )
+ break;
+
/* Check if there is an EOL */
- if( ( psz_eol = memchr( p_data, '\n', i_data ) ) )
+ if( s->i_char_width == 1 )
{
- if( s->b_little_endian == VLC_TRUE && s->i_char_width > 1 )
+ /* UTF-8: 0A <LF> */
+ psz_eol = memchr( p_data, '\n', i_data );
+ }
+ else
+ {
+ const uint8_t *p = p_data;
+ const uint8_t *p_last = p + i_data - s->i_char_width;
+
+ if( s->i_char_width == 2 )
{
- psz_eol += ( s->i_char_width - 1 );
+ if( s->b_little_endian == VLC_TRUE)
+ {
+ /* UTF-16LE: 0A 00 <LF> */
+ while( p <= p_last && ( p[0] != 0x0A || p[1] != 0x00 ) )
+ p += 2;
+ }
+ else
+ {
+ /* UTF-16BE: 00 0A <LF> */
+ while( p <= p_last && ( p[1] != 0x0A || p[0] != 0x00 ) )
+ p += 2;
+ }
+ }
+ else if( s->i_char_width == 4 )
+ {
+ if( s->b_little_endian == VLC_TRUE)
+ {
+ /* UTF-32LE: 0A 00 00 00 <LF> */
+ while( p <= p_last && ( p[0] != 0x0A || p[1] != 0x00 ||
+ p[2] != 0x00 || p[3] != 0x00 ) )
+ p += 4;
+ }
+ else
+ {
+ /* UTF-32BE: 00 00 00 0A <LF> */
+ while( p <= p_last && ( p[3] != 0x0A || p[2] != 0x00 ||
+ p[1] != 0x00 || p[0] != 0x00 ) )
+ p += 4;
+ }
+ }
+
+ if( p > p_last )
+ {
+ psz_eol = NULL;
+ }
+ else
+ {
+ psz_eol = (char *)p + ( s->i_char_width - 1 );
}
+ }
+
+ if(psz_eol)
+ {
i_data = (psz_eol - (char *)p_data) + 1;
p_line = realloc( p_line, i_line + i_data + s->i_char_width ); /* add \0 */
+ if( !p_line )
+ {
+ msg_Err( s, "Out of memory when reallocating p_line" );
+ goto error;
+ }
i_data = stream_Read( s, &p_line[i_line], i_data );
if( i_data <= 0 ) break; /* Hmmm */
i_line += i_data - s->i_char_width; /* skip \n */;
/* Read data (+1 for easy \0 append) */
p_line = realloc( p_line, i_line + STREAM_PROBE_LINE + s->i_char_width );
+ if( !p_line )
+ {
+ msg_Err( s, "Out of memory when reallocating p_line" );
+ goto error;
+ }
i_data = stream_Read( s, &p_line[i_line], STREAM_PROBE_LINE );
if( i_data <= 0 ) break; /* Hmmm */
i_line += i_data;
if( s->i_char_width > 1 )
{
size_t i_in = 0, i_out = 0;
- char * p_in = NULL;
+ const char * p_in = NULL;
char * p_out = NULL;
char * psz_new_line = NULL;
-
+
/* iconv */
psz_new_line = malloc( i_line );
-
+ if( psz_new_line == NULL )
+ {
+ msg_Err( s, "Out of memory when allocating psz_new_line" );
+ goto error;
+ }
i_in = i_out = (size_t)i_line;
p_in = p_line;
p_out = psz_new_line;
-
+
if( vlc_iconv( s->conv, &p_in, &i_in, &p_out, &i_out ) == (size_t)-1 )
{
msg_Err( s, "iconv failed" );
}
/* Remove trailing LF/CR */
- while( i_line > 0 && ( p_line[i_line-2] == '\r' ||
+ while( i_line >= 2 && ( p_line[i_line-2] == '\r' ||
p_line[i_line-2] == '\n') ) i_line--;
/* Make sure the \0 is there */
return p_line;
}
+error:
+
/* We failed to read any data, probably EOF */
- if( p_line ) free( p_line );
+ free( p_line );
if( s->conv != (vlc_iconv_t)(-1) ) vlc_iconv_close( s->conv );
return NULL;
}
{
stream_sys_t *p_sys = s->p_sys;
access_t *p_access = p_sys->p_access;
+ input_thread_t *p_input = NULL;
int i_read_orig = i_read;
+ int i_total = 0;
+
+ if( s->p_parent && s->p_parent->p_parent &&
+ s->p_parent->p_parent->i_object_type == VLC_OBJECT_INPUT )
+ p_input = (input_thread_t *)s->p_parent->p_parent;
if( !p_sys->i_list )
{
i_read = p_access->pf_read( p_access, p_read, i_read );
+ if( p_input )
+ {
+ vlc_object_yield( p_input );
+ vlc_mutex_lock( &p_input->p->counters.counters_lock );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_bytes, i_read,
+ &i_total );
+ stats_UpdateFloat( s, p_input->p->counters.p_input_bitrate,
+ (float)i_total, NULL );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_packets, 1, NULL );
+ vlc_mutex_unlock( &p_input->p->counters.counters_lock );
+ vlc_object_release( p_input );
+ }
return i_read;
}
msg_Dbg( s, "opening input `%s'", psz_name );
- p_list_access = access2_New( s, p_access->psz_access, 0, psz_name, 0 );
+ p_list_access = access2_New( s, p_access->psz_access, "", psz_name, 0 );
if( !p_list_access ) return 0;
}
/* Update read bytes in input */
- stats_UpdateInteger( s->p_parent, "read_bytes", i_read );
-
+ if( p_input )
+ {
+ vlc_object_yield( p_input );
+ vlc_mutex_lock( &p_input->p->counters.counters_lock );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_bytes, i_read, &i_total );
+ stats_UpdateFloat( s, p_input->p->counters.p_input_bitrate,
+ (float)i_total, NULL );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_packets, 1, NULL );
+ vlc_mutex_unlock( &p_input->p->counters.counters_lock );
+ vlc_object_release( p_input );
+ }
return i_read;
}
{
stream_sys_t *p_sys = s->p_sys;
access_t *p_access = p_sys->p_access;
+ input_thread_t *p_input = NULL;
block_t *p_block;
vlc_bool_t b_eof;
+ int i_total = 0;
+
+ if( s->p_parent && s->p_parent->p_parent &&
+ s->p_parent->p_parent->i_object_type == VLC_OBJECT_INPUT )
+ p_input = (input_thread_t *)s->p_parent->p_parent;
if( !p_sys->i_list )
{
p_block = p_access->pf_block( p_access );
if( pb_eof ) *pb_eof = p_access->info.b_eof;
+ if( p_input && p_block && p_access->p_libvlc->b_stats )
+ {
+ vlc_object_yield( p_input );
+ vlc_mutex_lock( &p_input->p->counters.counters_lock );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_bytes,
+ p_block->i_buffer, &i_total );
+ stats_UpdateFloat( s, p_input->p->counters.p_input_bitrate,
+ (float)i_total, NULL );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_packets, 1, NULL );
+ vlc_mutex_unlock( &p_input->p->counters.counters_lock );
+ vlc_object_release( p_input );
+ }
return p_block;
}
msg_Dbg( s, "opening input `%s'", psz_name );
- p_list_access = access2_New( s, p_access->psz_access, 0, psz_name, 0 );
+ p_list_access = access2_New( s, p_access->psz_access, "", psz_name, 0 );
if( !p_list_access ) return 0;
/* We have to read some data */
return AReadBlock( s, pb_eof );
}
-
+ if( p_block )
+ {
+ if( p_input )
+ {
+ vlc_object_yield( p_input );
+ vlc_mutex_lock( &p_input->p->counters.counters_lock );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_bytes,
+ p_block->i_buffer, &i_total );
+ stats_UpdateFloat( s, p_input->p->counters.p_input_bitrate,
+ (float)i_total, NULL );
+ stats_UpdateInteger( s, p_input->p->counters.p_read_packets,
+ 1 , NULL);
+ vlc_mutex_unlock( &p_input->p->counters.counters_lock );
+ vlc_object_release( p_input );
+ }
+ }
return p_block;
}
if( i != p_sys->i_list_index && i != 0 )
{
p_list_access =
- access2_New( s, p_access->psz_access, 0, psz_name, 0 );
+ access2_New( s, p_access->psz_access, "", psz_name, 0 );
}
else if( i != p_sys->i_list_index )
{
return p_access->pf_seek( p_access, i_pos );
}
+
+
+/**
+ * Try to read "i_read" bytes into a buffer pointed by "p_read". If
+ * "p_read" is NULL then data are skipped instead of read. The return
+ * value is the real numbers of bytes read/skip. If this value is less
+ * than i_read that means that it's the end of the stream.
+ */
+int stream_Read( stream_t *s, void *p_read, int i_read )
+{
+ return s->pf_read( s, p_read, i_read );
+}
+
+/**
+ * Store in pp_peek a pointer to the next "i_peek" bytes in the stream
+ * \return The real numbers of valid bytes, if it's less
+ * or equal to 0, *pp_peek is invalid.
+ * \note pp_peek is a pointer to internal buffer and it will be invalid as
+ * soons as other stream_* functions are called.
+ * \note Due to input limitation, it could be less than i_peek without meaning
+ * the end of the stream (but only when you have i_peek >=
+ * p_input->i_bufsize)
+ */
+int stream_Peek( stream_t *s, const uint8_t **pp_peek, int i_peek )
+{
+ return s->pf_peek( s, pp_peek, i_peek );
+}
+
+/**
+ * Use to control the "stream_t *". Look at #stream_query_e for
+ * possible "i_query" value and format arguments. Return VLC_SUCCESS
+ * if ... succeed ;) and VLC_EGENERIC if failed or unimplemented
+ */
+int stream_vaControl( stream_t *s, int i_query, va_list args )
+{
+ return s->pf_control( s, i_query, args );
+}
+
+/**
+ * Destroy a stream
+ */
+void stream_Delete( stream_t *s )
+{
+ s->pf_destroy( s );
+}
+
+int stream_Control( stream_t *s, int i_query, ... )
+{
+ va_list args;
+ int i_result;
+
+ if ( s == NULL )
+ return VLC_EGENERIC;
+
+ va_start( args, i_query );
+ i_result = s->pf_control( s, i_query, args );
+ va_end( args );
+ return i_result;
+}
+
+/**
+ * Read "i_size" bytes and store them in a block_t.
+ * It always read i_size bytes unless you are at the end of the stream
+ * where it return what is available.
+ */
+block_t *stream_Block( stream_t *s, int i_size )
+{
+ if( i_size <= 0 ) return NULL;
+
+ /* emulate block read */
+ block_t *p_bk = block_New( s, i_size );
+ if( p_bk )
+ {
+ p_bk->i_buffer = stream_Read( s, p_bk->p_buffer, i_size );
+ if( p_bk->i_buffer > 0 )
+ {
+ return p_bk;
+ }
+ }
+ if( p_bk ) block_Release( p_bk );
+ return NULL;
+}