[Mplayer-cvslog] CVS: main/libmpdemux asf_streaming.c,1.8,1.9 network.c,1.9,1.10 network.h,1.3,1.4
Bertrand Baudet
bertrand at mplayer.dev.hu
Tue Nov 20 23:20:23 CET 2001
Update of /cvsroot/mplayer/main/libmpdemux
In directory mplayer:/var/tmp.root/cvs-serv22643
Modified Files:
asf_streaming.c network.c network.h
Log Message:
Removed my buffer hack to use cache2.
Removed the network thread.
Changed the network layer to use cache2.
Index: asf_streaming.c
===================================================================
RCS file: /cvsroot/mplayer/main/libmpdemux/asf_streaming.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -r1.8 -r1.9
--- asf_streaming.c 30 Oct 2001 17:03:10 -0000 1.8
+++ asf_streaming.c 20 Nov 2001 22:20:20 -0000 1.9
@@ -11,67 +11,47 @@
#include "network.h"
#include "stream.h"
-//#include "demuxer.h"
-
-//extern demuxer_t *demuxer;
static ASF_StreamType_e streaming_type = ASF_Unknown_e;
+// ASF streaming support several network protocol.
+// One use UDP, not known, yet!
+// Another is HTTP, this one is known.
+// So for now, we use the HTTP protocol.
int
-asf_http_streaming_read( streaming_ctrl_t *streaming_ctrl ) {
- char *buffer;
- int drop_packet;
- int ret;
-printf("asf_http_streaming_read\n");
- ret = asf_streaming( streaming_ctrl->buffer->buffer, streaming_ctrl->buffer->length, &drop_packet );
-printf("ret: %d\n", ret);
- if( ret<0 ) return -1;
- if( ret>streaming_ctrl->buffer->length ) return 0;
- buffer = (char*)malloc(ret);
- if( buffer==NULL ) {
- printf("Memory allocation failed\n");
- return -1;
- }
-printf("buffer length: %d\n", streaming_ctrl->buffer->length );
- net_fifo_pop( streaming_ctrl->buffer, buffer, ret );
-printf(" pop: 0x%02X\n", *((unsigned int*)buffer) );
-printf("buffer length: %d\n", streaming_ctrl->buffer->length );
-printf("0x%02X\n", *((unsigned int*)(buffer+sizeof(ASF_stream_chunck_t))) );
- if( !drop_packet ) {
- write( streaming_ctrl->fd_pipe_in, buffer+sizeof(ASF_stream_chunck_t), ret-sizeof(ASF_stream_chunck_t) );
- }
- free( buffer );
- return ret;
+asf_streaming_start( stream_t *stream ) {
+ return asf_http_streaming_start( stream );
}
+
int
-asf_http_read( streaming_ctrl_t *streaming_ctrl ) {
- char *buffer;
- unsigned int length = streaming_ctrl->buffer->length;
-
- buffer = (char*)malloc(length);
- if( buffer==NULL ) {
- printf("Memory allocation failed\n");
- return -1;
- }
+asf_http_streaming_read( int fd, char *buffer, int size, streaming_ctrl_t *streaming_ctrl ) {
+ int drop_packet;
+ int ret;
+//printf("asf_http_streaming_read\n");
- net_fifo_pop( streaming_ctrl->buffer, buffer, length );
+ ret = nop_streaming_read( fd, buffer, size, streaming_ctrl );
+//printf("Read %d bytes\n", ret);
- write( streaming_ctrl->fd_pipe_in, buffer, length );
-
- free( buffer );
- return length;
+ ret = asf_streaming( buffer, size, &drop_packet );
+//printf("Streaming packet size=%d\n", ret);
+ if( ret<0 ) return -1;
+ if( !drop_packet ) {
+ memmove( buffer, buffer+sizeof(ASF_stream_chunck_t), ret-sizeof(ASF_stream_chunck_t) );
+ }
+ return ret-sizeof(ASF_stream_chunck_t);
}
int
asf_streaming(char *data, int length, int *drop_packet ) {
ASF_stream_chunck_t *stream_chunck=(ASF_stream_chunck_t*)data;
- printf("ASF stream chunck size=%d\n", stream_chunck->size);
+/*
+printf("ASF stream chunck size=%d\n", stream_chunck->size);
printf("length: %d\n", length );
printf("0x%02X\n", stream_chunck->type );
-
- if( drop_packet!=NULL ) *drop_packet = 0;
+*/
if( data==NULL || length<=0 ) return -1;
+ if( drop_packet!=NULL ) *drop_packet = 0;
if( stream_chunck->size<8 ) {
printf("Ahhhh, stream_chunck size is too small: %d\n", stream_chunck->size);
@@ -81,29 +61,28 @@
printf("size_confirm mismatch!: %d %d\n", stream_chunck->size, stream_chunck->size_confirm);
return -1;
}
-
+/*
printf(" type: 0x%02X\n", stream_chunck->type );
printf(" size: %d (0x%02X)\n", stream_chunck->size, stream_chunck->size );
printf(" sequence_number: 0x%04X\n", stream_chunck->sequence_number );
printf(" unknown: 0x%02X\n", stream_chunck->unknown );
printf(" size_confirm: 0x%02X\n", stream_chunck->size_confirm );
-
-
+*/
switch(stream_chunck->type) {
- case 0x4324: // Clear ASF configuration
+ case 0x4324: // $C Clear ASF configuration
printf("=====> Clearing ASF stream configuration!\n");
if( drop_packet!=NULL ) *drop_packet = 1;
return stream_chunck->size;
break;
- case 0x4424: // Data follows
- printf("=====> Data follows\n");
+ case 0x4424: // $D Data follows
+// printf("=====> Data follows\n");
break;
- case 0x4524: // Transfer complete
+ case 0x4524: // $E Transfer complete
printf("=====> Transfer complete\n");
if( drop_packet!=NULL ) *drop_packet = 1;
return stream_chunck->size;
break;
- case 0x4824: // ASF header chunk follows
+ case 0x4824: // $H ASF header chunk follows
printf("=====> ASF header chunk follows\n");
break;
default:
@@ -113,6 +92,11 @@
}
int
+asf_http_streaming_seek( int fd, off_t pos, streaming_ctrl_t *streaming_ctrl ) {
+ return -1;
+}
+
+int
asf_http_streaming_type(char *content_type, char *features) {
if( content_type==NULL ) return ASF_Unknown_e;
if( !strcasecmp(content_type, "application/octet-stream") ) {
@@ -178,9 +162,6 @@
ptr = str;
ptr += sprintf( ptr, "Pragma: stream-switch-entry=");
-// FIXME: why do you need demuxer here? if you really need it, pass it as
-// parameter. -- A'rpi
-
#if 0
for( i=0, asf_nb_stream=0 ; i<256 ; i++ ) {
// FIXME START
@@ -234,11 +215,13 @@
}
content_type = http_get_field( http_hdr, "Content-Type");
+//printf("Content-Type: [%s]\n", content_type);
pragma = http_get_field( http_hdr, "Pragma");
while( pragma!=NULL ) {
char *comma_ptr=NULL;
char *end;
+//printf("Pragma: [%s]\n", pragma );
// The pragma line can get severals attributes
// separeted with a comma ','.
do {
@@ -263,11 +246,7 @@
}
streaming_type = asf_http_streaming_type( content_type, features );
-/*
- if( http_hdr->body_size>0 ) {
- asf_streaming( http_hdr->body, http_hdr->body_size, NULL);
- }
-*/
+
return 0;
}
@@ -282,13 +261,13 @@
}
int
-asf_http_streaming_start( streaming_ctrl_t *streaming_ctrl ) {
+asf_http_streaming_start( stream_t *stream ) {
HTTP_header_t *http_hdr=NULL;
URL_t *url_next=NULL;
- URL_t *url = *(streaming_ctrl->url);
+ URL_t *url = stream->streaming_ctrl->url;
char buffer[BUFFER_SIZE];
int i;
- int fd = streaming_ctrl->fd_net;
+ int fd = stream->fd;
int done=1;
streaming_type = ASF_Live_e;
@@ -299,13 +278,13 @@
if( fd<0 ) return -1;
http_hdr = asf_http_request( url );
-printf("[%s]\n", http_hdr->buffer );
+printf("Request [%s]\n", http_hdr->buffer );
write( fd, http_hdr->buffer, http_hdr->buffer_size );
-// http_free( http_hdr );
+ http_free( http_hdr );
http_hdr = http_new_header();
do {
- i = readFromServer( fd, buffer, BUFFER_SIZE );
+ i = read( fd, buffer, BUFFER_SIZE );
printf("read: %d\n", i );
if( i<0 ) {
perror("read");
@@ -314,8 +293,8 @@
}
http_response_append( http_hdr, buffer, i );
} while( !http_is_header_entire( http_hdr ) );
-//http_hdr->buffer[http_hdr->buffer_len]='\0';
-//printf("[%s]\n", http_hdr->buffer );
+http_hdr->buffer[http_hdr->buffer_size]='\0';
+printf("Response [%s]\n", http_hdr->buffer );
if( asf_http_parse_response(http_hdr)<0 ) {
printf("Failed to parse header\n");
http_free( http_hdr );
@@ -326,19 +305,11 @@
case ASF_Prerecorded_e:
case ASF_PlainText_e:
if( http_hdr->body_size>0 ) {
- net_fifo_push( streaming_ctrl->buffer, http_hdr->body, http_hdr->body_size );
- } else {
- ASF_stream_chunck_t *ptr;
- int ret;
- i = readFromServer( fd, buffer, sizeof(ASF_stream_chunck_t) );
-printf("read: %d\n", i );
- ret = asf_streaming( buffer, i, NULL );
- net_fifo_push( streaming_ctrl->buffer, buffer, i );
- ptr = (ASF_stream_chunck_t*)buffer;
- if( ret==ptr->size ) {
+ if( streaming_bufferize( stream->streaming_ctrl, http_hdr->body, http_hdr->body_size )<0 ) {
+ http_free( http_hdr );
+ return -1;
}
}
-// done = 0;
break;
case ASF_Redirector_e:
url_next = asf_http_ASX_redirect( http_hdr );
@@ -349,10 +320,10 @@
return -1;
}
if( url_next->port==0 ) url_next->port=80;
- url_free( url );
+ url_free( stream->streaming_ctrl->url );
+ stream->streaming_ctrl->url = url_next;
url = url_next;
- *(streaming_ctrl->url) = url_next;
- url_next = NULL;
+ done = 0;
break;
case ASF_Unknown_e:
default:
@@ -365,15 +336,17 @@
// Check if we got a redirect.
} while(!done);
- streaming_ctrl->fd_net = fd;
+ stream->fd= fd;
if( streaming_type==ASF_PlainText_e ) {
- streaming_ctrl->streaming_read = asf_http_read;
+ stream->streaming_ctrl->streaming_read = nop_streaming_read;
+ stream->streaming_ctrl->streaming_seek = nop_streaming_seek;
} else {
- streaming_ctrl->streaming_read = asf_http_streaming_read;
+ stream->streaming_ctrl->streaming_read = asf_http_streaming_read;
+ stream->streaming_ctrl->streaming_seek = asf_http_streaming_seek;
}
- streaming_ctrl->prebuffer_size = 20000;
- streaming_ctrl->buffering = 1;
- streaming_ctrl->status = streaming_playing_e;
+ stream->streaming_ctrl->prebuffer_size = 20000;
+ stream->streaming_ctrl->buffering = 1;
+ stream->streaming_ctrl->status = streaming_playing_e;
http_free( http_hdr );
return fd;
Index: network.c
===================================================================
RCS file: /cvsroot/mplayer/main/libmpdemux/network.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- network.c 30 Oct 2001 17:03:11 -0000 1.9
+++ network.c 20 Nov 2001 22:20:20 -0000 1.10
@@ -34,75 +34,42 @@
#include "url.h"
#include "asf.h"
-streaming_ctrl_t *streaming_ctrl;
+static struct {
+ char *mime_type;
+ int demuxer_type;
+} mime_type_table[] = {
+ // MP3 streaming, some MP3 streaming server answer with audio/mpeg
+ { "audio/mpeg", DEMUXER_TYPE_MPEG_PS },
+ // MPEG streaming
+ { "video/mpeg", DEMUXER_TYPE_MPEG_PS },
+ // AVI ??? => video/x-msvideo
+ { "video/x-msvideo", DEMUXER_TYPE_AVI },
+ // MOV => video/quicktime
+ { "video/quicktime", DEMUXER_TYPE_MOV },
+ // ASF
+ { "audio/x-ms-wax", DEMUXER_TYPE_ASF },
+ { "audio/x-ms-wma", DEMUXER_TYPE_ASF },
+ { "video/x-ms-asf", DEMUXER_TYPE_ASF },
+ { "video/x-ms-afs", DEMUXER_TYPE_ASF },
+ { "video/x-ms-wvx", DEMUXER_TYPE_ASF },
+ { "video/x-ms-wmv", DEMUXER_TYPE_ASF },
+ { "video/x-ms-wma", DEMUXER_TYPE_ASF },
+ { "text/plain", DEMUXER_TYPE_ASF }, // This is the mime type that a web server send when sending a raw asf without streaming encapsulation.
+};
-static ASF_StreamType_e streaming_type = ASF_Unknown_e;
-
-Net_Fifo *
-net_fifo_new() {
- Net_Fifo *net_fifo;
- net_fifo = (Net_Fifo*)malloc(sizeof(Net_Fifo));
- if( net_fifo==NULL ) {
- printf("Memory allocation failed\n");
- return NULL;
- }
- memset( net_fifo, 0, sizeof(Net_Fifo) );
- return net_fifo;
-}
-
-void
-net_fifo_free( Net_Fifo *net_fifo ) {
- if( net_fifo->buffer!=NULL ) free( net_fifo->buffer );
- free( net_fifo );
-}
-
-int
-net_fifo_push(Net_Fifo *net_fifo, char *buffer, int length ) {
- char *ptr;
- if( net_fifo==NULL || buffer==NULL || length<0 ) return -1;
-
- ptr = (char*)malloc(length+net_fifo->length);
- if( ptr==NULL ) {
- printf("Memory allocation failed\n");
- return -1;
- }
- if( net_fifo->buffer!=NULL ) {
- memcpy( ptr, net_fifo->buffer, net_fifo->length );
- free( net_fifo->buffer );
- }
- memcpy( ptr+net_fifo->length, buffer, length );
- net_fifo->buffer = ptr;
- net_fifo->length += length;
- return net_fifo->length;
-}
-
-int
-net_fifo_pop(Net_Fifo *net_fifo, char *buffer, int length ) {
- char *ptr;
- int len;
- if( net_fifo==NULL || buffer==NULL || length<0 ) return -1;
- if( net_fifo->buffer==NULL || net_fifo->length==0 ) return -1;
-
- len = MIN(net_fifo->length, length);
-
- ptr = (char*)malloc(net_fifo->length-len);
- if( ptr==NULL ) {
- printf("Memory allocation failed\n");
- return -1;
- }
- memcpy( buffer, net_fifo->buffer, len );
- if( net_fifo->length-len!=0 ) {
- memcpy( ptr, net_fifo->buffer+len, net_fifo->length-len );
- free( net_fifo->buffer );
- net_fifo->buffer = ptr;
- net_fifo->length -= len;
- } else {
- free( net_fifo->buffer );
- net_fifo->buffer = NULL;
- net_fifo->length = 0;
- }
- return len;
-}
+static struct {
+ char *extension;
+ int demuxer_type;
+} extensions_table[] = {
+ { "mpeg", DEMUXER_TYPE_MPEG_PS },
+ { "mpg", DEMUXER_TYPE_MPEG_PS },
+ { "avi", DEMUXER_TYPE_AVI },
+ { "mov", DEMUXER_TYPE_MOV },
+ { "asx", DEMUXER_TYPE_ASF },
+ { "asf", DEMUXER_TYPE_ASF },
+ { "wmv", DEMUXER_TYPE_ASF },
+ { "wma", DEMUXER_TYPE_ASF },
+};
streaming_ctrl_t *
streaming_ctrl_new( ) {
@@ -113,61 +80,21 @@
return NULL;
}
memset( streaming_ctrl, 0, sizeof(streaming_ctrl_t) );
- streaming_ctrl->buffer = net_fifo_new();
return streaming_ctrl;
}
void
streaming_ctrl_free( streaming_ctrl_t *streaming_ctrl ) {
if( streaming_ctrl==NULL ) return;
- if( streaming_ctrl->buffer!=NULL ) net_fifo_free( streaming_ctrl->buffer );
free( streaming_ctrl );
}
-int
-readFromServer(int fd, char *buffer, int length) {
- int ret;
- int done=0;
- fd_set set;
- struct timeval tv;
- if( buffer==NULL || length<0 ) return -1;
-
-
-// fcntl( fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_NONBLOCK );
- return read( fd, buffer, length );
-
- do {
- tv.tv_sec = 0;
- tv.tv_usec = 10000; // 10 milli-seconds timeout
- FD_ZERO( &set );
- FD_SET( fd, &set );
- ret = select( fd+1, &set, NULL, NULL, &tv );
- if( ret<0 ) {
- perror("select");
- } else if( ret==0 ) {
- printf("timeout\n");
- }
- if( FD_ISSET(fd, &set) ) {
- ret = read( fd, buffer, length );
- if( ret<0 ) {
- if( errno!=EINPROGRESS ) {
- }
- } else {
- done = 1;
- }
- } else {
- return -1;
- }
- } while( !done );
-
- return ret;
-}
-
// Connect to a server using a TCP connection
int
connect2Server(char *host, int port) {
int socket_server_fd;
int err, err_len;
+ int ret;
fd_set set;
struct timeval tv;
struct sockaddr_in server_address;
@@ -175,14 +102,14 @@
printf("Connecting to server %s:%d ...\n", host, port );
socket_server_fd = socket(AF_INET, SOCK_STREAM, 0);
-// fcntl( socket_server_fd, F_SETFL, fcntl(socket_server_fd, F_GETFL) | O_NONBLOCK );
if( socket_server_fd==-1 ) {
perror("Failed to create socket");
return -1;
}
if( isalpha(host[0]) ) {
- struct hostent *hp =(struct hostent*)gethostbyname( host );
+ struct hostent *hp;
+ hp=(struct hostent*)gethostbyname( host );
if( hp==NULL ) {
printf("Counldn't resolve name: %s\n", host);
return -1;
@@ -193,7 +120,9 @@
}
server_address.sin_family=AF_INET;
server_address.sin_port=htons(port);
-
+
+ // Turn the socket as non blocking so we can timeout on the connection
+ fcntl( socket_server_fd, F_SETFL, fcntl(socket_server_fd, F_GETFL) | O_NONBLOCK );
if( connect( socket_server_fd, (struct sockaddr*)&server_address, sizeof(server_address) )==-1 ) {
if( errno!=EINPROGRESS ) {
perror("Failed to connect to server");
@@ -201,21 +130,20 @@
return -1;
}
}
-
- tv.tv_sec = 0;
- tv.tv_usec = 10000; // 10 milli-seconds timeout
+ tv.tv_sec = 5; // 5 seconds timeout on connection
+ tv.tv_usec = 0;
FD_ZERO( &set );
FD_SET( socket_server_fd, &set );
- if( select(socket_server_fd+1, NULL, &set, NULL, &tv)>0 ) {
- err_len = sizeof( err );
- getsockopt( socket_server_fd, SOL_SOCKET, SO_ERROR, &err, &err_len );
- if( err ) {
- printf("Couldn't connect to host %s\n", host );
- printf("Socket error: %d\n", err );
- close(socket_server_fd);
- return -1;
- }
+ // When the connection will be made, we will have a writable fd
+ ret = select(socket_server_fd+1, NULL, &set, NULL, &tv);
+ if( ret<=0 ) {
+ if( ret<0 ) perror("select failed");
+ else printf("Connection timeout\n");
+ return -1;
}
+
+ // Turn back the socket as blocking
+ fcntl( socket_server_fd, F_SETFL, fcntl(socket_server_fd, F_GETFL) & ~O_NONBLOCK );
return socket_server_fd;
}
@@ -253,7 +181,7 @@
}
do {
- i = readFromServer( fd, response, BUFFER_SIZE );
+ i = read( fd, response, BUFFER_SIZE );
if( i<0 ) {
printf("Read failed\n");
}
@@ -294,23 +222,15 @@
}
}
}
-// extension=NULL;
+extension=NULL;
if( extension!=NULL ) {
printf("Extension: %s\n", extension );
- if( !strcasecmp(extension, "asf") ||
- !strcasecmp(extension, "wmv") ||
- !strcasecmp(extension, "asx") ) {
- if( url->port==0 ) url->port = 80;
- return DEMUXER_TYPE_ASF;
- }
- if( !strcasecmp(extension, "mpg") ||
- !strcasecmp(extension, "mpeg") ) {
- if( url->port==0 ) url->port = 80;
- return DEMUXER_TYPE_MPEG_PS;
- }
- if( !strcasecmp(extension, "avi") ) {
- if( url->port==0 ) url->port = 80;
- return DEMUXER_TYPE_AVI;
+ // Look for the extension in the extensions table
+ for( i=0 ; i<(sizeof(extensions_table)/sizeof(extensions_table[0])) ; i++ ) {
+ if( !strcasecmp(extension, extensions_table[i].extension) ) {
+ if( url->port==0 ) url->port = 80;
+ return extensions_table[i].demuxer_type;
+ }
}
}
@@ -340,15 +260,17 @@
if( http_hdr==NULL ) {
close( fd );
*fd_out=-1;
+ http_free( http_hdr );
return DEMUXER_TYPE_UNKNOWN;
}
*fd_out=fd;
- //http_debug_hdr( http_hdr );
+ http_debug_hdr( http_hdr );
// Check if the response is an ICY status_code reason_phrase
if( !strcasecmp(http_hdr->protocol, "ICY") ) {
// Ok, we have detected an mp3 streaming
+ http_free( http_hdr );
return DEMUXER_TYPE_MPEG_PS;
}
@@ -359,22 +281,12 @@
if( content_type!=NULL ) {
printf("Content-Type: [%s]\n", content_type );
printf("Content-Length: [%s]\n", http_get_field(http_hdr, "Content-Length") );
- // Check for ASF
- if( asf_http_streaming_type(content_type, NULL)!=ASF_Unknown_e ) {
- return DEMUXER_TYPE_ASF;
- }
- // Check for MP3 streaming
- // Some MP3 streaming server answer with audio/mpeg
- if( !strcasecmp(content_type, "audio/mpeg") ) {
- return DEMUXER_TYPE_MPEG_PS;
- }
- // Check for MPEG streaming
- if( !strcasecmp(content_type, "video/mpeg") ) {
- return DEMUXER_TYPE_MPEG_PS;
- }
- // AVI ??? => video/x-msvideo
- if( !strcasecmp(content_type, "video/x-msvideo") ) {
- return DEMUXER_TYPE_AVI;
+ // Check in the mime type table for a demuxer type
+ for( i=0 ; i<(sizeof(mime_type_table)/sizeof(mime_type_table[0])) ; i++ ) {
+ if( !strcasecmp( content_type, mime_type_table[i].mime_type ) ) {
+ http_free( http_hdr );
+ return mime_type_table[i].demuxer_type;
+ }
}
}
break;
@@ -394,42 +306,71 @@
printf("Server returned %d: %s\n", http_hdr->status_code, http_hdr->reason_phrase );
close( fd );
*fd_out=-1;
+ http_free( http_hdr );
return DEMUXER_TYPE_UNKNOWN;
}
}
} while( redirect );
+ http_free( http_hdr );
return DEMUXER_TYPE_UNKNOWN;
}
int
-nop_streaming_read( streaming_ctrl_t *streaming_ctrl ) {
- char *buffer;
- int len;
- if( streaming_ctrl==NULL ) return -1;
- len = streaming_ctrl->buffer->length;
- if( len==0 ) return 0;
-
- buffer = (char*)malloc( len );
- if( buffer==NULL ) {
- printf("Memory allocation failed\n");
- return -1;
- }
- net_fifo_pop( streaming_ctrl->buffer, buffer, len );
- write( streaming_ctrl->fd_pipe_in, buffer, len );
- free( buffer );
+streaming_bufferize( streaming_ctrl_t *streaming_ctrl, char *buffer, int size) {
+printf("streaming_bufferize\n");
+ streaming_ctrl->buffer = (char*)malloc(size);
+ if( streaming_ctrl->buffer==NULL ) {
+ printf("Memory allocation failed\n");
+ return -1;
+ }
+ memcpy( streaming_ctrl->buffer, buffer, size );
+ streaming_ctrl->buffer_size = size;
+}
+
+int
+nop_streaming_read( int fd, char *buffer, int size, streaming_ctrl_t *stream_ctrl ) {
+ int len=0;
+//printf("nop_streaming_read\n");
+ if( stream_ctrl->buffer_size!=0 ) {
+ int buffer_len = stream_ctrl->buffer_size-stream_ctrl->buffer_pos;
+printf("%d bytes in buffer\n", stream_ctrl->buffer_size);
+ len = (size<buffer_len)?size:buffer_len;
+ memcpy( buffer, (stream_ctrl->buffer)+(stream_ctrl->buffer_pos), len );
+ stream_ctrl->buffer_pos += len;
+printf("buffer_pos = %d\n", stream_ctrl->buffer_pos );
+ if( stream_ctrl->buffer_pos>=stream_ctrl->buffer_size ) {
+ free( stream_ctrl->buffer );
+ stream_ctrl->buffer = NULL;
+ stream_ctrl->buffer_size = 0;
+ stream_ctrl->buffer_pos = 0;
+printf("buffer cleaned\n");
+ }
+printf("read %d bytes from buffer\n", len );
+ }
+
+ if( len<size ) {
+ len += read( fd, buffer+len, size-len );
+//printf("read %d bytes from network\n", len );
+ }
+
return len;
}
int
-nop_streaming_start( streaming_ctrl_t *streaming_ctrl ) {
+nop_streaming_seek( int fd, off_t pos, streaming_ctrl_t *stream_ctrl ) {
+ return -1;
+}
+
+int
+nop_streaming_start( stream_t *stream ) {
HTTP_header_t *http_hdr;
int fd;
- if( streaming_ctrl==NULL ) return -1;
+ if( stream==NULL ) return -1;
- fd = streaming_ctrl->fd_net;
+ fd = stream->fd;
if( fd<0 ) {
- fd = http_send_request( *(streaming_ctrl->url) );
+ fd = http_send_request( stream->streaming_ctrl->url );
if( fd<0 ) return -1;
http_hdr = http_read_response( fd );
if( http_hdr==NULL ) return -1;
@@ -439,7 +380,10 @@
printf("Content-Type: [%s]\n", http_get_field(http_hdr, "Content-Type") );
printf("Content-Length: [%s]\n", http_get_field(http_hdr, "Content-Length") );
if( http_hdr->body_size>0 ) {
- write( streaming_ctrl->fd_pipe_in, http_hdr->body, http_hdr->body_size );
+ if( streaming_bufferize( stream->streaming_ctrl, http_hdr->body, http_hdr->body_size )<0 ) {
+ http_free( http_hdr );
+ return -1;
+ }
}
break;
default:
@@ -447,148 +391,67 @@
close( fd );
fd = -1;
}
- streaming_ctrl->fd_net = fd;
+ stream->fd = fd;
}
http_free( http_hdr );
- streaming_ctrl->streaming_read = nop_streaming_read;
- streaming_ctrl->prebuffer_size = 180000;
-// streaming_ctrl->prebuffer_size = 0;
- streaming_ctrl->buffering = 1;
-// streaming_ctrl->buffering = 0;
- streaming_ctrl->status = streaming_playing_e;
+ stream->streaming_ctrl->streaming_read = nop_streaming_read;
+ stream->streaming_ctrl->streaming_seek = nop_streaming_seek;
+ stream->streaming_ctrl->prebuffer_size = 180000;
+// stream->streaming_ctrl->prebuffer_size = 0;
+ stream->streaming_ctrl->buffering = 1;
+// stream->streaming_ctrl->buffering = 0;
+ stream->streaming_ctrl->status = streaming_playing_e;
return fd;
}
-void
-network_streaming(void *arg) {
- char buffer[BUFFER_SIZE];
- fd_set fd_net_in;
- int ret;
-
- arg = arg;
-
- do {
- FD_ZERO( &fd_net_in );
- FD_SET( streaming_ctrl->fd_net, &fd_net_in );
-
- ret = select( streaming_ctrl->fd_net+1, &fd_net_in, NULL, NULL, NULL );
- if( ret<0 ) {
- perror("select");
- return; //exit(1); // FIXME!
- }
- if( FD_ISSET( streaming_ctrl->fd_net, &fd_net_in ) ) {
- ret = readFromServer( streaming_ctrl->fd_net, buffer, BUFFER_SIZE );
- if( ret<=0 ) {
- streaming_ctrl->status=streaming_stopped_e;
- } else {
-//printf(" push: 0x%02X\n", *((unsigned int*)buffer) );
- net_fifo_push( streaming_ctrl->buffer, buffer, ret );
- if( !streaming_ctrl->buffering ) {
- do {
- ret = streaming_ctrl->streaming_read( streaming_ctrl );
- if( ret<0 && streaming_ctrl->buffer->length<streaming_ctrl->prebuffer_size ) {
- // Need buffering
- streaming_ctrl->buffering = 1;
- }
- } while( streaming_ctrl->buffer->length>streaming_ctrl->prebuffer_size );
- } else {
- if( streaming_ctrl->buffer->length>streaming_ctrl->prebuffer_size ) {
- streaming_ctrl->buffering = 0;
- printf("\n");
- } else {
- printf(" Buffering: %d \%\r", (int)((float)(((float)streaming_ctrl->buffer->length)/((float)streaming_ctrl->prebuffer_size))*100) );
- fflush(stdout);
- }
- }
- }
- } else {
- printf("Network fd not set\n");
- }
- } while( streaming_ctrl->status==streaming_playing_e );
-
- // Flush the buffer
- while( streaming_ctrl->buffer->length>0 ) {
- ret = streaming_ctrl->streaming_read( streaming_ctrl );
- if( ret<0 ) break;
- }
-
-printf("Network thread done\n");
-
- // Close to the pipe to stop mplayer.
- close( streaming_ctrl->fd_pipe_in );
-
-}
-
int
-streaming_start(URL_t **url, int fd, int streaming_type) {
- int fd_pipe[2];
- // Open the pipe
- if( pipe(fd_pipe)<0 ) {
- printf("Pipe creation failed\n");
- return -1;
- }
-
- streaming_ctrl = streaming_ctrl_new( );
- if( streaming_ctrl==NULL ) {
+streaming_start(stream_t *stream, URL_t *url, int demuxer_type) {
+ int ret=-1;
+ if( stream==NULL ) return -1;
+
+ stream->streaming_ctrl = streaming_ctrl_new( );
+ if( stream->streaming_ctrl==NULL ) {
return -1;
}
- streaming_ctrl->url = url;
- streaming_ctrl->fd_pipe_in = fd_pipe[1];
- streaming_ctrl->fd_net = fd;
-
-#ifdef DUMP2FILE
-{
- int fd_file;
- fd_file = open("dump.stream", O_WRONLY | O_CREAT );
- if( fd_file<0 ) {
- perror("open");
- }
- streaming_ctrl->fd_pipe_in = fd_file;
-}
-#endif
+
+ stream->streaming_ctrl->url = url_copy(url);
+// stream->streaming_ctrl->demuxer_type = demuxer_type;
+ stream->fd = -1;
- switch( streaming_type ) {
+ switch( demuxer_type ) {
case DEMUXER_TYPE_ASF:
// Send the appropriate HTTP request
- fd = asf_http_streaming_start( streaming_ctrl );
+ // Need to filter the network stream.
+ // ASF raw stream is encapsulated.
+ ret = asf_streaming_start( stream );
break;
case DEMUXER_TYPE_AVI:
+ case DEMUXER_TYPE_MOV:
case DEMUXER_TYPE_MPEG_ES:
case DEMUXER_TYPE_MPEG_PS:
- fd = nop_streaming_start( streaming_ctrl );
+ // Generic start, doesn't need to filter
+ // the network stream, it's a raw stream
+ ret = nop_streaming_start( stream );
break;
case DEMUXER_TYPE_UNKNOWN:
default:
printf("Unable to detect the streaming type\n");
- close( fd );
- free( streaming_ctrl );
- return -1;
+ ret = -1;
}
- if( fd<0 ) {
- free( streaming_ctrl );
- return -1;
- }
-
- // Start the network thread
- if( pthread_create( &(streaming_ctrl->thread_id), NULL , (void*)network_streaming, (void*)NULL)<0 ) {
- printf("Unable to start the network thread.\n");
- close( fd );
- free( streaming_ctrl );
- return -1;
+ if( ret<0 ) {
+ free( stream->streaming_ctrl );
+ } else {
+// bufferize( stream );
}
-printf("Network thread created with id: %d\n", streaming_ctrl->thread_id );
-
-// streaming_ctrl->status = streaming_stopped_e;
-// return fd;
- return fd_pipe[0];
+ return ret;
}
int
-streaming_stop( ) {
- streaming_ctrl->status = streaming_stopped_e;
+streaming_stop( stream_t *stream ) {
+ stream->streaming_ctrl->status = streaming_stopped_e;
return 0;
}
Index: network.h
===================================================================
RCS file: /cvsroot/mplayer/main/libmpdemux/network.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- network.h 4 Jun 2001 17:52:33 -0000 1.3
+++ network.h 20 Nov 2001 22:20:20 -0000 1.4
@@ -7,10 +7,6 @@
#ifndef __NETWORK_H
#define __NETWORK_H
-#include <pthread.h>
-
-#include "stream.h"
-
#include "url.h"
#define BUFFER_SIZE 2048
@@ -20,30 +16,21 @@
streaming_playing_e
} streaming_status;
-typedef struct {
- char *buffer;
- int length;
-} Net_Fifo;
-
typedef struct streaming_control {
- URL_t **url;
- int fd_net;
- int fd_pipe_in;
+ URL_t *url;
streaming_status status;
- pthread_t thread_id;
- Net_Fifo *buffer;
int buffering; // boolean
- int prebuffer_size;
- int (*streaming_read)( struct streaming_control *stream_ctrl );
+ unsigned int prebuffer_size;
+ char *buffer;
+ unsigned int buffer_size;
+ unsigned int buffer_pos;
+ int (*streaming_read)( int fd, char *buffer, int buffer_size, struct streaming_control *stream_ctrl );
+ int (*streaming_seek)( int fd, off_t pos, struct streaming_control *stream_ctrl );
} streaming_ctrl_t;
-Net_Fifo* net_fifo_new( );
-void net_fifo_free(Net_Fifo *net_fifo );
-int net_fifo_pop(Net_Fifo *net_fifo, char *buffer, int length );
-int net_fifo_push(Net_Fifo *net_fifo, char *buffer, int length );
+int streaming_bufferize( streaming_ctrl_t *streaming_ctrl, char *buffer, int size);
-int connect2Server(char *host, int port);
-int readFromServer(int fd, char *buffer, int length );
-int autodetectProtocol( URL_t *url, int *fd_out );
+int nop_streaming_read( int fd, char *buffer, int size, streaming_ctrl_t *stream_ctrl );
+int nop_streaming_seek( int fd, off_t pos, streaming_ctrl_t *stream_ctrl );
#endif
More information about the MPlayer-cvslog
mailing list