Removed my buffer hack to use cache2.

Removed the network thread.
Changed the network layer to use cache2.


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@3043 b3059339-0415-0410-9bf9-f77b7e298cf2

3 files changed, 227 insertions, 404 deletions

diff --git a/libmpdemux/asf_streaming.c b/libmpdemux/asf_streaming.c
index 1438feb32d..5a4e430edc 100644
--- a/libmpdemux/asf_streaming.c
+++ b/libmpdemux/asf_streaming.c
@@ -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;
-	}
+int
+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 );
-
-	write( streaming_ctrl->fd_pipe_in, buffer, length );
+	ret = nop_streaming_read( fd, buffer, size, streaming_ctrl );
+//printf("Read %d bytes\n", ret);
 
-	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("0x%02X\n", stream_chunck->type );
 		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 @@ printf("0x%02X\n", stream_chunck->type );
 }
 
 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 @@ asf_http_request(URL_t *url) {
 			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 @@ asf_http_parse_response( HTTP_header_t *http_hdr ) {
 	}
 
 	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 @@ asf_http_parse_response( HTTP_header_t *http_hdr ) {
 	}
 
 	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 @@ asf_http_ASX_redirect( HTTP_header_t *http_hdr ) {
 }
 
 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 @@ streaming_type = ASF_Live_e;
 		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 @@ printf("read: %d\n", i );
 			}
 			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 @@ printf("read: %d\n", i );
 			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 @@ printf("read: %d\n", i );
 					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 @@ printf("read: %d\n", i );
 		// 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;
diff --git a/libmpdemux/network.c b/libmpdemux/network.c
index 523943b80f..bf9bfe6d72 100644
--- a/libmpdemux/network.c
+++ b/libmpdemux/network.c
@@ -34,75 +34,42 @@
 #include "url.h"
 #include "asf.h"
 
-streaming_ctrl_t *streaming_ctrl;
-
-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 *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 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 @@ streaming_ctrl_new( ) {
 		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 @@ connect2Server(char *host, int port) {
 	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 @@ connect2Server(char *host, int port) {
 	}
 	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 @@ connect2Server(char *host, int port) {
 			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 @@ http_read_response( int fd ) {
 	}
 
 	do {
-		i = readFromServer( fd, response, BUFFER_SIZE ); 
+		i = read( fd, response, BUFFER_SIZE ); 
 		if( i<0 ) {
 			printf("Read failed\n");
 		}
@@ -294,23 +222,15 @@ autodetectProtocol(URL_t *url, int *fd_out) {
 				}
 			}
 		}
-//	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 @@ autodetectProtocol(URL_t *url, int *fd_out) {
 			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 @@ autodetectProtocol(URL_t *url, int *fd_out) {
 					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 @@ autodetectProtocol(URL_t *url, int *fd_out) {
 					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 @@ nop_streaming_start( streaming_ctrl_t *streaming_ctrl ) {
 				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 @@ nop_streaming_start( streaming_ctrl_t *streaming_ctrl ) {
 				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;
-	}
-
-	if( fd<0 ) {
-		free( streaming_ctrl );
-		return -1;
+			ret = -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;
 }
diff --git a/libmpdemux/network.h b/libmpdemux/network.h
index 4ef14500e7..2f43c7da5b 100644
--- a/libmpdemux/network.h
+++ b/libmpdemux/network.h
@@ -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 @@ typedef enum {
 	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