X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fstream.c;h=18e77e221dd45a1d4bebd506fec1dd5c90e5eed5;hb=d2acb6213e0ec75d7d7050f2fdbb957f1e8c6006;hp=eedd3a4a4ca4d2ba69c7977992b3088f9b7cd698;hpb=b57a4d9d1fee564713abea99d74ddbb63c9de13a;p=vlc diff --git a/src/input/stream.c b/src/input/stream.c index eedd3a4a4c..18e77e221d 100644 --- a/src/input/stream.c +++ b/src/input/stream.c @@ -1,24 +1,24 @@ /***************************************************************************** * stream.c ***************************************************************************** - * Copyright (C) 1999-2004 the VideoLAN team + * Copyright (C) 1999-2004 VLC authors and VideoLAN * $Id$ * * Authors: Laurent Aimar * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. * - * 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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ #ifdef HAVE_CONFIG_H @@ -200,7 +200,6 @@ static int AReadStream( stream_t *s, void *p_read, unsigned int i_read ); /* Common */ static int AStreamControl( stream_t *s, int i_query, va_list ); static void AStreamDestroy( stream_t *s ); -static void UStreamDestroy( stream_t *s ); static int ASeek( stream_t *s, uint64_t i_pos ); /**************************************************************************** @@ -208,8 +207,7 @@ static int ASeek( stream_t *s, uint64_t i_pos ); ****************************************************************************/ stream_t *stream_CommonNew( vlc_object_t *p_obj ) { - stream_t *s = (stream_t *)vlc_custom_create( p_obj, sizeof(*s), - VLC_OBJECT_GENERIC, "stream" ); + stream_t *s = (stream_t *)vlc_custom_create( p_obj, sizeof(*s), "stream" ); if( !s ) return NULL; @@ -237,6 +235,7 @@ void stream_CommonDelete( stream_t *s ) vlc_iconv_close( s->p_text->conv ); free( s->p_text ); } + free( s->psz_access ); free( s->psz_path ); vlc_object_release( s ); } @@ -247,42 +246,25 @@ void stream_CommonDelete( stream_t *s ) ****************************************************************************/ stream_t *stream_UrlNew( vlc_object_t *p_parent, const char *psz_url ) { - const char *psz_access, *psz_demux; - char *psz_path; + const char *psz_access, *psz_demux, *psz_path, *psz_anchor; access_t *p_access; - stream_t *p_res; if( !psz_url ) return NULL; char psz_dup[strlen( psz_url ) + 1]; strcpy( psz_dup, psz_url ); - input_SplitMRL( &psz_access, &psz_demux, &psz_path, psz_dup ); + input_SplitMRL( &psz_access, &psz_demux, &psz_path, &psz_anchor, psz_dup ); - /* Get a weak link to the parent input */ - /* FIXME: This should probably be removed in favor of a NULL input. */ - input_thread_t *p_input = (input_thread_t *)vlc_object_find( p_parent, VLC_OBJECT_INPUT, FIND_PARENT ); - /* Now try a real access */ - p_access = access_New( p_parent, p_input, psz_access, psz_demux, psz_path ); - - if(p_input) - vlc_object_release((vlc_object_t*)p_input); - + p_access = access_New( p_parent, NULL, psz_access, psz_demux, psz_path ); if( p_access == NULL ) { msg_Err( p_parent, "no suitable access module for `%s'", psz_url ); return NULL; } - if( !( p_res = stream_AccessNew( p_access, NULL ) ) ) - { - access_Delete( p_access ); - return NULL; - } - - p_res->pf_destroy = UStreamDestroy; - return p_res; + return stream_AccessNew( p_access, NULL ); } stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) @@ -294,17 +276,15 @@ stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) return NULL; s->p_input = p_access->p_input; - s->psz_path = strdup( p_access->psz_path ); + s->psz_access = strdup( p_access->psz_access ); + s->psz_path = strdup( p_access->psz_location ); s->p_sys = p_sys = malloc( sizeof( *p_sys ) ); - if( !s->psz_path || !s->p_sys ) + if( !s->psz_access || !s->psz_path || !s->p_sys ) { stream_CommonDelete( s ); return NULL; } - /* Attach it now, needed for b_die */ - vlc_object_attach( s, p_access ); - s->pf_read = NULL; /* Set up later */ s->pf_peek = NULL; s->pf_control = AStreamControl; @@ -338,8 +318,8 @@ stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) if( !p_entry ) goto error; - p_entry->i_size = p_access->info.i_size; - p_entry->psz_path = strdup( p_access->psz_path ); + p_entry->i_size = access_GetSize( p_access ); + p_entry->psz_path = strdup( p_access->psz_location ); if( !p_entry->psz_path ) { free( p_entry ); @@ -348,7 +328,7 @@ stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) p_sys->p_list_access = p_access; TAB_APPEND( p_sys->i_list, p_sys->list, p_entry ); msg_Dbg( p_access, "adding file `%s', (%"PRId64" bytes)", - p_entry->psz_path, p_access->info.i_size ); + p_entry->psz_path, p_entry->i_size ); for( int i = 0; ppsz_list[i] != NULL; i++ ) { @@ -360,17 +340,19 @@ stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) access_t *p_tmp = access_New( p_access, p_access->p_input, p_access->psz_access, "", psz_name ); if( !p_tmp ) + { + free( psz_name ); continue; - - msg_Dbg( p_access, "adding file `%s', (%"PRId64" bytes)", - psz_name, p_tmp->info.i_size ); + } p_entry = malloc( sizeof(*p_entry) ); if( p_entry ) { - p_entry->i_size = p_tmp->info.i_size; + p_entry->i_size = access_GetSize( p_tmp ); p_entry->psz_path = psz_name; TAB_APPEND( p_sys->i_list, p_sys->list, p_entry ); + msg_Dbg( p_access, "adding file `%s', (%"PRId64" bytes)", + p_entry->psz_path, p_entry->i_size ); } access_Delete( p_tmp ); } @@ -382,7 +364,7 @@ stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) if( p_sys->method == STREAM_METHOD_BLOCK ) { - msg_Dbg( s, "Using AStream*Block" ); + msg_Dbg( s, "Using block method for AStream*" ); s->pf_read = AStreamReadBlock; s->pf_peek = AStreamPeekBlock; @@ -409,7 +391,7 @@ stream_t *stream_AccessNew( access_t *p_access, char **ppsz_list ) assert( p_sys->method == STREAM_METHOD_STREAM ); - msg_Dbg( s, "Using AStream*Stream" ); + msg_Dbg( s, "Using stream method for AStream*" ); s->pf_read = AStreamReadStream; s->pf_peek = AStreamPeekStream; @@ -461,6 +443,7 @@ error: free( p_sys->list ); free( s->p_sys ); stream_CommonDelete( s ); + access_Delete( p_access ); return NULL; } @@ -486,18 +469,11 @@ static void AStreamDestroy( stream_t *s ) free( p_sys->list[p_sys->i_list]->psz_path ); free( p_sys->list[p_sys->i_list] ); } - free( p_sys->list ); - free( p_sys ); stream_CommonDelete( s ); -} - -static void UStreamDestroy( stream_t *s ) -{ - access_t *p_access = (access_t *)s->p_parent; - AStreamDestroy( s ); - access_Delete( p_access ); + access_Delete( p_sys->p_access ); + free( p_sys ); } /**************************************************************************** @@ -566,6 +542,9 @@ static void AStreamControlUpdate( stream_t *s ) } } +#define static_control_match(foo) \ + static_assert((unsigned) STREAM_##foo == ACCESS_##foo, "Mismatch") + /**************************************************************************** * AStreamControl: ****************************************************************************/ @@ -574,14 +553,46 @@ static int AStreamControl( stream_t *s, int i_query, va_list args ) stream_sys_t *p_sys = s->p_sys; access_t *p_access = p_sys->p_access; - bool *p_bool; - uint64_t *pi_64, i_64; - int i_int; + static_control_match(CAN_SEEK); + static_control_match(CAN_FASTSEEK); + static_control_match(CAN_PAUSE); + static_control_match(CAN_CONTROL_PACE); + static_control_match(GET_PTS_DELAY); + static_control_match(GET_TITLE_INFO); + static_control_match(GET_TITLE); + static_control_match(GET_SEEKPOINT); + static_control_match(GET_META); + static_control_match(GET_CONTENT_TYPE); + static_control_match(GET_SIGNAL); + static_control_match(SET_PAUSE_STATE); + static_control_match(SET_TITLE); + static_control_match(SET_SEEKPOINT); + static_control_match(SET_PRIVATE_ID_STATE); + static_control_match(SET_PRIVATE_ID_CA); + static_control_match(GET_PRIVATE_ID_STATE); switch( i_query ) { + case STREAM_CAN_SEEK: + case STREAM_CAN_FASTSEEK: + case STREAM_CAN_PAUSE: + case STREAM_CAN_CONTROL_PACE: + case STREAM_GET_PTS_DELAY: + case STREAM_GET_TITLE_INFO: + case STREAM_GET_TITLE: + case STREAM_GET_SEEKPOINT: + case STREAM_GET_META: + case STREAM_GET_CONTENT_TYPE: + case STREAM_GET_SIGNAL: + case STREAM_SET_PAUSE_STATE: + case STREAM_SET_PRIVATE_ID_STATE: + case STREAM_SET_PRIVATE_ID_CA: + case STREAM_GET_PRIVATE_ID_STATE: + return access_vaControl( p_access, i_query, args ); + case STREAM_GET_SIZE: - pi_64 = va_arg( args, uint64_t * ); + { + uint64_t *pi_64 = va_arg( args, uint64_t * ); if( s->p_sys->i_list ) { int i; @@ -590,63 +601,42 @@ static int AStreamControl( stream_t *s, int i_query, va_list args ) *pi_64 += s->p_sys->list[i]->i_size; break; } - *pi_64 = p_access->info.i_size; - break; - - case STREAM_CAN_SEEK: - p_bool = (bool*)va_arg( args, bool * ); - access_Control( p_access, ACCESS_CAN_SEEK, p_bool ); - break; - - case STREAM_CAN_FASTSEEK: - p_bool = (bool*)va_arg( args, bool * ); - access_Control( p_access, ACCESS_CAN_FASTSEEK, p_bool ); + *pi_64 = access_GetSize( p_access ); break; + } case STREAM_GET_POSITION: - pi_64 = va_arg( args, uint64_t * ); - *pi_64 = p_sys->i_pos; + *va_arg( args, uint64_t * ) = p_sys->i_pos; break; case STREAM_SET_POSITION: - i_64 = va_arg( args, uint64_t ); + { + uint64_t offset = va_arg( args, uint64_t ); switch( p_sys->method ) { case STREAM_METHOD_BLOCK: - return AStreamSeekBlock( s, i_64 ); + return AStreamSeekBlock( s, offset ); case STREAM_METHOD_STREAM: - return AStreamSeekStream( s, i_64 ); + return AStreamSeekStream( s, offset ); default: assert(0); return VLC_EGENERIC; } - - case STREAM_CONTROL_ACCESS: - { - i_int = (int) va_arg( args, int ); - if( i_int != ACCESS_SET_PRIVATE_ID_STATE && - i_int != ACCESS_SET_PRIVATE_ID_CA && - i_int != ACCESS_GET_PRIVATE_ID_STATE && - i_int != ACCESS_SET_TITLE && - i_int != ACCESS_SET_SEEKPOINT ) - { - msg_Err( s, "Hey, what are you thinking ?" - "DON'T USE STREAM_CONTROL_ACCESS !!!" ); - return VLC_EGENERIC; - } - int i_ret = access_vaControl( p_access, i_int, args ); - if( i_int == ACCESS_SET_TITLE || i_int == ACCESS_SET_SEEKPOINT ) - AStreamControlReset( s ); - return i_ret; } case STREAM_UPDATE_SIZE: AStreamControlUpdate( s ); return VLC_SUCCESS; - case STREAM_GET_CONTENT_TYPE: - return access_Control( p_access, ACCESS_GET_CONTENT_TYPE, - va_arg( args, char ** ) ); + case STREAM_SET_TITLE: + case STREAM_SET_SEEKPOINT: + { + int ret = access_vaControl( p_access, i_query, args ); + if( ret == VLC_SUCCESS ) + AStreamControlReset( s ); + return ret; + } + case STREAM_SET_RECORD_STATE: default: msg_Err( s, "invalid stream_vaControl query=0x%x", i_query ); @@ -665,7 +655,7 @@ static void AStreamPrebufferBlock( stream_t *s ) int64_t i_first = 0; int64_t i_start; - msg_Dbg( s, "pre buffering" ); + msg_Dbg( s, "starting pre-buffering" ); i_start = mdate(); for( ;; ) { @@ -673,7 +663,7 @@ static void AStreamPrebufferBlock( stream_t *s ) bool b_eof; block_t *b; - if( s->b_die || p_sys->block.i_size > STREAM_CACHE_PREBUFFER_SIZE ) + if( !vlc_object_alive(s) || p_sys->block.i_size > STREAM_CACHE_PREBUFFER_SIZE ) { int64_t i_byterate; @@ -749,7 +739,7 @@ static int AStreamReadBlock( stream_t *s, void *p_read, unsigned int i_read ) { int i_current = p_sys->block.p_current->i_buffer - p_sys->block.i_offset; - unsigned int i_copy = __MIN( (unsigned int)__MAX(i_current,0), i_read - i_data); + unsigned int i_copy = VLC_CLIP( (unsigned int)i_current, 0, i_read - i_data); /* Copy data */ if( p_data ) @@ -1011,7 +1001,7 @@ static int AStreamRefillBlock( stream_t *s ) { bool b_eof; - if( s->b_die ) + if( !vlc_object_alive(s) ) return VLC_EGENERIC; /* Fetch a block */ @@ -1271,7 +1261,7 @@ static int AStreamSeekStream( stream_t *s, uint64_t i_pos ) if( p_sys->stream.i_used < STREAM_READ_ATONCE / 2 ) p_sys->stream.i_used = STREAM_READ_ATONCE / 2; - if( AStreamRefillStream( s ) && i_pos == tk->i_end ) + if( AStreamRefillStream( s ) && i_pos >= tk->i_end ) return VLC_EGENERIC; } return VLC_SUCCESS; @@ -1323,9 +1313,9 @@ static int AStreamReadNoSeekStream( stream_t *s, void *p_read, unsigned int i_re if( tk->i_end + i_data <= tk->i_start + p_sys->stream.i_offset + i_read ) { - const unsigned i_read_requested = __MAX( __MIN( i_read - i_data, - STREAM_READ_ATONCE * 10 ), - STREAM_READ_ATONCE / 2 ); + const unsigned i_read_requested = VLC_CLIP( i_read - i_data, + STREAM_READ_ATONCE / 2, + STREAM_READ_ATONCE * 10 ); if( p_sys->stream.i_used < i_read_requested ) p_sys->stream.i_used = i_read_requested; @@ -1367,7 +1357,7 @@ static int AStreamRefillStream( stream_t *s ) int i_off = tk->i_end % STREAM_CACHE_TRACK_SIZE; int i_read; - if( s->b_die ) + if( !vlc_object_alive(s) ) return VLC_EGENERIC; i_read = __MIN( i_toread, STREAM_CACHE_TRACK_SIZE - i_off ); @@ -1418,7 +1408,7 @@ static void AStreamPrebufferStream( stream_t *s ) int64_t i_first = 0; int64_t i_start; - msg_Dbg( s, "pre buffering" ); + msg_Dbg( s, "starting pre-buffering" ); i_start = mdate(); for( ;; ) { @@ -1428,7 +1418,7 @@ static void AStreamPrebufferStream( stream_t *s ) int i_read; int i_buffered = tk->i_end - tk->i_start; - if( s->b_die || i_buffered >= STREAM_CACHE_PREBUFFER_SIZE ) + if( !vlc_object_alive(s) || i_buffered >= STREAM_CACHE_PREBUFFER_SIZE ) { int64_t i_byterate; @@ -1483,7 +1473,7 @@ char *stream_ReadLine( stream_t *s ) char *p_line = NULL; int i_line = 0, i_read = 0; - while( i_read < STREAM_LINE_MAX ) + for( ;; ) { char *psz_eol; const uint8_t *p_data; @@ -1496,58 +1486,28 @@ char *stream_ReadLine( stream_t *s ) /* BOM detection */ i_pos = stream_Tell( s ); - if( i_pos == 0 && i_data >= 3 ) + if( i_pos == 0 && i_data >= 2 ) { - int i_bom_size = 0; const char *psz_encoding = NULL; - if( !memcmp( p_data, "\xEF\xBB\xBF", 3 ) ) - { - psz_encoding = "UTF-8"; - i_bom_size = 3; - } - else if( !memcmp( p_data, "\xFF\xFE", 2 ) ) + if( !memcmp( p_data, "\xFF\xFE", 2 ) ) { psz_encoding = "UTF-16LE"; s->p_text->b_little_endian = true; - s->p_text->i_char_width = 2; - i_bom_size = 2; } else if( !memcmp( p_data, "\xFE\xFF", 2 ) ) { psz_encoding = "UTF-16BE"; - s->p_text->i_char_width = 2; - i_bom_size = 2; - } - - /* Seek past the BOM */ - if( i_bom_size ) - { - stream_Seek( s, i_bom_size ); - p_data += i_bom_size; - i_data -= i_bom_size; } /* Open the converter if we need it */ if( psz_encoding != NULL ) { - msg_Dbg( s, "%s BOM detected", psz_encoding ); - if( s->p_text->i_char_width > 1 ) - { - s->p_text->conv = vlc_iconv_open( "UTF-8", psz_encoding ); - if( s->p_text->conv == (vlc_iconv_t)-1 ) - { - msg_Err( s, "iconv_open failed" ); - } - } - - /* FIXME that's UGLY */ - input_thread_t *p_input = s->p_input; - if( p_input != NULL) - { - var_Create( p_input, "subsdec-encoding", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); - var_SetString( p_input, "subsdec-encoding", "UTF-8" ); - } + msg_Dbg( s, "UTF-16 BOM detected" ); + s->p_text->i_char_width = 2; + s->p_text->conv = vlc_iconv_open( "UTF-8", psz_encoding ); + if( s->p_text->conv == (vlc_iconv_t)-1 ) + msg_Err( s, "iconv_open failed" ); } } @@ -1626,6 +1586,9 @@ char *stream_ReadLine( stream_t *s ) if( i_data <= 0 ) break; /* Hmmm */ i_line += i_data; i_read += i_data; + + if( i_read >= STREAM_LINE_MAX ) + goto error; /* line too long */ } if( i_read > 0 ) @@ -1638,16 +1601,20 @@ char *stream_ReadLine( stream_t *s ) i_line += s->p_text->i_char_width; /* the added \0 */ if( s->p_text->i_char_width > 1 ) { + int i_new_line = 0; size_t i_in = 0, i_out = 0; const char * p_in = NULL; char * p_out = NULL; char * psz_new_line = NULL; /* iconv */ - psz_new_line = malloc( i_line ); + /* UTF-8 needs at most 150% of the buffer as many as UTF-16 */ + i_new_line = i_line * 3 / 2; + psz_new_line = malloc( i_new_line ); if( psz_new_line == NULL ) goto error; - i_in = i_out = (size_t)i_line; + i_in = (size_t)i_line; + i_out = (size_t)i_new_line; p_in = p_line; p_out = psz_new_line; @@ -1658,7 +1625,7 @@ char *stream_ReadLine( stream_t *s ) } free( p_line ); p_line = psz_new_line; - i_line = (size_t)i_line - i_out; /* does not include \0 */ + i_line = (size_t)i_new_line - i_out; /* does not include \0 */ } /* Remove trailing LF/CR */ @@ -1689,27 +1656,20 @@ static int AReadStream( stream_t *s, void *p_read, unsigned int i_read ) { stream_sys_t *p_sys = s->p_sys; access_t *p_access = p_sys->p_access; - input_thread_t *p_input = NULL; + input_thread_t *p_input = s->p_input; int i_read_orig = i_read; - int i_total = 0; - - if( s->p_parent && s->p_parent->p_parent && - vlc_internals( 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_access->b_die ) - vlc_object_kill( s ); if( p_input ) { + uint64_t total; + 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 ); + stats_Update( p_input->p->counters.p_read_bytes, i_read, &total ); + stats_Update( p_input->p->counters.p_input_bitrate, total, NULL ); + stats_Update( p_input->p->counters.p_read_packets, 1, NULL ); vlc_mutex_unlock( &p_input->p->counters.counters_lock ); } return i_read; @@ -1717,8 +1677,6 @@ static int AReadStream( stream_t *s, void *p_read, unsigned int i_read ) i_read = p_sys->p_list_access->pf_read( p_sys->p_list_access, p_read, i_read ); - if( p_access->b_die ) - vlc_object_kill( s ); /* If we reached an EOF then switch to the next stream in the list */ if( i_read == 0 && p_sys->i_list_index + 1 < p_sys->i_list ) @@ -1744,11 +1702,12 @@ static int AReadStream( stream_t *s, void *p_read, unsigned int i_read ) /* Update read bytes in input */ if( p_input ) { + uint64_t total; + 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 ); + stats_Update( p_input->p->counters.p_read_bytes, i_read, &total ); + stats_Update( p_input->p->counters.p_input_bitrate, total, NULL ); + stats_Update( p_input->p->counters.p_read_packets, 1, NULL ); vlc_mutex_unlock( &p_input->p->counters.counters_lock ); } return i_read; @@ -1758,37 +1717,30 @@ static block_t *AReadBlock( stream_t *s, bool *pb_eof ) { stream_sys_t *p_sys = s->p_sys; access_t *p_access = p_sys->p_access; - input_thread_t *p_input = NULL; + input_thread_t *p_input = s->p_input; block_t *p_block; bool b_eof; - int i_total = 0; - - if( s->p_parent && s->p_parent->p_parent && - vlc_internals( 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( p_access->b_die ) - vlc_object_kill( s ); if( pb_eof ) *pb_eof = p_access->info.b_eof; if( p_input && p_block && libvlc_stats (p_access) ) { + uint64_t total; + 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 ); + stats_Update( p_input->p->counters.p_read_bytes, + p_block->i_buffer, &total ); + stats_Update( p_input->p->counters.p_input_bitrate, + total, NULL ); + stats_Update( p_input->p->counters.p_read_packets, 1, NULL ); vlc_mutex_unlock( &p_input->p->counters.counters_lock ); } return p_block; } p_block = p_sys->p_list_access->pf_block( p_sys->p_list_access ); - if( p_access->b_die ) - vlc_object_kill( s ); b_eof = p_sys->p_list_access->info.b_eof; if( pb_eof ) *pb_eof = b_eof; @@ -1816,13 +1768,13 @@ static block_t *AReadBlock( stream_t *s, bool *pb_eof ) { if( p_input ) { + uint64_t total; + 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); + stats_Update( p_input->p->counters.p_read_bytes, + p_block->i_buffer, &total ); + stats_Update( p_input->p->counters.p_input_bitrate, total, NULL ); + stats_Update( p_input->p->counters.p_read_packets, 1 , NULL); vlc_mutex_unlock( &p_input->p->counters.counters_lock ); } } @@ -1881,9 +1833,11 @@ static int ASeek( stream_t *s, uint64_t 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 + * "p_read" is NULL then data are skipped instead of read. + * \return The real number of bytes read/skip. If this value is less * than i_read that means that it's the end of the stream. + * \note stream_Read increments the stream position, and when p_read is NULL, + * this is its only task. */ int stream_Read( stream_t *s, void *p_read, int i_read ) { @@ -1892,12 +1846,15 @@ int stream_Read( stream_t *s, void *p_read, int 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 + * \return The real number 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 >= + * \note Contrary to stream_Read, stream_Peek doesn't modify the stream + * position, and doesn't necessarily involve copying of data. It's mainly + * used by the modules to quickly probe the (head of the) stream. + * \note Due to input limitation, the return value 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 ) @@ -1947,7 +1904,7 @@ 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 ); + block_t *p_bk = block_Alloc( i_size ); if( p_bk ) { int i_read = stream_Read( s, p_bk->p_buffer, i_size ); @@ -1960,3 +1917,48 @@ block_t *stream_Block( stream_t *s, int i_size ) } return NULL; } + +/** + * Read the remaining of the data if there is less than i_max_size bytes, otherwise + * return NULL. + * + * The stream position is unknown after the call. + */ +block_t *stream_BlockRemaining( stream_t *s, int i_max_size ) +{ + int i_allocate = __MIN(1000000, i_max_size); + int64_t i_size = stream_Size( s ); + if( i_size > 0 ) + { + int64_t i_position = stream_Tell( s ); + if( i_position + i_max_size < i_size ) + { + msg_Err( s, "Remaining stream size is greater than %d bytes", + i_max_size ); + return NULL; + } + i_allocate = i_size - i_position; + } + if( i_allocate <= 0 ) + return NULL; + + block_t *p_block = block_Alloc( i_allocate ); + int i_index = 0; + while( p_block ) + { + int i_read = stream_Read( s, &p_block->p_buffer[i_index], + p_block->i_buffer - i_index); + if( i_read <= 0 ) + break; + i_index += i_read; + i_max_size -= i_read; + if( i_max_size <= 0 ) + break; + p_block = block_Realloc( p_block, 0, p_block->i_buffer + + __MIN(1000000, i_max_size) ); + } + if( p_block ) + p_block->i_buffer = i_index; + return p_block; +} +