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

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

Windows CE

开发平台：

C/C++

softidct.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: softidct.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.  ****************************************************************************/
  23.  
  24. #include "../common.h"
  25. #include "softidct.h"
  27. #ifndef MIPS64
  28. #define MemCpy8 memcpy
  29. #define MemSet8 memset
  30. #else
  32. static void MemCpy8(void* dst,void* src,int len)
  33. {
  34. __asm( "addi $6,$6,-16;"
  35. "bltz $6,cpyskip16;"
  37. "cpyloop16:"
  38. "ldr $10,0($5);"
  39. "addi $6,$6,-16;"
  40. "ldr $11,8($5);"
  42. #ifdef MIPSVR41XX
  43. ".set noreorder;"
  44. "cache 13,0($4);" //cache without loading
  45. ".set reorder;"
  46. #endif
  47. "sdr $10,0($4);"
  48. "addi $5,$5,16;"
  49. "sdr $11,8($4);"
  50. "addi $4,$4,16;"
  51. "bgez $6,cpyloop16;"
  52. "cpyskip16:"
  54. "andi $6,$6,8;"
  55. "beq $6,$0,cpyskip8;"
  56. "ldr $10,0($5);"
  57. "sdr $10,0($4);"
  58. "cpyskip8:");
  59. }
  61. static void MemSet8(void* dst,int v,int len) 
  62. {
  63. __asm( "dsll $10,$5,56;"
  64. "dsrl $11,$10,8;"
  65. "or $10,$10,$11;"
  66. "dsrl $11,$10,16;"
  67. "or $10,$10,$11;"
  68. "dsrl $11,$10,32;"
  69. "or $10,$10,$11;"
  71. "addi $6,$6,-16;"
  72. "bltz $6,setskip16;"
  74. "setloop16:"
  76. #ifdef MIPSVR41XX
  77. ".set noreorder;"
  78. "cache 13,0($4);" //cache without loading
  79. ".set reorder;"
  80. #endif
  81. "sdr $10,0($4);"
  82. "addi $6,$6,-16;"
  83. "sdr $10,8($4);"
  84. "addi $4,$4,16;"
  85. "bgez $6,setloop16;"
  86. "setskip16:"
  88. "andi $6,$6,8;"
  89. "beq $6,$0,setskip8;"
  90. "sdr $10,0($4);"
  91. "setskip8:");
  92. }
  93. #endif
  95. static void FillEdge(uint8_t *Ptr, int Width, int Height, int EdgeX, int EdgeY)
  96. {
  97. int n;
  98. uint8_t *p;
  99. int InnerWidth = Width - EdgeX*2;
  100. int InnerHeight = Height - EdgeY*2;
  102. // left and right
  103. p = Ptr + EdgeX + EdgeY * Width;
  104. for (n=0;n<InnerHeight;++n)
  105. {
  106. MemSet8(p-EdgeX, p[0], EdgeX);
  107. MemSet8(p+InnerWidth,p[InnerWidth-1], EdgeX);
  108. p += Width;
  109. }
  111. // top
  112. p = Ptr;
  113. for (n=0;n<EdgeY;++n)
  114. {
  115. MemCpy8(p, Ptr+EdgeY * Width, Width);
  116. p += Width;
  117. }
  119. // bottom
  120. p = Ptr + (Height-EdgeY)*Width;
  121. for (n=0;n<EdgeY;++n)
  122. {
  123. MemCpy8(p, Ptr+(Height-EdgeY-1)*Width, Width);
  124. p += Width;
  125. }
  126. }
  128. static void FillEdgeYUV(softidct* p,uint8_t *Ptr)
  129. {
  130. FillEdge(Ptr, p->BufWidth, p->BufHeight, EDGE, EDGE);
  131. Ptr += p->YToU;
  132. FillEdge(Ptr, p->BufWidth>>p->UVX2, p->BufHeight>>p->UVY2, EDGE>>p->UVX2, EDGE>>p->UVY2);
  133. Ptr += p->YToU >> (p->UVX2+p->UVY2);
  134. FillEdge(Ptr, p->BufWidth>>p->UVX2, p->BufHeight>>p->UVY2, EDGE>>p->UVX2, EDGE>>p->UVY2);
  135. }
  137. #if defined(MIPS64_WIN32) 
  138. static int TouchPages(softidct* p)
  139. {
  140. uint8_t* i;
  141. int Sum = 0;
  142. for (i=p->CodeBegin;i<p->CodeEnd;i+=p->CodePage)
  143. Sum += *i;
  144. return Sum;
  145. }
  146. #endif
  148. static int Lock(softidct* p,int No,planes Planes,int* Brightness,video* Format)
  149. {
  150. if (Brightness)
  151. *Brightness = 0;
  152. if (Format)
  153. {
  154. *Format = p->Out.Format.Format.Video;
  155. Format->Pitch = p->BufWidth;
  156. Format->Width = p->BufWidth - 2*EDGE;
  157. Format->Height = p->BufHeight - 2*EDGE;
  158. }
  160. if (No<0 || No>=p->BufCount)
  161. {
  162. Planes[0] = NULL;
  163. Planes[1] = NULL;
  164. Planes[2] = NULL;
  165. return ERR_INVALID_PARAM;
  166. }
  168. Planes[0] = p->Buffer[No] + EDGE + EDGE*p->BufWidth;
  169. Planes[1] = p->Buffer[No] + p->YToU + (EDGE >> p->UVX2) + (EDGE >> p->UVY2)*(p->BufWidth >> p->UVX2);
  170. Planes[2] = (uint8_t*)Planes[1] + (p->YToU >> (p->UVX2+p->UVY2));
  171. return ERR_NONE;
  172. }
  174. static void Unlock(softidct* p,int No)
  175. {
  176. }
  178. #if defined(CONFIG_IDCT_LOWRES)
  180. static const copyblock AllCopyBlock4x4[2][16] = //[Rounding][x][y]
  181. {
  182.    { CopyBlock4x4_00, CopyBlock4x4_01, CopyBlock4x4_02, CopyBlock4x4_03,
  183.  CopyBlock4x4_10, CopyBlock4x4_11, CopyBlock4x4_12, CopyBlock4x4_13,
  184.  CopyBlock4x4_20, CopyBlock4x4_21, CopyBlock4x4_22, CopyBlock4x4_23,
  185.  CopyBlock4x4_30, CopyBlock4x4_31, CopyBlock4x4_32, CopyBlock4x4_33 },
  187.    { CopyBlock4x4_00, CopyBlock4x4_01R, CopyBlock4x4_02R, CopyBlock4x4_03R,
  188.      CopyBlock4x4_10R, CopyBlock4x4_11R, CopyBlock4x4_12R, CopyBlock4x4_13R,
  189.      CopyBlock4x4_20R, CopyBlock4x4_21R, CopyBlock4x4_22R, CopyBlock4x4_23R,
  190.      CopyBlock4x4_30R, CopyBlock4x4_31R, CopyBlock4x4_32R, CopyBlock4x4_33R },
  191. };
  193. #ifndef MIPS32
  194. const addblock TableAddBlock4x4[16] = 
  195. {
  196. AddBlock4x4_00,AddBlock4x4_01,AddBlock4x4_02,AddBlock4x4_03,
  197. AddBlock4x4_10,AddBlock4x4_11,AddBlock4x4_12,AddBlock4x4_13,
  198. AddBlock4x4_20,AddBlock4x4_21,AddBlock4x4_22,AddBlock4x4_23,
  199. AddBlock4x4_30,AddBlock4x4_31,AddBlock4x4_32,AddBlock4x4_33,
  200. };
  201. #endif
  202. #endif
  204. static const copyblock AllCopyBlock[2][4] = //[Rounding][x][y]
  205. {
  206. { CopyBlock, CopyBlockHor, CopyBlockVer, CopyBlockHorVer },
  207. { CopyBlock, CopyBlockHorRound, CopyBlockVerRound, CopyBlockHorVerRound }
  208. };
  210. #ifdef MIPS64
  211. static const copyblock AllCopyBlockM[2][4] = //[Rounding][x][y]
  212. {
  213. { CopyMBlock, CopyMBlockHor, CopyMBlockVer, CopyMBlockHorVer },
  214. { CopyMBlock, CopyMBlockHorRound, CopyMBlockVerRound, CopyMBlockHorVerRound }
  215. };
  216. #endif
  218. static int UpdateRounding(softidct* p)
  219. {
  220. #if defined(CONFIG_IDCT_LOWRES)
  221. if (p->Shift)
  222. p->CopyBlock4x4 = AllCopyBlock4x4[p->Rounding];
  223. else
  224. #endif
  225. memcpy(p->CopyBlock,p->AllCopyBlock[p->Rounding],sizeof(copyblock)*4);
  226. #ifdef MIPS64
  227. p->CopyMBlock = AllCopyBlockM[p->Rounding]; // no shift, instead 16x16
  228. #endif
  229. return ERR_NONE;
  230. }
  232. static const idctprocess Process[3] =   // pixelformat
  233. {
  234. (idctprocess)Process420,
  235. (idctprocess)Process422,
  236. (idctprocess)Process444,
  237. };
  239. static const idctcopy Copy16x16[3] =  // pixelformat
  240. {
  241. (idctcopy)Copy420,
  242. NULL,
  243. NULL,
  244. };
  246. #ifdef CONFIG_IDCT_SWAP
  247. static const idctprocess ProcessSwap[3] =   // pixelformat
  248. {
  249. (idctprocess)Process420Swap,
  250. (idctprocess)Process422Swap,
  251. (idctprocess)Process444Swap
  252. };
  254. static const idctcopy Copy16x16Swap[3] =  // pixelformat
  255. {
  256. (idctcopy)Copy420Swap,
  257. NULL,
  258. NULL,
  259. };
  260. #endif
  262. #if defined(CONFIG_IDCT_LOWRES)
  263. static const idctprocess ProcessHalf[3] =   // pixelformat
  264. {
  265. (idctprocess)Process420Half,
  266. (idctprocess)Process422Half,
  267. (idctprocess)Process444Half
  268. };
  270. static const idctprocess ProcessQuarter[3] =   // pixelformat
  271. {
  272. (idctprocess)Process420Quarter,
  273. (idctprocess)Process422Quarter,
  274. (idctprocess)Process444Quarter,
  275. };
  277. static const idctcopy Copy16x16Half[3] =  // pixelformat
  278. {
  279. (idctcopy)Copy420Half,
  280. NULL,
  281. NULL,
  282. };
  283. #endif
  285. static bool_t AllocBuffer(softidct* p,int i,block* Block,uint8_t** Ptr)
  286. {
  287. #ifndef MIPS
  288. int Align = 32;
  289. int Offset = 0;
  290. #else
  291. int Align = 8192;
  292. int Offset = ((i>>1)+(i&1)*2)*2048;
  293. #endif
  295. if (!AllocBlock(p->BufSize+Align+Offset,Block,0,HEAP_ANYWR))
  296. return 0;
  298. if (i>=2 && AvailMemory()<64*1024)
  299. {
  300. FreeBlock(Block);
  301. ShowOutOfMemory();
  302. return 0;
  303. }
  305. *Ptr = (uint8_t*)(((uintptr_t)Block->Ptr + Align-1) & ~(Align-1)) + Offset;
  306. return 1;
  307. }
  309. static int SetBufferCount(softidct* p, int n, int Temp)
  310. {
  311. int i;
  312. n += Temp;
  313. if (n>p->MaxCount) return ERR_NOT_SUPPORTED;
  315. for (i=n;i<p->BufCount;++i)
  316. {
  317. FreeBlock(&p->_Buffer[i]);
  318. p->Buffer[i] = NULL;
  319. p->BufAlloc[i] = 0;
  320. }
  321. if (p->BufCount > n)
  322. p->BufCount = n;
  324. for (i=p->BufCount;i<n;++i)
  325. {
  326. if (!p->BufSize)
  327. p->Buffer[i] = NULL;
  328. else
  329. if (!AllocBuffer(p,i,&p->_Buffer[i],&p->Buffer[i]))
  330. {
  331. p->MaxCount = p->BufCount;
  332. break;
  333. }
  334. p->BufAlloc[i] = p->BufSize;
  335. p->BufBorder[i] = 0;
  336. p->BufFrameNo[i] = -1;
  337. p->BufCount = i+1;
  338. }
  340. if (p->ShowNext >= p->BufCount)
  341. p->ShowNext = -1;
  342. if (p->ShowCurr >= p->BufCount)
  343. p->ShowCurr = -1;
  344. p->LastTemp = Temp && p->BufCount == n;
  346. if (p->BufCount != n)
  347. return ERR_OUT_OF_MEMORY;
  349. return ERR_NONE;
  350. }
  352. static int UpdateFormat(softidct* p)
  353. {
  354. if (p->Out.Format.Type == PACKET_VIDEO)
  355. {
  356. int AlignX,AlignY,Mode;
  357. int BlockSize;
  359. PlanarYUV(&p->Out.Format.Format.Video.Pixel,&p->UVX2,&p->UVY2,NULL);
  361. AlignX = (8 << p->UVX2) - 1;
  362. AlignY = (8 << p->UVY2) - 1;
  364. if (!p->BufferWidth || !p->BufferHeight)
  365. p->BufWidth = p->BufHeight = 0;
  366. else
  367. {
  368. p->BufWidth = (((p->BufferWidth+AlignX)&~AlignX) >> p->Shift)+2*EDGE;
  369. p->BufHeight = (((p->BufferHeight+AlignY)&~AlignY) >> p->Shift)+2*EDGE;
  370. }
  371. if (p->Out.Format.Format.Video.Direction & DIR_SWAPXY)
  372. SwapInt(&p->BufWidth,&p->BufHeight);
  374. p->YToU = p->BufHeight * p->BufWidth;
  375. p->BufSize = p->YToU + 2*(p->YToU >> (p->UVX2+p->UVY2));
  376. p->BufWidthUV = p->BufWidth >> p->UVX2;
  378. p->Out.Format.Format.Video.Pitch = p->BufWidth;
  380. BlockSize = 8 >> p->Shift;
  381. if (p->Out.Format.Format.Video.Pixel.Flags & PF_YUV420)
  382. {
  383. Mode = 0;
  384. p->Tab[0] = 2*(BlockSize); //Y[0;0] -> Y[0;1]
  385. p->Tab[1] = 2*(BlockSize*p->BufWidth-BlockSize); //Y[0;1] -> Y[1;0]
  386. p->Tab[2] = 2*(BlockSize); //Y[1;0] -> Y[1;1]
  387. p->Tab[4] = 2*(p->YToU >> 2); //U->V
  388. p->Tab[5] = 2*(0);
  389. }
  390. else 
  391. if (p->Out.Format.Format.Video.Pixel.Flags & PF_YUV422)
  392. {
  393. Mode = 1;
  394. p->Tab[0] = 2*(BlockSize); //Y[0;0] -> Y[0;1]
  395. p->Tab[2] = 2*(p->YToU >> 1); //U->V
  396. p->Tab[3] = 2*(0);
  397. }
  398. else
  399. if (p->Out.Format.Format.Video.Pixel.Flags & PF_YUV444)
  400. {
  401. Mode = 2;
  402. p->Tab[0] = 2*(p->YToU); //Y->U
  403. p->Tab[1] = 2*(p->YToU); //U->V
  404. p->Tab[2] = 2*(0);
  405. }
  406. else
  407. return ERR_NOT_SUPPORTED;
  409. if (Mode==0 && (p->Mode & IDCTMODE_QPEL))
  410. {
  411. p->IDCT.MComp8x8 = p->QPELMComp8x8;
  412. p->IDCT.MComp16x16 = p->QPELMComp16x16;
  413. }
  414. else
  415. {
  416. p->IDCT.MComp8x8 = (idctmcomp) SoftMComp8x8;
  417. p->IDCT.MComp16x16 = (idctmcomp) SoftMComp16x16;
  418. }
  420. #if defined(CONFIG_IDCT_LOWRES)
  421. if (p->Shift == 1)
  422. {
  423. p->IDCT.Process = ProcessHalf[Mode];
  424. p->IDCT.Copy16x16 = Copy16x16Half[Mode];
  425. p->IDCT.Intra8x8 = (idctintra)Intra8x8Half;
  426. }
  427. else
  428. if (p->Shift == 2)
  429. {
  430. p->IDCT.Process = ProcessQuarter[Mode];
  431. p->IDCT.Intra8x8 = (idctintra)Intra8x8Quarter;
  432. p->IDCT.Copy16x16 = NULL;
  433. }
  434. else
  435. #endif
  436. #ifdef CONFIG_IDCT_SWAP
  437. if (p->Out.Format.Format.Video.Direction & DIR_SWAPXY)
  438. {
  439. p->IDCT.Process = ProcessSwap[Mode];
  440. p->IDCT.Copy16x16 = Copy16x16Swap[Mode];
  441. p->IDCT.Intra8x8 = p->Intra8x8Swap;
  442. p->IDCT.MComp8x8 = (idctmcomp) SoftMComp8x8Swap;
  443. p->IDCT.MComp16x16 = (idctmcomp) SoftMComp16x16Swap;
  445. if (Mode == 0)
  446. {
  447. p->Tab[0] = 2*(8*p->BufWidth); //Y[0;0] -> Y[1;0]
  448. p->Tab[1] = 2*(8-8*p->BufWidth); //Y[1;0] -> Y[0;1]
  449. p->Tab[2] = 2*(8*p->BufWidth); //Y[0;1] -> Y[1;1]
  450. }
  451. }
  452. else
  453. #endif
  454. {
  455. p->IDCT.Process = Process[Mode];
  456. p->IDCT.Copy16x16 = Copy16x16[Mode];
  457. p->IDCT.Intra8x8 = p->Intra8x8;
  458. }
  460. #if defined(MIPS64)
  461. p->IDCT.Inter8x8 = Inter8x8Add;
  462. #endif
  464. }
  465. return ConnectionUpdate((node*)p,IDCT_OUTPUT,p->Out.Pin.Node,p->Out.Pin.No);
  466. }
  468. #ifdef CONFIG_IDCT_SWAP
  469. static int ChangeSwap(softidct* p)
  470. {
  471. if (p->BufCount > 0)
  472. {
  473. int No;
  474. planes TmpPlanes;
  475. video TmpFormat;
  476. int Brightness;
  477. video Format[2];
  478. planes Planes[2];
  480. TmpFormat = p->Out.Format.Format.Video;
  481. TmpFormat.Width = p->BufWidth - 2*EDGE;
  482. TmpFormat.Height = p->BufHeight - 2*EDGE;
  484. if (SurfaceAlloc(TmpPlanes,&TmpFormat) == ERR_NONE)
  485. {
  486. if (Lock(p,0,Planes[0],&Brightness,&Format[0])==ERR_NONE)
  487. {
  488. SurfaceCopy(&Format[0],&TmpFormat,Planes[0],TmpPlanes,NULL);
  489. Unlock(p,0);
  490. }
  492. for (No=1;No<p->BufCount;++No)
  493. if (Lock(p,No,Planes[0],&Brightness,&Format[0])==ERR_NONE)
  494. {
  495. SwapInt(&p->BufWidth,&p->BufHeight);
  496. if (Lock(p,0,Planes[1],&Brightness,&Format[1])==ERR_NONE)
  497. {
  498. block Tmp;
  499. SurfaceRotate(&Format[0],&Format[1],Planes[0],Planes[1],DIR_SWAPXY);
  500. Unlock(p,0);
  502. SwapPByte(&p->Buffer[No],&p->Buffer[0]);
  503. Tmp = p->_Buffer[0];
  504. p->_Buffer[0] = p->_Buffer[No];
  505. p->_Buffer[No] = Tmp;
  506. p->BufBorder[No] = 0;
  507. SwapInt(&p->BufAlloc[No],&p->BufAlloc[0]);
  508. }
  509. SwapInt(&p->BufWidth,&p->BufHeight);
  510. Unlock(p,No);
  511. }
  513. SwapInt(&p->BufWidth,&p->BufHeight);
  514. if (Lock(p,0,Planes[0],&Brightness,&Format[0])==ERR_NONE)
  515. {
  516. SurfaceRotate(&TmpFormat,&Format[0],TmpPlanes,Planes[0],DIR_SWAPXY);
  517. Unlock(p,0);
  518. p->BufBorder[0] = 0;
  519. }
  520. SwapInt(&p->BufWidth,&p->BufHeight);
  522. SurfaceFree(TmpPlanes);
  523. }
  524. }
  526. p->Out.Format.Format.Video.Direction ^= DIR_SWAPXY;
  527. SwapInt(&p->Out.Format.Format.Video.Width,&p->Out.Format.Format.Video.Height);
  528. SwapInt(&p->OutWidth,&p->OutHeight);
  529. return UpdateFormat(p);
  530. }
  531. #endif
  533. static int Send(softidct* p,tick_t RefTime,const flowstate* State);
  535. static int VerifyShift(softidct* p,int Shift)
  536. {
  537. // have to keep dword pitch alignment
  538. if (p->BufferWidth && Shift>0)
  539. {
  540. int AlignX = (8 << p->UVX2) - 1;
  541. int BufWidth = ((p->BufferWidth+AlignX)&~AlignX) >> (Shift+p->UVX2);
  542. if (BufWidth & 1)
  543. {
  544. Shift -= 2;
  545. }
  546. else
  547. if (BufWidth & 3)
  548. {
  549. --Shift;
  550. }
  551. if (Shift<0)
  552. Shift=0;
  553. }
  554. return Shift;
  555. }
  557. static int SetShift(softidct* p,int Shift,int Count)
  558. {
  559. #if !defined(CONFIG_IDCT_LOWRES)
  560. return ERR_NOT_SUPPORTED;
  561. #else
  562. if (Shift<0 || Shift>2) 
  563. return ERR_NOT_SUPPORTED;
  565. #ifdef CONFIG_IDCT_SWAP
  566. if (Shift>0 && (p->Out.Format.Format.Video.Direction & DIR_SWAPXY))
  567. ChangeSwap(p);
  568. #endif
  570. Shift = VerifyShift(p,Shift);
  571. if (p->Shift != Shift)
  572. {
  573. flowstate State;
  574. blitfx FX;
  575. planes Src[MAXIDCTBUF];
  576. planes Dst;
  577. video SrcFormat;
  578. video DstFormat;
  579. uint8_t *TmpPtr = NULL;
  580. planes Tmp;
  581. block TmpBlock;
  582. int Diff = Shift - p->Shift;
  583. int i;
  585. if (AllocBlock(p->BufSize+16,&TmpBlock,0,HEAP_ANYWR))
  586. {
  587. TmpPtr = (uint8_t*)ALIGN16((uintptr_t)TmpBlock.Ptr);
  588. Tmp[0] = TmpPtr + EDGE + EDGE*p->BufWidth;
  589. Tmp[1] = TmpPtr + p->YToU + (EDGE >> p->UVX2) + (EDGE >> p->UVY2)*(p->BufWidth >> p->UVX2);
  590. Tmp[2] = (uint8_t*)Tmp[1] + (p->YToU >> (p->UVX2+p->UVY2));
  591. }
  593. for (i=0;i<Count;++i)
  594. Lock(p,i,Src[i],NULL,&SrcFormat);
  596. p->Out.Format.Format.Video.Width = p->OutWidth >> Shift;
  597. p->Out.Format.Format.Video.Height = p->OutHeight >> Shift;
  599. memset(&FX,0,sizeof(FX));
  600. if (Diff>0)
  601. {
  602. FX.ScaleX = SCALE_ONE >> Diff;
  603. FX.ScaleY = SCALE_ONE >> Diff;
  604. }
  605. else
  606. {
  607. FX.ScaleX = SCALE_ONE << -Diff;
  608. FX.ScaleY = SCALE_ONE << -Diff;
  609. }
  611. p->Shift = Shift;
  612. UpdateRounding(p);
  613. UpdateFormat(p);
  615. for (i=0;i<Count;++i)
  616. {
  617. if (TmpPtr)
  618. SurfaceCopy(&SrcFormat,&SrcFormat,Src[i],Tmp,NULL);
  620. if (p->BufAlloc[i] < p->BufSize)
  621. {
  622. uint8_t* Ptr;
  623. block Block;
  624. if (!AllocBuffer(p,i,&Block,&Ptr)) // realloc buffer if neccessary)
  625. {
  626. if (TmpPtr)
  627. FreeBlock(&TmpBlock);
  628. SetShift(p,Shift - Diff,i); // restore (shrinking won't need more memory)
  629. return ERR_OUT_OF_MEMORY;
  630. }
  631. FreeBlock(&p->_Buffer[i]);
  632. p->Buffer[i] = Ptr;
  633. p->_Buffer[i] = Block;
  634. p->BufAlloc[i] = p->BufSize;
  635. }
  637. if (TmpPtr)
  638. {
  639. Lock(p,i,Dst,NULL,&DstFormat);
  640. SurfaceCopy(&SrcFormat,&DstFormat,Tmp,Dst,&FX);
  641. }
  642. p->BufBorder[i] = 0;
  643. }
  645. if (TmpPtr)
  646. FreeBlock(&TmpBlock);
  648. State.CurrTime = TIME_RESEND;
  649. State.DropLevel = 0;
  650. Send(p,TIME_UNKNOWN,&State);
  651. }
  652. return ERR_NONE;
  653. #endif
  654. }
  656. static int UpdateMode(softidct* p)
  657. {
  658. if (p->Mode & ~p->ModeSupported)
  659. return ERR_NOT_SUPPORTED;
  661. #ifdef CONFIG_IDCT_SWAP
  662. if (p->Mode && (p->Out.Format.Format.Video.Direction & DIR_SWAPXY))
  663. ChangeSwap(p);
  664. #endif
  666. #if defined(CONFIG_IDCT_LOWRES)
  667. if (p->Mode && p->Shift)
  668. return SetShift(p,0,p->BufCount);
  669. #endif
  671. UpdateRounding(p);
  672. UpdateFormat(p);
  673. return ERR_NONE;
  674. }
  676. static int SetFormat(softidct* p, const video* Format)
  677. {
  678. SetBufferCount(p,0,0);
  679. PacketFormatClear(&p->Out.Format);
  681. if (Format)
  682. {
  683. size_t Area;
  685. if (!(Format->Pixel.Flags & (PF_YUV420|PF_YUV422|PF_YUV444)))
  686. return ERR_NOT_SUPPORTED;
  688. p->Out.Format.Type = PACKET_VIDEO;
  689. p->Out.Format.Format.Video = *Format;
  690. if (p->Out.Format.Format.Video.Direction & DIR_SWAPXY)
  691. SwapInt(&p->Out.Format.Format.Video.Width,&p->Out.Format.Format.Video.Height);
  692. p->Out.Format.Format.Video.Direction = 0;
  693. p->Out.Format.Format.Video.Pixel.Flags |= PF_16ALIGNED | PF_SAFEBORDER;
  694. p->MaxCount = MAXBUF;
  695. p->Rounding = 0;
  697. Area = p->Out.Format.Format.Video.Width * p->Out.Format.Format.Video.Height;
  698. if (Area >= 1024*1024 && AvailMemory() < Area*2)
  699. {
  700. video Desktop;
  701. size_t DesktopArea;
  702. QueryDesktop(&Desktop);
  703. DesktopArea = Desktop.Width * Desktop.Height;
  704. if (Area >= DesktopArea*4 && p->Shift<1)
  705. p->Shift = 1;
  706. if (Area >= DesktopArea*16 && p->Shift<2)
  707. p->Shift = 2;
  708. }
  710. p->Shift = VerifyShift(p,p->Shift);
  712. #if defined(MIPS64)
  713. if (p->Shift>0)
  714. return ERR_NOT_SUPPORTED; // fallback to mips32
  715. #endif
  717. p->OutWidth = p->Out.Format.Format.Video.Width;
  718. p->OutHeight = p->Out.Format.Format.Video.Height;
  719. p->Out.Format.Format.Video.Width >>= p->Shift;
  720. p->Out.Format.Format.Video.Height >>= p->Shift;
  722. UpdateRounding(p);
  723. }
  725. #ifdef FREESCALE_MX1
  726. if (p->MX1)
  727. {
  728. volatile int* Cmd = p->MX1-64; //0x22400
  729. volatile int* GCCR = p->MX1-6972; //0x1B810
  730. if (Format)
  731. {
  732. *GCCR |= 2;
  733. ThreadSleep(1);
  734. *Cmd = 0x284C+0x20;
  735. ThreadSleep(1);
  736. *Cmd = 0x284D;
  737. }
  738. else
  739. {
  740. *Cmd = 0x00;
  741. *GCCR &= ~2;
  742. }
  743. }
  744. #endif
  746. return UpdateFormat(p);
  747. }
  749. static int Set(softidct* p, int No, const void* Data, int Size)
  750. {
  751. flowstate State;
  752. int Result = ERR_INVALID_PARAM;
  754. switch (No)
  755. {
  756. case NODE_SETTINGSCHANGED:
  757. p->NeedLast = QueryAdvanced(ADVANCED_SLOW_VIDEO);
  758. break;
  760. case IDCT_SHOW: 
  761. SETVALUE(p->ShowNext,int,ERR_NONE); 
  762. if (p->ShowNext >= p->BufCount) p->ShowNext = -1;
  763. break;
  765. case FLOW_FLUSH:
  766. p->ShowCurr = -1;
  767. p->ShowNext = -1;
  768. return ERR_NONE;
  770. case IDCT_BACKUP: 
  771. assert(Size == sizeof(idctbackup));
  772. Result = IDCTRestore(&p->IDCT,(idctbackup*)Data);
  773. break;
  775. case IDCT_MODE: SETVALUECMP(p->Mode,int,UpdateMode(p),EqInt); break;
  776. case IDCT_BUFFERWIDTH: SETVALUE(p->BufferWidth,int,ERR_NONE); break;
  777. case IDCT_BUFFERHEIGHT: SETVALUE(p->BufferHeight,int,ERR_NONE); break;
  778. case IDCT_FORMAT:
  779. assert(Size == sizeof(video) || !Data);
  780. Result = SetFormat(p,(const video*)Data);
  781. break;
  783. case IDCT_OUTPUT|PIN_PROCESS: SETVALUE(p->Out.Process,packetprocess,ERR_NONE); break;
  785. #ifdef CONFIG_IDCT_SWAP
  786. case IDCT_OUTPUT|PIN_FORMAT:
  787. assert(Size == sizeof(packetformat) || !Data);
  788. if (Data && QueryAdvanced(ADVANCED_IDCTSWAP) && !p->Shift && !p->Mode &&
  789. !(p->Out.Format.Format.Video.Pixel.Flags & PF_YUV422) &&
  790. PacketFormatRotatedVideo(&p->Out.Format,(packetformat*)Data,DIR_SWAPXY))
  791. Result = ChangeSwap(p);
  792. break;
  793. #endif
  795. case IDCT_OUTPUT: SETVALUE(p->Out.Pin,pin,ERR_NONE); break;
  796. case IDCT_ROUNDING: SETVALUE(p->Rounding,bool_t,UpdateRounding(p)); break;
  797. case IDCT_SHIFT: 
  798. assert(Size == sizeof(int));
  799. Result = SetShift(p,*(const int*)Data,p->BufCount);
  800. break;
  802. case IDCT_BUFFERCOUNT:
  803. assert(Size == sizeof(int));
  804. Result = ERR_NONE;
  805. if (p->BufCount < *(const int*)Data)
  806. Result = SetBufferCount(p,*(const int*)Data,0);
  807. break;
  809. case FLOW_RESEND:
  810. State.CurrTime = TIME_RESEND;
  811. State.DropLevel = 0;
  812. Result = Send(p,TIME_UNKNOWN,&State);
  813. break;
  814. }
  816. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+p->BufCount)
  817. SETVALUE(p->BufFrameNo[No-IDCT_FRAMENO],int,ERR_NONE);
  819. return Result;
  820. }
  822. static int Get(softidct* p, int No, void* Data, int Size)
  823. {
  824. int Result = ERR_INVALID_PARAM;
  825. switch (No)
  826. {
  827. case FLOW_BUFFERED: GETVALUE(1,bool_t); break;
  828. case IDCT_OUTPUT|PIN_PROCESS: GETVALUE(p->Out.Process,packetprocess); break;
  829. case IDCT_OUTPUT|PIN_FORMAT: GETVALUE(p->Out.Format,packetformat); break;
  830. case IDCT_OUTPUT: GETVALUE(p->Out.Pin,pin); break;
  831. case IDCT_FORMAT: GETVALUE(p->Out.Format.Format.Video,video); break;
  832. case IDCT_ROUNDING: GETVALUE(p->Rounding,bool_t); break;
  833. case IDCT_SHIFT: GETVALUE(p->Shift,int); break;
  834. case IDCT_MODE: GETVALUE(p->Mode,int); break;
  835. case IDCT_BUFFERCOUNT: GETVALUE(p->BufCount - p->LastTemp,int); break;
  836. case IDCT_BUFFERWIDTH: GETVALUE(p->BufferWidth,int); break;
  837. case IDCT_BUFFERHEIGHT: GETVALUE(p->BufferHeight,int); break;
  838. case IDCT_SHOW: GETVALUE(p->ShowNext,int); break;
  839. case IDCT_BACKUP: 
  840. assert(Size == sizeof(idctbackup));
  841. Result = IDCTBackup(&p->IDCT,(idctbackup*)Data);
  842. break;
  843. }
  844. if (No>=IDCT_FRAMENO && No<IDCT_FRAMENO+p->BufCount)
  845. GETVALUE(p->BufFrameNo[No-IDCT_FRAMENO],int);
  846. return Result;
  847. }
  849. static void Drop(softidct* p)
  850. {
  851. int i;
  852. for (i=0;i<p->BufCount;++i)
  853. p->BufFrameNo[i] = -1;
  854. }
  856. static int Null(softidct* p,const flowstate* State,bool_t Empty)
  857. {
  858. packet* Packet = NULL;
  859. packet EmptyPacket;
  860. flowstate DropState;
  861. if (!State)
  862. {
  863. DropState.CurrTime = TIME_UNKNOWN;
  864. DropState.DropLevel = 1;
  865. State = &DropState;
  866. }
  867. if (Empty)
  868. {
  869. memset(&EmptyPacket,0,sizeof(EmptyPacket));
  870. EmptyPacket.RefTime = TIME_UNKNOWN;
  871. Packet = &EmptyPacket;
  872. }
  873. return p->Out.Process(p->Out.Pin.Node,Packet,State);
  874. }
  876. static int Send(softidct* p,tick_t RefTime,const flowstate* State)
  877. {
  878. packet Packet;
  879. int Result = ERR_INVALID_DATA;
  881. if (State->DropLevel)
  882. return p->Out.Process(p->Out.Pin.Node,NULL,State);
  884. if (p->ShowNext < 0)
  885. return ERR_NEED_MORE_DATA;
  887. if (p->ShowCurr == p->ShowNext)
  888. p->ShowCurr = -1;
  890. if (Lock(p,p->ShowNext,*(planes*)&Packet.Data,NULL,NULL) == ERR_NONE)
  891. {
  892. Lock(p,p->ShowCurr,*(planes*)&Packet.LastData,NULL,NULL);
  894. Packet.RefTime = RefTime;
  895. Result = p->Out.Process(p->Out.Pin.Node,&Packet,State);
  897. Unlock(p,p->ShowCurr);
  898. Unlock(p,p->ShowNext);
  899. }
  901. if (Result != ERR_BUFFER_FULL)
  902. p->ShowCurr = p->ShowNext;
  904. return Result;
  905. }
  907. static int FrameStart(softidct* p,int FrameNo,int* OldFrameNo,int DstNo,int BackNo,int FwdNo,int ShowNo,bool_t Drop)
  908. {
  909. #if defined(MIPS64_WIN32) 
  910. // win32 doesn't support 64bit natively. thread and process
  911. // changes won't save upper part of 64bit registers.
  912. // we have to disable interrupt and make sure all 1KB
  913. // code pages are in memory so no page loading is called
  914. // during code execution 
  915. p->KMode = KernelMode(1);
  916. TouchPages(p);
  917. DisableInterrupts();
  918. p->NextIRQ = 0;
  919. #endif
  921. if (!p->CopyBlock && (BackNo>=0 || FwdNo>=0))
  922. return ERR_NOT_SUPPORTED;
  924. #ifdef ARM
  925. // ShowCurr will be the next "LastData" in output packet
  926. // we don't want to lose it's content
  927. if (p->NeedLast && p->ShowCurr == DstNo)
  928. {
  929. int SwapNo;
  930. for (SwapNo=0;SwapNo<p->BufCount;++SwapNo)
  931. if (SwapNo != DstNo && SwapNo != BackNo && SwapNo != FwdNo && SwapNo != ShowNo)
  932. break;
  934. if (SwapNo < p->BufCount || SetBufferCount(p,p->BufCount,1)==ERR_NONE)
  935. {
  936. //DEBUG_MSG2("IDCT Swap %d,%d",SwapNo,DstNo);
  937. block Tmp;
  939. Tmp = p->_Buffer[SwapNo];
  940. p->_Buffer[SwapNo] = p->_Buffer[DstNo];
  941. p->_Buffer[DstNo] = Tmp;
  943. SwapPByte(&p->Buffer[SwapNo],&p->Buffer[DstNo]);
  944. SwapInt(&p->BufFrameNo[SwapNo],&p->BufFrameNo[DstNo]);
  945. SwapBool(&p->BufBorder[SwapNo],&p->BufBorder[DstNo]);
  946. SwapInt(&p->BufAlloc[SwapNo],&p->BufAlloc[DstNo]);
  948. p->ShowCurr = SwapNo;
  949. }
  950. }
  951. #endif
  953. p->ShowNext = ShowNo;
  955. if (OldFrameNo)
  956. *OldFrameNo = p->BufFrameNo[DstNo];
  957. p->BufFrameNo[DstNo] = FrameNo;
  959. p->Dst = p->Buffer[DstNo];
  960. p->Ref[0] = NULL;
  961. p->Ref[1] = NULL;
  962. p->RefMin[0] = NULL;
  963. p->RefMin[1] = NULL;
  964. p->RefMax[0] = NULL;
  965. p->RefMax[1] = NULL;
  967. if (BackNo>=0)
  968. {
  969. p->Ref[0] = p->Buffer[BackNo];
  970. if (!p->BufBorder[BackNo])
  971. {
  972. p->BufBorder[BackNo] = 1;
  973. FillEdgeYUV(p,p->Ref[0]);
  974. }
  975. p->RefMin[0] = p->Ref[0];
  976. p->RefMax[0] = p->Ref[0] + p->BufSize - ((8+8*p->BufWidthUV)>>p->Shift);
  977. }
  979. if (FwdNo>=0)
  980. {
  981. p->Ref[1] = p->Buffer[FwdNo];
  982. if (!p->BufBorder[FwdNo])
  983. {
  984. p->BufBorder[FwdNo] = 1;
  985. FillEdgeYUV(p,p->Ref[1]);
  986. }
  987. p->RefMin[1] = p->Ref[1];
  988. p->RefMax[1] = p->Ref[1] + p->BufSize - ((8+8*p->BufWidthUV)>>p->Shift);
  989. }
  991. p->BufBorder[DstNo] = 0; //invalidate border for dst
  993. #if !defined(MIPS64)
  995. #if defined(CONFIG_IDCT_LOWRES)
  996. if (p->Shift == 1)
  997. p->IDCT.Inter8x8 = p->Ref[1]!=NULL?(idctinter)Inter8x8BackFwdHalf:(idctinter)Inter8x8BackHalf;
  998. else
  999. #endif
  1000. #ifdef CONFIG_IDCT_SWAP
  1001. if (p->Out.Format.Format.Video.Direction & DIR_SWAPXY)
  1002. p->IDCT.Inter8x8 = p->Inter8x8Swap[p->Ref[1]!=NULL];
  1003. else
  1004. #endif
  1005. p->IDCT.Inter8x8 = p->Inter8x8[p->Ref[1]!=NULL];
  1006. #endif
  1008. p->inter8x8uv = p->IDCT.Inter8x8; // for qpel
  1010. #ifdef FREESCALE_MX1
  1011. if (p->MX1)
  1012. p->MX1Pop = MX1PopNone;
  1013. #endif
  1015. return ERR_NONE;
  1016. } 
  1018. static void FrameEnd(softidct* p)
  1019. {
  1020. #ifdef MIPS64_WIN32
  1021. EnableInterrupts();
  1022. KernelMode(p->KMode);
  1023. #endif
  1024. #ifdef FREESCALE_MX1
  1025. if (p->MX1)
  1026. p->MX1Pop(p);
  1027. #endif
  1028. }
  1030. static int Create(softidct* p)
  1031. {
  1032. #if defined(MMX)
  1033. if (!(QueryPlatform(PLATFORM_CAPS) & CAPS_X86_MMX))
  1034. return ERR_NOT_SUPPORTED;
  1035. #endif
  1037. #if defined(MIPS64)
  1038. if (!QueryAdvanced(ADVANCED_VR41XX))
  1039. return ERR_NOT_SUPPORTED;
  1041. #if defined(MIPSVR41XX)
  1042. if (!(QueryPlatform(PLATFORM_CAPS) & CAPS_MIPS_VR4120))
  1043. return ERR_NOT_SUPPORTED;
  1044. #endif
  1045. #endif
  1047. p->IDCT.Get = (nodeget)Get;
  1048. p->IDCT.Set = (nodeset)Set;
  1049. p->IDCT.Send = (idctsend)Send;
  1050. p->IDCT.Null = (idctnull)Null;
  1051. p->IDCT.Drop = (idctdrop)Drop;
  1052. p->IDCT.Lock = (idctlock)Lock;
  1053. p->IDCT.Unlock = (idctunlock)Unlock;
  1054. p->IDCT.FrameStart = (idctframestart)FrameStart;
  1055. p->IDCT.FrameEnd = (idctframeend)FrameEnd;
  1057. #if !defined(MIPS64) && !defined(MIPS32)
  1058. p->AddBlock[0] = AddBlock;
  1059. p->AddBlock[1] = AddBlockHor;
  1060. p->AddBlock[2] = AddBlockVer;
  1061. p->AddBlock[3] = AddBlockHorVer;
  1062. #endif
  1064. memcpy(p->AllCopyBlock,AllCopyBlock,sizeof(AllCopyBlock));
  1066. p->Intra8x8 = (idctintra)Intra8x8;
  1068. #ifndef MIPS64
  1069. p->Inter8x8[0] = (idctinter)Inter8x8Back;
  1070. p->Inter8x8[1] = (idctinter)Inter8x8BackFwd;
  1071. p->QPELInter = (idctinter)Inter8x8QPEL;
  1072. p->QPELCopyBlockM = (copyblock)CopyBlockM;
  1073. p->Inter8x8GMC = (idctinter)Inter8x8GMC;
  1074. #endif
  1076. #ifdef CONFIG_IDCT_SWAP
  1077. p->Intra8x8Swap = (idctintra)Intra8x8Swap;
  1079. #ifndef MIPS64
  1080. p->Inter8x8Swap[0] = (idctinter)Inter8x8BackSwap;
  1081. p->Inter8x8Swap[1] = (idctinter)Inter8x8BackFwdSwap;
  1082. #endif
  1083. #endif 
  1085. #if defined(MIPS64_WIN32) 
  1086. CodeFindPages(*(void**)&p->IDCT.Enum,&p->CodeBegin,&p->CodeEnd,&p->CodePage);
  1087. #endif
  1089. #if defined(ARM)
  1091. #if defined(FREESCALE_MX1)
  1092. if (QueryPlatform(PLATFORM_MODEL)==MODEL_ZODIAC)
  1093. {
  1094. p->MX1 = (int*)0x80022500;
  1096. p->Intra8x8 = (idctintra)MX1Intra8x8;
  1097. p->Inter8x8[0] = (idctinter)MX1Inter8x8Back;
  1098. p->Inter8x8[1] = (idctinter)MX1Inter8x8BackFwd;
  1100. #ifdef CONFIG_IDCT_SWAP
  1101. p->Intra8x8Swap = (idctintra)MX1Intra8x8Swap;
  1102. p->Inter8x8Swap[0] = (idctinter)MX1Inter8x8BackSwap;
  1103. p->Inter8x8Swap[1] = (idctinter)MX1Inter8x8BackFwdSwap;
  1104. #endif
  1105. }
  1106. else
  1107. #endif
  1109. #if (!defined(TARGET_PALMOS) && !defined(TARGET_SYMBIAN)) || (__GNUC__>=4) || (__GNUC__==3 && __GNUC_MINOR__>=4)
  1110. if (!QueryAdvanced(ADVANCED_NOWMMX) && 
  1111. (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_WMMX))
  1112. {
  1113. p->Intra8x8 = (idctintra)WMMXIntra8x8;
  1114. p->Inter8x8[0] = (idctinter)WMMXInter8x8Back;
  1115. p->Inter8x8[1] = (idctinter)WMMXInter8x8BackFwd;
  1116. p->QPELInter = (idctinter)WMMXInter8x8QPEL;
  1117. p->Inter8x8GMC = (idctinter)WMMXInter8x8GMC;
  1118. p->QPELCopyBlockM = (copyblock)WMMXCopyBlockM;
  1120. #ifdef CONFIG_IDCT_SWAP
  1121. p->Intra8x8Swap = (idctintra)WMMXIntra8x8Swap;
  1122. p->Inter8x8Swap[0] = (idctinter)WMMXInter8x8BackSwap;
  1123. p->Inter8x8Swap[1] = (idctinter)WMMXInter8x8BackFwdSwap;
  1124. #endif
  1126. p->AllCopyBlock[0][0] = WMMXCopyBlock;
  1127. p->AllCopyBlock[0][1] = WMMXCopyBlockHor;
  1128. p->AllCopyBlock[0][2] = WMMXCopyBlockVer;
  1129. p->AllCopyBlock[0][3] = WMMXCopyBlockHorVer;
  1130. p->AllCopyBlock[1][0] = WMMXCopyBlock;
  1131. p->AllCopyBlock[1][1] = WMMXCopyBlockHorRound;
  1132. p->AllCopyBlock[1][2] = WMMXCopyBlockVerRound;
  1133. p->AllCopyBlock[1][3] = WMMXCopyBlockHorVerRound;
  1134. p->AddBlock[0] = WMMXAddBlock;
  1135. p->AddBlock[1] = WMMXAddBlockHor;
  1136. p->AddBlock[2] = WMMXAddBlockVer;
  1137. p->AddBlock[3] = WMMXAddBlockHorVer;
  1138. }
  1139. else
  1140. #endif // TARGET_PALMOS
  1141. {}
  1142. /* if (QueryPlatform(PLATFORM_CAPS) & CAPS_ARM_5E)
  1143. {
  1144. if (QueryPlatform(PLATFORM_ICACHE) >= 32768)
  1145. {
  1146. p->AllCopyBlock[0][0] = FastCopyBlock;
  1147. p->AllCopyBlock[0][1] = FastCopyBlockHor;
  1148. p->AllCopyBlock[0][2] = FastCopyBlockVer;
  1149. p->AllCopyBlock[0][3] = FastCopyBlockHorVer;
  1150. p->AllCopyBlock[0][0] = FastCopyBlock;
  1151. p->AllCopyBlock[1][1] = FastCopyBlockHorRound;
  1152. p->AllCopyBlock[1][2] = FastCopyBlockVerRound;
  1153. p->AllCopyBlock[1][3] = FastCopyBlockHorVerRound;
  1154. p->AddBlock[0] = FastAddBlock;
  1155. p->AddBlock[1] = FastAddBlockHor;
  1156. p->AddBlock[2] = FastAddBlockVer;
  1157. p->AddBlock[3] = FastAddBlockHorVer;
  1158. }
  1159. else
  1160. {
  1161. p->AllCopyBlock[0][0] = PreLoadCopyBlock;
  1162. p->AllCopyBlock[0][1] = PreLoadCopyBlockHor;
  1163. p->AllCopyBlock[0][2] = PreLoadCopyBlockVer;
  1164. p->AllCopyBlock[0][3] = PreLoadCopyBlockHorVer;
  1165. p->AllCopyBlock[0][0] = PreLoadCopyBlock;
  1166. p->AllCopyBlock[1][1] = PreLoadCopyBlockHorRound;
  1167. p->AllCopyBlock[1][2] = PreLoadCopyBlockVerRound;
  1168. p->AllCopyBlock[1][3] = PreLoadCopyBlockHorVerRound;
  1169. p->AddBlock[0] = PreLoadAddBlock;
  1170. p->AddBlock[1] = PreLoadAddBlockHor;
  1171. p->AddBlock[2] = PreLoadAddBlockVer;
  1172. p->AddBlock[3] = PreLoadAddBlockHorVer;
  1173. }
  1174. }
  1175. */
  1177. #endif //ARM
  1179. p->Tmp = (uint8_t*)ALIGN16((uintptr_t)p->_Tmp);
  1180. p->MaxCount = MAXBUF;
  1181. p->BufCount = 0;
  1182. p->LastTemp = 0;
  1183. p->ShowCurr = -1;
  1184. p->ShowNext = -1;
  1186. return ERR_NONE;
  1187. }
  1189. static const nodedef SoftIDCT =
  1190. {
  1191. sizeof(softidct),
  1192. #if defined(MPEG4_EXPORTS)
  1193. MPEG4IDCT_ID,
  1194. IDCT_CLASS,
  1195. PRI_DEFAULT+20,
  1196. #elif defined(MSMPEG4_EXPORTS)
  1197. MSMPEG4IDCT_ID,
  1198. IDCT_CLASS,
  1199. PRI_DEFAULT+10,
  1200. #else
  1201. SOFTIDCT_ID,
  1202. IDCT_CLASS,
  1203. PRI_DEFAULT,
  1204. #endif
  1205. (nodecreate)Create,
  1206. };
  1208. void SoftIDCT_Init()
  1209. {
  1210. NodeRegisterClass(&SoftIDCT);
  1211. }
  1213. void SoftIDCT_Done()
  1214. {
  1215. NodeUnRegisterClass(SoftIDCT.Class);
  1216. }