#endif
#include <vlc_network.h>
-#include "vlc_url.h"
+#include <vlc_url.h>
#include "asf.h"
#include "buffer.h"
void MMSTUClose ( access_t * );
-static ssize_t Read( access_t *, uint8_t *, size_t );
+static block_t *Block( access_t * );
static int Seek( access_t *, int64_t );
static int Control( access_t *, int, va_list );
int i_status;
/* Set up p_access */
- p_access->pf_read = Read;
- p_access->pf_block = NULL;
+ access_InitFields( p_access );
+ p_access->pf_read = NULL;
+ p_access->pf_block = Block;
p_access->pf_control = Control;
p_access->pf_seek = Seek;
- p_access->info.i_update = 0;
- p_access->info.i_size = 0;
- p_access->info.i_pos = 0;
- p_access->info.b_eof = false;
- p_access->info.i_title = 0;
- p_access->info.i_seekpoint = 0;
- p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
+
+ p_access->p_sys = p_sys = calloc( 1, sizeof( access_sys_t ) );
if( !p_sys ) return VLC_ENOMEM;
- memset( p_sys, 0, sizeof( access_sys_t ) );
p_sys->i_timeout = var_CreateGetInteger( p_access, "mms-timeout" );
/* Keep the connection alive when paused */
p_sys->p_keepalive = malloc( sizeof( mmstu_keepalive_t ) );
+ if( !p_sys->p_keepalive )
+ {
+ MMSTUClose ( p_access );
+ return VLC_ENOMEM;
+ }
p_sys->p_keepalive->p_access = p_access;
vlc_mutex_init( &p_sys->p_keepalive->lock );
vlc_cond_init( &p_sys->p_keepalive->wait );
access_sys_t *p_sys = p_access->p_sys;
bool *pb_bool;
bool b_bool;
- int *pi_int;
int64_t *pi_64;
int i_int;
- vlc_value_t val;
switch( i_query )
{
break;
/* */
- case ACCESS_GET_MTU:
- pi_int = (int*)va_arg( args, int * );
- *pi_int = 3 * p_sys->i_packet_length;
- break;
-
case ACCESS_GET_PTS_DELAY:
pi_64 = (int64_t*)va_arg( args, int64_t * );
- var_Get( p_access, "mms-caching", &val );
*pi_64 = (int64_t)var_GetInteger( p_access, "mms-caching" ) * INT64_C(1000);
break;
else
Seek( p_access, p_access->info.i_pos );
- vlc_mutex_lock( &p_sys->p_keepalive->lock );
- p_sys->p_keepalive->b_paused = b_bool;
- if( b_bool )
- vlc_cond_signal( &p_sys->p_keepalive->wait );
- vlc_mutex_unlock( &p_sys->p_keepalive->lock );
+ if( p_sys->p_keepalive )
+ {
+ vlc_mutex_lock( &p_sys->p_keepalive->lock );
+ p_sys->p_keepalive->b_paused = b_bool;
+ if( b_bool )
+ vlc_cond_signal( &p_sys->p_keepalive->wait );
+ vlc_mutex_unlock( &p_sys->p_keepalive->lock );
+ }
break;
case ACCESS_GET_TITLE_INFO:
i_packet = ( i_pos - p_sys->i_header ) / p_sys->i_packet_length;
i_offset = ( i_pos - p_sys->i_header ) % p_sys->i_packet_length;
}
+ if( p_sys->b_seekable && i_packet >= p_sys->i_packet_count )
+ return VLC_EGENERIC;
+
msg_Dbg( p_access, "seeking to %"PRId64 " (packet:%d)", i_pos, i_packet );
MMSStop( p_access );
}
/*****************************************************************************
- * Read:
+ * Block:
*****************************************************************************/
-static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
+static block_t *Block( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
- size_t i_data;
- size_t i_copy;
if( p_access->info.b_eof )
+ return NULL;
+
+ if( p_access->info.i_pos < p_sys->i_header )
{
- return 0;
- }
+ const size_t i_copy = p_sys->i_header - p_access->info.i_pos;
- i_data = 0;
+ block_t *p_block = block_New( p_access, i_copy );
+ if( !p_block )
+ return NULL;
- /* *** now send data if needed *** */
- while( i_data < i_len )
+ memcpy( p_block->p_buffer, &p_sys->p_header[p_access->info.i_pos], i_copy );
+ p_access->info.i_pos += i_copy;
+ return p_block;
+ }
+ else if( p_sys->p_media && p_sys->i_media_used < __MAX( p_sys->i_media, p_sys->i_packet_length ) )
{
- if( p_access->info.i_pos < p_sys->i_header )
- {
- i_copy = __MIN( i_len, p_sys->i_header - p_access->info.i_pos );
- memcpy( &p_buffer[i_data], &p_sys->p_header[p_access->info.i_pos], i_copy );
- i_data += i_copy;
- p_access->info.i_pos += i_copy;
- }
- else if( p_sys->i_media_used < p_sys->i_media )
- {
- i_copy = __MIN( i_len - i_data ,
- p_sys->i_media - p_sys->i_media_used );
- memcpy( &p_buffer[i_data], &p_sys->p_media[p_sys->i_media_used], i_copy );
- i_data += i_copy;
- p_sys->i_media_used += i_copy;
- p_access->info.i_pos += i_copy;
- }
- else if( p_sys->p_media != NULL &&
- p_sys->i_media_used < p_sys->i_packet_length )
- {
- i_copy = __MIN( i_len - i_data,
- p_sys->i_packet_length - p_sys->i_media_used);
- memset( &p_buffer[i_data], 0, i_copy );
+ size_t i_copy = 0;
+ size_t i_padding = 0;
- i_data += i_copy;
- p_sys->i_media_used += i_copy;
- p_access->info.i_pos += i_copy;
- }
- else if( p_access->info.b_eof ||
- mms_HeaderMediaRead( p_access, MMS_PACKET_MEDIA ) < 0 )
- {
- break;
- }
+ if( p_sys->i_media_used < p_sys->i_media )
+ i_copy = p_sys->i_media - p_sys->i_media_used;
+ if( __MAX( p_sys->i_media, p_sys->i_media_used ) < p_sys->i_packet_length )
+ i_padding = p_sys->i_packet_length - __MAX( p_sys->i_media, p_sys->i_media_used );
+
+ block_t *p_block = block_New( p_access, i_copy + i_padding );
+ if( !p_block )
+ return NULL;
+
+ if( i_copy > 0 )
+ memcpy( &p_block->p_buffer[0], &p_sys->p_media[p_sys->i_media_used], i_copy );
+ if( i_padding > 0 )
+ memset( &p_block->p_buffer[i_copy], 0, i_padding );
+
+ p_sys->i_media_used += i_copy + i_padding;
+ p_access->info.i_pos += i_copy + i_padding;
+ return p_block;
}
- return i_data;
+ mms_HeaderMediaRead( p_access, MMS_PACKET_MEDIA );
+ return NULL;
}
/****************************************************************************
{ \
int i; \
psz = malloc( size + 1); \
+ assert( psz ); \
for( i = 0; i < size; i++ ) \
{ \
psz[i] = p[i]; \
msg_Dbg( p_access,
"answer 0x06 flags:0x%8.8"PRIx32" media_length:%"PRIu32"s "
- "packet_length:%zul packet_count:%"PRId32" max_bit_rate:%d "
+ "packet_length:%zu packet_count:%"PRIu32" max_bit_rate:%d "
"header_size:%zu",
p_sys->i_flags_broadcast,
p_sys->i_media_length,
- (unsigned)p_sys->i_packet_length,
+ p_sys->i_packet_length,
p_sys->i_packet_count,
p_sys->i_max_bit_rate,
p_sys->i_header_size );
vlc_mutex_unlock( &p_sys->lock_netwrite );
if( i_ret != buffer.i_data - ( 8 - ( i_data - i_data_old ) ) )
{
+ var_buffer_free( &buffer );
msg_Err( p_access, "failed to send command" );
return VLC_EGENERIC;
}
}
if( i_udp > 0 )
{
- ufd[nfd].fd = p_sys->i_handle_tcp;
+ ufd[nfd].fd = p_sys->i_handle_udp;
ufd[nfd].events = POLLIN;
nfd++;
}
/* We'll wait 0.5 second if nothing happens */
- timeout = 500;
+ timeout = __MIN( 500, p_sys->i_timeout );
if( i_try * timeout > p_sys->i_timeout )
{
return -1;
}
- if( !vlc_object_alive (p_access) || p_access->b_error ) return -1;
+ if( !vlc_object_alive (p_access) || p_access->b_error )
+ return -1;
//msg_Dbg( p_access, "NetFillBuffer: trying again (select)" );
free( p_sys->p_cmd );
p_sys->i_cmd = i_data;
p_sys->p_cmd = malloc( i_data );
+ assert( p_sys->p_cmd );
memcpy( p_sys->p_cmd, p_data, i_data );
*pi_used = i_data; /* by default */
size_t i_packet_length;
uint32_t i_packet_id;
- uint8_t *p_packet;
-
-
*pi_used = i_data; /* default */
if( i_data <= 8 )
{
}
/* we now have a media or a header packet */
- p_packet = malloc( i_packet_length - 8 ); // don't bother with preheader
- memcpy( p_packet, p_data + 8, i_packet_length - 8 );
-
if( i_packet_seq_num != p_sys->i_packet_seq_num )
{
#if 0
{
if( p_sys->p_header )
{
- p_sys->p_header = realloc( p_sys->p_header,
- p_sys->i_header + i_packet_length - 8 );
+ p_sys->p_header = realloc_or_free( p_sys->p_header,
+ p_sys->i_header + i_packet_length - 8 );
+ assert( p_sys->p_header );
memcpy( &p_sys->p_header[p_sys->i_header],
- p_packet,
- i_packet_length - 8 );
+ p_data + 8, i_packet_length - 8 );
p_sys->i_header += i_packet_length - 8;
- free( p_packet );
}
else
{
+ uint8_t* p_packet = malloc( i_packet_length - 8 ); // don't bother with preheader
+ assert( p_packet );
+ memcpy( p_packet, p_data + 8, i_packet_length - 8 );
p_sys->p_header = p_packet;
p_sys->i_header = i_packet_length - 8;
}
}
else
{
+ uint8_t* p_packet = malloc( i_packet_length - 8 ); // don't bother with preheader
+ assert( p_packet );
+ memcpy( p_packet, p_data + 8, i_packet_length - 8 );
FREENULL( p_sys->p_media );
p_sys->p_media = p_packet;
p_sys->i_media = i_packet_length - 8;