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