开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
asf.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：29k
源码类别：

Windows CE

开发平台：

C/C++

asf.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * The Core Pocket Media Player
  18.  * Copyright (c) 2004-2005 Gabor Kovacs
  19.  *
  20.  ****************************************************************************/
  22. #include "../common/common.h"
  23. #include "asf.h"
  25. //#define DUMPASF
  27. typedef struct asfstreamstate
  28. {
  29. int Offset;
  30. int Size;
  31. tick_t RefTime;
  32. format_ref* Ref;
  33. format_ref** Tail;
  35. } asfstreamstate;
  37. typedef struct asfstream
  38. {
  39. format_stream Stream;
  41. int TimeOffset; // milliseconds
  42.     int DS_Span; // descrambling
  43.     int DS_PacketSize;
  44.     int DS_ChunkSize;
  45. asfstreamstate State;
  46. asfstreamstate Backup;
  48. } asfstream;
  50. typedef struct asfstate
  51. {
  52. bool_t Key;
  53. bool_t Multiple;
  54. bool_t Compressed;
  56. filepos_t End;
  57. int ValueLength;
  58. int Padding;
  59. asfstream* Stream;
  61. int PayloadCount;
  62. filepos_t PayloadEnd;
  63. int PayloadOffset;
  64. int PayloadTime;
  66. int CompressedTime;
  67. int CompressedDelta;
  69. } asfstate;
  71. typedef struct asfguid
  72. {
  73. guid ASFHeader;
  74. guid FileHeader;
  75. guid StreamHeader;
  76. guid AudioStream;
  77. guid VideoStream;
  78. guid CommentHeader;
  79. guid CodecCommentHeader;
  80. guid DataHeader;
  81. guid Index;
  82. guid HeadExt;
  83. guid Head2;
  84. guid NoErrorCorrection;
  85. guid AudioSpread;
  86. guid ExtendedComment;
  87. guid MarkerObject;
  88. guid StreamBitrate;
  89. guid StreamHeaderExt;
  91. } asfguid;
  93. typedef struct asf
  94. {
  95. format_base Format;
  97. filepos_t DataPos;
  98. int PacketMinSize;
  99. int PacketMaxSize;
  100. int64_t PacketCount;
  101. int64_t PlayTime;
  102. int PreRoll;
  103. int Flags;
  104. int ClientId;
  105. bool_t AdjustTime;
  106. bool_t AdjustTime0;
  107. array Bitrate;
  108. tick_t StreamingTime;
  110. format_ref* HTTPRef;
  111. format_reader HTTPReader;
  112. int HTTPChunkLeft;
  113. int HTTPChunkFilter;
  115. asfstate State;
  116. asfstate Backup;
  118. asfguid GUID;
  120. } asf;
  122. static const asfguid ASFGUID =
  123. {
  124.     { 0x75B22630, 0x668E, 0x11CF, { 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }},
  125.     { 0x8CABDCA1, 0xA947, 0x11CF, { 0x8E, 0xE4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }},
  126.     { 0xB7DC0791, 0xA9B7, 0x11CF, { 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }},
  127.     { 0xF8699E40, 0x5B4D, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B }},
  128.     { 0xBC19EFC0, 0x5B4D, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B }},
  129.     { 0x75B22633, 0x668E, 0x11CF, { 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }},
  130. { 0x86D15240, 0x311D, 0x11D0, { 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 }},
  131. { 0x75B22636, 0x668E, 0x11CF, { 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C }},
  132. { 0x33000890, 0xE5B1, 0x11CF, { 0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB }},
  133.     { 0x5FBF03B5, 0xA92E, 0x11CF, { 0x8E, 0xE3, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }},
  134.     { 0xABD3D211, 0xA9BA, 0x11CF, { 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }},
  135. { 0x20FB5700, 0x5B55, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B }},
  136. { 0xBFC3CD50, 0x618F, 0x11CF, { 0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20 }},
  137. { 0xD2D0A440, 0xE307, 0x11D2, { 0x97, 0xF0, 0x00, 0xA0, 0xC9, 0x5E, 0xA8, 0x50 }},
  138. { 0xF487CD01, 0xA951, 0x11CF, { 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 }},
  139. { 0x7BF875CE, 0x468D, 0x11D1, { 0x8D, 0x82, 0x00, 0x60, 0x97, 0xC9, 0xA2, 0xB2 }},
  140. { 0x14E6A5CB, 0xC672, 0x4332, { 0x83, 0x99, 0xA9, 0x69, 0x52, 0x06, 0x5B, 0x5A }}
  141. };
  143. static void ReadGUID(format_reader* p,guid* g)
  144. {
  145.     g->v1 = p->ReadLE32(p);
  146.     g->v2 = (uint16_t) p->ReadLE16(p);
  147.     g->v3 = (uint16_t) p->ReadLE16(p);
  148.     p->Read(p,g->v4,8);
  149. }
  151. static void ReadStr(format_reader* p, int Len, tchar_t *Buf, size_t BufLen)
  152. {
  153. uint16_t ch[2];
  154. ch[1] = 0;
  156.     for (;Len>0;Len-=2) 
  157. {
  158.         ch[0] = (uint16_t) p->ReadLE16(p);
  159. #ifndef UNICODE
  160.         WcsToTcs(Buf,BufLen,ch);
  161. BufLen -= tcslen(Buf);
  162. Buf += tcslen(Buf);
  163. #else
  164.         if (BufLen > 1)
  165. {
  166. *Buf++ = ch[0];
  167. --BufLen;
  168. }
  169. #endif
  170.     }
  171.     if (BufLen>0)
  172. *Buf = 0;
  173. }
  175. static void ReleaseStream(asf* p,asfstream* s)
  176. {
  177. Format_ReleaseRef(&p->Format,s->State.Ref);
  178. s->State.Ref = NULL;
  179. s->State.Tail = &s->State.Ref;
  180. s->State.Offset = 0;
  181. s->State.Size = 0;
  182. }
  184. static void AfterSeek(asf* p)
  185. {
  186. p->State.PayloadCount = 0;
  187. p->State.PayloadEnd = -1;
  188. p->State.End = -1;
  189. p->State.Stream = NULL;
  190. }
  192. static void BackupPacketState(asf* p, int Save)
  193. {
  194. int No;
  196. // ugly...
  197. if (Save)
  198. {
  199. p->Backup = p->State;
  200. AfterSeek(p);
  201. }
  202. else
  203. {
  204. AfterSeek(p);
  205. p->State = p->Backup;
  206. }
  208. for (No=0;No<p->Format.StreamCount;++No)
  209. {
  210. asfstream* s = (asfstream*) p->Format.Streams[No];
  211. if (Save)
  212. {
  213. s->Backup = s->State;
  214. s->State.Ref = NULL; // don't release fragref
  215. ReleaseStream(p,s);
  216. }
  217. else
  218. {
  219. ReleaseStream(p,s);
  220. s->State = s->Backup;
  221. }
  222. }
  223. }
  225. static void ReadStreamHeader(asf* p, format_reader* Reader)
  226. {
  227. int StreamId,i;
  228. int TimeOffset;
  229. int* BitRate;
  230. int FormatSize;
  231. int ErrorSize;
  232. guid Id,StreamType;
  233. asfstream* s;
  235. ReadGUID(Reader,&StreamType); // stream type
  237. ReadGUID(Reader,&Id); // error correction type
  238. TimeOffset = (int)(Reader->ReadLE64(Reader)/10000) - p->PreRoll;
  239. FormatSize = Reader->ReadLE32(Reader); // type-specific data length
  240. ErrorSize = Reader->ReadLE32(Reader); // error correction length
  241. StreamId = Reader->ReadLE16(Reader) & 0x7F; // flags
  242. Reader->Skip(Reader,4);
  244. for (i=0;i<p->Format.StreamCount;++i)
  245. if (p->Format.Streams[i]->Id == StreamId)
  246. return;
  248. s = (asfstream*) Format_AddStream(&p->Format,sizeof(asfstream));
  249. if (!s)
  250. return;
  252. ReleaseStream(p,s);
  253. s->Stream.Id = StreamId;
  254. s->TimeOffset = TimeOffset;
  255. s->DS_Span = 0;
  257. if (memcmp(&StreamType, &p->GUID.AudioStream, sizeof(guid))==0)
  258. {
  259. Format_WaveFormat(Reader,&s->Stream,FormatSize);
  260. if (memcmp(&Id,&p->GUID.AudioSpread,sizeof(guid))==0)
  261. {
  262. int SilentLength;
  263. s->DS_Span = Reader->Read8(Reader);
  264. s->DS_PacketSize = Reader->ReadLE16(Reader);
  265. s->DS_ChunkSize = Reader->ReadLE16(Reader);
  266. SilentLength = Reader->ReadLE16(Reader);
  267. Reader->Skip(Reader,SilentLength);
  268. }
  270. if (s->DS_Span > 1) 
  271. if (!s->DS_ChunkSize || (s->DS_PacketSize/s->DS_ChunkSize <= 1))
  272. s->DS_Span = 0;
  273. }
  274. else
  275. if (memcmp(&StreamType, &p->GUID.VideoStream, sizeof(guid))==0)
  276. {
  277. int BitmapInfoSize;
  278. PacketFormatClear(&s->Stream.Format);
  279. s->Stream.Format.Type = PACKET_VIDEO;
  281. Reader->Skip(Reader,4+4+1); 
  282. BitmapInfoSize = Reader->ReadLE16(Reader);
  283. if (BitmapInfoSize > 40 || FormatSize<=40+4+4+1+2)
  284. FormatSize = BitmapInfoSize;
  285. else
  286. FormatSize -= 4+4+1+2;
  287. Reader->Skip(Reader,4); 
  289. s->Stream.Format.Format.Video.Width = Reader->ReadLE32(Reader);
  290. s->Stream.Format.Format.Video.Height = Reader->ReadLE32(Reader);
  291. Reader->ReadLE16(Reader); // planes
  292. s->Stream.Format.Format.Video.Pixel.BitCount = Reader->ReadLE16(Reader);
  293. s->Stream.Format.Format.Video.Pixel.FourCC = Reader->ReadLE32(Reader);
  294. s->Stream.Format.Format.Video.Aspect = ASPECT_ONE; //todo
  295. Reader->Skip(Reader,20); //SizeImage,XPelsPerMeter,YPelsPerMeter,ClrUsed,ClrImportant
  297. FormatSize -= 40;
  298. if (FormatSize > 0 && PacketFormatExtra(&s->Stream.Format,FormatSize))
  299. Reader->Read(Reader,s->Stream.Format.Extra,s->Stream.Format.ExtraLength);
  301. PacketFormatDefault(&s->Stream.Format);
  302. }
  304. if (!s->Stream.Format.ByteRate)
  305. for (BitRate=ARRAYBEGIN(p->Bitrate,int);BitRate!=ARRAYEND(p->Bitrate,int);BitRate+=2)
  306. if (BitRate[0] == s->Stream.Id)
  307. {
  308. s->Stream.Format.ByteRate = BitRate[1]/8;
  309. break;
  310. }
  312. Format_PrepairStream(&p->Format,&s->Stream);
  313. }
  315. static int ReadHeaderExt(asf* p,format_reader* Reader,int Size)
  316. {
  317. guid Id;
  318. filepos_t EndPos;
  319. filepos_t End = Reader->FilePos+Size;
  321.     while (Reader->FilePos<End)
  322. {
  323. if (Reader->Eof(Reader))
  324. return ERR_INVALID_DATA;
  326.         ReadGUID(Reader,&Id);
  328.         EndPos = (filepos_t)Reader->ReadLE64(Reader) - 24;
  329.         if (EndPos < 0)
  330. return ERR_INVALID_DATA;
  331. EndPos += Reader->FilePos;
  333. DEBUG_MSG6(DEBUG_FORMAT,T("ASFExt %08x %08x-%04x-%04x-%08x%08x"),Reader->FilePos,Id.v1,Id.v2,Id.v3,*(int32_t*)&Id.v4[0],*(int32_t*)&Id.v4[4]);
  335.         if (memcmp(&Id, &p->GUID.StreamHeaderExt, sizeof(guid))==0) 
  336. {
  337. int i,n,PayloadCount,NameCount;
  339. // skip extended information
  340. // we are only interested in StreamHeader at the end...
  342. Reader->Skip(Reader,8); // start time
  343. Reader->Skip(Reader,8); // end time
  344. Reader->Skip(Reader,4+4+4); // data bitrate, buffer size, initial buffer fullness
  345. Reader->Skip(Reader,4+4+4); // alternate data bitrate, buffer size, initial buffer fullness
  346. Reader->Skip(Reader,4+4); // maximum object size, flags
  347. Reader->Skip(Reader,2); // stream id
  348. Reader->Skip(Reader,2+8); // language id, avg time per frame
  349. NameCount = Reader->ReadLE16(Reader);
  350. PayloadCount = Reader->ReadLE16(Reader);
  352. for (i=0;i<NameCount;++i)
  353. {
  354. Reader->Skip(Reader,2); // lang id
  355. n = Reader->ReadLE16(Reader);
  356. Reader->Skip(Reader,n*2);
  357. }
  359. for (i=0;i<PayloadCount;++i)
  360. {
  361. Reader->Skip(Reader,16+2); // guid, data size
  362. n = Reader->ReadLE32(Reader);
  363. Reader->Skip(Reader,n);
  364. }
  366. if (EndPos>Reader->FilePos+16+8)
  367. {
  368.         ReadGUID(Reader,&Id);
  369. Reader->ReadLE64(Reader);
  370. if (memcmp(&Id, &p->GUID.StreamHeader, sizeof(guid))==0)
  371. ReadStreamHeader(p,Reader);
  372. }
  373. }
  375.         Reader->Seek(Reader,EndPos,SEEK_SET);
  376. }
  377. return ERR_NONE;
  378. }
  380. static int ReadHeader(asf* p,format_reader* Reader)
  381. {
  382. int i,Count;
  383. tchar_t Buf[256];
  384. guid Id;
  385. filepos_t EndPos;
  387. ReadGUID(Reader,&Id);
  388. if (memcmp(&Id, &p->GUID.ASFHeader, sizeof(guid))!=0)
  389. return ERR_INVALID_DATA;
  391. ArrayDrop(&p->Bitrate);
  393. Reader->Skip(Reader,8+4+1+1);
  394.     for (;;)
  395. {
  396. if (Reader->Eof(Reader))
  397. return ERR_INVALID_DATA;
  399.         ReadGUID(Reader,&Id);
  401.         EndPos = (filepos_t)Reader->ReadLE64(Reader) - 24;
  403. if (!memcmp(&Id, &p->GUID.DataHeader, sizeof(guid))) // allow invalid EndPos for this chunk
  404. {
  405. Reader->Skip(Reader,sizeof(guid)+8+2); // file id, total data packets, reserved
  406.             break;
  407.         } 
  409.         if (EndPos < 0)
  410. return ERR_INVALID_DATA;
  411. EndPos += Reader->FilePos;
  413. DEBUG_MSG6(DEBUG_FORMAT,T("ASF %08x %08x-%04x-%04x-%08x%08x"),Reader->FilePos,Id.v1,Id.v2,Id.v3,*(int32_t*)&Id.v4[0],*(int32_t*)&Id.v4[4]);
  415.         if (memcmp(&Id, &p->GUID.FileHeader, sizeof(guid))==0) 
  416. {
  417. int BitRate;
  418. Reader->Skip(Reader,sizeof(guid)+8+8);
  419. p->PacketCount = Reader->ReadLE64(Reader);
  420. p->PlayTime = Reader->ReadLE64(Reader);
  421. Reader->Skip(Reader,8); // send_time (sometimes not even valid)
  422. p->AdjustTime = 0;
  423. p->PreRoll = Reader->ReadLE32(Reader);
  424. Reader->Skip(Reader,4); // ignore
  425. p->Flags = Reader->ReadLE32(Reader);
  426. p->PacketMinSize = Reader->ReadLE32(Reader); // min packet size
  427. p->PacketMaxSize = Reader->ReadLE32(Reader); // max packet size
  428. BitRate = Reader->ReadLE32(Reader); // max bitrate
  429. if (BitRate > 0)
  430. p->Format.SumByteRate = BitRate/8;
  431. if (!(p->Flags & 1)) // not broadcast
  432. p->Format.Duration = (tick_t)(((p->PlayTime - (int64_t)p->PreRoll * 10000) * TICKSPERSEC) / 10000000);
  433. else
  434. {
  435. p->AdjustTime = 1;
  436. p->Format.Duration = -1;
  437. if (p->PacketMinSize <= 0)
  438. p->PacketMinSize = 0;
  439. if (p->PacketMaxSize <= 0)
  440. p->PacketMaxSize = 4*1024*1024;
  441. }
  442. p->AdjustTime0 = p->AdjustTime;
  443.         }
  444. else if (memcmp(&Id, &p->GUID.StreamHeader, sizeof(guid))==0)
  445. {
  446. ReadStreamHeader(p,Reader);
  447. }
  448. else if (!memcmp(&Id, &p->GUID.MarkerObject, sizeof(guid)) && p->Format.Comment.Node)
  449. {
  450. int Len;
  451. Reader->Skip(Reader,sizeof(guid)); // reserved
  452. Count = Reader->ReadLE32(Reader);
  453. Reader->Skip(Reader,2);   // reserved
  454. Len = Reader->ReadLE16(Reader);
  455. ReadStr(Reader,Len,Buf,TSIZEOF(Buf)); // marker name
  457. for (i=0;i<Count;++i)
  458. {
  459. int64_t Time;
  460. filepos_t EndPos;
  462. Reader->Skip(Reader,8); // position
  463. Time = Reader->ReadLE64(Reader);
  464. EndPos = Reader->ReadLE16(Reader);
  465. EndPos += Reader->FilePos;
  466. Reader->Skip(Reader,8); // send time, flags
  468. stprintf_s(Buf,TSIZEOF(Buf),T("CHAPTER%02dNAME="),i+1);
  469. Len = Reader->ReadLE32(Reader);
  470. ReadStr(Reader,Len*sizeof(uint16_t),Buf+tcslen(Buf),TSIZEOF(Buf)-tcslen(Buf));
  471. p->Format.Comment.Node->Set(p->Format.Comment.Node,p->Format.Comment.No,Buf,sizeof(Buf));
  473. BuildChapter(Buf,TSIZEOF(Buf),i+1,Time,10000);
  474. p->Format.Comment.Node->Set(p->Format.Comment.Node,p->Format.Comment.No,Buf,sizeof(Buf));
  476. Reader->Seek(Reader,EndPos,SEEK_SET);
  477. }
  478. }
  479. else if (!memcmp(&Id, &p->GUID.ExtendedComment, sizeof(guid)) && p->Format.Comment.Node)
  480. {
  481. int Type,Len;
  483. Count = Reader->ReadLE16(Reader);
  484. for (i=0;i<Count;++i)
  485. {
  486. Len = Reader->ReadLE16(Reader);
  487. ReadStr(Reader,Len,Buf,TSIZEOF(Buf));
  488. Type = Reader->ReadLE16(Reader);
  489. Len = Reader->ReadLE16(Reader);
  490. if (Type == 0)
  491. {
  492. tcsupr(Buf);
  493. tcscat_s(Buf,TSIZEOF(Buf),T("="));
  494. ReadStr(Reader,Len,Buf+tcslen(Buf),TSIZEOF(Buf)-tcslen(Buf));
  495. p->Format.Comment.Node->Set(p->Format.Comment.Node,p->Format.Comment.No,Buf,sizeof(Buf));
  496. }
  497. else
  498. Reader->Skip(Reader,Len);
  499. }
  500. }
  501. else if (!memcmp(&Id, &p->GUID.HeadExt, sizeof(guid)))
  502. {
  503.         ReadGUID(Reader,&Id);
  504. if (!memcmp(&Id, &p->GUID.Head2, sizeof(guid)))
  505. {
  506. int Result;
  507. Reader->Skip(Reader,2);
  508. Result = ReadHeaderExt(p,Reader,Reader->ReadLE32(Reader));
  509. if (Result != ERR_NONE)
  510. return Result;
  511. }
  512. }
  513. else if (!memcmp(&Id, &p->GUID.StreamBitrate, sizeof(guid)))
  514. {
  515. int Len = Reader->ReadLE16(Reader);
  516. ArrayAppend(&p->Bitrate,NULL,Len*2*sizeof(int),32);
  517. for (i=0;i<Len;++i)
  518. {
  519. int No,Id,BitRate;
  520. ARRAYBEGIN(p->Bitrate,int)[i*2] = Id = Reader->ReadLE16(Reader);
  521. ARRAYBEGIN(p->Bitrate,int)[i*2+1] = BitRate = Reader->ReadLE32(Reader);
  523. for (No=0;No<p->Format.StreamCount;++No)
  524. {
  525. format_stream* Stream = p->Format.Streams[No];
  526. if (Stream->Id == Id && !Stream->Format.ByteRate)
  527. Stream->Format.ByteRate = BitRate/8;
  528. }
  529. }
  530. }
  531. else if (!memcmp(&Id, &p->GUID.CommentHeader, sizeof(guid)) && p->Format.Comment.Node) 
  532. {
  533. static const tchar_t* const Comment[5] = { T("TITLE="), T("AUTHOR="), T("COPYRIGHT="), T("COMMENT="), T("RATING=") };
  534.             int Len[5];
  536. for (i=0;i<5;++i) 
  537. Len[i] = Reader->ReadLE16(Reader);
  539. for (i=0;i<5;++i)
  540. if (Len[i])
  541. {
  542. tcscpy_s(Buf,TSIZEOF(Buf),Comment[i]);
  543. ReadStr(Reader,Len[i],Buf+tcslen(Buf),TSIZEOF(Buf)-tcslen(Buf));
  544. if (tcslen(Buf) != tcslen(Comment[i]))
  545. p->Format.Comment.Node->Set(p->Format.Comment.Node,p->Format.Comment.No,Buf,sizeof(Buf));
  546. }
  547. }
  549.         Reader->Seek(Reader,EndPos,SEEK_SET);
  550.     }
  552. return ERR_NONE;
  553. }
  555. static int Init(asf* p)
  556. {
  557. format_reader* Reader = p->Format.Reader;
  558. int Result;
  560. Result = ReadHeader(p,Reader);
  561. if (Result != ERR_NONE)
  562. return Result;
  563.  
  564. AfterSeek(p);
  566. p->StreamingTime = -1;
  567. p->Format.TimeStamps = 1;
  568. p->Format.HeaderLoaded = 1;
  569. p->Format.SeekByPacket_DataStart = Reader->FilePos;
  570. if (p->PacketMaxSize == p->PacketMinSize)
  571. p->Format.SeekByPacket_BlockAlign = p->PacketMaxSize;
  573. return Result;
  574. }
  576. static void Done(asf* p)
  577. {
  578. ArrayClear(&p->Bitrate);
  579. }
  581. static int NOINLINE ReadValue(asf* p, format_reader* Reader,int Bits,int Default)
  582. {
  583. switch (Bits & 3)
  584. {
  585. default:
  586. case 0: return Default;
  587. case 1: return Reader->Read8(Reader);
  588. case 2: return Reader->ReadLE16(Reader);
  589. case 3: return Reader->ReadLE32(Reader);
  590. }
  591. }
  593. static bool_t ReadPacketHead(asf* p, format_reader* Reader,filepos_t End)
  594. {
  595. filepos_t pos;
  596. int len,time,padding;
  597. int i;
  599. pos = Reader->FilePos;
  600. if (p->PacketMinSize>0 && p->PacketMaxSize==p->PacketMinSize)
  601. {
  602. p->State.End = pos + p->PacketMinSize;
  603. p->State.Padding = 0;
  605. }
  607. i = Reader->Read8(Reader);
  608. if (i<0)
  609. return 0;
  611. if (i & 0x80)
  612. {
  613. // no real error correction supported
  614. if (i != 0x82 && i != 0x90)
  615. return 1;
  617. Reader->Skip(Reader,i & 15);
  619. i = Reader->Read8(Reader);
  620. }
  622. p->State.Multiple = i & 1;
  623.     p->State.ValueLength = Reader->Read8(Reader);
  625. len = ReadValue(p,Reader,i>>5,p->PacketMaxSize);
  626. if (len<8 || len>p->PacketMaxSize)
  627. return 1;
  629.     ReadValue(p,Reader,i>>1,0); // sequence
  630. padding = ReadValue(p,Reader,i>>3,0);
  631. if (padding<0 || padding>=p->PacketMaxSize) 
  632. return 1;
  634.     time = Reader->ReadLE32(Reader); // send time (milliseconds)
  635. if (p->StreamingTime >= 0)
  636. {
  637. if (!p->AdjustTime)
  638. {
  639. // orb server uses global time as timestamp, have to adjust it (but there is duration)
  640. p->Format.GlobalOffset = p->StreamingTime - Scale(time,TICKSPERSEC,1000);
  641. p->Format.TimeStamps = 0;
  642. }
  643. p->StreamingTime = -1;
  644. }
  646.     Reader->Skip(Reader,2); // duration (milliseconds)
  648.     if (p->State.Multiple)
  649. {
  650. i = Reader->Read8(Reader);
  651. p->State.PayloadCount = i&63;
  652. p->State.ValueLength |= i<<8;
  653.     } 
  654. else 
  655. p->State.PayloadCount = 1;
  657. pos += len - padding;
  658. if (pos <= Reader->FilePos)
  659. {
  660. p->State.PayloadCount = 0;
  661. return 1;
  662. }
  664. assert(pos-Reader->FilePos<0x10000000);
  666.     if (len < p->PacketMinSize)
  667.         padding += p->PacketMinSize - len;
  669. p->State.End = pos;
  670.     p->State.Padding = padding;
  672. if (p->HTTPRef) // adjust padding to remaining http packet length
  673. {
  674. p->State.Padding = Reader->ReadLen + p->HTTPChunkLeft - Reader->ReadPos - (pos - Reader->FilePos);
  675. if (p->State.Padding < 0)
  676. {
  677. p->State.End += p->State.Padding;
  678. p->State.Padding = 0;
  679. }
  680. }
  682. // DEBUG_MSG3(-1,T("asf %08x %d count:%d"),p->State.End,p->State.Padding,p->State.PayloadCount);
  683. return 1;
  684. }
  686. static bool_t ReadPayload(asf* p,format_reader* Reader)
  687. {
  688. int n,v = Reader->Read8(Reader); // stream number + keyframe bit
  689. if (v<0)
  690. {
  691. p->State.PayloadCount = 0;
  692. return 0;
  693. }
  695. p->State.Stream = NULL;
  696. p->State.Key = v>>7;
  697. v &= 0x7F;
  699. for (n=0;n<p->Format.StreamCount;++n)
  700. if (p->Format.Streams[n]->Id == v)
  701. {
  702. p->State.Stream = (asfstream*) p->Format.Streams[n];
  703. break;
  704. }
  706. ReadValue(p,Reader,p->State.ValueLength>>4,0); // sequence
  707. v = ReadValue(p,Reader,p->State.ValueLength>>2,0);
  708. n = ReadValue(p,Reader,p->State.ValueLength,0); // replicated data length
  710. p->State.Compressed = n==1;
  711. if (p->State.Compressed)
  712. {
  713. p->State.CompressedTime = p->State.PayloadTime = v;
  714. p->State.CompressedDelta = Reader->Read8(Reader);
  715. p->State.PayloadOffset = 0;
  716. }
  717. else 
  718. {
  719. p->State.PayloadOffset = v;
  720. if (n>1)
  721. {
  722. if (n<8)
  723. {
  724. p->State.PayloadCount = 0;
  725. return 1;
  726. }
  727. if (p->State.Stream)
  728. {
  729. p->State.Stream->State.Size = Reader->ReadLE32(Reader);
  730. p->State.PayloadTime = Reader->ReadLE32(Reader);
  731. n -= 8;
  732. }
  733. Reader->Skip(Reader,n);
  734. }
  735. }
  737. if (p->AdjustTime)
  738. {
  739. p->AdjustTime = 0;
  740. for (n=0;n<p->Format.StreamCount;++n)
  741. ((asfstream*)p->Format.Streams[n])->TimeOffset = -p->State.PayloadTime;
  742. }
  744. if (p->State.Multiple)
  745. {
  746. p->State.PayloadEnd = ReadValue(p,Reader,p->State.ValueLength>>14,0);
  747. p->State.PayloadEnd += Reader->FilePos;
  748. if (p->State.PayloadEnd > p->State.End)
  749. {
  750. p->State.PayloadCount = 0;
  751. p->State.PayloadEnd = -1;
  752. return 1;
  753. }
  754. }
  755. else
  756. p->State.PayloadEnd = p->State.End;
  758. if (!p->State.Stream)
  759. {
  760. Reader->Skip(Reader,p->State.PayloadEnd - Reader->FilePos);
  761. p->State.PayloadEnd = -1;
  762. --p->State.PayloadCount;
  763. }
  764. return 1;
  765. }
  767. static int ReadPacket(asf* p, format_reader* Reader, format_packet* Packet)
  768. {
  769. filepos_t End = Reader->FilePos+BLOCKSIZE;
  770. for (;;)
  771. {
  772. if (p->State.PayloadCount<=0)
  773. {
  774. if (Reader->FilePos >= End)
  775. break;
  777. if (p->State.End >= 0)
  778. {
  779. Reader->Skip(Reader,p->State.End+p->State.Padding-Reader->FilePos);
  780. p->State.End = -1;
  781. }
  783. if (!ReadPacketHead(p,Reader,End))
  784. break;
  785. }
  786. else 
  787. if (p->State.PayloadEnd<0)
  788. {
  789. if (!ReadPayload(p,Reader))
  790. break;
  791. }
  792. else
  793. {
  794. int Size = p->State.PayloadEnd - Reader->FilePos;
  795. if (Size<=0)
  796. {
  797. p->State.PayloadEnd = -1;
  798. --p->State.PayloadCount;
  799. }
  800. else
  801. {
  802. asfstream* s = p->State.Stream;
  803. if (p->State.Compressed)
  804. {
  805. s->State.Size = Reader->Read8(Reader);
  806. if (s->State.Size > Size)
  807. {
  808. Reader->Skip(Reader,Size);
  809. continue;
  810. }
  811. Size = s->State.Size;
  812. p->State.PayloadTime = p->State.CompressedTime;
  813. p->State.CompressedTime += p->State.CompressedDelta;
  814. }
  816. if (s->State.Offset != p->State.PayloadOffset) // gap in offset
  817. {
  818. ReleaseStream(p,s);
  819. if (p->State.PayloadOffset)
  820. {
  821. Reader->Skip(Reader,Size);
  822. continue;
  823. }
  824. }
  826. if (s->State.Offset==0) // start of a new packet
  827. {
  828. s->State.RefTime = Scale(p->State.PayloadTime + s->TimeOffset,TICKSPERSEC,1000);
  829. if (s->State.RefTime < 0)
  830. s->State.RefTime = 0;
  831. }
  833. *s->State.Tail = Reader->ReadAsRef(Reader,Size);
  834. while (*s->State.Tail)
  835. s->State.Tail = &(*s->State.Tail)->Next;
  837. s->State.Offset += Size;
  838. if (s->State.Offset >= s->State.Size) 
  839. {
  840. Packet->Key = p->State.Key;
  841. Packet->Data = s->State.Ref;
  842. Packet->RefTime = s->State.RefTime;
  843. Packet->Stream = &s->Stream;
  845. if (s->DS_Span > 1) 
  846. {
  847. format_ref* New = NULL;
  848. format_ref** Ptr = &New;
  850. int Left = s->State.Size;
  851. int Row = 0;
  852. int Col = 0;
  853. while (Left>0) 
  854. {
  855. int Idx = Row+Col*s->DS_Span;
  857. *Ptr = Format_DupRef(&p->Format,Packet->Data,Idx * s->DS_ChunkSize, s->DS_ChunkSize );
  858. while (*Ptr)
  859. Ptr = &(*Ptr)->Next;
  861. Left -= s->DS_ChunkSize;
  862. Col++;
  863. if (Col == s->DS_Span)
  864. {
  865. Col = 0;
  866. Row++;
  867. }
  868. }
  870. Format_ReleaseRef(&p->Format,Packet->Data);
  871. Packet->Data = New;
  872. }
  874. s->State.Size = 0;
  875. s->State.Offset = 0;
  876. s->State.Ref = NULL;
  877. s->State.Tail = &s->State.Ref;
  878. return ERR_NONE;
  879. }
  880. }
  881. }
  882. }
  884. return ERR_DATA_NOT_FOUND;
  885. }
  887. static int Seek(asf* p,tick_t Time,filepos_t FilePos,bool_t PrevKey)
  888. {
  889. return Format_SeekByPacket(&p->Format,Time,FilePos,PrevKey);
  890. }
  892. #ifdef DUMPASF
  893. static FILE* Dump = NULL;
  894. #endif
  896. static bool_t GetHTTPBuffer(format_reader* HTTPReader)
  897. {
  898. int n,Ofs = 0;
  899. asf* p = ((asf*)((char*)(HTTPReader)-(int)&(((asf*)0)->HTTPReader)));
  900. format_reader* Reader = p->Format.Reader;
  902. for (n=0;n<16;++n) // maximum chunk tries
  903. {
  904. if (p->HTTPRef)
  905. {
  906. Format_ReleaseRef(&p->Format,p->HTTPRef);
  907. p->HTTPRef = NULL;
  908. HTTPReader->ReadBuffer = NULL;
  909. Ofs = HTTPReader->ReadPos - HTTPReader->ReadLen;
  910. HTTPReader->ReadLen = 0;
  911. }
  913. if (p->HTTPChunkLeft > 0)
  914. {
  915. p->HTTPRef = Reader->ReadAsRef(Reader,-p->HTTPChunkLeft);
  916. if (!p->HTTPRef)
  917. {
  918. HTTPReader->NoMoreInput = Reader->Eof(Reader);
  919. break;
  920. }
  921. else
  922. {
  923. HTTPReader->ReadBuffer = p->HTTPRef->Buffer;
  924. HTTPReader->ReadPos = p->HTTPRef->Begin + Ofs;
  925. HTTPReader->ReadLen = p->HTTPRef->Begin + p->HTTPRef->Length;
  926. p->HTTPChunkLeft -= p->HTTPRef->Length;
  928. #ifdef DUMPASF
  929. if (Dump)
  930. fwrite(HTTPReader->ReadBuffer->Block.Ptr+HTTPReader->ReadPos,1,HTTPReader->ReadLen-HTTPReader->ReadPos,Dump);
  931. #endif
  932. break;
  933. }
  934. }
  935. else
  936. {
  937. int Type,Len;
  939. Type = Reader->ReadLE16(Reader);
  940. Len = Reader->ReadLE16(Reader)-8;
  941. Reader->Skip(Reader,8);
  943. if ((Type & ASF_CHUNK_MASK) != p->HTTPChunkFilter)
  944. {
  945. if (Type == ASF_CHUNK_END && Len<0)
  946. Len += 8;
  948. HTTPReader->NoMoreInput = Reader->Eof(Reader);
  949. if (HTTPReader->NoMoreInput)
  950. break;
  952. if (Len >= 0)
  953. {
  954. #if 0 //def DUMPASF
  955. if (Dump)
  956. {
  957. void* i = malloc(Len);
  958. Reader->Read(Reader,i,Len);
  959. fwrite(i,1,Len,Dump);
  960. free(i);
  961. }
  962. else
  963. #endif
  965. Reader->Skip(Reader,Len);
  966. }
  967. }
  968. else
  969. p->HTTPChunkLeft = Len;
  970. }
  971. }
  973. return HTTPReader->ReadBuffer != NULL;
  974. }
  976. static void AfterSeekHTTP(asf* p)
  977. {
  978. AfterSeek(p);
  980. Format_ReleaseRef(&p->Format,p->HTTPRef);
  981. p->HTTPRef = NULL;
  982. p->HTTPChunkLeft = 0;
  983. p->HTTPReader.NoMoreInput = 0;
  984. p->HTTPReader.FilePos = 0;
  985. p->HTTPReader.ReadPos = 0;
  986. p->HTTPReader.ReadLen = 0;
  987. p->HTTPReader.ReadBuffer = NULL;
  988. }
  990. static int SetPragma(asf* p,tick_t Time)
  991. {
  992. int i;
  993. tchar_t Pragma[512];
  995. if (p->Format.StreamCount &&
  996. p->Format.Reader[0].Input->Get(p->Format.Reader[0].Input,STREAM_PRAGMA_GET,Pragma,sizeof(Pragma)) == ERR_NONE &&
  997. tcslen(Pragma)>0)
  998. {
  999. bool_t First=1;
  1000. int Count=0;
  1001. p->StreamingTime = Time;
  1003. for (i=0;i<p->Format.StreamCount;++i)
  1004. if (p->Format.Streams[i]->Pin.Node)
  1005. ++Count;
  1007. stprintf_s(Pragma,TSIZEOF(Pragma),
  1008. T("Pragma: no-cache,rate=1.000000,stream-time=%d,stream-offset=4294967295:4294967295,")
  1009. T("request-context=2,max-duration=0,")
  1010. T("xPlayStrm=1,")
  1011. T("xClientGUID={3300AD50-2C39-46c0-AE0A-132C%08X},")
  1012. T("stream-switch-count=%d,")
  1013. T("stream-switch-entry=")
  1014. ,Scale(Time,1000,TICKSPERSEC),p->ClientId,Count);
  1016. for (i=0;i<p->Format.StreamCount;++i)
  1017. if (p->Format.Streams[i]->Pin.Node)
  1018. {
  1019. if (!First) tcscat_s(Pragma,TSIZEOF(Pragma),T(" ")); else First=0;
  1020. stcatprintf_s(Pragma,TSIZEOF(Pragma),T("ffff:%d:0"),p->Format.Streams[i]->Id);
  1021. }
  1023. tcscat_s(Pragma,TSIZEOF(Pragma),T("n"));
  1025. if (p->Format.Reader[0].Input->Set(p->Format.Reader[0].Input,STREAM_PRAGMA_SEND,Pragma,sizeof(Pragma)) == ERR_NONE)
  1026. {
  1027. int Result = Format_SeekForce(&p->Format,0,SEEK_SET); //reopen (because of seeking)
  1028. if (Result == ERR_NONE)
  1029. p->AdjustTime = p->AdjustTime0;
  1030. return Result;
  1031. }
  1032. }
  1034. return ERR_NOT_SUPPORTED;
  1035. }
  1037. static int InitHTTP(asf* p)
  1038. {
  1039. int Result;
  1041. p->StreamingTime = 0;
  1042. p->HTTPRef = NULL;
  1044. memcpy(&p->HTTPReader,p->Format.Reader,sizeof(p->HTTPReader));
  1045. p->HTTPReader.BufferAvailable = 0;
  1046. p->HTTPReader.BufferFirst = NULL;
  1047. p->HTTPReader.BufferLast = NULL;
  1048. p->HTTPReader.Input = NULL;
  1049. p->HTTPReader.InputBuffer = NULL;
  1050. p->HTTPReader.GetReadBuffer = GetHTTPBuffer;
  1052. AfterSeekHTTP(p);
  1053. p->HTTPChunkFilter = ASF_CHUNK_HEADER;
  1055. Result = ReadHeader(p,&p->HTTPReader);
  1056. if (Result != ERR_NONE)
  1057. return Result;
  1058.  
  1059. AfterSeekHTTP(p);
  1060. p->HTTPChunkFilter = ASF_CHUNK_DATA;
  1061. p->PacketMinSize = 0; // it's possible packets are not padded to MinSize
  1063. p->ClientId = (rand() << 16) | rand();
  1064. p->Format.HeaderLoaded = 1;
  1065. p->Format.ReadSize = 4096;
  1067. if (!GetHTTPBuffer(&p->HTTPReader) && p->HTTPReader.Eof(&p->HTTPReader))
  1068. Result = SetPragma(p,0); // try reopen http stream with proper pragma
  1070. #ifdef DUMPASF
  1071. Dump = fopen("\dumpasf.asf","wb+");
  1072. #endif
  1074. return Result;
  1075. }
  1077. static void DoneHTTP(asf* p)
  1078. {
  1079. #ifdef DUMPASF
  1080. if (Dump)
  1081. {
  1082. fclose(Dump);
  1083. Dump = NULL;
  1084. }
  1085. #endif
  1086. Format_ReleaseRef(&p->Format,p->HTTPRef);
  1087. Done(p);
  1088. }
  1090. static int SetHTTP(asf* p,int No,const void* Data,int Size)
  1091. {
  1092. int Result = FormatBaseSet(&p->Format,No,Data,Size);
  1094. if (No==FORMAT_UPDATEMASK && Size==sizeof(tick_t))
  1095. SetPragma(p,*(tick_t*)Data);
  1097. return Result;
  1098. }
  1100. static int SeekHTTP(asf* p,tick_t Time,filepos_t FilePos,bool_t PrevKey)
  1101. {
  1102. if (Time < 0)
  1103. return ERR_NOT_SUPPORTED;
  1104. return SetPragma(p,Time);
  1105. }
  1107. static int ReadPacketHTTP(asf* p, format_reader* Reader, format_packet* Packet)
  1108. {
  1109. return ReadPacket(p,&p->HTTPReader,Packet);
  1110. }
  1112. static int Create(asf* p)
  1113. {
  1114. p->GUID = ASFGUID;
  1115. p->Format.Init = (fmtfunc)Init;
  1116. p->Format.Done = (fmtvoid)Done;
  1117. p->Format.Seek = (fmtseek)Seek;
  1118. p->Format.ReadPacket = (fmtreadpacket)ReadPacket;
  1119. p->Format.ReleaseStream = (fmtstream)ReleaseStream;
  1120. p->Format.AfterSeek = (fmtvoid)AfterSeek;
  1121. p->Format.BackupPacketState = (fmtbackup)BackupPacketState;
  1122. return ERR_NONE;
  1123. }
  1125. static int CreateHTTP(asf* p)
  1126. {
  1127. p->GUID = ASFGUID;
  1128. p->Format.Init = (fmtfunc)InitHTTP;
  1129. p->Format.Done = (fmtvoid)DoneHTTP;
  1130. p->Format.Seek = (fmtseek)SeekHTTP;
  1131. p->Format.ReadPacket = (fmtreadpacket)ReadPacketHTTP;
  1132. p->Format.AfterSeek = (fmtvoid)AfterSeekHTTP;
  1133. p->Format.Format.Set = (nodeset)SetHTTP;
  1134. return ERR_NONE;
  1135. }
  1137. static const nodedef ASF = 
  1138. {
  1139. sizeof(asf),
  1140. ASF_ID,
  1141. FORMATBASE_CLASS,
  1142. PRI_DEFAULT-1, // prefer WMVF and WMAF (just for the reader name)
  1143. (nodecreate)Create,
  1144. };
  1146. static const nodedef ASFHTTP = 
  1147. {
  1148. 0, // parent size
  1149. ASF_HTTP_ID,
  1150. ASF_ID,
  1151. PRI_DEFAULT,
  1152. (nodecreate)CreateHTTP,
  1153. NULL,
  1154. };
  1156. void ASF_Init()
  1157. {
  1158. NodeRegisterClass(&ASF);
  1159. NodeRegisterClass(&ASFHTTP);
  1160. }
  1162. void ASF_Done()
  1163. {
  1164. NodeUnRegisterClass(ASF_ID);
  1165. NodeUnRegisterClass(ASF_HTTP_ID);
  1166. }