git.sesse.net Git - ffmpeg/blob - libavformat/mmst.c

   1 /*
   2  * MMS protocol over TCP
   3  * Copyright (c) 2006,2007 Ryan Martell
   4  * Copyright (c) 2007 Björn Axelsson
   5  * Copyright (c) 2010 Zhentan Feng <spyfeng at gmail dot com>
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23 #include "avformat.h"
  24 #include "internal.h"
  25 #include "libavutil/intreadwrite.h"
  26 #include "libavcodec/bytestream.h"
  27 #include "network.h"
  28 #include "asf.h"
  29
  30 #define LOCAL_ADDRESS 0xc0a80081    // FIXME get and use correct local ip address.
  31 #define LOCAL_PORT    1037          // as above.
  32 /** Client to server packet types. */
  33 typedef enum {
  34     CS_PKT_INITIAL                  = 0x01,
  35     CS_PKT_PROTOCOL_SELECT          = 0x02,
  36     CS_PKT_MEDIA_FILE_REQUEST       = 0x05,
  37     CS_PKT_START_FROM_PKT_ID        = 0x07,
  38     CS_PKT_STREAM_PAUSE             = 0x09,
  39     CS_PKT_STREAM_CLOSE             = 0x0d,
  40     CS_PKT_MEDIA_HEADER_REQUEST     = 0x15,
  41     CS_PKT_TIMING_DATA_REQUEST      = 0x18,
  42     CS_PKT_USER_PASSWORD            = 0x1a,
  43     CS_PKT_KEEPALIVE                = 0x1b,
  44     CS_PKT_STREAM_ID_REQUEST        = 0x33,
  45 } MMSCSPacketType;
  46
  47 /** Server to client packet types. */
  48 typedef enum {
  49     /** Control packets. */
  50     /*@{*/
  51     SC_PKT_CLIENT_ACCEPTED          = 0x01,
  52     SC_PKT_PROTOCOL_ACCEPTED        = 0x02,
  53     SC_PKT_PROTOCOL_FAILED          = 0x03,
  54     SC_PKT_MEDIA_PKT_FOLLOWS        = 0x05,
  55     SC_PKT_MEDIA_FILE_DETAILS       = 0x06,
  56     SC_PKT_HEADER_REQUEST_ACCEPTED  = 0x11,
  57     SC_PKT_TIMING_TEST_REPLY        = 0x15,
  58     SC_PKT_PASSWORD_REQUIRED        = 0x1a,
  59     SC_PKT_KEEPALIVE                = 0x1b,
  60     SC_PKT_STREAM_STOPPED           = 0x1e,
  61     SC_PKT_STREAM_CHANGING          = 0x20,
  62     SC_PKT_STREAM_ID_ACCEPTED       = 0x21,
  63     /*@}*/
  64
  65     /** Pseudo packets. */
  66     /*@{*/
  67     SC_PKT_CANCEL                   = -1,
  68     SC_PKT_NO_DATA                  = -2,
  69     /*@}*/
  70
  71     /** Data packets. */
  72     /*@{*/
  73     SC_PKT_ASF_HEADER               = 0x010000,// make it bigger than 0xFF in case of
  74     SC_PKT_ASF_MEDIA                = 0x010001,// receiving false data packets.
  75     /*@}*/
  76 } MMSSCPacketType;
  77
  78 typedef struct {
  79     int id;
  80 }MMSStream;
  81
  82 typedef struct {
  83     int outgoing_packet_seq;             ///< Outgoing packet sequence number.
  84     char path[256];                      ///< Path of the resource being asked for.
  85     char host[128];                      ///< Host of the resources.
  86
  87     URLContext *mms_hd;                  ///< TCP connection handle
  88     MMSStream streams[MAX_STREAMS];
  89
  90     /** Buffer for outgoing packets. */
  91     /*@{*/
  92     uint8_t *write_out_ptr;              ///< Pointer for writting the buffer.
  93     uint8_t out_buffer[512];             ///< Buffer for outgoing packet.
  94     /*@}*/
  95
  96     /** Buffer for incoming packets. */
  97     /*@{*/
  98     uint8_t in_buffer[8192];             ///< Buffer for incoming packets.
  99     uint8_t *read_in_ptr;                ///< Pointer for reading from incoming buffer.
 100     int remaining_in_len;                ///< Reading length from incoming buffer.
 101     /*@}*/
 102
 103     int incoming_packet_seq;             ///< Incoming packet sequence number.
 104     int incoming_flags;                  ///< Incoming packet flags.
 105
 106     int packet_id;                       ///< Identifier for packets in the current stream.
 107     unsigned int header_packet_id;       ///< default is 2.
 108
 109     /** Internal handling of the ASF header */
 110     /*@{*/
 111     uint8_t *asf_header;                 ///< Stored ASF header.
 112     int asf_header_size;                 ///< Size of stored ASF header.
 113     int header_parsed;                   ///< The header has been received and parsed.
 114     int asf_packet_len;
 115     /*@}*/
 116
 117     int stream_num;                      ///< stream numbers.
 118     int is_playing;
 119 } MMSContext;
 120
 121 /** Create MMST command packet header */
 122 static void start_command_packet(MMSContext *mms, MMSCSPacketType packet_type)
 123 {
 124     mms->write_out_ptr = mms->out_buffer;
 125
 126     bytestream_put_le32(&mms->write_out_ptr, 1); // start sequence
 127     bytestream_put_le32(&mms->write_out_ptr, 0xb00bface);
 128     bytestream_put_le32(&mms->write_out_ptr, 0); // Length starts from after the protocol type bytes
 129     bytestream_put_le32(&mms->write_out_ptr, MKTAG('M','M','S',' '));
 130     bytestream_put_le32(&mms->write_out_ptr, 0);
 131     bytestream_put_le32(&mms->write_out_ptr, mms->outgoing_packet_seq++);
 132     bytestream_put_le64(&mms->write_out_ptr, 0); // timestamp
 133     bytestream_put_le32(&mms->write_out_ptr, 0);
 134     bytestream_put_le16(&mms->write_out_ptr, packet_type);
 135     bytestream_put_le16(&mms->write_out_ptr, 3); // direction to server
 136 }
 137
 138 /** Add prefixes to MMST command packet. */
 139 static void insert_command_prefixes(MMSContext *mms,
 140         uint32_t prefix1, uint32_t prefix2)
 141 {
 142     bytestream_put_le32(&mms->write_out_ptr, prefix1); // first prefix
 143     bytestream_put_le32(&mms->write_out_ptr, prefix2); // second prefix
 144 }
 145
 146 /** Send a prepared MMST command packet. */
 147 static int send_command_packet(MMSContext *mms)
 148 {
 149     int exact_length= mms->write_out_ptr - mms->out_buffer;
 150     int first_length= exact_length - 16;
 151     int len8= first_length/8;
 152     int write_result;
 153
 154     // update packet length fields.
 155     AV_WL32(mms->out_buffer + 8, first_length);
 156     AV_WL32(mms->out_buffer + 16, len8);
 157     AV_WL32(mms->out_buffer + 32, len8-2);
 158
 159     // write it out.
 160     write_result= url_write(mms->mms_hd, mms->out_buffer, exact_length);
 161     if(write_result != exact_length) {
 162         dprintf(NULL, "url_write returned: %d != %d\n",
 163                 write_result, exact_length);
 164         return AVERROR_IO;
 165     }
 166
 167     return 0;
 168 }
 169
 170 static void mms_put_utf16(MMSContext *mms, uint8_t *src)
 171 {
 172     ByteIOContext bic;
 173     int size = mms->write_out_ptr - mms->out_buffer;
 174     int len;
 175     init_put_byte(&bic, mms->write_out_ptr,
 176             sizeof(mms->out_buffer) - size, 1, NULL, NULL, NULL, NULL);
 177
 178     len = ff_put_str16_nolen(&bic, src);
 179     mms->write_out_ptr += len;
 180 }
 181
 182 static int send_time_test_data(MMSContext *mms)
 183 {
 184     start_command_packet(mms, CS_PKT_TIMING_DATA_REQUEST);
 185     insert_command_prefixes(mms, 0xf0f0f0f1, 0x0004000b);
 186     return send_command_packet(mms);
 187 }
 188
 189 static int send_protocol_select(MMSContext *mms)
 190 {
 191     char data_string[256];
 192
 193     start_command_packet(mms, CS_PKT_PROTOCOL_SELECT);
 194     insert_command_prefixes(mms, 0, 0xffffffff);
 195     bytestream_put_le32(&mms->write_out_ptr, 0);          // maxFunnelBytes
 196     bytestream_put_le32(&mms->write_out_ptr, 0x00989680); // maxbitRate
 197     bytestream_put_le32(&mms->write_out_ptr, 2);          // funnelMode
 198     snprintf(data_string, sizeof(data_string), "\\\\%d.%d.%d.%d\\%s\\%d",
 199             (LOCAL_ADDRESS>>24)&0xff,
 200             (LOCAL_ADDRESS>>16)&0xff,
 201             (LOCAL_ADDRESS>>8)&0xff,
 202             LOCAL_ADDRESS&0xff,
 203             "TCP",                                        // or UDP
 204             LOCAL_PORT);
 205
 206     mms_put_utf16(mms, data_string);
 207     return send_command_packet(mms);
 208 }
 209
 210 static int send_media_file_request(MMSContext *mms)
 211 {
 212     start_command_packet(mms, CS_PKT_MEDIA_FILE_REQUEST);
 213     insert_command_prefixes(mms, 1, 0xffffffff);
 214     bytestream_put_le32(&mms->write_out_ptr, 0);
 215     bytestream_put_le32(&mms->write_out_ptr, 0);
 216     mms_put_utf16(mms, mms->path + 1); // +1 for skip "/"
 217
 218     return send_command_packet(mms);
 219 }
 220
 221 static void handle_packet_stream_changing_type(MMSContext *mms)
 222 {
 223     dprintf(NULL, "Stream changing!\n");
 224
 225     // 40 is the packet header size, 7 is the prefix size.
 226     mms->header_packet_id= AV_RL32(mms->in_buffer + 40 + 7);
 227     dprintf(NULL, "Changed header prefix to 0x%x", mms->header_packet_id);
 228 }
 229
 230 static int send_keepalive_packet(MMSContext *mms)
 231 {
 232     // respond to a keepalive with a keepalive...
 233     start_command_packet(mms, CS_PKT_KEEPALIVE);
 234     insert_command_prefixes(mms, 1, 0x100FFFF);
 235     return send_command_packet(mms);
 236 }
 237
 238 /** Pad media packets smaller than max_packet_size and/or adjust read position
 239   * after a seek. */
 240 static void pad_media_packet(MMSContext *mms)
 241 {
 242     if(mms->remaining_in_len<mms->asf_packet_len) {
 243         int padding_size = mms->asf_packet_len - mms->remaining_in_len;
 244         memset(mms->in_buffer + mms->remaining_in_len, 0, padding_size);
 245         mms->remaining_in_len += padding_size;
 246     }
 247 }
 248
 249 /** Read incoming MMST media, header or command packet. */
 250 static MMSSCPacketType get_tcp_server_response(MMSContext *mms)
 251 {
 252     int read_result;
 253     MMSSCPacketType packet_type= -1;
 254
 255     for(;;) {
 256         if((read_result= url_read_complete(mms->mms_hd, mms->in_buffer, 8))==8) {
 257             // handle command packet.
 258             if(AV_RL32(mms->in_buffer + 4)==0xb00bface) {
 259                 mms->incoming_flags= mms->in_buffer[3];
 260                 read_result= url_read_complete(mms->mms_hd, mms->in_buffer+8, 4);
 261                 if(read_result == 4) {
 262                     int length_remaining= AV_RL32(mms->in_buffer+8) + 4;
 263                     int hr;
 264
 265                     dprintf(NULL, "Length remaining is %d\n", length_remaining);
 266                     // read the rest of the packet.
 267                     if (length_remaining < 0
 268                         || length_remaining > sizeof(mms->in_buffer) - 12) {
 269                         dprintf(NULL, "Incoming message len %d exceeds buffer len %d\n",
 270                             length_remaining, sizeof(mms->in_buffer) - 12);
 271                         return -1;
 272                     }
 273                     read_result = url_read_complete(mms->mms_hd, mms->in_buffer + 12,
 274                                                   length_remaining) ;
 275                     if (read_result == length_remaining) {
 276                         packet_type= AV_RL16(mms->in_buffer+36);
 277                     } else {
 278                         dprintf(NULL, "read for packet type failed%d!\n", read_result);
 279                         return -1;
 280                     }
 281                     hr = AV_RL32(mms->in_buffer + 40);
 282                     if (hr) {
 283                         dprintf(NULL, "The server side send back error code:0x%x\n", hr);
 284                         return -1;
 285                     }
 286                 } else {
 287                     dprintf(NULL, "read for length remaining failed%d!\n", read_result);
 288                     return -1;
 289                 }
 290             } else {
 291                 int length_remaining;
 292                 int packet_id_type;
 293                 int tmp;
 294
 295                 assert(mms->remaining_in_len==0);
 296
 297                 // note we cache the first 8 bytes,
 298                 // then fill up the buffer with the others
 299                 tmp                       = AV_RL16(mms->in_buffer + 6);
 300                 length_remaining          = (tmp - 8) & 0xffff;
 301                 mms->incoming_packet_seq  = AV_RL32(mms->in_buffer);
 302                 packet_id_type            = mms->in_buffer[4];
 303                 mms->incoming_flags       = mms->in_buffer[5];
 304
 305                 if (length_remaining < 0
 306                         || length_remaining > sizeof(mms->in_buffer) - 8) {
 307                     dprintf(NULL, "Incoming data len %d exceeds buffer len %d\n",
 308                             length_remaining, sizeof(mms->in_buffer));
 309                     return -1;
 310                 }
 311                 mms->remaining_in_len    = length_remaining;
 312                 mms->read_in_ptr         = mms->in_buffer;
 313                 read_result= url_read_complete(mms->mms_hd, mms->in_buffer, length_remaining);
 314                 if(read_result != length_remaining) {
 315                     dprintf(NULL, "read_bytes result: %d asking for %d\n",
 316                             read_result, length_remaining);
 317                     return -1;
 318                 } else {
 319                     // if we successfully read everything.
 320                     if(packet_id_type == mms->header_packet_id) {
 321                         packet_type = SC_PKT_ASF_HEADER;
 322                         // Store the asf header
 323                         if(!mms->header_parsed) {
 324                             void *p = av_realloc(mms->asf_header,
 325                                               mms->asf_header_size
 326                                               + mms->remaining_in_len);
 327                             if (!p) {
 328                                 av_freep(&mms->asf_header);
 329                                 return AVERROR(ENOMEM);
 330                             }
 331                             mms->asf_header = p;
 332                             memcpy(mms->asf_header + mms->asf_header_size,
 333                                                  mms->read_in_ptr,
 334                                                  mms->remaining_in_len);
 335                             mms->asf_header_size += mms->remaining_in_len;
 336                         }
 337                     } else if(packet_id_type == mms->packet_id) {
 338                         packet_type = SC_PKT_ASF_MEDIA;
 339                     } else {
 340                         dprintf(NULL, "packet id type %d is old.", packet_id_type);
 341                         continue;
 342                     }
 343                 }
 344             }
 345
 346             // preprocess some packet type
 347             if(packet_type == SC_PKT_KEEPALIVE) {
 348                 send_keepalive_packet(mms);
 349                 continue;
 350             } else if(packet_type == SC_PKT_STREAM_CHANGING) {
 351                 handle_packet_stream_changing_type(mms);
 352             } else if(packet_type == SC_PKT_ASF_MEDIA) {
 353                 pad_media_packet(mms);
 354             }
 355             return packet_type;
 356         } else {
 357             if(read_result<0) {
 358                 dprintf(NULL, "Read error (or cancelled) returned %d!\n", read_result);
 359                 packet_type = SC_PKT_CANCEL;
 360             } else {
 361                 dprintf(NULL, "Read result of zero?!\n");
 362                 packet_type = SC_PKT_NO_DATA;
 363             }
 364             return packet_type;
 365         }
 366     }
 367 }
 368
 369 static int mms_safe_send_recv(MMSContext *mms,
 370                               int (*send_fun)(MMSContext *mms),
 371                               const MMSSCPacketType expect_type)
 372 {
 373     MMSSCPacketType type;
 374     if(send_fun) {
 375         int ret = send_fun(mms);
 376         if (ret < 0) {
 377             dprintf(NULL, "Send Packet error before expecting recv packet %d\n", expect_type);
 378             return ret;
 379         }
 380     }
 381
 382     if ((type = get_tcp_server_response(mms)) != expect_type) {
 383         dprintf(NULL,"Unexpected packet type %d with type %d\n", type, expect_type);
 384         return -1;
 385     } else {
 386         return 0;
 387     }
 388 }
 389
 390 static int send_media_header_request(MMSContext *mms)
 391 {
 392     start_command_packet(mms, CS_PKT_MEDIA_HEADER_REQUEST);
 393     insert_command_prefixes(mms, 1, 0);
 394     bytestream_put_le32(&mms->write_out_ptr, 0);
 395     bytestream_put_le32(&mms->write_out_ptr, 0x00800000);
 396     bytestream_put_le32(&mms->write_out_ptr, 0xffffffff);
 397     bytestream_put_le32(&mms->write_out_ptr, 0);
 398     bytestream_put_le32(&mms->write_out_ptr, 0);
 399     bytestream_put_le32(&mms->write_out_ptr, 0);
 400
 401     // the media preroll value in milliseconds?
 402     bytestream_put_le32(&mms->write_out_ptr, 0);
 403     bytestream_put_le32(&mms->write_out_ptr, 0x40AC2000);
 404     bytestream_put_le32(&mms->write_out_ptr, 2);
 405     bytestream_put_le32(&mms->write_out_ptr, 0);
 406
 407     return send_command_packet(mms);
 408 }
 409
 410 /** Send the initial handshake. */
 411 static int send_startup_packet(MMSContext *mms)
 412 {
 413     char data_string[256];
 414     // SubscriberName is defined in MS specification linked below.
 415     // The guid value can be any valid value.
 416     // http://download.microsoft.com/
 417     // download/9/5/E/95EF66AF-9026-4BB0-A41D-A4F81802D92C/%5BMS-WMSP%5D.pdf
 418     snprintf(data_string, sizeof(data_string),
 419             "NSPlayer/7.0.0.1956; {%s}; Host: %s",
 420             "7E667F5D-A661-495E-A512-F55686DDA178", mms->host);
 421
 422     start_command_packet(mms, CS_PKT_INITIAL);
 423     insert_command_prefixes(mms, 0, 0x0004000b);
 424     bytestream_put_le32(&mms->write_out_ptr, 0x0003001c);
 425     mms_put_utf16(mms, data_string);
 426     return send_command_packet(mms);
 427 }
 428
 429 static int asf_header_parser(MMSContext *mms)
 430 {
 431     uint8_t *p = mms->asf_header;
 432     uint8_t *end;
 433     int flags, stream_id, real_header_size;
 434     mms->stream_num = 0;
 435
 436     if (mms->asf_header_size < sizeof(ff_asf_guid) * 2 + 22 ||
 437         memcmp(p, ff_asf_header, sizeof(ff_asf_guid)))
 438         return -1;
 439
 440     real_header_size = AV_RL64(p + sizeof(ff_asf_guid));
 441     end = mms->asf_header + real_header_size;
 442
 443     p += sizeof(ff_asf_guid) + 14;
 444     while(end - p >= sizeof(ff_asf_guid) + 8) {
 445         uint64_t chunksize = AV_RL64(p + sizeof(ff_asf_guid));
 446         if (!chunksize || chunksize > end - p) {
 447             dprintf(NULL, "chunksize is exceptional value:%"PRId64"!\n", chunksize);
 448             return -1;
 449         }
 450         if (!memcmp(p, ff_asf_file_header, sizeof(ff_asf_guid))) {
 451             /* read packet size */
 452             if (end - p > sizeof(ff_asf_guid) * 2 + 68) {
 453                 mms->asf_packet_len = AV_RL32(p + sizeof(ff_asf_guid) * 2 + 64);
 454                 if (mms->asf_packet_len <= 0 || mms->asf_packet_len > sizeof(mms->in_buffer)) {
 455                     dprintf(NULL,"Too large packet len:%d"
 456                         " may overwrite in_buffer when padding", mms->asf_packet_len);
 457                     return -1;
 458                 }
 459             }
 460         } else if (!memcmp(p, ff_asf_stream_header, sizeof(ff_asf_guid))) {
 461             flags     = AV_RL16(p + sizeof(ff_asf_guid)*3 + 24);
 462             stream_id = flags & 0x7F;
 463             //The second condition is for checking CS_PKT_STREAM_ID_REQUEST packet size,
 464             //we can calcuate the packet size by stream_num.
 465             //Please see function send_stream_selection_request().
 466             if (mms->stream_num < MAX_STREAMS &&
 467                     46 + mms->stream_num * 6 < sizeof(mms->out_buffer)) {
 468                 mms->streams[mms->stream_num].id = stream_id;
 469                 mms->stream_num++;
 470             } else {
 471                 dprintf(NULL, "Too many streams.\n");
 472                 return -1;
 473             }
 474         }
 475         p += chunksize;
 476     }
 477
 478     return 0;
 479 }
 480
 481 /** Send MMST stream selection command based on the AVStream->discard values. */
 482 static int send_stream_selection_request(MMSContext *mms)
 483 {
 484     int i;
 485
 486     //  send the streams we want back...
 487     start_command_packet(mms, CS_PKT_STREAM_ID_REQUEST);
 488     bytestream_put_le32(&mms->write_out_ptr, mms->stream_num);         // stream nums
 489     for(i= 0; i<mms->stream_num; i++) {
 490         bytestream_put_le16(&mms->write_out_ptr, 0xffff);              // flags
 491         bytestream_put_le16(&mms->write_out_ptr, mms->streams[i].id);  // stream id
 492         bytestream_put_le16(&mms->write_out_ptr, 0);                   // selection
 493     }
 494
 495     bytestream_put_le16(&mms->write_out_ptr, 0);
 496
 497     return send_command_packet(mms);
 498 }
 499
 500 static int read_data(MMSContext *mms, uint8_t *buf, const int buf_size)
 501 {
 502     int read_size;
 503     read_size = FFMIN(buf_size, mms->remaining_in_len);
 504     memcpy(buf, mms->read_in_ptr, read_size);
 505     mms->remaining_in_len -= read_size;
 506     mms->read_in_ptr      += read_size;
 507     return read_size;
 508 }
 509
 510 /** Read at most one media packet (or a whole header). */
 511 static int read_mms_packet(MMSContext *mms, uint8_t *buf, int buf_size)
 512 {
 513     int result = 0, read_header_size = 0;
 514     int size_to_copy;
 515
 516     do {
 517         if(read_header_size < mms->asf_header_size && !mms->is_playing) {
 518             /* Read from ASF header buffer */
 519             size_to_copy= FFMIN(buf_size,
 520                                 mms->asf_header_size - read_header_size);
 521             memcpy(buf, mms->asf_header + read_header_size, size_to_copy);
 522             read_header_size += size_to_copy;
 523             result += size_to_copy;
 524             dprintf(NULL, "Copied %d bytes from stored header. left: %d\n",
 525                    size_to_copy, mms->asf_header_size - read_header_size);
 526             if (mms->asf_header_size == read_header_size) {
 527                 av_freep(&mms->asf_header);
 528                 mms->is_playing = 1;
 529             }
 530         } else if(mms->remaining_in_len) {
 531             /* Read remaining packet data to buffer.
 532              * the result can not be zero because remaining_in_len is positive.*/
 533             result = read_data(mms, buf, buf_size);
 534         } else {
 535             /* Read from network */
 536             int err = mms_safe_send_recv(mms, NULL, SC_PKT_ASF_MEDIA);
 537             if (err == 0) {
 538                 if(mms->remaining_in_len>mms->asf_packet_len) {
 539                     dprintf(NULL, "Incoming packet"
 540                             "larger than the asf packet size stated (%d>%d)\n",
 541                             mms->remaining_in_len, mms->asf_packet_len);
 542                     result= AVERROR_IO;
 543                 } else {
 544                     // copy the data to the packet buffer.
 545                     result = read_data(mms, buf, buf_size);
 546                     if (result == 0) {
 547                         dprintf(NULL, "read asf media paket size is zero!\n");
 548                         break;
 549                     }
 550                 }
 551             } else {
 552                 dprintf(NULL, "read packet error!\n");
 553                 break;
 554             }
 555         }
 556     } while(!result); // only return one packet.
 557     return result;
 558 }
 559
 560 static int send_close_packet(MMSContext *mms)
 561 {
 562     start_command_packet(mms, CS_PKT_STREAM_CLOSE);
 563     insert_command_prefixes(mms, 1, 1);
 564
 565     return send_command_packet(mms);
 566 }
 567
 568 /** Close the MMSH/MMST connection */
 569 static int mms_close(URLContext *h)
 570 {
 571     MMSContext *mms = (MMSContext *)h->priv_data;
 572
 573     if(mms->mms_hd) {
 574         send_close_packet(mms);
 575         url_close(mms->mms_hd);
 576     }
 577
 578     /* free all separately allocated pointers in mms */
 579     av_free(mms->asf_header);
 580     av_freep(&h->priv_data);
 581
 582     return 0;
 583 }
 584
 585 static int mms_open(URLContext *h, const char *uri, int flags)
 586 {
 587     MMSContext *mms;
 588     int port, err;
 589     char tcpname[256];
 590
 591     h->is_streamed = 1;
 592     mms = h->priv_data = av_mallocz(sizeof(MMSContext));
 593     if (!h->priv_data)
 594         return AVERROR(ENOMEM);
 595
 596     // only for MMS over TCP, so set proto = NULL
 597     av_url_split(NULL, 0, NULL, 0,
 598             mms->host, sizeof(mms->host), &port, mms->path,
 599             sizeof(mms->path), uri);
 600
 601     if(port<0)
 602         port = 1755; // defaut mms protocol port
 603
 604     // establish tcp connection.
 605     ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, mms->host, port, NULL);
 606     err = url_open(&mms->mms_hd, tcpname, URL_RDWR);
 607     if (err)
 608         goto fail;
 609
 610     mms->packet_id        = 3;          // default, initial value.
 611     mms->header_packet_id = 2;          // default, initial value.
 612     err = mms_safe_send_recv(mms, send_startup_packet, SC_PKT_CLIENT_ACCEPTED);
 613     if (err)
 614         goto fail;
 615     err = mms_safe_send_recv(mms, send_time_test_data, SC_PKT_TIMING_TEST_REPLY);
 616     if (err)
 617         goto fail;
 618     err = mms_safe_send_recv(mms, send_protocol_select, SC_PKT_PROTOCOL_ACCEPTED);
 619     if (err)
 620         goto fail;
 621     err = mms_safe_send_recv(mms, send_media_file_request, SC_PKT_MEDIA_FILE_DETAILS);
 622     if (err)
 623         goto fail;
 624     err = mms_safe_send_recv(mms, send_media_header_request, SC_PKT_HEADER_REQUEST_ACCEPTED);
 625     if (err)
 626         goto fail;
 627     err = mms_safe_send_recv(mms, NULL, SC_PKT_ASF_HEADER);
 628     if (err)
 629         goto fail;
 630     if((mms->incoming_flags != 0X08) && (mms->incoming_flags != 0X0C))
 631         goto fail;
 632     err = asf_header_parser(mms);
 633     if (err) {
 634         dprintf(NULL, "asf header parsed failed!\n");
 635         goto fail;
 636     }
 637     mms->header_parsed = 1;
 638
 639     if (!mms->asf_packet_len || !mms->stream_num)
 640         goto fail;
 641
 642     dprintf(NULL, "Leaving open (success)\n");
 643     return 0;
 644 fail:
 645     mms_close(h);
 646     dprintf(NULL, "Leaving open (failure: %d)\n", err);
 647     return err;
 648 }
 649
 650 static int send_media_packet_request(MMSContext *mms)
 651 {
 652     start_command_packet(mms, CS_PKT_START_FROM_PKT_ID);
 653     insert_command_prefixes(mms, 1, 0x0001FFFF);
 654     bytestream_put_le64(&mms->write_out_ptr, 0);          // seek timestamp
 655     bytestream_put_le32(&mms->write_out_ptr, 0xffffffff); // unknown
 656     bytestream_put_le32(&mms->write_out_ptr, 0xffffffff); // packet offset
 657     bytestream_put_byte(&mms->write_out_ptr, 0xff);       // max stream time limit
 658     bytestream_put_byte(&mms->write_out_ptr, 0xff);       // max stream time limit
 659     bytestream_put_byte(&mms->write_out_ptr, 0xff);       // max stream time limit
 660     bytestream_put_byte(&mms->write_out_ptr, 0x00);       // stream time limit flag
 661
 662     mms->packet_id++;                                     // new packet_id
 663     bytestream_put_le32(&mms->write_out_ptr, mms->packet_id);
 664     return send_command_packet(mms);
 665 }
 666
 667
 668 static void clear_stream_buffers(MMSContext *mms)
 669 {
 670     mms->remaining_in_len = 0;
 671     mms->read_in_ptr      = mms->in_buffer;
 672 }
 673
 674 /** Read ASF data through the protocol. */
 675 static int mms_read(URLContext *h, uint8_t *buf, int size)
 676 {
 677     /* TODO: see tcp.c:tcp_read() about a possible timeout scheme */
 678     MMSContext *mms = h->priv_data;
 679     int result = 0;
 680
 681     /* Since we read the header at open(), this shouldn't be possible */
 682     assert(mms->header_parsed);
 683
 684     if (!mms->is_playing) {
 685         dprintf(NULL, "mms_read() before play().\n");
 686         clear_stream_buffers(mms);
 687         result = mms_safe_send_recv(mms, send_stream_selection_request, SC_PKT_STREAM_ID_ACCEPTED);
 688         if (result)
 689             return result;
 690         // send media packet request
 691         result = mms_safe_send_recv(mms, send_media_packet_request, SC_PKT_MEDIA_PKT_FOLLOWS);
 692         if (result) {
 693             return result;
 694         }
 695     }
 696     return read_mms_packet(mms, buf, size);
 697 }
 698
 699 URLProtocol mmst_protocol = {
 700     "mmst",
 701     mms_open,
 702     mms_read,
 703     NULL, // write
 704     NULL, // seek
 705     mms_close,
 706 };