mirror of
https://github.com/mpv-player/mpv.git
synced 2024-09-20 12:02:23 +02:00
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
This commit is contained in:
bertrand
parent
e70d05ec5a
commit
55d2e87d8f
@ -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("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:
|
||||
@ -112,6 +91,11 @@ printf("0x%02X\n", stream_chunck->type );
|
||||
return stream_chunck->size+4;
|
||||
}
|
||||
|
||||
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;
|
||||
@ -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;
|
||||
|
||||
@ -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 @@ 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");
|
||||
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;
|
||||
}
|
||||
|
||||
stream->streaming_ctrl->url = url_copy(url);
|
||||
// stream->streaming_ctrl->demuxer_type = demuxer_type;
|
||||
stream->fd = -1;
|
||||
|
||||
streaming_ctrl = streaming_ctrl_new( );
|
||||
if( 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
|
||||
|
||||
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;
|
||||
if( ret<0 ) {
|
||||
free( stream->streaming_ctrl );
|
||||
} else {
|
||||
// bufferize( stream );
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user