Mercurial > audlegacy-plugins
diff src/wma/libffwma/mms.c @ 12:3da1b8942b8b trunk
[svn] - remove src/Input src/Output src/Effect src/General src/Visualization src/Container
| author | nenolod |
|---|---|
| date | Mon, 18 Sep 2006 03:14:20 -0700 |
| parents | src/Input/wma/libffwma/mms.c@13389e613d67 |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/wma/libffwma/mms.c Mon Sep 18 03:14:20 2006 -0700 @@ -0,0 +1,1496 @@ +/* + * Copyright (C) 2002-2004 the xine project + * + * This file is part of LibMMS, an MMS protocol handling library. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the ree Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * + * $Id: mms.c,v 1.21 2006/07/13 12:32:20 shawarma Exp $ + * + * MMS over TCP protocol + * based on work from major mms + * utility functions to handle communication with an mms server + * + * TODO: + * error messages + * enable seeking ! + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <unistd.h> +#include <stdio.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <stdlib.h> +#include <time.h> + +/********** logging **********/ +#define LOG_MODULE "mms" +#define LOG_VERBOSE +#ifdef DEBUG +# define lprintf printf +#else +# define lprintf(x...) +#endif + + +#include "bswap.h" +#include "mms.h" +#include "asfheader.h" +#include "uri.h" + + +/* + * mms specific types + */ + +#define MMST_PORT 1755 + +#define BUF_SIZE 102400 + +#define CMD_HEADER_LEN 40 +#define CMD_PREFIX_LEN 8 +#define CMD_BODY_LEN 1024 + +#define ASF_HEADER_LEN 8192 + + +#define MMS_PACKET_ERR 0 +#define MMS_PACKET_COMMAND 1 +#define MMS_PACKET_ASF_HEADER 2 +#define MMS_PACKET_ASF_PACKET 3 + +#define ASF_HEADER_PACKET_ID_TYPE 2 +#define ASF_MEDIA_PACKET_ID_TYPE 4 + + +typedef struct mms_buffer_s mms_buffer_t; +struct mms_buffer_s { + uint8_t *buffer; + int pos; +}; + +typedef struct mms_packet_header_s mms_packet_header_t; +struct mms_packet_header_s { + uint32_t packet_len; + uint8_t flags; + uint8_t packet_id_type; + uint32_t packet_seq; +}; + + +struct mms_s { + + /* FIXME: de-xine-ification */ + void *custom_data; + + int s; + + /* url parsing */ + char *url; + char *proto; + char *host; + int port; + char *user; + char *password; + char *uri; + + /* command to send */ + char scmd[CMD_HEADER_LEN + CMD_BODY_LEN]; + char *scmd_body; /* pointer to &scmd[CMD_HEADER_LEN] */ + int scmd_len; /* num bytes written in header */ + + char str[1024]; /* scratch buffer to built strings */ + + /* receive buffer */ + uint8_t buf[BUF_SIZE]; + int buf_size; + int buf_read; + + uint8_t asf_header[ASF_HEADER_LEN]; + uint32_t asf_header_len; + uint32_t asf_header_read; + int seq_num; + int num_stream_ids; + int stream_ids[ASF_MAX_NUM_STREAMS]; + int stream_types[ASF_MAX_NUM_STREAMS]; + off_t start_packet_seq; /* for live streams != 0, need to keep it around */ + int need_discont; /* whether we need to set start_packet_seq */ + uint32_t asf_packet_len; + uint64_t file_len; + char guid[37]; + uint32_t bitrates[ASF_MAX_NUM_STREAMS]; + uint32_t bitrates_pos[ASF_MAX_NUM_STREAMS]; + int bandwidth; + + int has_audio; + int has_video; + int live_flag; + off_t current_pos; + int eos; +}; + +static int fallback_io_select(void *data, int socket, int state, int timeout_msec) +{ + fd_set set; + struct timeval tv = { timeout_msec / 1000, (timeout_msec % 1000) * 1000}; + FD_ZERO(&set); + FD_SET(socket, &set); + return select(1, (state == MMS_IO_READ_READY) ? &set : NULL, + (state == MMS_IO_WRITE_READY) ? &set : NULL, NULL, &tv); +} + +static off_t fallback_io_read(void *data, int socket, char *buf, off_t num) +{ + off_t len = 0, ret; +/* lprintf("%d\n", fallback_io_select(data, socket, MMS_IO_READ_READY, 1000)); */ + errno = 0; + while (len < num) + { + ret = (off_t)read(socket, buf + len, num - len); + if(ret == 0) + break; /* EOF */ + if(ret < 0) + switch(errno) + { + case EAGAIN: + lprintf("len == %lld\n", (long long int) len); + break; + default: + lprintf("len == %lld\n", (long long int) len); + perror(NULL); + /* if already read something, return it, we will fail next time */ + return len ? len : ret; + } + len += ret; + } + lprintf("ret len == %lld\nnum == %lld\n", (long long int) len, (long long int) num); + return len; +} + +static off_t fallback_io_write(void *data, int socket, char *buf, off_t num) +{ + return (off_t)write(socket, buf, num); +} + +static int fallback_io_tcp_connect(void *data, const char *host, int port) +{ + + struct hostent *h; + int i, s; + + h = gethostbyname(host); + if (h == NULL) { +/* fprintf(stderr, "unable to resolve host: %s\n", host); */ + return -1; + } + + s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + if (s == -1) { +/* fprintf(stderr, "failed to create socket: %s", strerror(errno)); */ + return -1; + } + + if (fcntl (s, F_SETFL, fcntl (s, F_GETFL) & ~O_NONBLOCK) == -1) { +/* _x_message(stream, XINE_MSG_CONNECTION_REFUSED, "can't put socket in non-blocking mode", strerror(errno), NULL); */ + return -1; + } + + for (i = 0; h->h_addr_list[i]; i++) { + struct in_addr ia; + struct sockaddr_in sin; + + memcpy (&ia, h->h_addr_list[i], 4); + sin.sin_family = AF_INET; + sin.sin_addr = ia; + sin.sin_port = htons(port); + + if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) ==-1 && errno != EINPROGRESS) { + + /* FIXME: de-xine-ification */ +/* _x_message(stream, XINE_MSG_CONNECTION_REFUSED, strerror(errno), NULL); */ + close(s); + continue; + } + + return s; + } + return -1; +} + + +static mms_io_t fallback_io = + { + &fallback_io_select, + NULL, + &fallback_io_read, + NULL, + &fallback_io_write, + NULL, + &fallback_io_tcp_connect, + NULL, + }; + +static mms_io_t default_io = { + &fallback_io_select, + NULL, + &fallback_io_read, + NULL, + &fallback_io_write, + NULL, + &fallback_io_tcp_connect, + NULL, + }; + + +#define io_read(io, args...) ((io) ? (io)->read(io->read_data , ## args) : default_io.read(NULL , ## args)) +#define io_write(io, args...) ((io) ? (io)->write(io->write_data , ## args) : default_io.write(NULL , ## args)) +#define io_select(io, args...) ((io) ? (io)->select(io->select_data , ## args) : default_io.select(NULL , ## args)) +#define io_connect(io, args...) ((io) ? (io)->connect(io->connect_data , ## args) : default_io.connect(NULL , ## args)) + +const mms_io_t* mms_get_default_io_impl() +{ + return &default_io; +} + +void mms_set_default_io_impl(const mms_io_t *io) +{ + if(io->select) + { + default_io.select = io->select; + default_io.select_data = io->select_data; + } else + { + default_io.select = fallback_io.select; + default_io.select_data = fallback_io.select_data; + } + if(io->read) + { + default_io.read = io->read; + default_io.read_data = io->read_data; + } else + { + default_io.read = fallback_io.read; + default_io.read_data = fallback_io.read_data; + } + if(io->write) + { + default_io.write = io->write; + default_io.write_data = io->write_data; + } else + { + default_io.write = fallback_io.write; + default_io.write_data = fallback_io.write_data; + } + if(io->connect) + { + default_io.connect = io->connect; + default_io.connect_data = io->connect_data; + } else + { + default_io.connect = fallback_io.connect; + default_io.connect_data = fallback_io.connect_data; + } +} + +static void mms_buffer_init (mms_buffer_t *mms_buffer, uint8_t *buffer) { + mms_buffer->buffer = buffer; + mms_buffer->pos = 0; +} + +static void mms_buffer_put_8 (mms_buffer_t *mms_buffer, uint8_t value) { + + mms_buffer->buffer[mms_buffer->pos] = value & 0xff; + + mms_buffer->pos += 1; +} + +#if 0 +static void mms_buffer_put_16 (mms_buffer_t *mms_buffer, uint16_t value) { + + mms_buffer->buffer[mms_buffer->pos] = value & 0xff; + mms_buffer->buffer[mms_buffer->pos + 1] = (value >> 8) & 0xff; + + mms_buffer->pos += 2; +} +#endif + +static void mms_buffer_put_32 (mms_buffer_t *mms_buffer, uint32_t value) { + + mms_buffer->buffer[mms_buffer->pos] = value & 0xff; + mms_buffer->buffer[mms_buffer->pos + 1] = (value >> 8) & 0xff; + mms_buffer->buffer[mms_buffer->pos + 2] = (value >> 16) & 0xff; + mms_buffer->buffer[mms_buffer->pos + 3] = (value >> 24) & 0xff; + + mms_buffer->pos += 4; +} + +static int get_guid (unsigned char *buffer, int offset) { + int i; + GUID g; + + g.Data1 = LE_32(buffer + offset); + g.Data2 = LE_16(buffer + offset + 4); + g.Data3 = LE_16(buffer + offset + 6); + for(i = 0; i < 8; i++) { + g.Data4[i] = buffer[offset + 8 + i]; + } + + for (i = 1; i < GUID_END; i++) { + if (!memcmp(&g, &guids[i].guid, sizeof(GUID))) { + lprintf("GUID: %s\n", guids[i].name); + return i; + } + } + + lprintf("unknown GUID: 0x%x, 0x%x, 0x%x, " + "{ 0x%hx, 0x%hx, 0x%hx, 0x%hx, 0x%hx, 0x%hx, 0x%hx, 0x%hx }\n", + g.Data1, g.Data2, g.Data3, + g.Data4[0], g.Data4[1], g.Data4[2], g.Data4[3], + g.Data4[4], g.Data4[5], g.Data4[6], g.Data4[7]); + + return GUID_ERROR; +} + + +static void print_command (char *data, int len) { + +#ifdef DEBUG + int i; + int dir = LE_32 (data + 36) >> 16; + int comm = LE_32 (data + 36) & 0xFFFF; + + lprintf ("----------------------------------------------\n"); + if (dir == 3) { + lprintf ("send command 0x%02x, %d bytes\n", comm, len); + } else { + lprintf ("receive command 0x%02x, %d bytes\n", comm, len); + } + lprintf (" start sequence %08x\n", LE_32 (data + 0)); + lprintf (" command id %08x\n", LE_32 (data + 4)); + lprintf (" length %8x \n", LE_32 (data + 8)); + lprintf (" protocol %08x\n", LE_32 (data + 12)); + lprintf (" len8 %8x \n", LE_32 (data + 16)); + lprintf (" sequence # %08x\n", LE_32 (data + 20)); + lprintf (" len8 (II) %8x \n", LE_32 (data + 32)); + lprintf (" dir | comm %08x\n", LE_32 (data + 36)); + if (len >= 4) + lprintf (" prefix1 %08x\n", LE_32 (data + 40)); + if (len >= 8) + lprintf (" prefix2 %08x\n", LE_32 (data + 44)); + + for (i = (CMD_HEADER_LEN + CMD_PREFIX_LEN); i < (CMD_HEADER_LEN + CMD_PREFIX_LEN + len); i += 1) { + unsigned char c = data[i]; + + if ((c >= 32) && (c < 128)) + lprintf ("%c", c); + else + lprintf (" %02x ", c); + + } + if (len > CMD_HEADER_LEN) + lprintf ("\n"); + lprintf ("----------------------------------------------\n"); +#endif +} + + + +static int send_command (mms_io_t *io, mms_t *this, int command, + uint32_t prefix1, uint32_t prefix2, + int length) { + int len8; + off_t n; + mms_buffer_t command_buffer; + + len8 = (length + 7) / 8; + + this->scmd_len = 0; + + mms_buffer_init(&command_buffer, this->scmd); + mms_buffer_put_32 (&command_buffer, 0x00000001); /* start sequence */ + mms_buffer_put_32 (&command_buffer, 0xB00BFACE); /* #-)) */ + mms_buffer_put_32 (&command_buffer, len8 * 8 + 32); + mms_buffer_put_32 (&command_buffer, 0x20534d4d); /* protocol type "MMS " */ + mms_buffer_put_32 (&command_buffer, len8 + 4); + mms_buffer_put_32 (&command_buffer, this->seq_num); + this->seq_num++; + mms_buffer_put_32 (&command_buffer, 0x0); /* timestamp */ + mms_buffer_put_32 (&command_buffer, 0x0); + mms_buffer_put_32 (&command_buffer, len8 + 2); + mms_buffer_put_32 (&command_buffer, 0x00030000 | command); /* dir | command */ + /* end of the 40 byte command header */ + + mms_buffer_put_32 (&command_buffer, prefix1); + mms_buffer_put_32 (&command_buffer, prefix2); + + if (length & 7) + memset(this->scmd + length + CMD_HEADER_LEN + CMD_PREFIX_LEN, 0, 8 - (length & 7)); + + n = io_write(io, this->s, this->scmd, len8 * 8 + CMD_HEADER_LEN + CMD_PREFIX_LEN); + if (n != (len8 * 8 + CMD_HEADER_LEN + CMD_PREFIX_LEN)) { + return 0; + } + + print_command (this->scmd, length); + + return 1; +} + +static void string_utf16(int unused, char *dest, char *src, int len) { + int i; + + memset (dest, 0, 2 * len); + + for (i = 0; i < len; i++) { + dest[i * 2] = src[i]; + dest[i * 2 + 1] = 0; + } + + dest[i * 2] = 0; + dest[i * 2 + 1] = 0; +} + +/* + * return packet type + */ +static int get_packet_header (mms_io_t *io, mms_t *this, mms_packet_header_t *header) { + size_t len; + int packet_type; + + header->packet_len = 0; + header->packet_seq = 0; + header->flags = 0; + header->packet_id_type = 0; + len = io_read(io, this->s, this->buf, 8); + if (len != 8) + goto error; + + if (LE_32(this->buf + 4) == 0xb00bface) { + /* command packet */ + header->flags = this->buf[3]; + len = io_read(io, this->s, this->buf + 8, 4); + if (len != 4) + goto error; + + header->packet_len = LE_32(this->buf + 8) + 4; + if (header->packet_len > BUF_SIZE - 12) { + header->packet_len = 0; + goto error; + } + lprintf("mms command\n"); + packet_type = MMS_PACKET_COMMAND; + } else { + header->packet_seq = LE_32(this->buf); + header->packet_id_type = this->buf[4]; + header->flags = this->buf[5]; + header->packet_len = (LE_16(this->buf + 6) - 8) & 0xffff; + if (header->packet_id_type == ASF_HEADER_PACKET_ID_TYPE) { + lprintf("asf header\n"); + packet_type = MMS_PACKET_ASF_HEADER; + } else { + lprintf("asf packet\n"); + packet_type = MMS_PACKET_ASF_PACKET; + } + } + + return packet_type; + +error: + lprintf("read error, len=%d\n", len); + perror("Could not read packet header"); + return MMS_PACKET_ERR; +} + + +static int get_packet_command (mms_io_t *io, mms_t *this, uint32_t packet_len) { + + + int command = 0; + size_t len; + + /* always enter this loop */ + lprintf("packet_len: %d bytes\n", packet_len); + + len = io_read(io, this->s, this->buf + 12, packet_len) ; + if (len != packet_len) { + return 0; + } + + print_command (this->buf, len); + + /* check protocol type ("MMS ") */ + if (LE_32(this->buf + 12) != 0x20534D4D) { + lprintf("unknown protocol type: %c%c%c%c (0x%08X)\n", + this->buf[12], this->buf[13], this->buf[14], this->buf[15], + LE_32(this->buf + 12)); + return 0; + } + + command = LE_32 (this->buf + 36) & 0xFFFF; + lprintf("command = 0x%2x\n", command); + + return command; +} + +static int get_answer (mms_io_t *io, mms_t *this) { + int command = 0; + mms_packet_header_t header; + + switch (get_packet_header (io, this, &header)) { + case MMS_PACKET_ERR: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to read mms packet header\n"); + break; + case MMS_PACKET_COMMAND: + command = get_packet_command (io, this, header.packet_len); + + if (command == 0x1b) { + + if (!send_command (io, this, 0x1b, 0, 0, 0)) { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to send command\n"); + return 0; + } + /* FIXME: limit recursion */ + command = get_answer (io, this); + } + break; + case MMS_PACKET_ASF_HEADER: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: unexpected asf header packet\n"); + break; + case MMS_PACKET_ASF_PACKET: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " +"libmms: unexpected asf packet\n"); + break; + } + + return command; +} + + +static int get_asf_header (mms_io_t *io, mms_t *this) { + + off_t len; + int stop = 0; + + this->asf_header_read = 0; + this->asf_header_len = 0; + + while (!stop) { + mms_packet_header_t header; + int command; + + switch (get_packet_header (io, this, &header)) { + case MMS_PACKET_ERR: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to read mms packet header\n"); + return 0; + break; + case MMS_PACKET_COMMAND: + command = get_packet_command (io, this, header.packet_len); + + if (command == 0x1b) { + + if (!send_command (io, this, 0x1b, 0, 0, 0)) { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to send command\n"); + return 0; + } + command = get_answer (io, this); + } else { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: unexpected command packet\n"); + } + break; + case MMS_PACKET_ASF_HEADER: + case MMS_PACKET_ASF_PACKET: + if (header.packet_len + this->asf_header_len > ASF_HEADER_LEN) { + lprintf( "***LOG:*** -- " + "libmms: asf packet too large\n"); + return 0; + } + len = io_read(io, this->s, + this->asf_header + this->asf_header_len, header.packet_len); + if (len != header.packet_len) { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: get_asf_header failed\n"); + return 0; + } + this->asf_header_len += header.packet_len; + lprintf("header flags: %d\n", header.flags); + if ((header.flags == 0X08) || (header.flags == 0X0C)) + stop = 1; + break; + } + } + lprintf ("get header packet succ\n"); + return 1; +} + +static void interp_asf_header (mms_t *this) { + + int i; + + this->asf_packet_len = 0; + this->num_stream_ids = 0; + /* + * parse header + */ + + i = 30; + while (i < this->asf_header_len) { + + int guid; + uint64_t length; + + guid = get_guid(this->asf_header, i); + i += 16; + + length = LE_64(this->asf_header + i); + i += 8; + + switch (guid) { + + case GUID_ASF_FILE_PROPERTIES: + + this->asf_packet_len = LE_32(this->asf_header + i + 92 - 24); + if (this->asf_packet_len > BUF_SIZE) { + this->asf_packet_len = 0; + lprintf( "***LOG:*** -- " + "libmms: asf packet len too large\n"); + break; + } + this->file_len = LE_64(this->asf_header + i + 40 - 24); + lprintf ("file object, packet length = %d (%d)\n", + this->asf_packet_len, LE_32(this->asf_header + i + 96 - 24)); + break; + + case GUID_ASF_STREAM_PROPERTIES: + { + uint16_t flags; + uint16_t stream_id; + int type; + int encrypted; + + guid = get_guid(this->asf_header, i); + switch (guid) { + case GUID_ASF_AUDIO_MEDIA: + type = ASF_STREAM_TYPE_AUDIO; + this->has_audio = 1; + break; + + case GUID_ASF_VIDEO_MEDIA: + case GUID_ASF_JFIF_MEDIA: + case GUID_ASF_DEGRADABLE_JPEG_MEDIA: + type = ASF_STREAM_TYPE_VIDEO; + this->has_video = 1; + break; + + case GUID_ASF_COMMAND_MEDIA: + type = ASF_STREAM_TYPE_CONTROL; + break; + + default: + type = ASF_STREAM_TYPE_UNKNOWN; + } + + flags = LE_16(this->asf_header + i + 48); + stream_id = flags & 0x7F; + encrypted = flags >> 15; + + lprintf ("stream object, stream id: %d, type: %d, encrypted: %d\n", + stream_id, type, encrypted); + + if (this->num_stream_ids < ASF_MAX_NUM_STREAMS && stream_id < ASF_MAX_NUM_STREAMS) { + this->stream_types[stream_id] = type; + this->stream_ids[this->num_stream_ids] = stream_id; + this->num_stream_ids++; + } else { + lprintf ("too many streams, skipping\n"); + } + } + break; + + case GUID_ASF_STREAM_BITRATE_PROPERTIES: + { + uint16_t streams = LE_16(this->asf_header + i); + uint16_t stream_id; + int j; + + lprintf ("stream bitrate properties\n"); + lprintf ("streams %d\n", streams); + + for(j = 0; j < streams; j++) { + stream_id = LE_16(this->asf_header + i + 2 + j * 6); + lprintf ("stream id %d\n", stream_id); + this->bitrates[stream_id] = LE_32(this->asf_header + i + 4 + j * 6); + this->bitrates_pos[stream_id] = i + 4 + j * 6; + lprintf ("stream id %d, bitrate %d\n", stream_id, + this->bitrates[stream_id]); + } + } + break; + + default: + lprintf ("unknown object\n"); + break; + } + + lprintf ("length : %lld\n", length); + + if (length > 24) { + i += length - 24; + } + } +} + +const static char *const mmst_proto_s[] = { "mms", "mmst", NULL }; + +static int mmst_valid_proto (char *proto) { + int i = 0; + + lprintf("mmst_valid_proto\n"); + + if (!proto) + return 0; + + while(mmst_proto_s[i]) { + if (!strcasecmp(proto, mmst_proto_s[i])) { + return 1; + } + i++; + } + return 0; +} + +/* FIXME: de-xine-ification */ + +/* static void report_progress (void *data, int p) { + + xine_event_t event; + xine_progress_data_t prg; + + prg.description = _("Connecting MMS server (over tcp)..."); + prg.percent = p; + + event.type = XINE_EVENT_PROGRESS; + event.data = &prg; + event.data_length = sizeof (xine_progress_data_t); + + xine_event_send (stream, &event); +} */ + + +/* + * returns 1 on error + */ +static int mms_tcp_connect(mms_io_t *io, mms_t *this) { + int progress, res; + + if (!this->port) this->port = MMST_PORT; + + /* + * try to connect + */ + lprintf("try to connect to %s on port %d \n", this->host, this->port); + this->s = io_connect(io, this->host, this->port); + if (this->s == -1) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "failed to connect '%s'\n", this->host); + return 1; + } + + /* connection timeout 15s */ + progress = 0; + do { + /*FIXME: de-xine-ification */ +/* report_progress(this->stream, progress); */ + res = io_select(io, this->s, MMS_IO_WRITE_READY, 500); + progress += 1; + } while ((res == MMS_IO_STATUS_TIMEOUT) && (progress < 30)); + if (res != MMS_IO_STATUS_READY) { + return 1; + } + lprintf ("connected\n"); + return 0; +} + +static void mms_gen_guid(char guid[]) { + static char digit[16] = "0123456789ABCDEF"; + int i = 0; + + srand(time(NULL)); + for (i = 0; i < 36; i++) { + guid[i] = digit[(int) ((16.0*rand())/(RAND_MAX+1.0))]; + } + guid[8] = '-'; guid[13] = '-'; guid[18] = '-'; guid[23] = '-'; + guid[36] = '\0'; +} + +/* + * return 0 on error + */ +int static mms_choose_best_streams(mms_io_t *io, mms_t *this) { + int i; + int video_stream = 0; + int audio_stream = 0; + int max_arate = 0; + int min_vrate = 0; + int min_bw_left = 0; + int stream_id; + int bandwitdh_left; + int res; + + /* command 0x33 */ + /* choose the best quality for the audio stream */ + /* i've never seen more than one audio stream */ + lprintf("num_stream_ids=%d\n", this->num_stream_ids); + for (i = 0; i < this->num_stream_ids; i++) { + stream_id = this->stream_ids[i]; + switch (this->stream_types[stream_id]) { + case ASF_STREAM_TYPE_AUDIO: + if (this->bitrates[stream_id] > max_arate) { + audio_stream = stream_id; + max_arate = this->bitrates[stream_id]; + } + break; + default: + break; + } + } + + /* choose a video stream adapted to the user bandwidth */ + bandwitdh_left = this->bandwidth - max_arate; + if (bandwitdh_left < 0) { + bandwitdh_left = 0; + } + lprintf("bandwitdh %d, left %d\n", this->bandwidth, bandwitdh_left); + + min_bw_left = bandwitdh_left; + for (i = 0; i < this->num_stream_ids; i++) { + stream_id = this->stream_ids[i]; + switch (this->stream_types[stream_id]) { + case ASF_STREAM_TYPE_VIDEO: + if (((bandwitdh_left - this->bitrates[stream_id]) < min_bw_left) && + (bandwitdh_left >= this->bitrates[stream_id])) { + video_stream = stream_id; + min_bw_left = bandwitdh_left - this->bitrates[stream_id]; + } + break; + default: + break; + } + } + + /* choose the lower bitrate of */ + if (!video_stream && this->has_video) { + for (i = 0; i < this->num_stream_ids; i++) { + stream_id = this->stream_ids[i]; + switch (this->stream_types[stream_id]) { + case ASF_STREAM_TYPE_VIDEO: + if ((this->bitrates[stream_id] < min_vrate) || + (!min_vrate)) { + video_stream = stream_id; + min_vrate = this->bitrates[stream_id]; + } + break; + default: + break; + } + } + } + + lprintf("selected streams: audio %d, video %d\n", audio_stream, video_stream); + lprintf("disabling other streams\n"); + memset (this->scmd_body, 0, 40); + for (i = 1; i < this->num_stream_ids; i++) { + this->scmd_body [ (i - 1) * 6 + 2 ] = 0xFF; + this->scmd_body [ (i - 1) * 6 + 3 ] = 0xFF; + this->scmd_body [ (i - 1) * 6 + 4 ] = this->stream_ids[i] ; + this->scmd_body [ (i - 1) * 6 + 5 ] = this->stream_ids[i] >> 8; + if ((this->stream_ids[i] == audio_stream) || + (this->stream_ids[i] == video_stream)) { + this->scmd_body [ (i - 1) * 6 + 6 ] = 0x00; + this->scmd_body [ (i - 1) * 6 + 7 ] = 0x00; + } else { + lprintf("disabling stream %d\n", this->stream_ids[i]); + this->scmd_body [ (i - 1) * 6 + 6 ] = 0x02; + this->scmd_body [ (i - 1) * 6 + 7 ] = 0x00; + + /* forces the asf demuxer to not choose this stream */ + if (this->bitrates_pos[this->stream_ids[i]]) { + this->asf_header[this->bitrates_pos[this->stream_ids[i]]] = 0; + this->asf_header[this->bitrates_pos[this->stream_ids[i]] + 1] = 0; + this->asf_header[this->bitrates_pos[this->stream_ids[i]] + 2] = 0; + this->asf_header[this->bitrates_pos[this->stream_ids[i]] + 3] = 0; + } + } + } + + if (!send_command (io, this, 0x33, this->num_stream_ids, + 0xFFFF | this->stream_ids[0] << 16, + this->num_stream_ids * 6 + 2)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: mms_choose_best_streams failed\n"); + return 0; + } + + if ((res = get_answer (io, this)) != 0x21) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: unexpected response: %02x (0x21)\n", res); + } + + return 1; +} + +/* + * TODO: error messages + * network timing request + */ +/* FIXME: got somewhat broken during xine_stream_t->(void*) conversion */ +mms_t *mms_connect (mms_io_t *io, void *data, const char *url, int bandwidth) { + int url_conv = 0; + mms_t *this; + int res; + GURI *uri; + + if (!url) + return NULL; + + /* FIXME: needs proper error-signalling work */ + this = (mms_t*) malloc (sizeof (mms_t)); + + this->custom_data = data; + this->url = strdup (url); + this->s = -1; + this->seq_num = 0; + this->scmd_body = this->scmd + CMD_HEADER_LEN + CMD_PREFIX_LEN; + this->asf_header_len = 0; + this->asf_header_read = 0; + this->num_stream_ids = 0; + this->asf_packet_len = 0; + this->start_packet_seq= 0; + this->need_discont = 1; + this->buf_size = 0; + this->buf_read = 0; + this->has_audio = 0; + this->has_video = 0; + this->bandwidth = bandwidth; + this->current_pos = 0; + this->eos = 0; + + /* FIXME de-xine-ification */ +/* report_progress (stream, 0); */ + + uri = gnet_uri_new(this->url); + if(!uri) { + lprintf ("invalid url\n"); + goto fail; + } + this->proto = uri->scheme; + this->user = uri->user; + this->host = uri->hostname; + this->port = uri->port; + this->password = uri->passwd; + this->uri = uri->path; + + if (!mmst_valid_proto(this->proto)) { + lprintf ("unsupported protocol\n"); + goto fail; + } + + if (mms_tcp_connect(io, this)) { + goto fail; + } + /* FIXME de-xine-ification */ +/* report_progress (stream, 30); */ + + /* + * let the negotiations begin... + */ + + /* command 0x1 */ + lprintf("send command 0x01\n"); + mms_gen_guid(this->guid); + sprintf (this->str, "\x1c\x03NSPlayer/7.0.0.1956; {%s}; Host: %s", + this->guid, this->host); + string_utf16 (url_conv, this->scmd_body, this->str, strlen(this->str) + 2); + + if (!send_command (io, this, 1, 0, 0x0004000b, strlen(this->str) * 2 + 8)) { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to send command 0x01\n"); + goto fail; + } + + if ((res = get_answer (io, this)) != 0x01) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: unexpected response: %02x (0x01)\n", res); + lprintf("answer: %d\n", res); + goto fail; + } + + /* FIXME de-xine-ification */ +/* report_progress (stream, 40); */ + + /* TODO: insert network timing request here */ + /* command 0x2 */ + lprintf("send command 0x02\n"); + string_utf16 (url_conv, &this->scmd_body[8], "\002\000\\\\192.168.0.129\\TCP\\1037\0000", 28); + memset (this->scmd_body, 0, 8); + if (!send_command (io, this, 2, 0, 0, 28 * 2 + 8)) { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to send command 0x02\n"); + + goto fail; + } + + switch (res = get_answer (io, this)) { + case 0x02: + /* protocol accepted */ + break; + case 0x03: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: protocol failed\n"); + goto fail; + break; + default: + lprintf("unexpected response: %02x (0x02 or 0x03)\n", res); + goto fail; + } + + /* FIXME de-xine-ification */ +/* report_progress (stream, 50); */ + + /* command 0x5 */ + { + mms_buffer_t command_buffer; + + lprintf("send command 0x05\n"); + mms_buffer_init(&command_buffer, this->scmd_body); + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + string_utf16 (url_conv, this->scmd_body + command_buffer.pos, this->uri, strlen(this->uri)); + if (!send_command (io, this, 5, 1, 0xffffffff, strlen(this->uri) * 2 + 12)) + goto fail; + } + + switch (res = get_answer (io, this)) { + case 0x06: + { + int xx, yy; + /* no authentication required */ + + /* Warning: sdp is not right here */ + xx = this->buf[62]; + yy = this->buf[63]; + this->live_flag = ((xx == 0) && ((yy & 0xf) == 2)); + lprintf("live: live_flag=%d, xx=%d, yy=%d\n", this->live_flag, xx, yy); + } + break; + case 0x1A: + /* authentication request, not yet supported */ + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: authentication request, not yet supported\n"); + goto fail; + break; + default: + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: unexpected response: %02x (0x06 or 0x1A)\n", res); + goto fail; + } + + /* FIXME de-xine-ification */ +/* report_progress (stream, 60); */ + + /* command 0x15 */ + lprintf("send command 0x15\n"); + { + mms_buffer_t command_buffer; + mms_buffer_init(&command_buffer, this->scmd_body); + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x00800000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0xFFFFFFFF); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0x40AC2000); /* ?? */ + mms_buffer_put_32 (&command_buffer, ASF_HEADER_PACKET_ID_TYPE); /* Header Packet ID type */ + mms_buffer_put_32 (&command_buffer, 0x00000000); /* ?? */ + if (!send_command (io, this, 0x15, 1, 0, command_buffer.pos)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: failed to send command 0x15\n"); + goto fail; + } + } + + if ((res = get_answer (io, this)) != 0x11) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: unexpected response: %02x (0x11)\n", res); + goto fail; + } + + this->num_stream_ids = 0; + + if (!get_asf_header (io, this)) + goto fail; + + interp_asf_header (this); + + /* FIXME de-xine-ification */ +/* report_progress (stream, 70); */ + + if (!mms_choose_best_streams(io, this)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: mms_choose_best_streams failed"); + goto fail; + } + + /* FIXME de-xine-ification */ +/* report_progress (stream, 80); */ + + /* command 0x07 */ + { + mms_buffer_t command_buffer; + mms_buffer_init(&command_buffer, this->scmd_body); + mms_buffer_put_32 (&command_buffer, 0x00000000); /* 64 byte float timestamp */ + mms_buffer_put_32 (&command_buffer, 0x00000000); + mms_buffer_put_32 (&command_buffer, 0xFFFFFFFF); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0xFFFFFFFF); /* first packet sequence */ + mms_buffer_put_8 (&command_buffer, 0xFF); /* max stream time limit (3 bytes) */ + mms_buffer_put_8 (&command_buffer, 0xFF); + mms_buffer_put_8 (&command_buffer, 0xFF); + mms_buffer_put_8 (&command_buffer, 0x00); /* stream time limit flag */ + mms_buffer_put_32 (&command_buffer, ASF_MEDIA_PACKET_ID_TYPE); /* asf media packet id type */ + if (!send_command (io, this, 0x07, 1, 0x0001FFFF, command_buffer.pos)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: failed to send command 0x07\n"); + goto fail; + } + } + +/* report_progress (stream, 100); */ + + lprintf("mms_connect: passed\n" ); + + return this; + +fail: + if (this->s != -1) + close (this->s); + if (this->url) + free(this->url); + if (this->proto) + free(this->proto); + if (this->host) + free(this->host); + if (this->user) + free(this->user); + if (this->password) + free(this->password); + if (this->uri) + free(this->uri); + + free (this); + return NULL; +} + +static int get_media_packet (mms_io_t *io, mms_t *this) { + mms_packet_header_t header; + off_t len; + + switch (get_packet_header (io, this, &header)) { + case MMS_PACKET_ERR: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to read mms packet header\n"); + return 0; + break; + + case MMS_PACKET_COMMAND: + { + int command; + command = get_packet_command (io, this, header.packet_len); + + switch (command) { + case 0x1e: + { + uint32_t error_code; + + /* Warning: sdp is incomplete. Do not stop if error_code==1 */ + error_code = LE_32(this->buf + CMD_HEADER_LEN); + lprintf ("End of the current stream. Continue=%d\n", error_code); + + if (error_code == 0) { + this->eos = 1; + return 0; + } + + } + break; + + case 0x20: + { + lprintf ("new stream.\n"); + /* asf header */ + if (!get_asf_header (io, this)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "failed to read new ASF header\n"); + return 0; + } + + interp_asf_header (this); + + if (!mms_choose_best_streams(io, this)) + return 0; + + /* send command 0x07 */ + /* TODO: ugly */ + /* command 0x07 */ + { + mms_buffer_t command_buffer; + mms_buffer_init(&command_buffer, this->scmd_body); + mms_buffer_put_32 (&command_buffer, 0x00000000); /* 64 byte float timestamp */ + mms_buffer_put_32 (&command_buffer, 0x00000000); + mms_buffer_put_32 (&command_buffer, 0xFFFFFFFF); /* ?? */ + mms_buffer_put_32 (&command_buffer, 0xFFFFFFFF); /* first packet sequence */ + mms_buffer_put_8 (&command_buffer, 0xFF); /* max stream time limit (3 bytes) */ + mms_buffer_put_8 (&command_buffer, 0xFF); + mms_buffer_put_8 (&command_buffer, 0xFF); + mms_buffer_put_8 (&command_buffer, 0x00); /* stream time limit flag */ + mms_buffer_put_32 (&command_buffer, ASF_MEDIA_PACKET_ID_TYPE); /* asf media packet id type */ + if (!send_command (io, this, 0x07, 1, 0x0001FFFF, command_buffer.pos)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: failed to send command 0x07\n"); + return 0; + } + } + this->current_pos = 0; + } + break; + + case 0x1b: + { + if (!send_command (io, this, 0x1b, 0, 0, 0)) { + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: failed to send command\n"); + return 0; + } + } + break; + + case 0x05: + break; + + default: + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "unexpected mms command %02x\n", command); + } + this->buf_size = 0; + } + break; + + case MMS_PACKET_ASF_HEADER: + /* FIXME: de-xine-ification */ + lprintf( "***LOG:*** -- " + "libmms: unexpected asf header packet\n"); + this->buf_size = 0; + break; + + case MMS_PACKET_ASF_PACKET: + { + /* media packet */ + + /* FIXME: probably needs some more sophisticated logic, but + until we do seeking, this should work */ + if(this->need_discont) + { + this->need_discont = 0; + this->start_packet_seq = header.packet_seq; + } + + lprintf ("asf media packet detected, packet_len=%d, packet_seq=%d\n", + header.packet_len, header.packet_seq); + if (header.packet_len > this->asf_packet_len) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: invalid asf packet len: %d bytes\n", header.packet_len); + return 0; + } + + /* simulate a seek */ + this->current_pos = (off_t)this->asf_header_len + + ((off_t)header.packet_seq - this->start_packet_seq) * (off_t)this->asf_packet_len; + + len = io_read(io, this->s, this->buf, header.packet_len); + if (len != header.packet_len) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: read failed\n"); + return 0; + } + + /* explicit padding with 0 */ + lprintf("padding: %d bytes\n", this->asf_packet_len - header.packet_len); + { + char *base = (char *)(this->buf); + char *start = base + header.packet_len; + char *end = start + this->asf_packet_len - header.packet_len; + if ((start > base) && (start < (base+BUF_SIZE-1)) && + (start < end) && (end < (base+BUF_SIZE-1))) { + memset(this->buf + header.packet_len, 0, this->asf_packet_len - header.packet_len); + } + if (this->asf_packet_len > BUF_SIZE) { + this->buf_size = BUF_SIZE; + } else { + this->buf_size = this->asf_packet_len; + } + } + } + break; + } + + lprintf ("get media packet succ\n"); + + return 1; +} + + +int mms_peek_header (mms_t *this, char *data, int maxsize) { + + int len; + + len = (this->asf_header_len < maxsize) ? this->asf_header_len : maxsize; + + memcpy(data, this->asf_header, len); + return len; +} + +int mms_read (mms_io_t *io, mms_t *this, char *data, int len) { + int total; + + total = 0; + while (total < len && !this->eos) { + + if (this->asf_header_read < this->asf_header_len) { + int n, bytes_left; + + bytes_left = this->asf_header_len - this->asf_header_read ; + + if ((len - total) < bytes_left) + n = len-total; + else + n = bytes_left; + + memcpy (&data[total], &this->asf_header[this->asf_header_read], n); + + this->asf_header_read += n; + total += n; + this->current_pos += n; + } else { + + int n, bytes_left; + + bytes_left = this->buf_size - this->buf_read; + if (bytes_left == 0) { + this->buf_size = this->buf_read = 0; + if (!get_media_packet (io, this)) { + /* FIXME: de-xine-ification */ + lprintf ( "***LOG:*** -- " + "libmms: get_media_packet failed\n"); + return total; + } + bytes_left = this->buf_size; + } + + if ((len - total) < bytes_left) + n = len - total; + else + n = bytes_left; + + memcpy (&data[total], &this->buf[this->buf_read], n); + + this->buf_read += n; + total += n; + this->current_pos += n; + } + } + return total; +} + + +void mms_close (mms_t *this) { + + if (this->s != -1) + close (this->s); + if (this->url) + free(this->url); + if (this->proto) + free(this->proto); + if (this->host) + free(this->host); + if (this->user) + free(this->user); + if (this->password) + free(this->password); + if (this->uri) + free(this->uri); + + free (this); +} + +uint32_t mms_get_length (mms_t *this) { + return this->file_len; +} + +off_t mms_get_current_pos (mms_t *this) { + return this->current_pos; +}