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

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

Windows CE

开发平台：

C/C++

node.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: node.c 585 2006-01-16 09:48:55Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  26. #define MODULE_PATH FOURCC('M','P','A','T')
  27. #define PLUGIN_KEEPALIVE 3*60
  29. typedef struct nodeclass
  30. {
  31. nodedef Def;
  32. bool_t Registered;
  33. int ModuleNo;
  34. struct nodeclass* Parent;
  36. } nodeclass;
  38. typedef struct nodemodule
  39. {
  40. int Id;
  41. int ObjectCount;
  42. bool_t Tmp;
  43. int64_t Date;
  44. int KeepAlive;
  45. void* Module;
  46. void* Db;
  47. void* Func;
  48. uint8_t* Min;
  49. uint8_t* Max;
  51. } nodemodule;
  53. static NOINLINE void FreeModule(nodemodule* p)
  54. {
  55. NodeFreeModule(p->Module,p->Db);
  56. p->Module = NULL;
  57. p->Db = NULL;
  58. p->Func = NULL;
  59. p->Min = NULL;
  60. }
  62. void NodeAddModule(const tchar_t* Path,int Id,int64_t Date,bool_t Load,bool_t Tmp)
  63. {
  64. context* p = Context();
  65. LockEnter(p->NodeLock);
  66. if (ArrayAppend(&p->NodeModule,NULL,sizeof(nodemodule),256))
  67. {
  68. int No = ARRAYCOUNT(p->NodeModule,nodemodule)-1;
  69. nodemodule* Module = ARRAYBEGIN(p->NodeModule,nodemodule)+No;
  70. memset(Module,0,sizeof(nodemodule));
  71. Module->Id = Id;
  72. Module->Date = Date;
  73. Module->Tmp = Tmp;
  75. StringAdd(1,MODULE_PATH,No,Path);
  76. if (Load)
  77. {
  78. p->LoadModuleNo = No;
  79. Module->Module = NodeLoadModule(Path,&Module->Id,&Module->Func,&Module->Db);
  80. p->LoadModuleNo = 0;
  81. #ifdef PLUGINCLEANUP
  82. FreeModule(Module);
  83. #endif
  84. }
  85. }
  86. LockLeave(p->NodeLock);
  87. }
  89. static NOINLINE bool_t TmpModule(context* p,int No)
  90. {
  91. return ARRAYBEGIN(p->NodeModule,nodemodule)[No].Tmp;
  92. }
  94. static NOINLINE int FindModule(context* p,const tchar_t* Path,int Id)
  95. {
  96. // important to find from the begining for Palm OS 
  97. // so the exising plugins are found first
  99. int No,Count;
  100. int Result = -1;
  102. LockEnter(p->NodeLock);
  103. Count = ARRAYCOUNT(p->NodeModule,nodemodule);
  104. if (!Path) Path = T("");
  105. for (No=0;No<Count;++No)
  106. {
  107. bool_t SameId = ARRAYBEGIN(p->NodeModule,nodemodule)[No].Id == Id;
  108. bool_t SameName = tcsicmp(Path,LangStrDef(MODULE_PATH,No))==0;
  110. if (SameId && Id!=0) // same Id means same module
  111. SameName = 1;
  112. if (SameName && !Id)
  113. SameId = 1;
  115. if (SameId && SameName)
  116. {
  117. Result = No;
  118. break;
  119. }
  120. }
  121. LockLeave(p->NodeLock);
  122. return Result;
  123. }
  125. int NodeGetClassCount()
  126. {
  127. return ARRAYCOUNT(Context()->NodeClass,nodeclass*);
  128. }
  130. const nodedef* NodeGetClass(int No,int* Module)
  131. {
  132. nodeclass* i = ARRAYBEGIN(Context()->NodeClass,nodeclass*)[No];
  133. if (Module)
  134. *Module = i->ModuleNo;
  135. return &i->Def;
  136. }
  138. int NodeGetModuleCount()
  139. {
  140. return ARRAYCOUNT(Context()->NodeModule,nodemodule);
  141. }
  143. const tchar_t* NodeGetModule(int No,int* Id,int64_t* Date)
  144. {
  145. *Id = ARRAYBEGIN(Context()->NodeModule,nodemodule)[No].Id;
  146. *Date = ARRAYBEGIN(Context()->NodeModule,nodemodule)[No].Date;
  147. return LangStrDef(MODULE_PATH,No);
  148. }
  150. bool_t NodeFindModule(const tchar_t* Path,int Id)
  151. {
  152. return FindModule(Context(),Path,Id)>0;
  153. }
  155. static int CmpClass(const nodeclass* const* a, const nodeclass* const* b)
  156. {
  157. int AClass = (*a)->Def.Class;
  158. int BClass = (*b)->Def.Class;
  159. if (AClass > BClass) return 1;
  160. if (AClass < BClass) return -1;
  161. return 0;
  162. }
  164. static int CmpClassPri(const nodeclass* const* a, const nodeclass* const* b)
  165. {
  166. int APriority = (*a)->Def.Priority;
  167. int BPriority = (*b)->Def.Priority;
  168. if (APriority > BPriority) return -1;
  169. if (APriority < BPriority) return 1;
  170. return CmpClass(a,b);
  171. }
  173. static NOINLINE nodeclass* FindClass(context* p,int Class)
  174. {
  175. int Pos;
  176. bool_t Found;
  177. nodeclass Item;
  178. nodeclass* Ptr = &Item;
  180. LockEnter(p->NodeLock);
  181. Item.Def.Class = Class;
  182. Pos = ArrayFind(&p->NodeClass,ARRAYCOUNT(p->NodeClass,nodeclass*),
  183.                 sizeof(nodeclass*),&Ptr,(arraycmp)CmpClass,&Found);
  184. if (Found)
  185. Ptr = ARRAYBEGIN(p->NodeClass,nodeclass*)[Pos];
  186. else
  187. Ptr = NULL;
  188. LockLeave(p->NodeLock);
  189. return Ptr;
  190. }
  192. static int CmpNodePri(const node* const* a,const node* const* b)
  193. {
  194. context* p = Context();
  195. const nodeclass* ca = FindClass(p,(*a)->Class);
  196. const nodeclass* cb = FindClass(p,(*b)->Class);
  197. return CmpClassPri(&ca,&cb);
  198. }
  200. static NOINLINE int ReleaseModules(context* p,bool_t Force)
  201. {
  202. int n=0;
  203. int Time = Force ? MAX_INT:GetTimeTick();
  204. nodemodule* j;
  205. LockEnter(p->NodeLock);
  206. for (j=ARRAYBEGIN(p->NodeModule,nodemodule);j!=ARRAYEND(p->NodeModule,nodemodule);++j)
  207. if (j->ObjectCount==0 && j->Module && j->KeepAlive < Time)
  208. {
  209. //DEBUG_MSG1(-1,T("FreeModule %s"),LangStrDef(MODULE_PATH,j-ARRAYBEGIN(p->NodeModule,nodemodule)));
  210. FreeModule(j);
  211. ++n;
  212. }
  213. LockLeave(p->NodeLock);
  214. return n;
  215. }
  217. static NOINLINE void UnlockModule(context* p,int No)
  218. {
  219. nodemodule* Module = ARRAYBEGIN(p->NodeModule,nodemodule)+No;
  220. if (--Module->ObjectCount==0 && Module->Module)
  221. {
  222. #ifdef PLUGINCLEANUP
  223. Module->KeepAlive = GetTimeTick() + GetTimeFreq()*PLUGIN_KEEPALIVE;
  224. ReleaseModules(p,0);
  225. #endif
  226. }
  227. }
  229. static NOINLINE void CallDelete(context* p,node* Node,nodeclass* Class0,bool_t Global)
  230. {
  231. nodeclass* Class;
  233. for (Class=Class0;Class;Class=Class->Parent)
  234. if (Class->Def.Delete)
  235. Class->Def.Delete(Node);
  237. if (!Global)
  238. for (Class=Class0;Class;Class=Class->Parent)
  239. UnlockModule(p,Class->ModuleNo);
  240. }
  242. static NOINLINE nodemodule* LoadModule(context* p,int No)
  243. {
  244. nodemodule* Module = ARRAYBEGIN(p->NodeModule,nodemodule)+No;
  245. if (!Module->Module && No>0 && p->LoadModuleNo!=No)
  246. {
  247. //DEBUG_MSG1(-1,T("LoadModule %s"),LangStrDef(MODULE_PATH,No));
  248. p->LoadModuleNo = No;
  249. Module->Module = NodeLoadModule(LangStrDef(MODULE_PATH,No),&Module->Id,&Module->Func,&Module->Db);
  250. p->LoadModuleNo = 0;
  251. if (!Module->Module)
  252. return NULL;
  253. }
  254. return Module;
  255. }
  257. static int CallCreate(context* p,node* Node,nodeclass* Class,bool_t Global)
  258. {
  259. if (Class)
  260. {
  261. nodemodule* Module = LoadModule(p,Class->ModuleNo);
  262. if (!Module)
  263. return ERR_NOT_SUPPORTED;
  265. if (Class->Def.ParentClass && !Class->Parent)
  266. return ERR_NOT_SUPPORTED;
  268. if (CallCreate(p,Node,Class->Parent,Global)!=ERR_NONE)
  269. return ERR_NOT_SUPPORTED;
  271. if (!Class->Registered || (Class->Def.Create && Class->Def.Create(Node) != ERR_NONE))
  272. {
  273. CallDelete(p,Node,Class->Parent,Global);
  274. return ERR_NOT_SUPPORTED;
  275. }
  277. if (!Global)
  278. Module->ObjectCount++;
  279. }
  280. return ERR_NONE;
  281. }
  283. static void Delete(context* p,node** i)
  284. {
  285. node* Node = *i;
  286. nodeclass* Item = FindClass(p,Node->Class);
  287. *i = NULL;
  288. if (Item)
  289. CallDelete(p,Node,Item,(Item->Def.Flags & CF_GLOBAL)!=0);
  290. free(Node);
  291. }
  293. static void Register(context* p,const nodedef* Def,bool_t Registered,int ModuleNo)
  294. {
  295. nodeclass* Class;
  297. LockEnter(p->NodeLock);
  299. Class = FindClass(p,Def->Class);
  300. if (!Class)
  301. {
  302. nodeclass **c;
  304. Class = (nodeclass*) malloc(sizeof(nodeclass));
  305. if (!Class)
  306. {
  307. LockLeave(p->NodeLock);
  308. return;
  309. }
  311. Class->Def.Class = Def->Class;
  312. Class->Def.ParentClass = 0;
  313. Class->Registered = 0;
  314. Class->ModuleNo = 0;
  315. Class->Def.Flags = 0;
  316. Class->Def.Priority = -1;
  317. if (!ArrayAdd(&p->NodeClass,ARRAYCOUNT(p->NodeClass,nodeclass*),
  318.               sizeof(nodeclass*),&Class,(arraycmp)CmpClass,128))
  319. {
  320. free(Class);
  321. LockLeave(p->NodeLock);
  322. return;
  323. }
  325. // fix possible child classes
  326. for (c=ARRAYBEGIN(p->NodeClass,nodeclass*);c!=ARRAYEND(p->NodeClass,nodeclass*);++c)
  327. if ((*c)->Def.ParentClass == Def->Class)
  328. (*c)->Parent = Class;
  329. }
  330. else
  331. if (!Registered)
  332. {
  333. LockLeave(p->NodeLock);
  334. return;
  335. }
  337. if (Registered)
  338. {
  339. if (Class->Def.Priority > Def->Priority && Class->ModuleNo != ModuleNo)
  340. {
  341. LockLeave(p->NodeLock);
  342. return; // already exits with higher priority in another module
  343. }
  345. #ifndef REGISTRY_GLOBAL
  346. if (ModuleNo>0 && (Class->ModuleNo != ModuleNo || Class->Def.ParentClass != Def->ParentClass || Class->Def.Flags != Def->Flags))
  347. {
  348. // save settings to registry for new classes 
  349. NodeRegSaveString(Def->Class,NODE_NAME);
  350. NodeRegSaveString(Def->Class,NODE_CONTENTTYPE);
  351. NodeRegSaveString(Def->Class,NODE_EXTS);
  352. NodeRegSaveString(Def->Class,NODE_PROBE);
  353. NodeRegSaveValue(Def->Class,NODE_MODULE_PATH,LangStrDef(MODULE_PATH,ModuleNo),MAXPATH,TYPE_STRING);
  354. NodeRegSaveValue(Def->Class,NODE_PARENT,&Def->ParentClass,sizeof(int),TYPE_INT);
  355. NodeRegSaveValue(Def->Class,NODE_FLAGS,&Def->Flags,sizeof(int),TYPE_INT);
  356. }
  357. #endif
  358. }
  360. if (Class->Def.Priority != Def->Priority)
  361. {
  362. ArrayRemove(&p->NodeClassPri,ARRAYCOUNT(p->NodeClassPri,nodeclass*),
  363.             sizeof(nodeclass*),&Class,(arraycmp)CmpClassPri);
  364. Class->Def.Priority = Def->Priority;
  365. ArrayAdd(&p->NodeClassPri,ARRAYCOUNT(p->NodeClassPri,nodeclass*),
  366.          sizeof(nodeclass*),&Class,(arraycmp)CmpClassPri,128);
  368. #ifndef REGISTRY_GLOBAL
  369. if (ModuleNo>0 && Registered)
  370. NodeRegSaveValue(Def->Class,NODE_PRIORITY,Def->Priority!=PRI_DEFAULT?&Def->Priority:NULL,sizeof(int),TYPE_INT);
  371. #endif
  372. }
  374. Class->Def = *Def;
  375. Class->ModuleNo = ModuleNo;
  376. Class->Parent = FindClass(p,Def->ParentClass);
  377. Class->Registered = Registered;
  379. LockLeave(p->NodeLock);
  380. }
  382. void NodeLoadClass(const nodedef* Def,const tchar_t* Module,int ModuleId)
  383. {
  384. context* p = Context();
  385. int ModuleNo = FindModule(p,Module,ModuleId);
  386. if (ModuleNo>=0)
  387. Register(p,Def,0,ModuleNo);
  388. }
  390. void NodeUnRegisterClass(int ClassId)
  391. {
  392. context* p = Context();
  393. nodeclass* Class = FindClass(p,ClassId);
  394. if (Class && Class->Registered)
  395. {
  396. node **i;
  398. LockEnter(p->NodeLock);
  400. Class->Registered = 0;
  402. // delete all objects
  403. for (i=ARRAYBEGIN(p->Node,node*);i!=ARRAYEND(p->Node,node*);++i)
  404. if (*i && NodeIsClass((*i)->Class,ClassId))
  405. Delete(p,i);
  407. Class->Def.Create = NULL;
  408. Class->Def.Delete = NULL;
  410. LockLeave(p->NodeLock);
  411. }
  412. }
  414. static node* NodeCreateFromClass(context* p, nodeclass* Class)
  415. {
  416. node **Empty = NULL;
  417. node **i;
  418. nodemodule* Module;
  419. node* Node;
  420. int Size;
  421. nodeclass *j;
  423. if (!Class || (Class->Def.Flags & CF_ABSTRACT))
  424. return NULL;
  426. Size = 0;
  427. for (j=Class;j;j=j->Parent)
  428. if (Size < (j->Def.Flags & CF_SIZE))
  429. Size = (j->Def.Flags & CF_SIZE);
  430. if (!Size)
  431. return NULL;
  433. LockEnter(p->NodeLock);
  435. if ((Class->Def.Flags & CF_GLOBAL) && 
  436. (Module = LoadModule(p,Class->ModuleNo))!=NULL &&
  437. (Node = NodeEnumObject(NULL,Class->Def.Class))!=NULL)
  438. {
  439. ++Module->ObjectCount;
  440. LockLeave(p->NodeLock);
  441. return Node;
  442. }
  444. for (i=ARRAYBEGIN(p->Node,node*);i!=ARRAYEND(p->Node,node*);++i)
  445. if (!*i)
  446. {
  447. Empty = i;
  448. break;
  449. }
  451. if (!Empty)
  452. {
  453. if (!ArrayAppend(&p->Node,NULL,sizeof(node**),256))
  454. {
  455. LockLeave(p->NodeLock);
  456. return NULL;
  457. }
  458. Empty = ARRAYEND(p->Node,node*)-1;
  459. }
  461. *Empty = Node = (node*) malloc(Size);
  462. if (Node)
  463. {
  464. memset(Node,0,Size);
  465. Node->Class = Class->Def.Class;
  466. if (CallCreate(p,Node,Class,(Class->Def.Flags & CF_GLOBAL)!=0) != ERR_NONE)
  467. {
  468. for (i=ARRAYBEGIN(p->Node,node*);i!=ARRAYEND(p->Node,node*);++i)
  469. if (*i == Node)
  470. *i = NULL;
  471. free(Node);
  472. Node = NULL;
  473. }
  474. else
  475. {
  476. #ifndef REGISTRY_GLOBAL
  477. if (Class->Def.Flags & CF_GLOBAL)
  478. NodeRegLoad(Node);
  479. #endif
  480. Node->Set(Node,NODE_SETTINGSCHANGED,NULL,0); // should be after NodeRegLoad
  481. }
  482. }
  484. LockLeave(p->NodeLock);
  485. return Node;
  486. }
  488. void NodeRegisterClass(const nodedef* Def)
  489. {
  490. context* p = Context();
  491. if (Def->Flags & CF_GLOBAL)
  492. {
  493. //create global object with fake class and don't register if fails
  494. nodeclass Class;
  495. memset(&Class,0,sizeof(Class));
  496. Class.Def = *Def;
  497. Class.ModuleNo = p->LoadModuleNo; 
  498. Class.Parent = FindClass(p,Def->ParentClass);
  499. Class.Registered = 1;
  500. if (!Class.Parent || !NodeCreateFromClass(p,&Class))
  501. return;
  502. }
  503. Register(p,Def,1,p->LoadModuleNo);
  504. }
  506. node* NodeCreate(int ClassId)
  507. {
  508. context* p = Context();
  509. return NodeCreateFromClass(p,FindClass(p,ClassId));
  510. }
  512. void NodeDelete(node* Node)
  513. {
  514. if (Node)
  515. {
  516. nodeclass* Class;
  517. context* p = Context();
  519. LockEnter(p->NodeLock); 
  520. Class = FindClass(p,Node->Class);
  521. if (Class && (Class->Def.Flags & CF_GLOBAL))
  522. UnlockModule(p,Class->ModuleNo);
  523. else
  524. {
  525. node **i;
  526. for (i=ARRAYBEGIN(p->Node,node*);i!=ARRAYEND(p->Node,node*);++i)
  527. if (*i == Node)
  528. {
  529. Delete(p,i);
  530. break;
  531. }
  532. }
  533. LockLeave(p->NodeLock);
  534. }
  535. }
  537. const nodedef* NodeClassDef(int Class)
  538. {
  539. nodeclass* i = FindClass(Context(),Class);
  540. return i?&i->Def:NULL;
  541. }
  543. static NOINLINE bool_t GetNode(context* p,int n,node** Node)
  544. {
  545. node** i;
  546. bool_t Result = 0;
  547. LockEnter(p->NodeLock);
  548. i = ARRAYBEGIN(p->Node,node*)+n;
  549. if (i<ARRAYEND(p->Node,node*))
  550. {
  551. *Node = *i;
  552. Result = 1;
  553. }
  554. LockLeave(p->NodeLock);
  555. return Result;
  556. }
  558. bool_t NodeHibernate()
  559. {
  560. int Mode;
  561. int No;
  562. node* Node;
  563. context* p = Context();
  564. bool_t Changed = 0;
  566. if (p && !p->InHibernate)
  567. {
  568. p->InHibernate = 1;
  570. #ifdef PLUGINCLEANUP
  571. if (ReleaseModules(p,1))
  572. Changed = 1;
  573. #endif
  575. for (Mode=0;!Changed && Mode<HIBERNATEMODES;++Mode)
  576. for (No=0;GetNode(p,No,&Node);++No)
  577. if (Node && Node->Set && Node->Set(Node,NODE_HIBERNATE,&Mode,sizeof(int))==ERR_NONE)
  578. Changed = 1;
  580. if (!Changed && ReleaseModules(p,1))
  581. Changed = 1;
  583. p->InHibernate = 0;
  584. }
  585. return Changed;
  586. }
  588. int NodeBroadcast(int Msg,const void* Data,int Size)
  589. {
  590. int No;
  591. context* p = Context();
  592. node* Node;
  594. for (No=0;GetNode(p,No,&Node);++No)
  595. if (Node && Node->Set)
  596. Node->Set(Node,Msg,Data,Size);
  598. return ERR_NONE;
  599. }
  601. int NodeSettingsChanged()
  602. {
  603. return NodeBroadcast(NODE_SETTINGSCHANGED,NULL,0);
  604. }
  606. node* NodeEnumObject(array* List, int Class)
  607. {
  608. context* p = Context();
  609. node **i;
  611. if (List)
  612. memset(List,0,sizeof(array));
  614. LockEnter(p->NodeLock);
  616. for (i=ARRAYBEGIN(p->Node,node*);i!=ARRAYEND(p->Node,node*);++i)
  617. if (*i && NodeIsClass((*i)->Class,Class))
  618. {
  619. if (!List)
  620. {
  621. node* Node = *i;
  622. LockLeave(p->NodeLock);
  623. return Node;
  624. }
  625. ArrayAppend(List,i,sizeof(node**),64);
  626. }
  628. LockLeave(p->NodeLock);
  630. if (List)
  631. ArraySort(List,ARRAYCOUNT(*List,node*),sizeof(node*),(arraycmp)CmpNodePri);
  633. return NULL;
  634. }
  636. bool_t NodeIsClass(int ClassId, int PartOfClass)
  637. {
  638. nodeclass* Item;
  639. for (Item = FindClass(Context(),ClassId);Item;Item=Item->Parent)
  640. if (Item->Def.Class == PartOfClass)
  641. return 1;
  642. return 0;
  643. }
  645. static void DumpPtr(stream* File, tchar_t* s, node* Ptr, int No)
  646. {
  647. if (Ptr)
  648. {
  649. tchar_t v[32];
  650. if (No)
  651. stprintf_s(v,TSIZEOF(v),T(":%d"),No);
  652. else
  653. v[0] = 0;
  654. StreamPrintf(File,T("%s%s%s (0x%08x)n"),s,LangStrDef(Ptr->Class,0),v,(int)Ptr);
  655. }
  656. else
  657. StreamPrintf(File,T("%sNULLn"),s);
  658. }
  660. static void DumpFormat(stream* File, tchar_t* s,const packetformat* Format)
  661. {
  662. tchar_t v[8];
  663. switch (Format->Type)
  664. {
  665. case PACKET_VIDEO:
  666. StreamPrintf(File,T("%svideo"),s);
  667. if (Format->Format.Video.Pixel.Flags & PF_FOURCC) 
  668. {
  669. FourCCToString(v,TSIZEOF(v),Format->Format.Video.Pixel.FourCC);
  670. StreamPrintf(File,T(" fourcc=%s"),v);
  671. }
  672. else
  673. StreamPrintf(File,T(" bitcount=%d rmask=%04x gmask=%04x bmask=%04x"),Format->Format.Video.Pixel.BitCount,
  674. Format->Format.Video.Pixel.BitMask[0],Format->Format.Video.Pixel.BitMask[1],Format->Format.Video.Pixel.BitMask[2]);
  675. if (Format->Format.Video.Width) StreamPrintf(File,T(" width=%d"),Format->Format.Video.Width);
  676. if (Format->Format.Video.Height) StreamPrintf(File,T(" height=%d"),Format->Format.Video.Height);
  677. if (Format->Format.Video.Pitch) StreamPrintf(File,T(" pitch=%d"),Format->Format.Video.Pitch);
  678. if (Format->Format.Video.Direction) StreamPrintf(File,T(" dir=%d"),Format->Format.Video.Direction);
  679. if (Format->ByteRate) StreamPrintf(File,T(" bitrate=%d"),Format->ByteRate*8);
  680. StreamPrintf(File,T("n"));
  681. break;
  682. case PACKET_AUDIO:
  683. StreamPrintf(File,T("%saudio"),s);
  684. if (Format->Format.Audio.Format) StreamPrintf(File,T(" fmt=%04x"),Format->Format.Audio.Format);
  685. if (Format->Format.Audio.SampleRate) StreamPrintf(File,T(" rate=%d"),Format->Format.Audio.SampleRate);
  686. if (Format->Format.Audio.Channels) StreamPrintf(File,T(" ch=%d"),Format->Format.Audio.Channels);
  687. if (Format->Format.Audio.Bits) StreamPrintf(File,T(" bits=%d"),Format->Format.Audio.Bits);
  688. if (Format->ByteRate) StreamPrintf(File,T(" bitrate=%d"),Format->ByteRate*8);
  689. StreamPrintf(File,T("n"));
  690. break;
  691. case PACKET_SUBTITLE:
  692. FourCCToString(v,TSIZEOF(v),Format->Format.Subtitle.FourCC);
  693. StreamPrintf(File,T("%ssubtitle fourcc=%sn"),s,v);
  694. break;
  695. case PACKET_NONE:
  696. StreamPrintf(File,T("%sempty packet formatn"),s);
  697. break;
  698. default:
  699. StreamPrintf(File,T("%sunknown packet format (%d)n"),s,Format->Type);
  700. break;
  701. }
  702. }
  704. void NodeDump(struct stream* File)
  705. {
  706. context* p = Context();
  707. node **i;
  708. nodemodule* j;
  709. nodeclass** k;
  710. int No;
  712. for (No=0,j=ARRAYBEGIN(p->NodeModule,nodemodule);j!=ARRAYEND(p->NodeModule,nodemodule);++j,++No)
  713. TRY_BEGIN 
  714. {
  715. int ClassCount = 0;
  716. for (k=ARRAYBEGIN(p->NodeClass,nodeclass*);k!=ARRAYEND(p->NodeClass,nodeclass*);++k)
  717. if ((*k)->ModuleNo == No)
  718. ++ClassCount;
  720. if (j->Func && !j->Min)
  721. CodeFindPages(j->Func,&j->Min,&j->Max,NULL);
  722. StreamPrintf(File,T("%s %08x-%08x obj:%d class:%dn"),LangStrDef(MODULE_PATH,No),j->Min,j->Max,j->ObjectCount,ClassCount);
  723. }
  724. TRY_END
  726. StreamPrintf(File,T("nn"));
  728. //no NodeLock, becase may be stayed locked when dumping after crash 
  729. for (i=ARRAYBEGIN(p->Node,node*);i!=ARRAYEND(p->Node,node*);++i)
  730. if (*i)
  731. TRY_BEGIN 
  732. {
  733. tchar_t Flags[64];
  734. tchar_t s[256];
  735. tchar_t Buffer[512];
  736. const tchar_t* Name;
  737. rect Rect;
  738. packetformat Format;
  739. pin Pin;
  740. rgb RGB;
  741. point Point;
  742. bool_t Bool;
  743. tick_t Tick;
  744. fraction Fraction;
  745. node* Ptr;
  746. int Int,No;
  747. node* p = *i;
  748. datadef DataDef;
  750. StreamPrintf(File,T("%s (0x%08x)n"),LangStrDef(p->Class,0),(int)p);
  752. for (No=0;NodeEnum(p,No,&DataDef)==ERR_NONE;++No)
  753. {
  754. TRY_BEGIN 
  755. {
  757. Name = LangStrDef(DataDef.Class,DataDef.No);
  758. if (!Name[0]) Name = DataDef.Name ? DataDef.Name : T("");
  760. Flags[0] = 0;
  761. if (DataDef.Flags & DF_INPUT)
  762. tcscat_s(Flags,TSIZEOF(Flags),T(":IN"));
  763. if (DataDef.Flags & DF_OUTPUT)
  764. tcscat_s(Flags,TSIZEOF(Flags),T(":OUT"));
  766. stprintf_s(s,TSIZEOF(s),T("  %s(%d)%s="),Name,DataDef.No,Flags);
  768. switch (DataDef.Type)
  769. {
  770. case TYPE_BOOL:
  771. if (p->Get(p,DataDef.No,&Bool,sizeof(bool_t))==ERR_NONE)
  772. {
  773. BoolToString(Buffer,TSIZEOF(Buffer),Bool);
  774. StreamPrintf(File,T("%s%sn"),s,Buffer);
  775. }
  776. break;
  777. case TYPE_TICK:
  778. if (p->Get(p,DataDef.No,&Tick,sizeof(tick_t))==ERR_NONE)
  779. {
  780. TickToString(Buffer,TSIZEOF(Buffer),Tick,Tick<TICKSPERSEC,1,0);
  781. StreamPrintf(File,T("%s%sn"),s,Buffer);
  782. }
  783. break;
  784. case TYPE_INT:
  785. if (p->Get(p,DataDef.No,&Int,sizeof(int))==ERR_NONE)
  786. {
  787. IntToString(Buffer,TSIZEOF(Buffer),Int,(DataDef.Flags & DF_HEX)!=0);
  788. StreamPrintf(File,T("%s%sn"),s,Buffer);
  789. }
  790. break;
  791. case TYPE_HOTKEY:
  792. if (p->Get(p,DataDef.No,&Int,sizeof(int))==ERR_NONE)
  793. {
  794. HotKeyToString(Buffer,TSIZEOF(Buffer),Int);
  795. StreamPrintf(File,T("%s%sn"),s,Buffer);
  796. }
  797. break;
  798. case TYPE_FRACTION:
  799. if (p->Get(p,DataDef.No,&Fraction,sizeof(fraction))==ERR_NONE)
  800. {
  801. FractionToString(Buffer,TSIZEOF(Buffer),&Fraction,1,2);
  802. StreamPrintf(File,T("%s%sn"),s,Buffer);
  803. }
  804. break;
  805. case TYPE_STRING:
  806. if (p->Get(p,DataDef.No,Buffer,sizeof(Buffer))==ERR_NONE)
  807. StreamPrintf(File,T("%s%sn"),s,Buffer);
  808. break;
  809. case TYPE_RECT:
  810. if (p->Get(p,DataDef.No,&Rect,sizeof(rect))==ERR_NONE)
  811. StreamPrintf(File,T("%s%d:%d:%d:%dn"),s,Rect.x,Rect.y,Rect.Width,Rect.Height);
  812. break;
  813. case TYPE_POINT:
  814. if (p->Get(p,DataDef.No,&Point,sizeof(point))==ERR_NONE)
  815. StreamPrintf(File,T("%s%d:%dn"),s,Point.x,Point.y);
  816. break;
  817. case TYPE_RGB:
  818. if (p->Get(p,DataDef.No,&RGB.v,sizeof(RGB.v))==ERR_NONE)
  819. StreamPrintf(File,T("%s0x%082%082%082n"),s,RGB.c.r,RGB.c.b,RGB.c.b);
  820. break;
  821. case TYPE_COMMENT:
  822. if (p->Get(p,DataDef.No,&Pin,sizeof(Pin))==ERR_NONE)
  823. DumpPtr(File,s,Pin.Node,Pin.No);
  824. break;
  825. case TYPE_PACKET:
  826. if (p->Get(p,DataDef.No|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE)
  827. DumpFormat(File,s,&Format);
  828. if (p->Get(p,DataDef.No,&Pin,sizeof(Pin))==ERR_NONE)
  829. DumpPtr(File,s,Pin.Node,Pin.No);
  830. break;
  831. case TYPE_NODE:
  832. if (p->Get(p,DataDef.No,&Ptr,sizeof(Ptr)) == ERR_NONE)
  833. DumpPtr(File,s,Ptr,0);
  834. break;
  835. }
  836. }
  837. TRY_END
  838. }
  839. }
  840. TRY_END
  842. StreamPrintf(File,T("nn"));
  844. for (k=ARRAYBEGIN(p->NodeClass,nodeclass*);k!=ARRAYEND(p->NodeClass,nodeclass*);++k)
  845. TRY_BEGIN 
  846. {
  847. tchar_t s[16],s2[16];
  848. int Class = (*k)->Def.Class;
  849. FourCCToString(s,TSIZEOF(s),Class);
  850. FourCCToString(s2,TSIZEOF(s2),(*k)->Def.ParentClass);
  851. StreamPrintf(File,T("%s %s p:%d r:%d "),s,s2,(*k)->Parent!=NULL,(*k)->Registered);
  852. StreamPrintf(File,T("c:%s e:%s p:%s m:%sn"),
  853. LangStrDef(Class,NODE_CONTENTTYPE),
  854. LangStrDef(Class,NODE_EXTS),
  855. LangStrDef(Class,NODE_PROBE),
  856. LangStrDef(MODULE_PATH,(*k)->ModuleNo));
  857. }
  858. TRY_END
  859. }
  861. int NodeEnumTable(int* No, datadef* Out, const datatable* p)
  862. {
  863. int Count;
  864. for (Count=0;p[Count].Type>=0;++Count);
  866. if (*No < Count)
  867. {
  868. Out->Class = p[Count].No;
  869. p += *No;
  870. Out->No = p->No;
  871. Out->Type = p->Type;
  872. Out->Flags = p->Flags;
  873. Out->Format1 = p->Format1;
  874. Out->Format2 = p->Format2;
  876. switch (Out->Type)
  877. {
  878. case TYPE_BOOL: Out->Size = sizeof(bool_t); break;
  879. case TYPE_INT: Out->Size = sizeof(int); break;
  880. case TYPE_HOTKEY: Out->Size = sizeof(int); break;
  881. case TYPE_FRACTION: Out->Size = sizeof(fraction); break;
  882. case TYPE_STRING: Out->Size = MAXDATA; break;
  883. case TYPE_RECT: Out->Size = sizeof(rect); break;
  884. case TYPE_POINT: Out->Size = sizeof(point); break;
  885. case TYPE_RGB: Out->Size = sizeof(rgbval_t); break;
  886. case TYPE_BINARY: Out->Size = Out->Format1; break;
  887. case TYPE_NODE: Out->Size = sizeof(node*); break;
  888. case TYPE_NOTIFY: Out->Size = sizeof(notify); break;
  889. case TYPE_COMMENT:
  890. case TYPE_PACKET: Out->Size = sizeof(pin); break;
  891. case TYPE_TICK: Out->Size = sizeof(tick_t); break;
  892. case TYPE_BLITFX: Out->Size = sizeof(blitfx); break;
  893. default:
  894. Out->Size = 0;
  895. break;
  896. }
  897. Out->Name = LangStr(Out->Class,Out->No);
  898. return ERR_NONE;
  899. }
  901. *No -= Count;
  902. return ERR_INVALID_PARAM;
  903. }
  905. bool_t NodeDataDef(node* p, int No, datadef* Out)
  906. {
  907. int i;
  908. for (i=0;NodeEnum(p,i,Out)==ERR_NONE;++i)
  909. if (Out->No == No)
  910. return 1;
  911. return 0;
  912. }
  914. int NodeEnum(node* p,int No,datadef* Param)
  915. {
  916. if (!p) return ERR_INVALID_PARAM;
  917. return p->Enum(p,&No,Param);
  918. }
  920. int NodeEnumClass(array* List, int Class)
  921. {
  922. return NodeEnumClassEx(List,Class,NULL,NULL,NULL,0);
  923. }
  925. int NodeEnumClassEx(array* List, int Class, const tchar_t* ContentType, const tchar_t* URL, const void* Data, int Length)
  926. {
  927. context* p = Context();
  928. nodeclass* v;
  929. nodeclass **i;
  931. if (ContentType && !ContentType[0])
  932. ContentType = NULL;
  934. if (URL && !URL[0])
  935. URL = NULL;
  937. if (List)
  938. memset(List,0,sizeof(array));
  940. LockEnter(p->NodeLock);
  941. for (i=ARRAYBEGIN(p->NodeClassPri,nodeclass*);i!=ARRAYEND(p->NodeClassPri,nodeclass*);++i)
  942. if (!((*i)->Def.Flags & CF_ABSTRACT) && !TmpModule(p,(*i)->ModuleNo)) // skip abstract
  943. for (v=*i;v;v=v->Parent)
  944. if (v->Def.Class == Class)
  945. {
  946. int Id = (*i)->Def.Class;
  948. if ((ContentType || URL || Data) &&
  949. (!ContentType || !CheckContentType(ContentType,LangStrDef(Id,NODE_CONTENTTYPE))) &&
  950. (!URL || !CheckExts(URL,LangStrDef(Id,NODE_EXTS))) &&
  951. (!Data || !DataProbe(Data,Length,LangStrDef(Id,NODE_PROBE))))
  952. continue;
  954. if (!List)
  955. {
  956. LockLeave(p->NodeLock);
  957. return Id;
  958. }
  959. ArrayAppend(List,&Id,sizeof(int),64);
  960. break;
  961. }
  963. LockLeave(p->NodeLock);
  964. return 0;
  965. }
  967. static int Enum(void* This,int* EnumNo,datadef* Out) { return ERR_INVALID_PARAM; }
  968. static int Get(void* This,int No,void* Data,int Size) { return ERR_INVALID_PARAM; }
  969. static int Set(void* This,int No,const void* Data,int Size) { return ERR_INVALID_PARAM; }
  971. static int Create(node* p)
  972. {
  973. p->Enum = Enum;
  974. p->Get = Get;
  975. p->Set = Set;
  976. return ERR_NONE;
  977. }
  979. static const nodedef Node =
  980. {
  981. CF_ABSTRACT,
  982. NODE_CLASS,
  983. 0,
  984. PRI_DEFAULT,
  985. (nodecreate)Create
  986. };
  988. void Node_Init()
  989. {
  990. context* p = Context();
  991. ArrayAlloc(&p->NodeClass,sizeof(nodeclass*)*100,128);
  992. ArrayAlloc(&p->NodeClassPri,sizeof(nodeclass*)*100,128);
  993. p->NodeLock = LockCreate();
  995. NodeAddModule(T("common"),0,0,0,0);
  996. if (!ARRAYEMPTY(p->NodeModule))
  997. *(void(**)())&ARRAYBEGIN(p->NodeModule,nodemodule)->Func = Node_Init;
  998. NodeRegisterClass(&Node);
  999. }
  1001. void Node_Done()
  1002. {
  1003. context* p = Context();
  1004. nodeclass **i;
  1005. NodeUnRegisterClass(NODE_CLASS);
  1006. #ifndef NDEBUG
  1007. {
  1008. nodemodule* j;
  1009. for (j=ARRAYBEGIN(p->NodeModule,nodemodule);j!=ARRAYEND(p->NodeModule,nodemodule);++j)
  1010. {
  1011. if (j->ObjectCount!=0)
  1012. DebugMessage(T("module problem %s"),LangStr(MODULE_PATH,j-ARRAYBEGIN(p->NodeModule,nodemodule)));
  1013. assert(j->ObjectCount==0);
  1014. }
  1015. }
  1016. #endif
  1017. ReleaseModules(p,1);
  1018. for (i=ARRAYBEGIN(p->NodeClass,nodeclass*);i!=ARRAYEND(p->NodeClass,nodeclass*);++i)
  1019. free(*i);
  1020. ArrayClear(&p->Node);
  1021. ArrayClear(&p->NodeClass);
  1022. ArrayClear(&p->NodeClassPri);
  1023. ArrayClear(&p->NodeModule);
  1024. LockDelete(p->NodeLock);
  1025. p->NodeLock = NULL;
  1026. }
  1028. bool_t NodeLocatePtr(void* Ptr, tchar_t* OutName, int OutLen, int* OutBase)
  1029. {
  1030. if (Ptr)
  1031. {
  1032. context* p = Context();
  1033. if (p) 
  1034. {
  1035. int No;
  1036. uint8_t* v = (uint8_t*)Ptr;
  1037. nodemodule *i;
  1038. // no locking (dump after crash)
  1039. for (No=0,i=ARRAYBEGIN(p->NodeModule,nodemodule);i!=ARRAYEND(p->NodeModule,nodemodule);++i,++No)
  1040. {
  1041. if (i->Func)
  1042. {
  1043. if (!i->Min)
  1044. CodeFindPages(i->Func,&i->Min,&i->Max,NULL);
  1046. if (i->Min <= v && i->Max > v)
  1047. {
  1048. tcscpy_s(OutName,OutLen,LangStrDef(MODULE_PATH,No));
  1049. *OutBase = v - i->Min;
  1050. return 1;
  1051. }
  1052. }
  1053. }
  1054. }
  1055. }
  1056. return 0;
  1057. }
  1059. #ifndef REGISTRY_GLOBAL
  1061. bool_t NodeRegLoadString(int Class, int Id)
  1062. {
  1063. uint8_t Buffer[MAXDATA];
  1064. if (NodeRegLoadValue(Class,Id,Buffer,sizeof(Buffer),TYPE_STRING))
  1065. {
  1066. StringAdd(1,Class,Id,(tchar_t*)Buffer);
  1067. return 1;
  1068. }
  1069. return 0;
  1070. }
  1072. void NodeRegSaveString(int Class, int Id)
  1073. {
  1074. const tchar_t* s = LangStrDef(Class,Id);
  1075. int Len = tcslen(s);
  1076. if (Len)
  1077. ++Len;
  1078. else 
  1079. s = NULL;
  1080. NodeRegSaveValue(Class,Id,s,Len*sizeof(tchar_t),TYPE_STRING);
  1081. }
  1083. #endif