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

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

Windows CE

开发平台：

C/C++

nsv.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.  * $Id: nsv.c 551 2006-01-09 11:55:09Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "nsv.h"
  27. typedef struct nsvstream
  28. {
  29. format_stream Stream;
  30. uint32_t FourCC;
  31. filepos_t FirstPos;
  33. } nsvstream;
  35. typedef struct nsv_t
  36. {
  37. format_base Format;
  38. filepos_t Head;
  39. tick_t FirstTime;
  40. tick_t AVSync;
  41. int AVSyncFrame;
  42. bool_t NeedSync;
  43. uint32_t State;
  45. uint32_t AudioFourCC;
  46. uint32_t VideoFourCC;
  47. int VideoWidth;
  48. int VideoHeight;
  49. fraction VideoRate;
  51. int AuxCount;
  52. int AuxSize;
  53. int AudioSize;
  55. int64_t FrameState;
  56. int Frame;
  57. bool_t FrameValid;
  59. } nsv;
  61. static void Invalid(nsv* p)
  62. {
  63. p->AVSyncFrame = -1;
  64. p->State = 0;
  65. p->AuxCount = 0;
  66. p->AuxSize = 0;
  67. p->AudioSize = 0;
  68. }
  70. static int Init(nsv* p)
  71. {
  72. int i;
  73. format_reader* Reader = p->Format.Reader;
  74. p->Head = 0;
  75. Invalid(p);
  77. for (i=0;i<4;++i)
  78. p->State = (p->State << 8) | Reader->Read8(Reader);
  80. if (p->State == FOURCCBE('N','S','V','f'))
  81. {
  82. uint32_t MetaSize;
  83. uint32_t Duration;
  84. p->Head = Reader->FilePos - 4;
  85. p->Head += Reader->ReadLE32(Reader);
  87. Reader->Skip(Reader,4);
  88. Duration = Reader->ReadLE32(Reader);
  89. if (Duration != (uint32_t)-1)
  90. p->Format.Duration = Scale(Duration,TICKSPERSEC,1000);
  92. MetaSize = Reader->ReadLE32(Reader);
  93. Reader->Skip(Reader,8);
  95. //parse metadata...
  97. Reader->Seek(Reader,p->Head,SEEK_SET);
  98. }
  100. p->Frame = 0;
  101. p->FrameValid = 0;
  102. p->FrameState = 0;
  103. p->AVSyncFrame = -1;
  104. p->NeedSync = 1;
  105. p->FirstTime = 1; // but don't want to return 0
  106. return ERR_NONE;
  107. }
  109. static INLINE bool_t AVCStartSlice(int code,int data)
  110. {
  111. return 0;
  112. }
  114. #define AVC_NAL_SLICE 1
  115. #define AVC_NAL_IDR_SLICE 5
  117. static void CountFrame(nsv* p, const uint8_t* Data, int Len)
  118. {
  119. int i;
  120. int32_t code;
  121. int64_t v = p->FrameState;
  122. switch (p->VideoFourCC)
  123. {
  124. case FOURCC('H','2','6','4'):
  125. for (i=0;i<Len;++i)
  126. {
  127. v = (v<<8) | Data[i];
  128. code = (int32_t)(v>>8) & ~0xE0;
  129. if ((code == 0x100+AVC_NAL_SLICE || code == 0x100+AVC_NAL_IDR_SLICE) && (v & 0x80)==0x80) // bitgolomb()=0 -> slice_pos=0
  130. ++p->Frame;
  131. }
  132. p->FrameValid = 1;
  133. break;
  134. }
  135. p->FrameState = v;
  136. }
  138. static void ReadData(nsv* p, format_reader* Reader, format_packet* Packet, uint32_t FourCC, int Size, int Mode)
  139. {
  140. nsvstream* s = NULL;
  141. int n;
  143. if (FourCC == FOURCC('N','O','N','E') || !FourCC || p->NeedSync)
  144. {
  145. Reader->Skip(Reader,Size);
  146. return;
  147. }
  149. for (n=0;n<p->Format.StreamCount;++n)
  150. {
  151. s = (nsvstream*)p->Format.Streams[n];
  152. if (s->FourCC == FourCC)
  153. break;
  154. }
  155. if (n==p->Format.StreamCount)
  156. {
  157. packetformat Format;
  158. memset(&Format,0,sizeof(Format));
  159. Format.Type = PACKET_NONE;
  161. switch (Mode)
  162. {
  163. case 0:
  164. Format.Type = PACKET_VIDEO;
  165. Format.Format.Video.Width = p->VideoWidth;
  166. Format.Format.Video.Height = p->VideoHeight;
  167. Format.Format.Video.Pixel.Flags = PF_FOURCC | PF_FRAGMENTED;
  168. Format.Format.Video.Pixel.FourCC = UpperFourCC(FourCC);
  169. Format.PacketRate = p->VideoRate;
  170. break;
  172. case 1:
  173. switch (FourCC)
  174. {
  175. case FOURCC('M','P','3',' '):
  176. Format.Type = PACKET_AUDIO;
  177. Format.Format.Audio.Format = AUDIOFMT_MP3;
  178. break;
  180. case FOURCC('A','A','C','P'):
  181. case FOURCC('A','A','C',' '):
  182. Format.Type = PACKET_AUDIO;
  183. Format.Format.Audio.Format = AUDIOFMT_AAC;
  184. break;
  186. case FOURCC('S','P','X',' '):
  187. Format.Type = PACKET_AUDIO;
  188. Format.Format.Audio.Format = AUDIOFMT_SPEEX;
  189. break;
  190. }
  191. break;
  193. case 2:
  194. break;
  196. }
  198. if (Format.Type == PACKET_NONE || (s = (nsvstream*)Format_AddStream(&p->Format,sizeof(nsvstream)))==NULL)
  199. {
  200. Reader->Skip(Reader,Size);
  201. return;
  202. }
  204. s->FourCC = FourCC;
  205. PacketFormatCopy(&s->Stream.Format,&Format);
  206. s->Stream.Fragmented = 1;
  207. s->Stream.DisableDrop = Format.Type = PACKET_AUDIO;
  208. s->FirstPos = -1;
  210. Format_PrepairStream(&p->Format,&s->Stream);
  211. }
  213. if (s->FirstPos<0)
  214. s->FirstPos = Reader->FilePos;
  216. if (p->FrameValid && Mode==0)
  217. Packet->RefTime = p->FirstTime + Scale(p->Frame,TICKSPERSEC*p->VideoRate.Den,p->VideoRate.Num);
  218. else
  219. if (p->FrameValid && Mode==1 && p->AVSyncFrame>=0)
  220. {
  221. Packet->RefTime = p->FirstTime + p->AVSync + Scale(p->AVSyncFrame,TICKSPERSEC*p->VideoRate.Den,p->VideoRate.Num);
  222. p->AVSyncFrame = -1;
  223. }
  224. else
  225. if (Reader->FilePos <= s->FirstPos)
  226. Packet->RefTime = p->FirstTime;
  227. else
  228. Packet->RefTime = TIME_UNKNOWN;
  230. Packet->Data = Reader->ReadAsRef(Reader,Size);
  231. Packet->Stream = &s->Stream;
  232. if (s->Stream.LastTime < TIME_UNKNOWN)
  233. s->Stream.LastTime = TIME_UNKNOWN;
  235. if (Mode==0)
  236. {
  237. format_ref* Ref;
  238. for (Ref=Packet->Data;Ref;Ref=Ref->Next)
  239. CountFrame(p,Ref->Buffer->Block.Ptr + Ref->Begin, Ref->Length);
  240. }
  241. }
  243. static void ReadPayload(nsv* p, format_reader* Reader)
  244. {
  245. int AuxCount = Reader->Read8(Reader);
  246. p->AuxSize = (Reader->ReadLE16(Reader) << 4) + (AuxCount >> 4);
  247. p->AuxCount = AuxCount & 15;
  248. p->AudioSize = Reader->ReadLE16(Reader);
  249. p->State = 0;
  250. if (p->AuxSize > 32768 || p->AuxSize > 0x80000 + p->AuxCount * (0x8000+6))
  251. Invalid(p);
  252. }
  254. static int ReadPacket(nsv* p, format_reader* Reader, format_packet* Packet)
  255. {
  256. filepos_t End = Reader->FilePos + BLOCKSIZE;
  257. while (Reader->FilePos<End)
  258. {
  259. if (p->AuxCount>0)
  260. {
  261. int Size = Reader->ReadLE16(Reader);
  262. if (Size > 32768)
  263. Invalid(p);
  264. else
  265. {
  266. uint32_t FourCC = Reader->ReadLE32(Reader);
  267. ReadData(p,Reader,Packet,FourCC,Size,2);
  268. p->AuxSize -= 6-Size;
  269. --p->AuxCount;
  270. return ERR_NONE;
  271. }
  272. }
  273. else
  274. if (p->AuxSize>0)
  275. {
  276. ReadData(p,Reader,Packet,p->VideoFourCC,p->AuxSize,0);
  277. p->AuxSize = 0;
  278. return ERR_NONE;
  279. }
  280. else
  281. if (p->AudioSize>0)
  282. {
  283. ReadData(p,Reader,Packet,p->AudioFourCC,p->AudioSize,1);
  284. p->AudioSize = 0;
  285. return ERR_NONE;
  286. }
  287. else
  288. if (p->State == FOURCCBE('N','S','V','s'))
  289. {
  290. int FrameRate;
  291. p->VideoFourCC = Reader->ReadLE32(Reader);
  292. p->AudioFourCC = Reader->ReadLE32(Reader);
  293. p->VideoWidth = Reader->ReadLE16(Reader);
  294. p->VideoHeight = Reader->ReadLE16(Reader);
  296. FrameRate = Reader->Read8(Reader);
  297. p->VideoRate.Num = FrameRate;
  298. p->VideoRate.Den = 1;
  299. if (FrameRate & 128)
  300. {
  301. int t = (FrameRate & 127) >> 2;
  302. if (t<16)
  303. {
  304. p->VideoRate.Num = 1;
  305. p->VideoRate.Den = t+1;
  306. }
  307. else
  308. {
  309. p->VideoRate.Num = t-15;
  310. p->VideoRate.Den = 1;
  311. }
  313. switch (FrameRate & 3)
  314. {
  315. case 0:
  316. p->VideoRate.Num *= 30;
  317. break;
  318. case 1:
  319. p->VideoRate.Num *= 30*1000;
  320. p->VideoRate.Den *= 1001;
  321. break;
  322. case 2:
  323. p->VideoRate.Num *= 25;
  324. break;
  325. case 3:
  326. p->VideoRate.Num *= 24*1000;
  327. p->VideoRate.Den *= 1001;
  328. break;
  329. }
  330. }
  332. p->AVSync = Scale((int16_t)Reader->ReadLE16(Reader),TICKSPERSEC,1000);
  333. p->AVSyncFrame = p->Frame;
  335. ReadPayload(p,Reader);
  336. if (p->NeedSync && (p->AuxSize || p->AudioSize))
  337. p->NeedSync = 0;
  338. }
  339. else
  340. if ((p->State & 0xFFFF) == 0xEFBE)
  341. ReadPayload(p,Reader);
  342. else
  343. {
  344. int ch = Reader->Read8(Reader);
  345. if (ch<0)
  346. {
  347. if (Reader->Eof(Reader))
  348. return ERR_END_OF_FILE;
  349. break;
  350. }
  351. p->State = (p->State << 8) + ch;
  352. }
  353. }
  354. return ERR_DATA_NOT_FOUND;
  355. }
  357. static int Seek(nsv* p, tick_t Time, filepos_t FilePos,bool_t PrevKey)
  358. {
  359. int i;
  360. if (FilePos < 0)
  361. {
  362. if (Time>0)
  363. {
  364. if (p->Format.Duration>=0 && p->Format.FileSize>=p->Head)
  365. FilePos = p->Head + Scale(Time,p->Format.FileSize-p->Head,p->Format.Duration);
  366. else
  367. return ERR_NOT_SUPPORTED;
  368. }
  369. else
  370. FilePos = p->Head;
  371. }
  373. Invalid(p);
  374. p->NeedSync = 1;
  375. p->Frame = 0;
  376. p->FrameValid = 0;
  377. p->FrameState = 0;
  378. p->FirstTime = Time>0?Time:TIME_UNKNOWN;
  379. for (i=0;i<p->Format.StreamCount;++i)
  380. ((nsvstream*)p->Format.Streams[i])->FirstPos = -1;
  382. return Format_Seek(&p->Format,FilePos,SEEK_SET);
  383. }
  385. static int Create(nsv* p)
  386. {
  387. p->Format.Init = (fmtfunc)Init;
  388. p->Format.Seek = (fmtseek)Seek;
  389. p->Format.ReadPacket = (fmtreadpacket)ReadPacket;
  390. p->Format.MinHeaderLoad = MINBUFFER/2;
  391. return ERR_NONE;
  392. }
  394. static const nodedef NSV = 
  395. {
  396. sizeof(nsv),
  397. NSV_ID,
  398. FORMATBASE_CLASS,
  399. PRI_DEFAULT,
  400. (nodecreate)Create,
  401. NULL,
  402. };
  404. void NSV_Init()
  405. {
  406.  NodeRegisterClass(&NSV);
  407. }
  409. void NSV_Done()
  410. {
  411. NodeUnRegisterClass(NSV_ID);
  412. }