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

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

Windows CE

开发平台：

C/C++

idct.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: idct.c 607 2006-01-22 20:58:29Z 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 Params[] = 
  27. {
  28. { IDCT_FORMAT, TYPE_BINARY, DF_HIDDEN, sizeof(video) },
  29. { IDCT_OUTPUT, TYPE_PACKET, DF_OUTPUT },
  30. { IDCT_ROUNDING, TYPE_BOOL, DF_HIDDEN },
  31. { IDCT_SHIFT, TYPE_INT, DF_HIDDEN },
  32. { IDCT_MODE, TYPE_INT, DF_HIDDEN },
  33. { IDCT_BUFFERCOUNT, TYPE_INT, DF_HIDDEN },
  34. { IDCT_BUFFERWIDTH, TYPE_INT, DF_HIDDEN },
  35. { IDCT_BUFFERHEIGHT,TYPE_INT, DF_HIDDEN },
  37. DATATABLE_END(IDCT_CLASS)
  38. };
  40. static const datatable CodecParams[] = 
  41. {
  42. { CODECIDCT_INPUT, TYPE_PACKET, DF_INPUT },
  43. { CODECIDCT_IDCT, TYPE_NODE, DF_OUTPUT, IDCT_CLASS },
  45. DATATABLE_END(CODECIDCT_CLASS)
  46. };
  48. int IDCTEnum(void* p, int* No, datadef* Param)
  49. {
  50. if (FlowEnum(p,No,Param)==ERR_NONE)
  51. return ERR_NONE;
  52. return NodeEnumTable(No,Param,Params);
  53. }
  55. static void DummyGMC(idct* p,const idct_gmc* gmc)
  56. {
  57. }
  59. static void DummyInter8x8GMC(idct* p,void* Data,int Length)
  60. {
  61. p->Inter8x8(p,Data,Length);
  62. }
  64. static void DummyMCompGMC(idct* p,int x,int y)
  65. {
  66. static const int Zero[6] = {0,0,0,0,0,0};
  67. p->MComp16x16(p,Zero,NULL);
  68. }
  70. static int IDCTCreate(idct* p)
  71. {
  72. p->Enum = IDCTEnum;
  73. p->GMC = (idctgmc)DummyGMC;
  74. p->Inter8x8GMC = (idctinter)DummyInter8x8GMC;
  75. p->MCompGMC = (idctprocess)DummyMCompGMC;
  76. return ERR_NONE;
  77. }
  79. static const nodedef IDCT =
  80. {
  81. sizeof(idct)|CF_ABSTRACT,
  82. IDCT_CLASS,
  83. FLOW_CLASS,
  84. PRI_DEFAULT,
  85. (nodecreate)IDCTCreate,
  86. };
  88. int IDCTBackup(idct* p,idctbackup* Backup)
  89. {
  90. int No;
  91. planes Planes;
  92. video Format;
  94. memset(Backup,0,sizeof(idctbackup));
  96. if (p->Get(p,IDCT_FORMAT,&Backup->Format,sizeof(video))!=ERR_NONE || !Backup->Format.Pixel.Flags ||
  97. p->Get(p,IDCT_BUFFERWIDTH,&Backup->Width,sizeof(int))!=ERR_NONE ||
  98. p->Get(p,IDCT_BUFFERHEIGHT,&Backup->Height,sizeof(int))!=ERR_NONE ||
  99. p->Get(p,IDCT_BUFFERCOUNT,&Backup->Count,sizeof(int))!=ERR_NONE ||
  100. p->Get(p,IDCT_SHOW,&Backup->Show,sizeof(int))!=ERR_NONE)
  101. return ERR_INVALID_DATA;
  103. p->Get(p,IDCT_SHIFT,&Backup->Shift,sizeof(int)); // optional
  104. p->Get(p,IDCT_MODE,&Backup->Mode,sizeof(int));
  106. for (No=0;No<Backup->Count;++No)
  107. {
  108. idctbufferbackup* Buffer = Backup->Buffer+No;
  110. Buffer->FrameNo = -1;
  111. p->Get(p,IDCT_FRAMENO+No,&Buffer->FrameNo,sizeof(int));
  113. if (p->Lock(p,No,Planes,&Buffer->Brightness,&Format) == ERR_NONE)
  114. {
  115. Buffer->Format = Format;
  116. DefaultPitch(&Buffer->Format);
  117. if (SurfaceAlloc(Buffer->Buffer,&Buffer->Format) == ERR_NONE)
  118. SurfaceCopy(&Format,&Buffer->Format,Planes,Buffer->Buffer,NULL);
  119. p->Unlock(p,No);
  120. }
  121. }
  123. p->Set(p,IDCT_FORMAT,NULL,0);
  124. return ERR_NONE;
  125. }
  127. int IDCTRestore(idct* p,idctbackup* Backup)
  128. {
  129. int No;
  130. if (p && Backup->Format.Pixel.Flags)
  131. {
  132. int Brightness;
  133. planes Planes;
  134. video Format;
  135. blitfx FX;
  137. memset(&FX,0,sizeof(FX));
  138. FX.ScaleX = SCALE_ONE;
  139. FX.ScaleY = SCALE_ONE;
  141. p->Set(p,IDCT_MODE,&Backup->Mode,sizeof(int));
  142. p->Set(p,IDCT_SHIFT,&Backup->Shift,sizeof(int));
  143. p->Set(p,IDCT_BUFFERWIDTH,&Backup->Width,sizeof(int));
  144. p->Set(p,IDCT_BUFFERHEIGHT,&Backup->Height,sizeof(int));
  145. p->Set(p,IDCT_FORMAT,&Backup->Format,sizeof(video));
  146. p->Set(p,IDCT_BUFFERCOUNT,&Backup->Count,sizeof(int));
  148. for (No=0;No<Backup->Count;++No)
  149. {
  150. idctbufferbackup* Buffer = Backup->Buffer+No;
  152. p->Set(p,IDCT_FRAMENO+No,&Buffer->FrameNo,sizeof(int));
  154. if (Buffer->Buffer[0] && p->Lock(p,No,Planes,&Brightness,&Format) == ERR_NONE)
  155. {
  156. FX.Direction = CombineDir(Buffer->Format.Direction, 0, Format.Direction);
  157. FX.Brightness = Brightness - Buffer->Brightness;
  159. SurfaceCopy(&Buffer->Format,&Format,Buffer->Buffer,Planes,&FX);
  161. p->Unlock(p,No);
  162. }
  163. }
  165. p->Set(p,IDCT_SHOW,&Backup->Show,sizeof(int));
  166. }
  168. for (No=0;No<Backup->Count;++No)
  169. SurfaceFree(Backup->Buffer[No].Buffer);
  171. memset(Backup,0,sizeof(idctbackup));
  172. return ERR_NONE;
  173. }
  175. //-----------------------------------------------------------------------------------------------
  177. int CodecIDCTEnum(void* p, int* No, datadef* Param)
  178. {
  179. if (FlowEnum(p,No,Param)==ERR_NONE)
  180. return ERR_NONE;
  181. return NodeEnumTable(No,Param,CodecParams);
  182. }
  184. static int Discontinuity(codecidct* p)
  185. {
  186. p->RefTime = TIME_UNKNOWN;
  187. p->Dropping = 1;
  188. p->Show = -1;
  189. if (p->IDCT.Ptr)
  190. p->IDCT.Ptr->Drop(p->IDCT.Ptr);
  191. if (p->Discontinuity)
  192. p->Discontinuity(p);
  193. return ERR_NONE;
  194. }
  196. static int Flush(codecidct* p)
  197. {
  198. Discontinuity(p);
  199. p->RefUpdated = 0;
  200. p->FrameEnd = 0;
  201. p->Dropping = 0;
  202. BufferClear(&p->Buffer);
  203. if (p->Flush)
  204. p->Flush(p);
  205. return ERR_NONE;
  206. }
  208. static int UpdateCount(codecidct* p)
  209. {
  210. if (p->IDCT.Ptr)
  211. {
  212. p->IDCT.Ptr->Get(p->IDCT.Ptr,IDCT_BUFFERCOUNT,&p->IDCT.Count,sizeof(int));
  214. if (p->UpdateCount)
  215. p->UpdateCount(p);
  217. if (p->IDCT.Width>0 && p->IDCT.Height>0 && p->IDCT.Count<p->MinCount)
  218. {
  219. p->IDCT.Ptr->Set(p->IDCT.Ptr,IDCT_FORMAT,NULL,0);
  220. return ERR_OUT_OF_MEMORY;
  221. }
  222. }
  223. return ERR_NONE;
  224. }
  226. static bool_t Prepair(codecidct* p)
  227. {
  228. int Result;
  229. idct* IDCT = p->IDCT.Ptr;
  230. p->IDCT.Count = 0;
  232. if (!IDCT || !p->IDCT.Format.Pixel.Flags)
  233. return ERR_NONE;
  235. Result = IDCT->Set(IDCT,IDCT_BUFFERWIDTH,&p->IDCT.Width,sizeof(int));
  236. if (Result != ERR_NONE) return Result;
  237. Result = IDCT->Set(IDCT,IDCT_BUFFERHEIGHT,&p->IDCT.Height,sizeof(int));
  238. if (Result != ERR_NONE) return Result;
  239. Result = IDCT->Set(IDCT,IDCT_FORMAT,&p->IDCT.Format,sizeof(video));
  240. if (Result != ERR_NONE) return Result;
  242. IDCT->Set(IDCT,IDCT_BUFFERCOUNT,&p->MinCount,sizeof(int));
  243. if (p->DefCount > p->MinCount) // optional
  244. {
  245. DisableOutOfMemory();
  246. IDCT->Set(IDCT,IDCT_BUFFERCOUNT,&p->DefCount,sizeof(int));
  247. EnableOutOfMemory();
  248. }
  249. IDCT->Drop(IDCT);
  251. return UpdateCount(p);
  252. }
  254. static int SetIDCT(codecidct* p, idct* Dst)
  255. {
  256. int Count;
  257. blitfx FX;
  258. planes SrcPlanes,DstPlanes;
  259. int SrcBrightness,DstBrightness;
  260. int SrcShift,DstShift;
  261. int No;
  262. int Result;
  263. idct* Src = p->IDCT.Ptr;
  265. if (Src == Dst)
  266. return ERR_NONE;
  268. if (!Src)
  269. {
  270. p->IDCT.Ptr = Dst;
  271. Result= Prepair(p);
  272. if (Result != ERR_NONE)
  273. p->IDCT.Ptr = NULL;
  274. return Result;
  275. }
  277. if (Dst)
  278. {
  279. assert(NodeIsClass(Dst->Class,IDCT_CLASS));
  281. if (Src->Get(Src,IDCT_SHIFT,&SrcShift,sizeof(SrcShift))!=ERR_NONE)
  282. SrcShift = 0;
  283. Dst->Set(Dst,IDCT_SHIFT,&SrcShift,sizeof(SrcShift));
  284. if (Dst->Get(Dst,IDCT_SHIFT,&DstShift,sizeof(DstShift))!=ERR_NONE)
  285. DstShift = 0;
  287. Result = Dst->Set(Dst,IDCT_MODE,&p->IDCT.Mode,sizeof(int));
  288. if (Result != ERR_NONE) return Result;
  289. Result = Dst->Set(Dst,IDCT_BUFFERWIDTH,&p->IDCT.Width,sizeof(int));
  290. if (Result != ERR_NONE) return Result;
  291. Result = Dst->Set(Dst,IDCT_BUFFERHEIGHT,&p->IDCT.Height,sizeof(int));
  292. if (Result != ERR_NONE) return Result;
  293. Result = Dst->Set(Dst,IDCT_FORMAT,&p->IDCT.Format,sizeof(video));
  294. if (Result != ERR_NONE) return Result;
  295. Result = Dst->Set(Dst,IDCT_BUFFERCOUNT,&p->MinCount,sizeof(int));
  296. if (Result != ERR_NONE) return Result;
  298. if (Src->Get(Src,IDCT_BUFFERCOUNT,&Count,sizeof(Count))==ERR_NONE && Count>p->MinCount)
  299. Dst->Set(Dst,IDCT_BUFFERCOUNT,&Count,sizeof(Count)); // optional
  301. memset(&FX,0,sizeof(FX));
  302. FX.ScaleX = SCALE_ONE;
  303. FX.ScaleY = SCALE_ONE;
  305. No = SrcShift - DstShift;
  306. if (No>0)
  307. {
  308. FX.ScaleX <<= No;
  309. FX.ScaleY <<= No;
  310. }
  311. else if (No<0)
  312. {
  313. FX.ScaleX >>= No;
  314. FX.ScaleY >>= No;
  315. }
  317. for (No=0;No<Count;++No)
  318. {
  319. video SrcFormat,DstFormat;
  320. int FrameNo = -1;
  321. Src->Get(Src,IDCT_FRAMENO+No,&FrameNo,sizeof(FrameNo));
  322. Dst->Set(Dst,IDCT_FRAMENO+No,&FrameNo,sizeof(FrameNo));
  324. if (Src->Lock(Src,No,SrcPlanes,&SrcBrightness,&SrcFormat) == ERR_NONE)
  325. {
  326. if (Dst->Lock(Dst,No,DstPlanes,&DstBrightness,&DstFormat) == ERR_NONE)
  327. {
  328. FX.Direction = CombineDir(SrcFormat.Direction, 0, DstFormat.Direction);
  329. FX.Brightness = DstBrightness - SrcBrightness;
  331. SurfaceCopy(&SrcFormat,&DstFormat,SrcPlanes,DstPlanes,&FX);
  333. Dst->Unlock(Dst,No);
  334. }
  335. Src->Unlock(Src,No);
  336. }
  337. }
  339. if (Src->Get(Src,IDCT_SHOW,&No,sizeof(No))==ERR_NONE)
  340. Dst->Set(Dst,IDCT_SHOW,&No,sizeof(No));
  341. }
  343. Src->Set(Src,IDCT_FORMAT,NULL,0);
  344. p->IDCT.Ptr = Dst;
  345. UpdateCount(p); // can't and shouldn't fail here (src already cleared and dst pointer saved)
  346. return ERR_NONE;
  347. }
  349. int CodecIDCTSetCount(codecidct* p, int Count)
  350. {
  351. if (!p->IDCT.Ptr)
  352. return ERR_NONE;
  353. p->IDCT.Ptr->Set(p->IDCT.Ptr,IDCT_BUFFERCOUNT,&Count,sizeof(int));
  354. return UpdateCount(p);
  355. }
  357. int CodecIDCTSetMode(codecidct* p, int Mode, bool_t Value)
  358. {
  359. if (Value)
  360. p->IDCT.Mode |= Mode;
  361. else
  362. p->IDCT.Mode &= ~Mode;
  364. if (p->IDCT.Ptr && p->IDCT.Ptr->Set(p->IDCT.Ptr,IDCT_MODE,&p->IDCT.Mode,sizeof(int))!=ERR_NONE)
  365. {
  366. if (p->NotSupported.Node)
  367. {
  368. pin Pin;
  369. Pin.No = CODECIDCT_IDCT;
  370. Pin.Node = &p->Node;
  371. if (p->NotSupported.Node->Set(p->NotSupported.Node,p->NotSupported.No,&Pin,sizeof(Pin)) == ERR_NONE)
  372. return ERR_NOT_COMPATIBLE;
  373. }
  374. return ERR_NOT_SUPPORTED;
  375. }
  376. return ERR_NONE;
  377. }
  379. int CodecIDCTSetFormat(codecidct* p, int Flags, int Width, int Height, int IDCTWidth, int IDCTHeight, int Aspect)
  380. {
  381. int Result = ERR_NONE;
  383. Flags |= p->In.Format.Format.Video.Pixel.Flags & PF_NOPREROTATE;
  385. if (p->IDCT.Format.Pixel.Flags != Flags ||
  386. p->IDCT.Format.Width != Width || 
  387. p->IDCT.Format.Height != Height ||
  388. p->IDCT.Format.Aspect != Aspect ||
  389. p->IDCT.Width != IDCTWidth ||
  390. p->IDCT.Height != IDCTHeight)
  391. {
  392. p->IDCT.Format.Pixel.Flags = Flags;
  393. p->IDCT.Format.Width = Width;
  394. p->IDCT.Format.Height = Height;
  395. p->IDCT.Format.Aspect = Aspect;
  396. p->IDCT.Width = IDCTWidth;
  397. p->IDCT.Height = IDCTHeight;
  399. p->In.Format.Format.Video.Width = Width;
  400. p->In.Format.Format.Video.Height = Height;
  402. if (p->UpdateSize)
  403. Result = p->UpdateSize(p);
  405. if (Result == ERR_NONE)
  406. Result = Prepair(p);
  407. }
  409. return Result;
  410. }
  412. static int UpdateInput(codecidct* p)
  413. {
  414. int Result = ERR_NONE;
  416. Flush(p);
  418. if (!PacketFormatMatch(p->Node.Class, &p->In.Format))
  419. PacketFormatClear(&p->In.Format);
  421. memset(&p->IDCT.Format,0,sizeof(video));
  422. if (p->UpdateInput)
  423. Result = p->UpdateInput(p);
  425. if (Result != ERR_NONE)
  426. PacketFormatClear(&p->In.Format);
  428. if (p->In.Format.Type != PACKET_VIDEO && p->IDCT.Ptr)
  429. p->IDCT.Ptr->Set(p->IDCT.Ptr,IDCT_FORMAT,NULL,0);
  431. return Result;
  432. }
  434. static int Process(codecidct* p, const packet* Packet, const flowstate* State)
  435. {
  436. int Result;
  437. idct* IDCT = p->IDCT.Ptr;
  439. if (p->IDCT.Count<=0 && p->IDCT.Width>0 && p->IDCT.Height>0)
  440. return ERR_INVALID_DATA;
  442. p->State.CurrTime = State->CurrTime;
  443. if (State->DropLevel > 1)
  444. Discontinuity(p);
  446. if (p->Show>=0) // pending frame?
  447. {
  448. Result = IDCT->Send(IDCT,p->RefTime,&p->State);
  449. if (Result == ERR_BUFFER_FULL)
  450. return Result;
  451. p->Show = -1;
  452. }
  454. if (!Packet) // end of file or dropped
  455. return IDCT->Null(IDCT,State,0);
  457. if ((p->In.Format.Format.Video.Pixel.Flags & PF_FRAGMENTED) && p->FindNext)
  458. {
  459. bool_t Processed = 0;
  461. //DEBUG_MSG2(DEBUG_CODEC,T("%d %d"),Packet->Length,Packet->RefTime);
  463. for (;;)
  464. {
  465. if (!p->FindNext(p))
  466. {
  467. if (Processed)
  468. {
  469. Result = ERR_NEED_MORE_DATA;
  470. break;
  471. }
  473. p->FrameEnd -= p->Buffer.ReadPos;
  474. BufferPack(&p->Buffer,0);
  475. BufferWrite(&p->Buffer,Packet->Data[0],Packet->Length,32768);
  476. Processed = 1;
  478. if (Packet->RefTime >= 0)
  479. {
  480. if (!p->RefUpdated)
  481. {
  482. p->RefTime = Packet->RefTime;
  483. p->RefUpdated = 1;
  484. // if (p->IDCT.Count >= 3 && p->FrameTime>0 && p->RefTime >= p->FrameTime)
  485. // p->RefTime -= p->FrameTime;
  486. }
  487. }
  488. else
  489. p->RefUpdated = 0;
  490. }
  491. else
  492. {
  493. //static tick_t Last = 0;
  494. //DEBUG_MSG2(DEBUG_CODEC,T("%d %d"),p->RefTime,p->RefTime-Last);
  495. //Last = p->RefTime;
  497. if (!p->FrameTime && !p->RefUpdated)
  498. p->RefTime = State->CurrTime;
  500. p->State.DropLevel = p->RefTime >= 0 && State->CurrTime >= 0 &&  
  501.                      p->RefTime < (State->CurrTime - p->DropTolerance);
  503. if (State->DropLevel > 1)
  504. {
  505. p->IDCT.Ptr->Null(p->IDCT.Ptr,NULL,0);
  506. Result = ERR_NONE;
  507. }
  508. else
  509. Result = p->Frame(p,p->Buffer.Data+p->Buffer.ReadPos,p->FrameEnd-p->Buffer.ReadPos); 
  511. p->Buffer.ReadPos = p->FrameEnd;
  513. if (p->RefTime >= 0)
  514. p->RefTime += p->FrameTime; 
  516. p->RefUpdated = 0;
  518. if (Result==ERR_NONE && p->Show>=0)
  519. {
  520. if (!Processed)
  521. Result = ERR_BUFFER_FULL; // resend packet next time
  522. break;
  523. }
  524. }
  525. }
  526. }
  527. else
  528. {
  529. if (State->DropLevel > 1)
  530. {
  531. p->IDCT.Ptr->Null(p->IDCT.Ptr,NULL,0);
  532. Result = ERR_NONE;
  533. }
  534. else
  535. {
  536. p->State.DropLevel = State->DropLevel;
  537. p->RefTime = Packet->RefTime;
  538. // if (p->IDCT.Count >= 3 && p->FrameTime>0 && p->RefTime >= p->FrameTime)
  539. // p->RefTime -= p->FrameTime;
  540. Result = p->Frame(p,Packet->Data[0],Packet->Length);
  541. }
  542. }
  544. if (p->Show>=0 && IDCT->Send(IDCT,p->RefTime,&p->State) != ERR_BUFFER_FULL)
  545. p->Show = -1;
  547. return Result;
  548. }
  550. int CodecIDCTSet(codecidct* p, int No, const void* Data, int Size)
  551. {
  552. node* Advanced;
  553. int Result = ERR_INVALID_PARAM;
  554. switch (No)
  555. {
  556. case CODECIDCT_INPUT: SETVALUE(p->In.Pin,pin,ERR_NONE); break;
  557. case CODECIDCT_INPUT|PIN_FORMAT: SETPACKETFORMAT(p->In.Format,packetformat,UpdateInput(p)); break;
  558. case CODECIDCT_IDCT:
  559. assert(Size==sizeof(idct*));
  560. Result = SetIDCT(p,*(idct**)Data);
  561. break;
  563. case FLOW_NOT_SUPPORTED: SETVALUE(p->NotSupported,pin,ERR_NONE); break;
  564. case FLOW_FLUSH: Result = Flush(p); break;
  565. case NODE_SETTINGSCHANGED:
  566. Advanced = Context()->Advanced;
  567. if (Advanced)
  568. Advanced->Get(Advanced,ADVANCED_DROPTOL,&p->DropTolerance,sizeof(tick_t));
  569. break;
  570. }
  571. return Result;
  572. }
  574. int CodecIDCTGet(codecidct* p, int No, void* Data, int Size)
  575. {
  576. int Result = ERR_INVALID_PARAM;
  577. switch (No)
  578. {
  579. case CODECIDCT_INPUT: GETVALUE(p->In.Pin,pin); break;
  580. case CODECIDCT_INPUT|PIN_FORMAT: GETVALUE(p->In.Format,packetformat); break;
  581. case CODECIDCT_INPUT|PIN_PROCESS: GETVALUE((packetprocess)Process,packetprocess); break;
  582. case CODECIDCT_IDCT: GETVALUE(p->IDCT.Ptr,idct*); break;
  583. }
  584. return Result;
  585. }
  587. static int Create(codecidct* p)
  588. {
  589. p->Node.Enum = CodecIDCTEnum;
  590. p->Node.Get = (nodeget)CodecIDCTGet;
  591. p->Node.Set = (nodeset)CodecIDCTSet;
  592. return ERR_NONE;
  593. }
  595. static void Delete(codecidct* p)
  596. {
  597. PacketFormatClear(&p->In.Format);
  598. if (p->UpdateInput)
  599. p->UpdateInput(p);
  600. }
  602. static const nodedef CodecIDCT =
  603. {
  604. sizeof(codecidct)|CF_ABSTRACT,
  605. CODECIDCT_CLASS,
  606. FLOW_CLASS,
  607. PRI_DEFAULT,
  608. (nodecreate)Create,
  609. (nodedelete)Delete,
  610. };
  612. void IDCT_Init()
  613. {
  614. NodeRegisterClass(&IDCT);
  615. NodeRegisterClass(&CodecIDCT);
  616. }
  618. void IDCT_Done()
  619. {
  620. NodeUnRegisterClass(CODECIDCT_CLASS);
  621. NodeUnRegisterClass(IDCT_CLASS);
  622. }