You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

742 lines
27KB

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