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

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

Windows CE

开发平台：

C/C++

flow.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: flow.c 543 2006-01-07 22:06:24Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  26. static const datatable FlowParams[] =
  27. {
  28. { FLOW_BUFFERED,TYPE_BOOL, DF_HIDDEN },
  30. DATATABLE_END(FLOW_CLASS)
  31. };
  33. int FlowEnum(void* p, int* No, datadef* Param)
  34. {
  35. return NodeEnumTable(No,Param,FlowParams);
  36. }
  38. static const nodedef Flow =
  39. {
  40. CF_ABSTRACT,
  41. FLOW_CLASS,
  42. NODE_CLASS,
  43. PRI_DEFAULT,
  44. };
  46. static const datatable OutParams[] =
  47. {
  48. { OUT_INPUT, TYPE_PACKET, DF_INPUT },
  49. { OUT_OUTPUT, TYPE_PACKET, DF_OUTPUT|DF_RDONLY },
  50. { OUT_TOTAL, TYPE_INT,  DF_HIDDEN },
  51. { OUT_DROPPED, TYPE_INT,  DF_HIDDEN },
  52. { OUT_KEEPALIVE,TYPE_BOOL,  DF_HIDDEN },
  54. DATATABLE_END(OUT_CLASS)
  55. };
  57. int OutEnum(void* p, int* No, datadef* Param)
  58. {
  59. return NodeEnumTable(No,Param,OutParams);
  60. }
  62. static const nodedef Out =
  63. {
  64. CF_ABSTRACT,
  65. OUT_CLASS,
  66. FLOW_CLASS,
  67. PRI_DEFAULT,
  68. };
  70. void Flow_Init()
  71. {
  72. NodeRegisterClass(&Flow);
  73. NodeRegisterClass(&Out);
  74. }
  76. void Flow_Done()
  77. {
  78. NodeUnRegisterClass(OUT_CLASS);
  79. NodeUnRegisterClass(FLOW_CLASS);
  80. }
  82. void Disconnect(node* Src,int SrcNo,node* Dst,int DstNo)
  83. {
  84. ConnectionUpdate(NULL,0,Dst,DstNo);
  85. ConnectionUpdate(Src,SrcNo,NULL,0);
  86. }
  88. int ConnectionUpdate(node* Src,int SrcNo,node* Dst,int DstNo)
  89. {
  90. int Result;
  91. pin Pin;
  92. packetformat Format;
  93. packetprocess Process;
  95. memset(&Format,0,sizeof(Format));
  97. // first setup connection via Pin, so when PIN_FORMAT is set the nodes can negotiate
  98. // ConnectionUpdate should not disconnect nodes even is something fails
  100. if (Dst && Dst->Get(Dst,DstNo,&Pin,sizeof(Pin))==ERR_NONE && (Pin.Node != Src || Pin.No != SrcNo))
  101. {
  102. Pin.Node = Src;
  103. Pin.No = SrcNo;
  104. Result = Dst->Set(Dst,DstNo,&Pin,sizeof(Pin));
  105. if (Result != ERR_NONE)
  106. return Result;
  107. }
  109. if (Src && Src->Get(Src,SrcNo,&Pin,sizeof(Pin))==ERR_NONE && (Pin.Node != Dst || Pin.No != DstNo))
  110. {
  111. Pin.Node = Dst;
  112. Pin.No = DstNo;
  113. Result = Src->Set(Src,SrcNo,&Pin,sizeof(Pin));
  114. if (Result != ERR_NONE)
  115. return Result;
  116. }
  118. if (Src && Dst)
  119. {
  120. Src->Get(Src,SrcNo|PIN_FORMAT,&Format,sizeof(Format));
  121. Result = Dst->Set(Dst,DstNo|PIN_FORMAT,&Format,sizeof(Format));
  122. if (Result != ERR_NONE)
  123. Dst->Set(Dst,DstNo|PIN_FORMAT,NULL,0);
  125. Dst->Get(Dst,DstNo|PIN_PROCESS,&Process,sizeof(packetprocess));
  126. Src->Set(Src,SrcNo|PIN_PROCESS,&Process,sizeof(packetprocess));
  128. if (Result != ERR_NONE)
  129. return Result;
  130. }
  131. else
  132. if (Dst)
  133. Dst->Set(Dst,DstNo|PIN_FORMAT,NULL,0);
  135. return ERR_NONE;
  136. }
  138. int DummyProcess(void* p, const packet* Packet, const flowstate* State)
  139. {
  140. if (State->CurrTime >= 0 && Packet && Packet->RefTime > State->CurrTime + SHOWAHEAD)
  141. return ERR_BUFFER_FULL;
  142. return ERR_NONE;
  143. }
  145. static bool_t ContentType(const packetformat* Format,tchar_t* Out,int OutLen)
  146. {
  147. tchar_t Id[16];
  148. switch (Format->Type)
  149. {
  150. case PACKET_VIDEO:
  151. FourCCToString(Id,TSIZEOF(Id),Format->Format.Video.Pixel.FourCC);
  152. stprintf_s(Out,OutLen,T("vcodec/%s"),Id);
  153. break;
  154. case PACKET_AUDIO:
  155. stprintf_s(Out,OutLen,T("acodec/0x%04x"),Format->Format.Audio.Format);
  156. break;
  157. case PACKET_SUBTITLE:
  158. FourCCToString(Id,TSIZEOF(Id),Format->Format.Subtitle.FourCC);
  159. stprintf_s(Out,OutLen,T("subtitle/%s"),Id);
  160. break;
  161. default:
  162. return 0;
  163. }
  164. return 1;
  165. }
  167. void PacketFormatEnumClass(array* List, const packetformat* Format)
  168. {
  169. tchar_t s[16];
  170. if (ContentType(Format,s,TSIZEOF(s)))
  171. NodeEnumClassEx(List,FLOW_CLASS,s,NULL,NULL,0);
  172. else
  173. memset(List,0,sizeof(array));
  174. }
  176. bool_t PacketFormatMatch(int Class, const packetformat* Format)
  177. {
  178. tchar_t s[16];
  179. const tchar_t* Supported = LangStr(Class,NODE_CONTENTTYPE);
  180. assert(Supported[0]!=0);
  181. if (Supported[0]==0)
  182. return 0;
  183. if (!ContentType(Format,s,TSIZEOF(s)))
  184. return 0;
  185. return CheckContentType(s,Supported);
  186. }
  188. bool_t PacketFormatSimilarAudio(const packetformat* Current, const packetformat* New)
  189. {
  190. return Current && Current->Type == PACKET_AUDIO && New && New->Type == PACKET_AUDIO &&
  191. Current->Format.Audio.Format == New->Format.Audio.Format &&
  192. Current->Format.Audio.Channels == New->Format.Audio.Channels &&
  193. Current->Format.Audio.SampleRate == New->Format.Audio.SampleRate;
  194. }
  196. bool_t PacketFormatRotatedVideo(const packetformat* Current, const packetformat* New,int Mask)
  197. {
  198. if (Current && Current->Type == PACKET_VIDEO && New && New->Type == PACKET_VIDEO &&
  199. (Current->Format.Video.Direction ^ New->Format.Video.Direction) & Mask)
  200. {
  201. video Tmp = New->Format.Video;
  202. Tmp.Pitch = Current->Format.Video.Pitch;
  203. if ((Current->Format.Video.Direction ^ Tmp.Direction) & DIR_SWAPXY)
  204. SwapInt(&Tmp.Width,&Tmp.Height);
  205. Tmp.Direction = Current->Format.Video.Direction;
  206. return EqVideo(&Current->Format.Video,&Tmp);
  207. }
  208. return 0;
  209. }
  211. bool_t EqPacketFormat(const packetformat* a, const packetformat* b)
  212. {
  213. if (!a || !b || a->Type != b->Type)
  214. return 0;
  216. switch (a->Type)
  217. {
  218. case PACKET_VIDEO: return EqVideo(&a->Format.Video,&b->Format.Video);
  219. case PACKET_AUDIO: return EqAudio(&a->Format.Audio,&b->Format.Audio);
  220. case PACKET_SUBTITLE: return EqSubtitle(&a->Format.Subtitle,&b->Format.Subtitle);
  221. }
  222. return 1;
  223. }
  225. int PacketFormatCopy(packetformat* Dst, const packetformat* Src)
  226. {
  227. PacketFormatClear(Dst);
  228. if (Src)
  229. {
  230. *Dst = *Src;
  231. if (Src->ExtraLength >= 0)
  232. {
  233. Dst->Extra = NULL;
  234. Dst->ExtraLength = 0;
  235. if (Src->ExtraLength && PacketFormatExtra(Dst,Src->ExtraLength))
  236. memcpy(Dst->Extra,Src->Extra,Dst->ExtraLength);
  237. if (Src->Type==PACKET_VIDEO && Src->Format.Video.Pixel.Palette == (rgb*)Src->Extra)
  238. Dst->Format.Video.Pixel.Palette = (rgb*)Dst->Extra;
  239. }
  240. }
  241. return ERR_NONE;
  242. }
  244. void PacketFormatCombine(packetformat* Dst, const packetformat* Src)
  245. {
  246. if (Dst->Type == Src->Type)
  247. {
  248. if (!Dst->ByteRate)
  249. Dst->ByteRate = Src->ByteRate;
  250. if (!Dst->PacketRate.Num)
  251. Dst->PacketRate = Src->PacketRate;
  253. switch (Dst->Type)
  254. {
  255. case PACKET_VIDEO:
  256. if (!Dst->Format.Video.Width && !Dst->Format.Video.Height)
  257. {
  258. Dst->Format.Video.Width = Src->Format.Video.Width;
  259. Dst->Format.Video.Height = Src->Format.Video.Height;
  260. Dst->Format.Video.Direction = Src->Format.Video.Direction;
  261. }
  262. if (!Dst->Format.Video.Aspect)
  263. Dst->Format.Video.Aspect = Src->Format.Video.Aspect;
  264. break;
  266. case PACKET_AUDIO:
  267. // force update
  268. Dst->Format.Audio.Channels = Src->Format.Audio.Channels;
  269. Dst->Format.Audio.SampleRate = Src->Format.Audio.SampleRate; 
  270. if (!Dst->Format.Audio.Bits)
  271. {
  272. Dst->Format.Audio.Bits = Src->Format.Audio.Bits;
  273. Dst->Format.Audio.FracBits = Src->Format.Audio.FracBits;
  274. }
  275. break;
  276. }
  277. }
  278. }
  280. void PacketFormatClear(packetformat* p)
  281. {
  282. if (p->ExtraLength>=0)
  283. free(p->Extra);
  284. memset(p,0,sizeof(packetformat));
  285. }
  287. bool_t PacketFormatExtra(packetformat* p, int Length)
  288. {
  289. if (Length<=0)
  290. {
  291. if (p->ExtraLength>=0)
  292. free(p->Extra);
  293. p->Extra = NULL;
  294. p->ExtraLength = 0;
  295. return 0;
  296. }
  297. else
  298. {
  299. void* Extra = realloc(p->Extra,Length);
  300. if (!Extra && Length)
  301. return 0;
  302. p->Extra = Extra;
  303. p->ExtraLength = Length;
  304. return 1;
  305. }
  306. }
  308. void PacketFormatPCM(packetformat* p, const packetformat* In, int Bits)
  309. {
  310. PacketFormatClear(p);
  311. p->Type = PACKET_AUDIO;
  312. p->Format.Audio.Format = AUDIOFMT_PCM;
  313. p->Format.Audio.Bits = Bits;
  314. p->Format.Audio.SampleRate = In->Format.Audio.SampleRate;
  315. p->Format.Audio.Channels = In->Format.Audio.Channels;
  316. if (p->Format.Audio.Channels > 2)
  317. p->Format.Audio.Channels = 2;
  318. PacketFormatDefault(p);
  319. }
  321. void PacketFormatDefault(packetformat* p)
  322. {
  323. switch (p->Type)
  324. {
  325. case PACKET_VIDEO:
  326. if (p->Format.Video.Pixel.FourCC==0) // DIB?
  327. {
  328. if (p->Format.Video.Pixel.BitCount <= 8)
  329. p->Format.Video.Pixel.Flags = PF_PALETTE;
  330. else
  331. switch (p->Format.Video.Pixel.BitCount)
  332. {
  333. case 16:
  334. DefaultRGB(&p->Format.Video.Pixel,p->Format.Video.Pixel.BitCount,5,5,5,0,0,0);
  335. break;
  336. case 24:
  337. case 32:
  338. DefaultRGB(&p->Format.Video.Pixel,p->Format.Video.Pixel.BitCount,8,8,8,0,0,0);
  339. break;
  340. }
  341. p->Format.Video.Direction = DIR_MIRRORUPDOWN;
  342. }
  343. else
  344. if (p->Format.Video.Pixel.FourCC==3)
  345. {
  346. p->Format.Video.Pixel.Flags = PF_RGB;
  347. p->Format.Video.Direction = DIR_MIRRORUPDOWN;
  348. }
  349. else
  350. {
  351. p->Format.Video.Pixel.Flags = PF_FOURCC;
  352. p->Format.Video.Pixel.FourCC = UpperFourCC(p->Format.Video.Pixel.FourCC);
  353. p->Format.Video.Direction = 0;
  354. }
  356. DefaultPitch(&p->Format.Video);
  358. if (p->Format.Video.Height<0)
  359. {
  360. p->Format.Video.Height = -p->Format.Video.Height;
  361. p->Format.Video.Direction ^= DIR_MIRRORUPDOWN;
  362. }
  363. break;
  365. case PACKET_AUDIO:
  366. // detect fake PCM
  367. if (p->Format.Audio.Format > 8192 && 
  368. p->Format.Audio.BlockAlign > 0 &&
  369. p->ByteRate > 0 &&
  370. p->Format.Audio.BlockAlign == ((p->Format.Audio.Channels * p->Format.Audio.Bits) >> 3) &&
  371. p->ByteRate == p->Format.Audio.SampleRate * p->Format.Audio.BlockAlign)
  372. p->Format.Audio.Format = AUDIOFMT_PCM;
  374. if (p->Format.Audio.Format == AUDIOFMT_PCM)
  375. {
  376. p->Format.Audio.FracBits = p->Format.Audio.Bits - 1;
  377. if (p->Format.Audio.Bits <= 8)
  378. p->Format.Audio.Flags |= PCM_UNSIGNED;
  379. p->Format.Audio.Bits = ALIGN8(p->Format.Audio.Bits);
  380. p->Format.Audio.BlockAlign = (p->Format.Audio.Channels * p->Format.Audio.Bits) >> 3;
  381. p->ByteRate = p->Format.Audio.SampleRate * p->Format.Audio.BlockAlign;
  382. }
  383. break;
  384. }
  385. }
  387. bool_t PacketFormatName(packetformat* p, tchar_t* Name, int NameLen)
  388. {
  389. tchar_t Id[8];
  390. switch (p->Type)
  391. {
  392. case PACKET_SUBTITLE:
  393. tcscpy_s(Name,NameLen,LangStr(p->Format.Subtitle.FourCC,0x4400));
  394. if (!Name[0])
  395. FourCCToString(Name,NameLen,p->Format.Subtitle.FourCC);
  396. return 1;
  397. case PACKET_AUDIO:
  398. if (p->Format.Audio.Format != AUDIOFMT_PCM)
  399. {
  400. stprintf_s(Id,TSIZEOF(Id),T("%04X"),p->Format.Audio.Format);
  401. tcscpy_s(Name,NameLen,LangStr(FOURCC(Id[0],Id[1],Id[2],Id[3]),0x4400));
  402. if (!Name[0])
  403. tcscpy_s(Name,NameLen,Id);
  404. }
  405. else
  406. tcscpy_s(Name,NameLen,T("PCM"));
  407. return 1;
  408. case PACKET_VIDEO:
  409. if (Compressed(&p->Format.Video.Pixel))
  410. {
  411. tcscpy_s(Name,NameLen,LangStr(p->Format.Video.Pixel.FourCC,0x4400));
  412. if (!Name[0])
  413. FourCCToString(Name,NameLen,p->Format.Video.Pixel.FourCC);
  414. }
  415. else
  416. if (AnyYUV(&p->Format.Video.Pixel))
  417. tcscpy_s(Name,NameLen,T("YUV"));
  418. else
  419. stprintf_s(Name,NameLen,T("RGB %d bits"),p->Format.Video.Pixel.BitCount);
  420. return 1;
  421. }
  422. return 0;
  423. }