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

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

Windows CE

开发平台：

C/C++

overlay.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: overlay.c 551 2006-01-09 11:55:09Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  26. int OverlayDefaultBlit(overlay* p, const constplanes Data, const constplanes DataLast)
  27. {
  28. planes Planes;
  29. int Result = p->Lock(p,Planes,1);
  30. if (Result==ERR_NONE)
  31. {
  32. BlitImage(p->Soft,Planes,Data,DataLast,p->Output.Format.Video.Pitch,-1);
  33. p->Unlock(p);
  34. }
  35. return Result;
  36. }
  38. int OverlayEnum(overlay* p, int* No, datadef* Param)
  39. {
  40. return VOutEnum(p,No,Param);
  41. }
  43. static int Create(overlay* p)
  44. {
  45. p->Node.Enum = (nodeenum)OverlayEnum;
  46. p->Node.Get = (nodeget)OverlayGet;
  47. p->Node.Set = (nodeset)OverlaySet;
  48. p->Blit = (ovlblit)OverlayDefaultBlit;
  49. p->Update = (ovlfunc)OverlayUpdateAlign;
  51. p->Caps = -1;
  52. p->Soft = NULL;
  53. p->Primary = 1;
  54. p->Overlay = 0;
  55. p->DoPowerOff = 0;
  57. memset(&p->Backup,0,sizeof(idctbackup));
  58. memset(&p->OrigFX,0,sizeof(blitfx));
  59. p->OrigFX.ScaleX = SCALE_ONE;
  60. p->OrigFX.ScaleY = SCALE_ONE;
  61. p->AutoPrerotate = 0;
  62. p->ColorKey = RGB_NULL;
  63. p->Aspect.Num = 0;
  64. p->Aspect.Den = 1;
  65. p->Output.Type = PACKET_VIDEO;
  67. return ERR_NONE;
  68. }
  70. static void Delete(overlay* p)
  71. {
  72. BlitRelease(p->Soft);
  73. ReleaseModule(&p->Module);
  74. }
  76. void OverlayClearBorder(overlay* p)
  77. {
  78. planes Planes;
  79. p->Dirty = 1;
  80. if (p->Lock && p->Lock(p,Planes,0) == ERR_NONE)
  81. {
  82. uint32_t c = RGBToFormat(CRGB(0,0,0),&p->Output.Format.Video.Pixel);
  83. rect Viewport;
  84. VirtToPhy(&p->Viewport,&Viewport,&p->Output.Format.Video);
  86. FillColor(Planes[0],p->Output.Format.Video.Pitch,Viewport.x,Viewport.y,
  87. Viewport.Width,p->DstAlignedRect.y-Viewport.y,
  88. p->Output.Format.Video.Pixel.BitCount,c);
  90. FillColor(Planes[0],p->Output.Format.Video.Pitch,Viewport.x,p->DstAlignedRect.y,
  91. p->DstAlignedRect.x-Viewport.x,p->DstAlignedRect.Height,
  92. p->Output.Format.Video.Pixel.BitCount,c);
  94. FillColor(Planes[0],p->Output.Format.Video.Pitch,p->DstAlignedRect.x+p->DstAlignedRect.Width,p->DstAlignedRect.y,
  95. (Viewport.x+Viewport.Width)-(p->DstAlignedRect.x+p->DstAlignedRect.Width),p->DstAlignedRect.Height,
  96. p->Output.Format.Video.Pixel.BitCount,c);
  98. FillColor(Planes[0],p->Output.Format.Video.Pitch,Viewport.x,p->DstAlignedRect.y+p->DstAlignedRect.Height,
  99. Viewport.Width,(Viewport.y+Viewport.Height)-(p->DstAlignedRect.y+p->DstAlignedRect.Height),
  100. p->Output.Format.Video.Pixel.BitCount,c);
  102. p->Unlock(p);
  103. }
  104. }
  106. int OverlayUpdateAlign(overlay* p)
  107. {
  108. rect OldGUI = p->GUIAlignedRect;
  109. rect Old = p->DstAlignedRect;
  111. DEBUG_MSG4(DEBUG_TEST,T("BLIT Viewport:%d %d %d %d"),p->Viewport.x,p->Viewport.y,p->Viewport.Width,p->Viewport.Height);
  113. VirtToPhy(&p->Viewport,&p->DstAlignedRect,&p->Output.Format.Video);
  114. VirtToPhy(NULL,&p->SrcAlignedRect,&p->Input.Format.Video);
  116. BlitRelease(p->Soft);
  117. p->Soft = BlitCreate(&p->Output.Format.Video,&p->Input.Format.Video,&p->FX,&p->Caps);
  119. BlitAlign(p->Soft,&p->DstAlignedRect, &p->SrcAlignedRect);
  120. PhyToVirt(&p->DstAlignedRect,&p->GUIAlignedRect,&p->Output.Format.Video);
  122. //DEBUG_MSG4(DEBUG_TEST,T("BLIT DstRect:%d %d %d %d"),p->DstAlignedRect.x,p->DstAlignedRect.y,p->DstAlignedRect.Width,p->DstAlignedRect.Height);
  123. //DEBUG_MSG4(DEBUG_TEST,T("BLIT SrcRect:%d %d %d %d"),p->SrcAlignedRect.x,p->SrcAlignedRect.y,p->SrcAlignedRect.Width,p->SrcAlignedRect.Height);
  125. if (!EqRect(&Old,&p->DstAlignedRect) && p->Show && p->Primary)
  126. {
  127. WinInvalidate(&OldGUI,0);
  128. WinInvalidate(&p->Viewport,1);
  129. WinValidate(&p->GUIAlignedRect);
  130. }
  132. if (p->Show && (p->FullScreenViewport || !p->Primary))
  133. OverlayClearBorder(p);
  135. return ERR_NONE;
  136. }
  138. static int Blit(overlay* p,const packet* Packet,const flowstate* State)
  139. {
  140. int Result = ERR_NONE;
  142. if (Packet)
  143. {
  144. if (State->DropLevel)
  145. {
  146. ++p->Dropped;
  147. return ERR_NONE;
  148. }
  150. if (State->CurrTime >= 0)
  151. {
  152. if (!p->Play && State->CurrTime == p->LastTime)
  153. return ERR_BUFFER_FULL;
  155. if (Packet->RefTime >= (State->CurrTime + SHOWAHEAD))
  156. return ERR_BUFFER_FULL;
  158. p->LastTime = State->CurrTime;
  159. }
  160. else
  161. p->LastTime = Packet->RefTime;
  163. p->CurrTime = State->CurrTime;
  165. if (State->CurrTime != TIME_RESEND)
  166. ++p->Total;
  168. if (p->Soft && p->Inited && p->Show && Packet->Data[0])
  169. {
  170. const constplanes* LastData = &Packet->LastData;
  171. if (p->Dirty)
  172. LastData = NULL;
  174. /* { static tick_t Last = 0;
  175. DebugMessage("%d %d",Packet->RefTime,Packet->RefTime-Last);
  176. Last = Packet->RefTime; } */
  178. Result = p->Blit(p,Packet->Data,*LastData);
  180. if (Result == ERR_NONE)
  181. p->Dirty = 0;
  182. }
  183. }
  184. else
  185. if (State->DropLevel)
  186. ++p->Dropped;
  188. return Result;
  189. }
  191. int OverlayGet(overlay* p,int No,void* Data,int Size)
  192. {
  193. int Result = ERR_INVALID_PARAM;
  194. switch (No)
  195. {
  196. case OUT_INPUT: GETVALUE(p->Pin,pin); break;
  197. case OUT_OUTPUT|PIN_FORMAT: GETVALUE(p->Output,packetformat); break;
  198. case OUT_INPUT|PIN_FORMAT: GETVALUE(p->Input,packetformat); break;
  199. case OUT_INPUT|PIN_PROCESS: GETVALUE((packetprocess)Blit,packetprocess); break;
  200. case OUT_TOTAL: GETVALUE(p->Total,int); break;
  201. case OUT_DROPPED: GETVALUE(p->Dropped,int); break;
  202. case VOUT_PRIMARY: GETVALUE(p->Primary,bool_t); break;
  203. case VOUT_OVERLAY: GETVALUE(p->Overlay,bool_t); break;
  204. case VOUT_IDCT: GETVALUE(p->AccelIDCT,idct*); break;
  205. case VOUT_VISIBLE: GETVALUE(p->Visible,bool_t); break;
  206. case VOUT_CLIPPING: GETVALUE(p->Clipping,bool_t); break;
  207. case VOUT_FX: GETVALUE(p->OrigFX,blitfx); break;
  208. case VOUT_VIEWPORT: GETVALUE(p->Viewport,rect); break;
  209. case VOUT_FULLSCREEN: GETVALUE(p->FullScreenViewport,bool_t); break;
  210. case VOUT_OUTPUTRECT: GETVALUECOND(p->GUIAlignedRect,rect,!p->Disabled); break;
  211. case VOUT_AUTOPREROTATE: GETVALUE(p->AutoPrerotate,bool_t); break;
  212. case VOUT_UPDATING: GETVALUE(p->Updating,bool_t); break;
  213. case VOUT_PLAY: GETVALUE(p->Play,bool_t); break;
  214. case VOUT_CAPS: GETVALUE(p->Caps,int); break;
  215. case VOUT_COLORKEY: GETVALUECOND(p->ColorKey,rgbval_t,!p->Disabled && p->ColorKey!=RGB_NULL); break;
  216. case VOUT_ASPECT: GETVALUE(p->Aspect,fraction); break;
  217. case FLOW_BACKGROUND: GETVALUECOND(p->Background,bool_t,p->DoPowerOff); break;
  218. }
  219. return Result;
  220. }
  222. static NOINLINE void UpdateInputFormat(overlay* p)
  223. {
  224. if (p->Inited && !p->UpdateInputFormat && p->PrefDirection != p->Input.Format.Video.Direction && p->Pin.Node)
  225. {
  226. packetformat Format = p->Input;
  227. if ((p->PrefDirection ^ Format.Format.Video.Direction) & DIR_SWAPXY)
  228. SwapInt(&Format.Format.Video.Width,&Format.Format.Video.Height);
  229. Format.Format.Video.Direction = p->PrefDirection;
  231. p->UpdateInputFormat = 1;
  232. p->Pin.Node->Set(p->Pin.Node,p->Pin.No|PIN_FORMAT,&Format,sizeof(Format));
  233. p->UpdateInputFormat = 0;
  234. }
  235. }
  237. int OverlayUpdateFX(overlay* p, bool_t ForceUpdate)
  238. {
  239. fraction Aspect = p->Aspect;
  240. blitfx LastFX = p->FX;
  241. int Width,Height,ScaleX,ScaleY;
  243. if (!p->Inited || p->Updating) return ERR_NONE;
  245. if (Aspect.Num==0) // source
  246. {
  247. Aspect.Num = p->Input.Format.Video.Aspect;
  248. Aspect.Den = ASPECT_ONE;
  249. if (Aspect.Num == ASPECT_ONE || !Aspect.Num)
  250. Aspect.Num = DefaultAspect(p->Input.Format.Video.Width,p->Input.Format.Video.Height);
  251. }
  252. else
  253. if (Aspect.Num<0)
  254. {
  255. // screen aspect ratio -> pixel aspect ratio
  256. if (p->InputDirection & DIR_SWAPXY)
  257. {
  258. Aspect.Num *= -p->Input.Format.Video.Width;
  259. Aspect.Den *= p->Input.Format.Video.Height;
  260. }
  261. else
  262. {
  263. Aspect.Num *= -p->Input.Format.Video.Height;
  264. Aspect.Den *= p->Input.Format.Video.Width;
  265. }
  266. }
  268. p->FX = p->OrigFX;
  269. p->FX.Flags |= p->SetFX;
  270. p->FX.Flags &= ~p->ClearFX;
  271. p->FX.Direction = CombineDir(p->InputDirection,p->OrigFX.Direction,p->Output.Format.Video.Direction);
  272. p->PrefDirection = CombineDir(p->FX.Direction,0,p->Input.Format.Video.Direction);
  274. if (p->OrigFX.ScaleX<=0)
  275. {
  276. int v = p->OrigFX.ScaleX;
  278. Width = p->Viewport.Width;
  279. Height = p->Viewport.Height;
  281. if ((p->InputDirection ^ p->OrigFX.Direction) & DIR_SWAPXY)
  282. SwapInt(&Width,&Height);
  284. if (p->InputDirection & DIR_SWAPXY)
  285. {
  286. ScaleX = Scale(Width,SCALE_ONE,p->Input.Format.Video.Width);
  287. ScaleY = Scale(Height,SCALE_ONE,Scale(p->Input.Format.Video.Height,Aspect.Num,Aspect.Den));
  288. }
  289. else
  290. {
  291. ScaleX = Scale(Width,SCALE_ONE,Scale(p->Input.Format.Video.Width,Aspect.Num,Aspect.Den));
  292. ScaleY = Scale(Height,SCALE_ONE,p->Input.Format.Video.Height);
  293. }
  295. if ((p->InputDirection & DIR_SWAPXY) && (v == -1 || v == -2))
  296. v = -3-v; // swap 'fit width' and 'fit height'
  298. if (v==-3)
  299. {
  300. //todo: fill screen, but always using the fullscreen aspect ratio!
  301. p->FX.ScaleY = ScaleY;
  302. p->FX.ScaleX = ScaleX;
  303. }
  304. else
  305. {
  306. if ((v == -2) || (v!=-1 && v!=-4 && ScaleX>ScaleY) || (v==-4 && ScaleX<ScaleY))
  307. ScaleX = ScaleY;
  309. if (v<-4)
  310. ScaleX = Scale(ScaleX,-v,SCALE_ONE);
  312. p->FX.ScaleY = ScaleX;
  313. p->FX.ScaleX = Scale(ScaleX,Aspect.Num,Aspect.Den);
  315. if (p->InputDirection & DIR_SWAPXY)
  316. SwapInt(&p->FX.ScaleX,&p->FX.ScaleY);
  317. }
  318. }
  319. else
  320. {
  321. // prefer source horizontal scaling (because of smooth scale option)
  322. if (p->InputDirection & DIR_SWAPXY)
  323. p->FX.ScaleY = Scale(p->FX.ScaleY,Aspect.Num,Aspect.Den);
  324. else
  325. p->FX.ScaleX = Scale(p->FX.ScaleX,Aspect.Num,Aspect.Den);
  326. }
  328. if (p->Output.Format.Video.Pixel.Flags & PF_PIXELDOUBLE)
  329. {
  330. p->FX.ScaleX >>= 1;
  331. p->FX.ScaleY >>= 1;
  332. }
  334. if ((p->FX.Flags & BLITFX_ONLYDIFF) && p->FX.ScaleX < (SCALE_ONE*2)/3)
  335. p->FX.Flags &= ~BLITFX_ONLYDIFF;
  337. if (p->ForceUpdate)
  338. {
  339. p->ForceUpdate = 0;
  340. ForceUpdate = 1;
  341. }
  343. if (ForceUpdate || !EqBlitFX(&p->FX,&LastFX))
  344. {
  345. p->Update(p);
  346. p->Dirty = 1;
  347. p->LastTime = -1;
  348. UpdateInputFormat(p);
  349. }
  351. return ERR_NONE;
  352. }
  354. static int UpdateInputDirection(overlay* p,bool_t Update)
  355. {
  356. if (p->Inited && !p->Updating)
  357. {
  358. p->InputDirection = p->Input.Format.Video.Direction;
  359. p->PreRotate = 0;
  361. if (p->AutoPrerotate && !(p->Input.Format.Video.Pixel.Flags & PF_NOPREROTATE))
  362. {
  363. rect r;
  364. PhyToVirt(NULL,&r,&p->Input.Format.Video);
  366. // portrait?
  367. if (r.Width < r.Height)
  368. {
  369. p->PreRotate = 1;
  370. if (p->InputDirection & DIR_SWAPXY)
  371. p->InputDirection ^= DIR_SWAPXY | DIR_MIRRORLEFTRIGHT;
  372. else
  373. p->InputDirection ^= DIR_SWAPXY | DIR_MIRRORUPDOWN;
  374. }
  375. }
  377. if (Update)
  378. OverlayUpdateFX(p,0);
  379. }
  380. return ERR_NONE;
  381. }
  383. int OverlayUpdateShow(overlay* p,bool_t Temp)
  384. {
  385. bool_t Show = !p->Disabled && p->Visible && (p->ColorKey != RGB_NULL || !p->Clipping || !p->Primary);
  386. if (!p->Updating && p->Show != Show)
  387. {
  388. p->Show = Show;
  389. p->Dirty = 1;
  390. p->LastTime = -1;
  392. if (p->Inited && !Temp)
  393. {
  394. if (p->Primary && p->Overlay && p->ColorKey != RGB_NULL && !p->Show)
  395. {
  396. // clear colorkey before turning off overlay
  397. WinInvalidate(&p->Viewport,1);
  398. WinUpdate(); 
  399. }
  401. if (p->UpdateShow)
  402. p->UpdateShow(p);
  404. if (p->Primary)
  405. {
  406. if (p->Overlay)
  407. {
  408. if (p->ColorKey != RGB_NULL && p->Show)
  409. WinInvalidate(&p->Viewport,1);
  410. }
  411. else
  412. if (p->Show)
  413. {
  414. WinInvalidate(&p->Viewport,1); // redraw border (zoom may have changed)
  415. WinValidate(&p->GUIAlignedRect);
  416. }
  417. else
  418. {
  419. WinInvalidate(&p->Viewport,0); // redraw other windows
  420. WinValidate(&p->Viewport); // own window is fine
  421. }
  422. }
  423. }
  424. }
  425. return ERR_NONE;
  426. }
  428. static int Updating(overlay* p)
  429. {
  430. if (!p->Updating)
  431. {
  432. UpdateInputDirection(p,0);
  433. OverlayUpdateFX(p,0);
  434. OverlayUpdateShow(p,0);
  435. }
  436. return ERR_NONE;
  437. }
  439. static int UpdateInput(overlay* p)
  440. {
  441. if (p->Inited)
  442. {
  443. if (p->Show)
  444. {
  445. bool_t Old = p->Visible;
  446. p->Visible = 0;
  447. p->Show = 0;
  448. if (p->UpdateShow)
  449. p->UpdateShow(p); // maybe calls OverlayUpdateShow
  450. p->Visible = Old;
  451. }
  452. p->Done(p);
  453. BlitRelease(p->Soft);
  454. p->Soft = NULL;
  455. p->Inited = 0;
  456. memset(&p->GUIAlignedRect,0,sizeof(rect));
  458. if (p->Primary)
  459. WinInvalidate(&p->Viewport,1);
  460. }
  462. if (!p->TurningOff)
  463. IDCTRestore(NULL,&p->Backup);
  465. memset(&p->FX,0,sizeof(blitfx));
  466. memset(&p->DstAlignedRect,0,sizeof(rect));
  467. memset(&p->SrcAlignedRect,0,sizeof(rect));
  468. memset(&p->GUIAlignedRect,0,sizeof(rect));
  470. p->Total = 0;
  471. p->Dropped = 0;
  472. p->Disabled = 0;
  473. p->Updating = 0;
  474. p->Show = 0;
  475. p->Dirty = 1;
  476. p->LastTime = -1;
  477. p->ColorKey = RGB_NULL;
  479. if (p->Input.Type == PACKET_VIDEO)
  480. {
  481. if (Compressed(&p->Input.Format.Video.Pixel))
  482. return ERR_INVALID_DATA;
  484. if (p->Input.Format.Video.Width<=0) 
  485. {
  486. p->Disabled = 1;
  487. p->Input.Format.Video.Width = 2;
  488. }
  490. if (p->Input.Format.Video.Height<=0) 
  491. {
  492. p->Disabled = 1;
  493. p->Input.Format.Video.Height = 2;
  494. }
  496. if (!p->Background)
  497. {
  498. int Result = p->Init(p);
  499. if (Result != ERR_NONE)
  500. {
  501. if (Result == ERR_DEVICE_ERROR)
  502. ShowError(p->Node.Class,ERR_ID,ERR_DEVICE_ERROR);
  503. return Result;
  504. }
  506. p->Inited = 1;
  507. p->ForceUpdate = 1;
  509. UpdateInputDirection(p,0);
  510. OverlayUpdateFX(p,1);
  511. OverlayUpdateShow(p,0);
  513. if (p->Primary && !p->TurningOff)
  514. WinInvalidate(&p->Viewport,1);
  515. }
  516. }
  517. else
  518. if (p->Input.Type != PACKET_NONE)
  519. return ERR_INVALID_DATA;
  521. return ERR_NONE;
  522. }
  524. static int UpdateBackground(overlay* p)
  525. {
  526. if (p->DoPowerOff)
  527. {
  528. p->TurningOff = 1;
  529. if (p->Background)
  530. {
  531. IDCTRestore(NULL,&p->Backup); // free old backup
  532. if (!p->AccelIDCT || p->AccelIDCT->Get(p->AccelIDCT,IDCT_BACKUP,&p->Backup,sizeof(idctbackup))!=ERR_NONE)
  533. UpdateInput(p);
  534. }
  535. else
  536. {
  537. if (p->AccelIDCT && p->Backup.Format.Pixel.Flags)
  538. {
  539. p->AccelIDCT->Set(p->AccelIDCT,IDCT_BACKUP,&p->Backup,sizeof(idctbackup));
  540. p->AccelIDCT->Set(p->AccelIDCT,FLOW_RESEND,NULL,0);
  541. }
  542. else
  543. {
  544. node* Player = Context()->Player;
  545. UpdateInput(p);
  546. if (p->Inited && Player)
  547. Player->Set(Player,PLAYER_UPDATEVIDEO,NULL,0); 
  548. }
  549. IDCTRestore(NULL,&p->Backup); // free backup in any case
  550. }
  551. p->TurningOff = 0;
  552. }
  553. return ERR_NONE;
  554. }
  556. static bool_t PitchChanged(const packetformat* Current, const packetformat* New)
  557. {
  558. if (Current && Current->Type == PACKET_VIDEO && New && New->Type == PACKET_VIDEO)
  559. {
  560. video Tmp = New->Format.Video;
  561. Tmp.Pitch = Current->Format.Video.Pitch;
  562. return EqVideo(&Current->Format.Video,&Tmp);
  563. }
  564. return 0;
  565. }
  567. int OverlaySet(overlay* p,int No,const void* Data,int Size)
  568. {
  569. int Result = ERR_INVALID_PARAM;
  570. switch (No)
  571. {
  572. case NODE_SETTINGSCHANGED:
  573. p->ForceUpdate = 1;
  574. break;
  576. case OUT_INPUT: SETVALUE(p->Pin,pin,ERR_NONE); break;
  577. case OUT_TOTAL: SETVALUE(p->Total,int,ERR_NONE); break;
  578. case OUT_DROPPED: SETVALUE(p->Dropped,int,ERR_NONE); break;
  579. case OUT_INPUT|PIN_FORMAT:
  580. if (p->Inited && (
  581. PitchChanged(&p->Input,(const packetformat*)Data) ||
  582. PacketFormatRotatedVideo(&p->Input,(const packetformat*)Data,DIR_SWAPXY|DIR_MIRRORLEFTRIGHT|DIR_MIRRORUPDOWN)))
  583. {
  584. PacketFormatCopy(&p->Input,(const packetformat*)Data);
  585. UpdateInputDirection(p,0);
  586. Result = OverlayUpdateFX(p,1);
  587. }
  588. else
  589. SETPACKETFORMAT(p->Input,packetformat,UpdateInput(p)); 
  590. break;
  592. case FLOW_BACKGROUND: SETVALUECMP(p->Background,bool_t,UpdateBackground(p),EqBool); break;
  593. case VOUT_PLAY: SETVALUE(p->Play,bool_t,ERR_NONE); break;
  594. case VOUT_UPDATING: SETVALUECMP(p->Updating,bool_t,Updating(p),EqBool); break;
  595. case VOUT_CLIPPING: SETVALUE(p->Clipping,bool_t,OverlayUpdateShow(p,0)); break;
  596. case VOUT_VISIBLE: SETVALUE(p->Visible,bool_t,OverlayUpdateShow(p,0)); break;
  597. case VOUT_AUTOPREROTATE: SETVALUE(p->AutoPrerotate,bool_t,UpdateInputDirection(p,1)); break;
  598. case VOUT_ASPECT: SETVALUECMP(p->Aspect,fraction,OverlayUpdateFX(p,0),EqFrac); break;
  599. case VOUT_FX: SETVALUE(p->OrigFX,blitfx,OverlayUpdateFX(p,0)); break;
  600. case VOUT_FULLSCREEN: SETVALUECMP(p->FullScreenViewport,bool_t,OverlayUpdateFX(p,0),EqBool); break;
  601. case VOUT_VIEWPORT:
  602. if (Size == sizeof(rect))
  603. {
  604. Result = ERR_NONE;
  605. if (!EqRect(&p->Viewport,(const rect*)Data))
  606. {
  607. p->Viewport = *(const rect*)Data;
  608. p->ForceUpdate = 1; // when in updating
  609. OverlayUpdateFX(p,1);
  610. }
  611. }
  612. break;
  614. case FLOW_FLUSH:
  615. p->Dirty = 1;
  616. break;
  618. case VOUT_RESET:
  619. if (p->Inited && p->Reset)
  620. {
  621. p->Reset(p);
  622. OverlayUpdateFX(p,1);
  623. }
  624. Result = ERR_NONE;
  625. break;
  626. }
  627. return Result;
  628. }
  630. static const nodedef Overlay =
  631. {
  632. sizeof(overlay)|CF_ABSTRACT,
  633. OVERLAY_CLASS,
  634. VOUT_CLASS,
  635. PRI_DEFAULT,
  636. (nodecreate)Create,
  637. (nodedelete)Delete,
  638. };
  640. void Overlay_Init()
  641. {
  642. NodeRegisterClass(&Overlay);
  643. }
  645. void Overlay_Done()
  646. {
  647. NodeUnRegisterClass(OVERLAY_CLASS);
  648. }