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

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

Windows CE

开发平台：

C/C++

player.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: player.c 623 2006-02-01 13:19:15Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "common.h"
  25. #include "playlist/m3u.h"
  26. #include "../config.h"
  28. #define VIDEO_STREAMING_UNDERRUN (256*1024)/BLOCKSIZE
  30. #define ALIGN_SIZE 4096
  31. #define PROBE_SIZE ALIGN_SIZE
  32. #define MAXSKIP 16
  34. typedef struct ref
  35. {
  36. node* Node;
  37. int RefCount;
  39. } ref;
  41. typedef struct item
  42. {
  43. tchar_t URL[MAXPATH];
  44. tchar_t Title[256];
  45. tick_t Length;
  46. bool_t Changed;
  47. } item;
  49. typedef struct player_base
  50. {
  51. player Player;
  52. bool_t BufferWarning;
  53. int BufferSize2; //in blocksize
  54. int MDBufferSize2; //in blocksize
  55. int CurrBufferSize2; //in blocksize
  56. bool_t SoftVolume;
  57. bool_t Background;
  58. bool_t Foreground;
  59. bool_t PowerOff;
  60. bool_t PowerOffReSync;
  61. bool_t FlowBackground;
  62. bool_t MicroDrive;
  63. bool_t Repeat;
  64. bool_t Shuffle;
  65. bool_t PlayAtOpen;
  66. bool_t PlayAtOpenFull;
  67. bool_t ExitAtEnd;
  68. bool_t KeepPlayVideo;
  69. bool_t KeepPlayAudio;
  70. bool_t ShowInBackground;
  71. bool_t SingleClickFullScreen;
  72. bool_t KeepList;
  73. tick_t MoveBack;
  74. tick_t MoveFFwd;
  75. int BurstStart; // in blocksize
  76. int UnderRun; // percent
  77. int AudioUnderRun; //kbyte
  78. fraction FullZoom;
  79. fraction SkinZoom;
  80. fraction Aspect;
  81. int FullDir;
  82. int SkinDir;
  83. int RelDir;
  84. bool_t SmoothZoom50;
  85. bool_t SmoothZoomAlways;
  86. bool_t VideoAccel;
  87. bool_t AutoPreRotate;
  88. int SkipAccelFrom;
  89. int AudioQuality;
  90. int VideoQuality;
  91. int AOutputId;
  92. int VOutputId;
  93. int AOutputIdMax;
  94. int VOutputIdMax;
  95. fraction SeekAfterSync;
  96. bool_t SeekAfterSyncPrevKey;
  97. fraction InSeekPos;
  98. fraction PlaySpeed;
  99. fraction FFwdSpeed;
  100. int Volume;
  101. int Pan;
  102. int PreAmp;
  103. bool_t Mute;
  104. bool_t TimerLeft;
  105. node* Color;
  106. node* Equalizer;
  107. bool_t Eq;
  109. // states
  110. notify ListNotify;
  111. notify Notify;
  112. rect SkinViewport;
  113. void* Wnd;
  114. bool_t DiscardList;
  115. bool_t FullScreen;
  116. bool_t Clipping;
  117. bool_t Rotating;
  118. rect Viewport;
  119. bool_t Primary;
  120. bool_t Overlay;
  121. bool_t HasHost;
  122. bool_t Streaming; // HasHost and filesize==-1
  123. bool_t Timing;
  124. bool_t TemporaryHidden; // hidden till next sync
  125. bool_t FullScreenAfterSync;
  126. int Stereo;
  127. int StreamNo;
  129. // current media
  130. bool_t PreRotate;
  131. int BufferMax;
  132. stream* Input;
  133. stream* InputBase;
  134. node* Timer;
  135. node* AOutput;
  136. node* VOutput;
  137. node* VIDCT;
  138. node* FlowBuffer;
  139. format* Format;
  140. int Selected[PACKET_MAX]; // stream numbers
  142. // threads and timings
  143. bool_t NoMoreInput;
  144. bool_t Play;
  145. bool_t FFwd;
  146. bool_t Sync;
  147. bool_t Fill;
  148. bool_t LoadMode;
  149. bool_t Bench;
  150. bool_t SaveMicroDrive;
  151. bool_t WaitForProcess;
  152. bool_t TimerPlay;
  153. bool_t InSeek;
  154. bool_t UpdateStreamsNeeded;
  155. tick_t Position;
  156. tick_t PosNotify;
  157. fraction Speed;
  158. tick_t PosNotifyStep;
  159. tick_t BenchTime;
  160. point BenchSrc;
  161. point BenchDst;
  162. int BenchStart;
  163. int IOError;
  164. int UsedEnough2; //in blocksize
  165. int MinBuffer; //in blocksize
  166. uint32_t RndSeed;
  168. bool_t RunInput;
  169. bool_t RunProcess;
  171. #ifdef MULTITHREAD
  172. int ProcessPriority;
  173. int InputPriority;
  175. int LockInputCount; // just hint to sleep in input thread so other other thread can lock it
  176. int LockProcessCount; // just hint to sleep in process thread so other other thread can lock it
  177. void* Lock;  // parameter read/write
  178. void* LockComment;
  179. void* LockInput;
  180. void* LockProcess;
  182. void* EventProcess; // ProcessThread has processed some packets (InputThread can continue)
  184. void* EventRunInput;
  185. void* EventRunProcess; 
  187. void* ProcessThread;
  188. void* InputThread;
  190. int ProcessLocked;
  191. int InputLocked;
  192. #endif
  194. // playlist
  195. int Current;
  196. bool_t CurrentChanged;
  197. int PlayListCount;
  198. item* PlayList;
  199. int* PlayIndex;
  201. // paint
  202. rgbval_t ColorKey; // colorkeybursh color
  203. void* ColorKeyBrush;
  204. void* BlackBrush;
  206. array Ref; // ref
  207. array Comment; // [Stream,Name,0,Value,0]
  208. bool_t StreamSkip[MAXSTREAM];
  209. tchar_t Title[256];
  210. tchar_t CurrentDir[MAXPATH];
  212. int CodecSkipCount;
  213. int CodecSkip[MAXSKIP];
  215. } player_base;
  217. static const datatable PlayerParams[] = 
  218. {
  219. { PLAYER_AUTOPREROTATE, TYPE_BOOL, DF_SETUP },
  220. { PLAYER_REPEAT, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  221. { PLAYER_SHUFFLE, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  222. { PLAYER_KEEPPLAY_AUDIO,TYPE_BOOL, DF_SETUP },
  223. { PLAYER_KEEPPLAY_VIDEO,TYPE_BOOL, DF_SETUP },
  224. { PLAYER_SHOWINBACKGROUND,TYPE_BOOL, DF_SETUP },
  225. { PLAYER_SINGLECLICKFULLSCREEN, TYPE_BOOL, DF_SETUP },
  226. { PLAYER_KEEPLIST, TYPE_BOOL, DF_SETUP },
  227. { PLAYER_PLAYATOPEN, TYPE_BOOL, DF_SETUP },
  228. { PLAYER_PLAYATOPEN_FULL,TYPE_BOOL, DF_SETUP },
  229. { PLAYER_EXIT_AT_END, TYPE_BOOL, DF_SETUP },
  230. { PLAYER_FULL_ZOOM, TYPE_FRACTION, DF_SETUP|DF_PERCENT|DF_HIDDEN },
  231. { PLAYER_SKIN_ZOOM, TYPE_FRACTION, DF_SETUP|DF_PERCENT|DF_HIDDEN },
  232. { PLAYER_PLAY_SPEED, TYPE_FRACTION, DF_SETUP|DF_PERCENT|DF_GAP },
  233. { PLAYER_FFWD_SPEED, TYPE_FRACTION, DF_SETUP|DF_PERCENT },
  234. { PLAYER_MOVEFFWD_STEP, TYPE_TICK, DF_SETUP|DF_MINMAX, 0, 600*TICKSPERSEC },
  235. { PLAYER_MOVEBACK_STEP, TYPE_TICK, DF_SETUP|DF_MINMAX, 0, 600*TICKSPERSEC },
  237. { PLAYER_BUFFER_SIZE, TYPE_INT, DF_SETUP|DF_KBYTE|DF_GAP|DF_HIDDEN, 512, 128*1024 },
  238. { PLAYER_UNDERRUN, TYPE_INT, DF_SETUP|DF_PERCENT|DF_HIDDEN,0,PERCENT_ONE },
  239. { PLAYER_AUDIO_UNDERRUN,TYPE_INT, DF_SETUP|DF_KBYTE|DF_HIDDEN,32,128*1024 },
  241. { PLAYER_MICRODRIVE, TYPE_BOOL, DF_SETUP|DF_GAP|DF_HIDDEN },
  242. { PLAYER_MD_BUFFER_SIZE,TYPE_INT, DF_SETUP|DF_KBYTE|DF_HIDDEN, 512, 128*1024 },
  243. { PLAYER_BURSTSTART, TYPE_INT, DF_SETUP|DF_KBYTE|DF_HIDDEN, 512, 128*1024 },
  245. { PLAYER_AOUTPUTID, TYPE_INT, DF_SETUP|DF_HIDDEN },
  246. { PLAYER_AOUTPUTID_MAX, TYPE_INT, DF_SETUP|DF_HIDDEN }, // should be after PLAYER_AOUTPUTID
  247. { PLAYER_VOUTPUTID, TYPE_INT, DF_SETUP|DF_HIDDEN },
  248. { PLAYER_VOUTPUTID_MAX, TYPE_INT, DF_SETUP|DF_HIDDEN }, // should be after PLAYER_VOUTPUTID
  249. { PLAYER_VIDEO_ACCEL, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  250. { PLAYER_LIST_COUNT, TYPE_INT, DF_SETUP|DF_HIDDEN },
  251. { PLAYER_LIST_CURRENT, TYPE_INT, DF_SETUP|DF_HIDDEN },
  252. { PLAYER_LIST_CURRIDX, TYPE_INT, DF_HIDDEN },
  253. { PLAYER_SMOOTH50, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  254. { PLAYER_SMOOTHALWAYS, TYPE_BOOL, DF_SETUP|DF_HIDDEN },
  255. { PLAYER_STEREO, TYPE_INT,  DF_SETUP|DF_HIDDEN },
  256. { PLAYER_ASPECT, TYPE_FRACTION, DF_SETUP|DF_HIDDEN },
  257. { PLAYER_FULL_DIR, TYPE_INT, DF_SETUP|DF_HIDDEN },
  258. { PLAYER_SKIN_DIR, TYPE_INT, DF_SETUP|DF_HIDDEN },
  259. { PLAYER_AUDIO_QUALITY, TYPE_INT, DF_SETUP|DF_ENUMSTRING|DF_HIDDEN, PLAYERQUALITY_ENUM },
  260. { PLAYER_VIDEO_QUALITY, TYPE_INT, DF_SETUP|DF_ENUMSTRING|DF_HIDDEN, PLAYERQUALITY_ENUM },
  261. { PLAYER_ASTREAM, TYPE_INT, DF_HIDDEN|DF_SETUP },
  262. { PLAYER_VSTREAM, TYPE_INT, DF_HIDDEN|DF_SETUP },
  263. { PLAYER_SUBSTREAM, TYPE_INT, DF_HIDDEN|DF_SETUP },
  264. { PLAYER_PERCENT, TYPE_FRACTION, DF_HIDDEN|DF_SETUP },
  265. { PLAYER_VOLUME, TYPE_INT, DF_MINMAX|DF_HIDDEN|DF_SETUP, 0, 100 },
  266. { PLAYER_PAN, TYPE_INT, DF_MINMAX|DF_HIDDEN|DF_SETUP, -100, 100 },
  267. { PLAYER_PREAMP, TYPE_INT, DF_MINMAX|DF_HIDDEN|DF_SETUP, -100, 100 },
  268. { PLAYER_MUTE, TYPE_BOOL, DF_HIDDEN|DF_SETUP },
  269. { PLAYER_TIMER_LEFT, TYPE_BOOL, DF_HIDDEN|DF_SETUP },
  271. { PLAYER_BACKGROUND, TYPE_BOOL, DF_HIDDEN },
  272. { PLAYER_FOREGROUND, TYPE_BOOL, DF_HIDDEN },
  273. { PLAYER_PLAY, TYPE_BOOL, DF_HIDDEN },
  274. { PLAYER_FFWD, TYPE_BOOL, DF_HIDDEN },
  275. { PLAYER_POSITION, TYPE_TICK, DF_HIDDEN },
  276. { PLAYER_DURATION, TYPE_TICK, DF_HIDDEN },
  277. { PLAYER_TIMER, TYPE_STRING, DF_HIDDEN },
  278. { PLAYER_TITLE, TYPE_STRING },
  279. { PLAYER_INPUT, TYPE_NODE, DF_HIDDEN, STREAM_CLASS },
  280. { PLAYER_FORMAT, TYPE_NODE, DF_HIDDEN, FORMAT_CLASS },
  281. { PLAYER_AOUTPUT, TYPE_NODE, DF_HIDDEN, AOUT_CLASS },
  282. { PLAYER_VOUTPUT, TYPE_NODE, DF_HIDDEN, VOUT_CLASS },
  283. { PLAYER_SKIN_VIEWPORT, TYPE_RECT, DF_HIDDEN },
  284. { PLAYER_CLIPPING, TYPE_BOOL, DF_HIDDEN },
  285. { PLAYER_FULLSCREEN, TYPE_BOOL, DF_HIDDEN },
  286. { PLAYER_LOADMODE, TYPE_BOOL, DF_HIDDEN | DF_RDONLY },
  288. { PLAYER_CURRENTDIR, TYPE_STRING, DF_SETUP|DF_HIDDEN },
  290. DATATABLE_END(PLAYER_ID)
  291. };
  293. static const datatable BufferParams[] = 
  294. {
  295. { PLAYER_BUFFER_SIZE, TYPE_INT, DF_SETUP|DF_KBYTE|DF_GAP, 512, 128*1024 },
  296. { PLAYER_UNDERRUN, TYPE_INT, DF_SETUP|DF_PERCENT,0,PERCENT_ONE },
  297. { PLAYER_AUDIO_UNDERRUN,TYPE_INT, DF_SETUP|DF_KBYTE,32,128*1024 },
  299. { PLAYER_MICRODRIVE, TYPE_BOOL, DF_SETUP|DF_GAP },
  300. { PLAYER_MD_BUFFER_SIZE,TYPE_INT, DF_SETUP|DF_KBYTE, 512, 128*1024 },
  301. { PLAYER_BURSTSTART, TYPE_INT, DF_SETUP|DF_KBYTE, 512, 128*1024 },
  303. DATATABLE_END(PLAYER_BUFFER_ID)
  304. };
  306. static int Enum(player_base* p, int* No, datadef* Param)
  307. {
  308. if (NodeEnumTable(No,Param,PlayerParams) == ERR_NONE)
  309. return ERR_NONE;
  311. if (*No<p->PlayListCount*3)
  312. {
  313. memset(Param,0,sizeof(datadef));
  314. if (*No >= 2*p->PlayListCount)
  315. {
  316. Param->No = PLAYER_LIST_LENGTH + (*No - 2*p->PlayListCount);
  317. Param->Type = TYPE_TICK;
  318. Param->Size = sizeof(tick_t);
  319. }
  320. else
  321. {
  322. if (*No >= p->PlayListCount)
  323. Param->No = PLAYER_LIST_TITLE + (*No - p->PlayListCount);
  324. else
  325. Param->No = PLAYER_LIST_URL + *No;
  326. Param->Type = TYPE_STRING;
  327. Param->Size = MAXDATA;
  328. }
  329. Param->Flags = DF_HIDDEN | DF_SETUP;
  330. Param->Class = PLAYER_ID;
  331. return ERR_NONE;
  332. }
  334. *No -= p->PlayListCount*3;
  335. return ERR_INVALID_PARAM;
  336. }
  338. static NOINLINE int UpdateSpeed(player_base* p)
  339. {
  340. if (p->Bench)
  341. {
  342. p->Speed.Num = 0;
  343. p->Speed.Den = 1;
  344. }
  345. else
  346. if (p->FFwd)
  347. p->Speed = p->FFwdSpeed;
  348. else
  349. p->Speed = p->PlaySpeed;
  351. p->PosNotifyStep = Scale(TICKSPERSEC,p->Speed.Num,p->Speed.Den);
  353. if (p->Timer)
  354. p->Timer->Set(p->Timer,TIMER_SPEED,&p->Speed,sizeof(p->Speed));
  356. return ERR_NONE;
  357. }
  359. static NOINLINE void NotifyList(player_base* p)
  360. {
  361. if (p->ListNotify.Func)
  362. p->ListNotify.Func(p->ListNotify.This,0,0);
  363. }
  365. static NOINLINE void Notify(player_base* p,int Id,int Value)
  366. {
  367. if (p->Notify.Func)
  368. p->Notify.Func(p->Notify.This,Id,Value);
  369. }
  371. static NOINLINE void UpdateListLength(player_base* p,tick_t Length)
  372. {
  373. if (p->Current < p->PlayListCount && !p->PlayList[p->Current].Changed && 
  374. p->PlayList[p->Current].Length != Length)
  375. {
  376. p->PlayList[p->Current].Length = Length;
  377. NotifyList(p);
  378. }
  379. }
  381. #define INVALID_COMMENT -2
  382. static INLINE int CommentStream(const uint8_t* p) { return *(tchar_t*)p; }
  383. static INLINE const tchar_t* CommentName(const uint8_t* p) { return (const tchar_t*)(p+sizeof(tchar_t)); }
  384. static INLINE const tchar_t* CommentValue(const uint8_t* p) { const tchar_t* i = CommentName(p); return i+tcslen(i)+1; }
  385. static const uint8_t* CommentNext(const uint8_t* p) { const tchar_t* i = CommentValue(p); return (const uint8_t*)(i+tcslen(i)+1); }
  387. static const tchar_t* GetFirstComment(player_base* p, int Id)
  388. {
  389. const uint8_t *i;
  390. const tchar_t* Name = PlayerComment(Id);
  391. for (i=ARRAYBEGIN(p->Comment,uint8_t);i!=ARRAYEND(p->Comment,uint8_t);i=CommentNext(i))
  392. if (CommentStream(i)!=INVALID_COMMENT && tcsicmp(CommentName(i),Name)==0)
  393. return CommentValue(i);
  394. return T("");
  395. }
  397. static void UpdateListTitle(player_base* p)
  398. {
  399. const tchar_t* Title;
  400. const tchar_t* Artist;
  402. LockEnter(p->LockComment);
  404. Title = GetFirstComment(p,COMMENT_TITLE);
  405. Artist = GetFirstComment(p,COMMENT_ARTIST);
  406. if (!Artist[0])
  407. Artist = GetFirstComment(p,COMMENT_AUTHOR);
  409. if (Artist[0] && Title[0])
  410. stprintf_s(p->Title,TSIZEOF(p->Title),T("%s - %s"),Artist,Title);
  411. else
  412. {
  413. if (!Title[0])
  414. Title = Artist;
  415. tcscpy_s(p->Title,TSIZEOF(p->Title),Title);
  416. }
  418. LockLeave(p->LockComment);
  419. Notify(p,PLAYER_TITLE,0);
  421. if (p->Current < p->PlayListCount && !p->PlayList[p->Current].Changed)
  422. {
  423. tcscpy_s(p->PlayList[p->Current].Title,TSIZEOF(p->PlayList[p->Current].Title),p->Title);
  424. NotifyList(p);
  425. }
  426. }
  428. static NOINLINE bool_t IsCoverArt(player_base* p)
  429. {
  430. int CoverArt = -2;
  431. if (p->Format)
  432. p->Format->Get(p->Format,FORMAT_COVERART,&CoverArt,sizeof(CoverArt));
  433. return CoverArt==p->Selected[PACKET_VIDEO];
  434. }
  436. static NOINLINE bool_t IsVideo(player_base* p)
  437. {
  438. return p->VOutput && !IsCoverArt(p);
  439. }
  441. static NOINLINE void UpdateTimeouts(player_base* p)
  442. {
  443. bool_t KeepProcess = (p->Play || p->FFwd) && p->Format;
  444. if (!KeepProcess || !p->Sync) // VOutput not neccessary updated till first sync is over
  445. SleepTimeout(KeepProcess,p->Bench || (p->Primary && IsVideo(p)));
  446. }
  448. static NOINLINE void UpdateRunInput(player_base* p)
  449. {
  450. // we don't want deadlocks so LoadMode will restart InputThread even with NoMoreInput
  451. p->RunInput = p->Format && p->Input && (!p->NoMoreInput || p->LoadMode);
  452. #ifdef MULTITHREAD
  453. if (p->RunInput)
  454. EventSet(p->EventRunInput);
  455. else
  456. EventReset(p->EventRunInput);
  457. #endif
  458. }
  460. static NOINLINE void UpdateRunProcess(player_base* p)
  461. {
  462. p->RunProcess = p->Format && p->Input && p->Timer && (((p->FFwd || p->Play) && !p->LoadMode) || p->Sync || p->Fill);
  463. #ifdef MULTITHREAD
  464. if (p->RunProcess)
  465. EventSet(p->EventRunProcess);
  466. else
  467. EventReset(p->EventRunProcess);
  468. #endif
  469. }
  471. static NOINLINE void UpdatePriority(player_base* p)
  472. {
  473. #ifdef MULTITHREAD
  474. if (p->InputThread && p->ProcessThread)
  475. {
  476. int Priority;
  477. Priority = (!p->TimerPlay || !QueryAdvanced(ADVANCED_PRIORITY))?0:1;
  478. if (p->ProcessPriority != Priority)
  479. {
  480. p->ProcessPriority = Priority;
  481. ThreadPriority(p->ProcessThread,Priority);
  482. }
  483. Priority = (((p->Play || p->FFwd) && !p->Sync) || p->LoadMode)?0:1;
  484. if (p->InputPriority != Priority)
  485. {
  486. p->InputPriority = Priority;
  487. ThreadPriority(p->InputThread,Priority);
  488. }
  489. }
  490. #endif
  491. }
  493. static NOINLINE void UpdatePlay(player_base* p)
  494. {
  495. p->TimerPlay = (p->Play || p->FFwd) && !p->InSeek && !p->Sync && !p->Fill && !p->LoadMode;
  496. UpdatePriority(p);
  497. p->Timer->Set(p->Timer,TIMER_PLAY,&p->TimerPlay,sizeof(bool_t));
  498. if (p->VOutput)
  499. p->VOutput->Set(p->VOutput,VOUT_PLAY,&p->TimerPlay,sizeof(bool_t));
  500. }
  502. static int CmpRef(const ref* a, const ref* b)
  503. {
  504. if (a->Node > b->Node) return 1;
  505. if (a->Node < b->Node) return -1;
  506. return 0;
  507. }
  509. static void Unlock(player_base* p, bool_t Input);
  510. static void Lock(player_base* p, bool_t Input);
  512. static NOINLINE bool_t Used(player_base* p,node* Node)
  513. {
  514. const ref *i;
  515. for (i=ARRAYBEGIN(p->Ref,ref);i!=ARRAYEND(p->Ref,ref);++i)
  516. if (i->Node == Node)
  517. return 1;
  518. return 0;
  519. }
  521. static NOINLINE void Flush(player_base* p)
  522. {
  523. const ref *i;
  524. node* Skip = NULL;
  525. if (IsCoverArt(p))
  526. Skip = p->FlowBuffer;
  528. for (i=ARRAYBEGIN(p->Ref,ref);i!=ARRAYEND(p->Ref,ref);++i)
  529. if (i->Node != Skip)
  530. i->Node->Set(i->Node,FLOW_FLUSH,NULL,0);
  532. if (p->FlowBuffer && p->FlowBuffer != Skip)
  533. p->FlowBuffer->Set(p->FlowBuffer,FLOW_FLUSH,NULL,0);
  534. }
  536. static NOINLINE int UpdateBackground(player_base* p)
  537. {
  538. bool_t b;
  539. #ifdef MULTITHREAD
  540. assert(p->ProcessLocked != ThreadId() && p->InputLocked != ThreadId());
  541. #endif
  543. LockEnter(p->Lock);
  544. b = p->Background && !p->ShowInBackground && !p->Play && !p->FFwd;
  546. #if !defined(TARGET_WINCE)
  547. if (p->PowerOff) b = 1;
  548. #endif
  550. if (b != p->FlowBackground)
  551. {
  552. bool_t Locked = 0;
  553. const ref *i;
  554. p->FlowBackground = b;
  556. for (i=ARRAYBEGIN(p->Ref,ref);i!=ARRAYEND(p->Ref,ref);++i)
  557. if (i->Node->Get(i->Node,FLOW_BACKGROUND,&b,sizeof(b))==ERR_NONE)
  558. {
  559. if (!Locked)
  560. {
  561. Lock(p,1);
  562. Locked = 1;
  563. }
  564. i->Node->Set(i->Node,FLOW_BACKGROUND,&p->FlowBackground,sizeof(p->FlowBackground));
  565. }
  567. if (Locked)
  568. Unlock(p,1);
  569. }
  570. LockLeave(p->Lock);
  571. return ERR_NONE;
  572. }
  574. static void ReSync(player_base* p,bool_t Seek);
  575. static int UpdateFormat(player_base* p,bool_t BufferChanged);
  576. static int SetPlay(player_base* p,bool_t Stop);
  577. static int SetPlayListCount(player_base* p, int Count);
  578. static void Paint(player_base* p,void* DC,int x0,int y0);
  580. static int UpdateVideoEx(player_base* p,node* VOutput,int ForceRefresh,bool_t Active)
  581. {
  582. int Caps;
  583. bool_t Dither;
  584. packetformat Mode;
  585. blitfx FX;
  586. bool_t FullScreen;
  587. bool_t Visible = (p->Foreground || p->ShowInBackground) && !p->Rotating && Active;
  588. bool_t Refresh;
  589. bool_t Updating;
  590. bool_t VOutVisible;
  591. bool_t Primary;
  592. bool_t Overlay;
  593. rect Viewport;
  594. int RelDir;
  596. if (VOutput)
  597. {
  598. VOutput->Get(VOutput,VOUT_PRIMARY,&Primary,sizeof(bool_t));
  600. Viewport = p->SkinViewport;
  601. FullScreen = p->FullScreen || !Primary;
  602. if (FullScreen && VOutput->Get(VOutput,OUT_OUTPUT|PIN_FORMAT,&Mode,sizeof(Mode))==ERR_NONE && Mode.Type == PACKET_VIDEO)
  603. PhyToVirt(NULL,&Viewport,&Mode.Format.Video);
  605. FX.Flags = 0;
  606. if (p->SmoothZoom50)
  607. FX.Flags |= BLITFX_ARITHSTRETCH50;
  608. if (p->SmoothZoomAlways)
  609. FX.Flags |= BLITFX_ARITHSTRETCHALWAYS;
  610. if (QueryAdvanced(ADVANCED_SLOW_VIDEO))
  611. FX.Flags |= BLITFX_ONLYDIFF;
  612. if (QueryAdvanced(ADVANCED_COLOR_LOOKUP))
  613. FX.Flags |= BLITFX_COLOR_LOOKUP;
  615. p->Color->Get(p->Color,COLOR_DITHER,&Dither,sizeof(Dither));
  616. if (Dither)
  617. FX.Flags |= BLITFX_DITHER;
  619. p->Color->Get(p->Color,COLOR_BRIGHTNESS,&FX.Brightness,sizeof(FX.Brightness));
  620. p->Color->Get(p->Color,COLOR_CONTRAST,&FX.Contrast,sizeof(FX.Contrast));
  621. p->Color->Get(p->Color,COLOR_SATURATION,&FX.Saturation,sizeof(FX.Saturation));
  622. p->Color->Get(p->Color,COLOR_R_ADJUST,&FX.RGBAdjust[0],sizeof(FX.RGBAdjust[0]));
  623. p->Color->Get(p->Color,COLOR_G_ADJUST,&FX.RGBAdjust[1],sizeof(FX.RGBAdjust[1]));
  624. p->Color->Get(p->Color,COLOR_B_ADJUST,&FX.RGBAdjust[2],sizeof(FX.RGBAdjust[2]));
  626. if (FullScreen)
  627. {
  628. FX.Direction = p->FullDir;
  629. FX.ScaleY = FX.ScaleX = Scale(SCALE_ONE,p->FullZoom.Num,p->FullZoom.Den);
  630. }
  631. else
  632. {
  633. FX.Direction = p->SkinDir;
  634. FX.ScaleY = FX.ScaleX = Scale(SCALE_ONE,p->SkinZoom.Num,p->SkinZoom.Den);
  635. }
  637. if (FX.Direction < 0)
  638. FX.Direction = 0;
  639. else
  640. if (Primary)
  641. FX.Direction = CombineDir(GetOrientation(),0,FX.Direction);
  643. RelDir = FX.Direction;
  645. VOutVisible = Visible && !p->TemporaryHidden;
  646. Updating = 1;
  647. VOutput->Set(VOutput,VOUT_UPDATING,&Updating,sizeof(bool_t));
  649. VOutput->Set(VOutput,VOUT_FULLSCREEN,&FullScreen,sizeof(bool_t));
  650. VOutput->Set(VOutput,VOUT_VIEWPORT,&Viewport,sizeof(rect));
  651. VOutput->Set(VOutput,VOUT_FX,&FX,sizeof(blitfx));
  652. VOutput->Set(VOutput,VOUT_ASPECT,&p->Aspect,sizeof(fraction));
  653. VOutput->Set(VOutput,VOUT_CLIPPING,&p->Clipping,sizeof(p->Clipping));
  654. VOutput->Set(VOutput,VOUT_VISIBLE,&VOutVisible,sizeof(VOutVisible));
  655. VOutput->Set(VOutput,VOUT_AUTOPREROTATE,&p->AutoPreRotate,sizeof(bool_t));
  657. Updating = 0;
  658. VOutput->Set(VOutput,VOUT_UPDATING,&Updating,sizeof(bool_t));
  659. VOutput->Get(VOutput,VOUT_OVERLAY,&Overlay,sizeof(bool_t));
  660. }
  661. else
  662. {
  663. Primary = 1;
  664. Overlay = 0;
  665. RelDir = 0;
  666. Viewport = p->SkinViewport;
  667. }
  669. if (Active)
  670. {
  671. p->RelDir = RelDir;
  672. p->Primary = Primary;
  673. p->Overlay = Overlay;
  674. p->Viewport = Viewport;
  676. #ifdef TARGET_PALMOS
  677. if (!p->Clipping && Visible)
  678. Paint(p,p->Wnd,0,0);
  679. #endif
  681. // try to redraw overlay
  682. Refresh = VOutput && ForceRefresh>=0 && !p->Sync;
  683. if (Refresh && p->FlowBuffer && !ForceRefresh)
  684. Refresh = p->FlowBuffer->Set(p->FlowBuffer,FLOW_RESEND,NULL,0) != ERR_NONE;
  685. if (Refresh && p->Format)
  686. ReSync(p,0); // redraw the hard way: resync
  688. if (!p->Wnd || !VOutput || VOutput->Get(VOutput,VOUT_CAPS,&Caps,sizeof(Caps))!=ERR_NONE)
  689. Caps = -1;
  690. p->Color->Set(p->Color,COLOR_CAPS,&Caps,sizeof(Caps));
  691. }
  693. return ERR_NONE;
  694. }
  696. static NOINLINE int UpdateVideo(player_base* p,int ForceRefresh)
  697. {
  698. return UpdateVideoEx(p,p->VOutput,ForceRefresh,1);
  699. }
  701. static NOINLINE int UpdateBuffer(player_base* p)
  702. {
  703. node* Node = p->AOutput;
  704. if (Node)
  705. {
  706. bool_t b = IsVideo(p);
  707. Node->Set(Node,AOUT_MODE,&b,sizeof(b));
  708. }
  710. p->MinBuffer = 0;
  711. if (p->Format)
  712. p->Format->Get(p->Format,FORMAT_MIN_BUFFER,&p->MinBuffer,sizeof(int));
  714. return ERR_NONE;
  715. }
  717. static NOINLINE player_base* RefreshAudio(player_base* p)
  718. {
  719. node* Node = p->AOutput;
  720. if (Node && QueryAdvanced(ADVANCED_SYSTEMVOLUME))
  721. {
  722. Node->Get(Node,AOUT_VOLUME,&p->Volume,sizeof(int));
  723. Node->Get(Node,AOUT_MUTE,&p->Mute,sizeof(bool_t));
  724. Node->Get(Node,AOUT_PAN,&p->Pan,sizeof(int));
  725. }
  726. return p;
  727. }
  729. static NOINLINE int UpdateAudioEx(player_base* p,node* Node)
  730. {
  731. if (Node)
  732. {
  733. Node->Set(Node,AOUT_STEREO,&p->Stereo,sizeof(int));
  734. Node->Set(Node,AOUT_QUALITY,&p->AudioQuality,sizeof(int));
  735. Node->Set(Node,AOUT_PREAMP,&p->PreAmp,sizeof(int));
  736. Node->Set(Node,AOUT_VOLUME,&p->Volume,sizeof(int));
  737. Node->Set(Node,AOUT_MUTE,&p->Mute,sizeof(bool_t));
  738. Node->Set(Node,AOUT_PAN,&p->Pan,sizeof(int));
  739. }
  740. return ERR_NONE;
  741. }
  743. static NOINLINE int UpdateAudio(player_base* p)
  744. {
  745. return UpdateAudioEx(p,p->AOutput);
  746. }
  748. static NOINLINE int UpdateVolume(player_base* p)
  749. {
  750. if (p->AOutput)
  751. p->AOutput->Set(p->AOutput,AOUT_VOLUME,&p->Volume,sizeof(int));
  752. return ERR_NONE;
  753. }
  755. static int UpdateStreams(player_base* p,int ForceRefresh,bool_t CodecSkip);
  757. static NOINLINE int UpdatePowerOff(player_base* p)
  758. {
  759. Notify(p,PLAYER_POWEROFF,p->PowerOff); // before poweroff is handled! (PalmOS may need to turn on clipping)
  761. #ifdef TARGET_WINCE
  762. if (p->PowerOff)
  763. {
  764. bool_t b;
  766. Lock(p,0);
  768. if (p->VOutput && p->VOutput->Get(p->VOutput,FLOW_BACKGROUND,&b,sizeof(b))==ERR_NONE)
  769. {
  770. int Old = p->VOutputId;
  771. bool_t OldAccel = p->VideoAccel;
  773. p->VOutputId = 0;
  774. UpdateStreams(p,-1,0);
  776. p->VOutputId = Old;
  777. p->VideoAccel = OldAccel;
  778. p->PowerOffReSync = 1;
  779. }
  781. if (p->Play || p->FFwd)
  782. {
  783. Lock(p,1);
  784. p->Play = 0;
  785. p->FFwd = 0;
  786. p->Fill = 1;
  787. SetPlay(p,0);
  788. Unlock(p,1);
  789. }
  791. Unlock(p,0);
  792. }
  793. else
  794. {
  795. if (p->PowerOffReSync)
  796. {
  797. p->PowerOffReSync = 0;
  798. UpdateStreams(p,-1,0);
  799. ReSync(p,1);
  800. }
  801. }
  802. #else
  803. if (p->PowerOff && (p->Play || p->FFwd || p->Fill))
  804. {
  805. Lock(p,1);
  806. p->Play = 0;
  807. p->FFwd = 0;
  808. p->Fill = 0; // do not fill, because acceleration devices could be turned off
  809. SetPlay(p,0); // calls UpdateBackground
  810. Unlock(p,1);
  811. }
  812. else
  813. if (!p->PowerOff && !p->Play && !p->FFwd && !p->Fill)
  814. {
  815. Lock(p,1);
  816. p->Fill = 1; // turn on fill
  817. SetPlay(p,0); // calls UpdateBackground
  818. Unlock(p,1);
  819. }
  820. else
  821. UpdateBackground(p);
  822. #endif
  824. return ERR_NONE;
  825. }
  827. static NOINLINE int UpdateForeground(player_base* p)
  828. {
  829. if (!p->Foreground)
  830. if ((IsVideo(p) && !p->KeepPlayVideo) ||
  831. (!IsVideo(p) && !p->KeepPlayAudio))
  832. {
  833. Lock(p,1);
  834. SetPlay(p,1);
  835. Unlock(p,1);
  836. }
  838. UpdateVideo(p,0);
  839. return ERR_NONE;
  840. }
  842. static int FindCurrentIndex(player_base* p)
  843. {
  844. int Index;
  845. for (Index=0;Index<p->PlayListCount;++Index)
  846. if (p->PlayIndex[Index] == p->Current)
  847. return Index;
  849. return 0;
  850. }
  852. static uint32_t Rand(player_base* p)
  853. { 
  854. p->RndSeed = p->RndSeed*0x8088405U + 0x251001U;
  855. return p->RndSeed;
  856. }
  858. static int RandomizePlayIndex(player_base* p,bool_t CurrentAsFirst)
  859. {
  860. int No,n;
  861. int* Index = p->PlayIndex;
  862. for (No=0;No<p->PlayListCount;++No)
  863. Index[No] = No;
  865. if (p->Shuffle)
  866. {
  867. for (n=0;n<4;++n)
  868. for (No=0;No<p->PlayListCount;++No)
  869. SwapInt(&Index[No],&Index[Rand(p) % p->PlayListCount]);
  871. if (CurrentAsFirst)
  872. {
  873. // make sure current media is the first
  874. // so the full range of playlist will be played before it's regenerated
  875. No = FindCurrentIndex(p);
  876. if (No>0)
  877. SwapInt(&Index[No],&Index[0]);
  878. }
  879. }
  881. return ERR_NONE;
  882. }
  884. static int SetPlayListCount(player_base* p, int Count)
  885. {
  886. int i,j;
  887. int* Index = p->PlayIndex;
  888. item* List = (item*)realloc(p->PlayList,sizeof(item)*Count);
  889. if (!List && Count)
  890. return ERR_OUT_OF_MEMORY;
  892. if (p->PlayListCount > Count)
  893. {
  894. // remove unwanted indexes
  895. for (i=0,j=0;i<p->PlayListCount;++i)
  896. if (Index[i]<Count)
  897. Index[j++] = Index[i];
  898. assert(j==Count);
  899. }
  901. // realloc index
  902. Index = (int*)realloc(Index,sizeof(int)*Count);
  903. if (!Index && Count)
  904. {
  905. SetPlayListCount(p,0);
  906. return ERR_OUT_OF_MEMORY;
  907. }
  909. // add new items
  910. for (i=p->PlayListCount;i<Count;++i)
  911. {
  912. memset(List+i,0,sizeof(item));
  913. List[i].Length = -1;
  914. List[i].Changed = 1;
  915. Index[i] = i;
  916. if (p->Shuffle)
  917. SwapInt(&Index[i],&Index[Rand(p) % (i+1)]);
  918. }
  920. p->PlayIndex = Index;
  921. p->PlayList = List;
  922. p->PlayListCount = Count;
  924. if (p->Current >= Count)
  925. {
  926. p->Current = 0;
  927. p->CurrentChanged = 1;
  928. }
  930. NotifyList(p);
  931. return ERR_NONE;
  932. }
  934. static void StopLoadMode(player_base* p)
  935. {
  936. if (p->LoadMode)
  937. {
  938. DEBUG_MSG(DEBUG_TEST,T("LoadMode Leaving"));
  940. p->LoadMode = 0;
  941. UpdatePlay(p); // UpdateInputPriority(p) called too
  942. UpdateRunProcess(p);
  943. UpdateRunInput(p);
  944. Notify(p,PLAYER_LOADMODE,p->LoadMode);
  945. }
  946. }
  948. static void StopBench(player_base* p)
  949. {
  950. p->BenchTime = Scale(GetTimeTick() - p->BenchStart,TICKSPERSEC,GetTimeFreq());
  951. p->Bench = 0;
  952. p->MicroDrive = p->SaveMicroDrive;
  954. p->BenchSrc.x = p->BenchSrc.y = 0;
  955. p->BenchDst.x = p->BenchDst.y = 0;
  957. if (p->VOutput)
  958. {
  959. rect Rect;
  960. packetformat Format;
  961. if (p->VOutput->Get(p->VOutput,OUT_INPUT|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE)
  962. {
  963. p->BenchSrc.x = Format.Format.Video.Width;
  964. p->BenchSrc.y = Format.Format.Video.Height;
  965. }
  966. if (p->VOutput->Get(p->VOutput,VOUT_OUTPUTRECT,&Rect,sizeof(Rect))==ERR_NONE)
  967. {
  968. p->BenchDst.x = Rect.Width;
  969. p->BenchDst.y = Rect.Height;
  970. }
  971. }
  973. UpdateFormat(p,0);
  974. UpdatePlay(p);
  975. UpdateSpeed(p);
  977. Flush(p);
  979. Notify(p,PLAYER_BENCHMARK,p->BenchTime);
  980. }
  982. static void UpdateKeepAlive(player_base* p)
  983. {
  984. bool_t KeepAlive = p->FFwd || p->Play;
  985. if (p->VOutput)
  986. p->VOutput->Set(p->VOutput,OUT_KEEPALIVE,&KeepAlive,sizeof(KeepAlive));
  987. if (p->AOutput)
  988. p->AOutput->Set(p->AOutput,OUT_KEEPALIVE,&KeepAlive,sizeof(KeepAlive));
  989. }
  991. static int SetPlay(player_base* p,bool_t Stop)
  992. {
  993. bool_t Refresh;
  995. if (Stop)
  996. {
  997. p->Play = 0;
  998. p->FFwd = 0;
  999. p->Fill = 0;
  1000. p->Sync = 0;
  1001. p->InSeek = 0;
  1003. if (p->TemporaryHidden)
  1004. {
  1005. p->TemporaryHidden = 0;
  1006. UpdateVideo(p,-1);
  1007. }
  1008. }
  1010. DEBUG_MSG2(DEBUG_PLAYER,T("Play %d,%d"),p->Play,p->FFwd);
  1012. StopLoadMode(p);
  1014. if (p->Bench && !p->Play)
  1015. StopBench(p);
  1017. if (p->Format && p->Input && p->Timer)
  1018. {
  1019. if (p->NoMoreInput && (p->Play || p->FFwd) && p->IOError)
  1020. {
  1021. p->Fill = 1;
  1022. p->NoMoreInput = 0;
  1023. p->IOError = 0;
  1024. UpdateRunInput(p);
  1025. }
  1027. if (p->TimerPlay)
  1028. {
  1029. UpdateKeepAlive(p);
  1030. UpdatePlay(p);
  1031. UpdateSpeed(p);
  1032. }
  1033. else
  1034. {
  1035. UpdateSpeed(p);
  1036. UpdatePlay(p);
  1037. UpdateKeepAlive(p);
  1038. }
  1040. UpdateRunProcess(p);
  1042. // make sure current frame is show after pausing a dropping period
  1043. Refresh = p->VOutput && !p->Play && !p->FFwd && !p->Sync && p->Fill;
  1044. if (Refresh && p->FlowBuffer)
  1045. Refresh = p->FlowBuffer->Set(p->FlowBuffer,FLOW_RESEND,NULL,0) != ERR_NONE;
  1046. if (Refresh)
  1047. ReSync(p,0);
  1048. }
  1049. else
  1050. UpdateKeepAlive(p);
  1052. UpdateTimeouts(p);
  1053. UpdateBackground(p);
  1054. Notify(p,PLAYER_PLAY,p->Play);
  1056. return ERR_NONE;
  1057. }
  1059. static int Seek2(player_base* p,tick_t Time,const fraction* Percent,bool_t PrevKey)
  1060. {
  1061. tick_t Duration;
  1062. int Result = ERR_INVALID_DATA;
  1064. if (p->Format && p->Input && p->Timer)
  1065. {
  1066. int FileSize;
  1067. int FilePos = -1;
  1069. if (Percent)
  1070. {
  1071. if (p->Format->Get(p->Format,FORMAT_DURATION,&Duration,sizeof(Duration))==ERR_NONE)
  1072. {
  1073. Time = Scale(Duration,Percent->Num,Percent->Den);
  1074. if (Time < 0)
  1075. Time = 0;
  1076. }
  1077. else
  1078. if (p->Input->Get(p->Input,STREAM_LENGTH,&FileSize,sizeof(FileSize))==ERR_NONE)
  1079. {
  1080. Time = -1;
  1081. FilePos = Scale(FileSize,Percent->Num,Percent->Den);
  1082. if (FilePos < 0)
  1083. FilePos = 0;
  1084. }
  1085. else
  1086. return ERR_NOT_SUPPORTED;
  1087. }
  1089. p->SeekAfterSync.Num = -1;
  1091. DEBUG_MSG2(DEBUG_PLAYER,T("Sync time:%d filepos:%d"),Time,FilePos);
  1092. Result = p->Format->Sync(p->Format,Time,FilePos,PrevKey);
  1094. if (Result == ERR_LOADING_HEADER && p->Sync && Percent)
  1095. {
  1096. p->SeekAfterSync = *Percent;
  1097. p->SeekAfterSyncPrevKey = PrevKey;
  1098. Result = ERR_NONE;
  1099. }
  1100. else
  1101. if (Result == ERR_NONE)
  1102. {
  1103. Flush(p);
  1105. p->NoMoreInput = 0;
  1106. p->BufferMax = p->CurrBufferSize2;
  1107. p->Position = Time;
  1108. p->Sync = 1;
  1109. p->PosNotify = -1;
  1111. StopLoadMode(p);
  1112. UpdatePlay(p);
  1113. UpdateRunProcess(p);
  1114. UpdateRunInput(p);
  1116. // wakeup input threads (if needed)
  1117. #ifdef MULTITHREAD
  1118. EventSet(p->EventProcess); 
  1119. #else
  1120. p->WaitForProcess = 0;
  1121. #endif
  1122. }
  1123. Notify(p,PLAYER_PERCENT,0);
  1124. }
  1125. else
  1126. if (!p->Wnd && Percent)
  1127. {
  1128. p->SeekAfterSync = *Percent;
  1129. p->SeekAfterSyncPrevKey = 1;
  1130. Result = ERR_NONE;
  1131. }
  1133. return Result;
  1134. }
  1136. static int InSeek(player_base* p,tick_t Time,const fraction* Percent,bool_t PrevKey)
  1137. {
  1138. int Result;
  1139. #ifdef MULTITHREAD
  1140. assert(p->ProcessLocked != ThreadId() && p->InputLocked != ThreadId());
  1141. #endif
  1143. LockEnter(p->Lock);
  1145. if (p->InSeek)
  1146. {
  1147. tick_t Duration;
  1148. fraction Pos;
  1149. if (Percent)
  1150. Pos = *Percent;
  1151. else
  1152. if (p->Format->Get(p->Format,FORMAT_DURATION,&Duration,sizeof(Duration))==ERR_NONE)
  1153. {
  1154. Pos.Num = Time;
  1155. Pos.Den = Duration;
  1156. }
  1157. else
  1158. {
  1159. Pos.Num = -1;
  1160. Pos.Den = 0;
  1161. }
  1163. if (EqFrac(&p->InSeekPos,&Pos))
  1164. {
  1165. LockLeave(p->Lock);
  1166. return ERR_NONE;
  1167. }
  1169. p->InSeekPos = Pos;
  1170. if (p->InSeekPos.Num>=0 && (p->Sync || !IsVideo(p)))
  1171. {
  1172. p->SeekAfterSync = p->InSeekPos;
  1173. p->SeekAfterSyncPrevKey = PrevKey;
  1174. Notify(p,PLAYER_PERCENT,0);
  1176. LockLeave(p->Lock);
  1177. return ERR_NONE;
  1178. }
  1179. }
  1181. Lock(p,1);
  1182. Result = Seek2(p,Time,Percent,PrevKey);
  1183. Unlock(p,1);
  1185. LockLeave(p->Lock);
  1186. return Result;
  1187. }
  1189. static void ReSync(player_base* p,bool_t DoSeek)
  1190. {
  1191. if (p->Format)
  1192. {
  1193. if (DoSeek && p->Position>=0)
  1194. Seek2(p,p->Position,NULL,1);
  1195. else
  1196. if (p->Format->Sync(p->Format,-1,-1,0) == ERR_NONE)
  1197. {
  1198. p->Sync = 1;
  1199. p->PosNotify = -1;
  1201. StopLoadMode(p);
  1202. UpdatePlay(p);
  1203. UpdateRunProcess(p);
  1205. // wakeup input threads, just in case
  1206. #ifdef MULTITHREAD
  1207. EventSet(p->EventProcess); 
  1208. #else
  1209. p->WaitForProcess = 0;
  1210. #endif
  1211. }
  1212. }
  1213. }
  1215. static bool_t SupportVQNode(node* Node)
  1216. {
  1217. int Shift;
  1218. bool_t Buffered;
  1219. if (NodeIsClass(Node->Class,IDCT_CLASS))
  1220. {
  1221. if (Node->Get(Node,IDCT_SHIFT,&Shift,sizeof(Shift))!=ERR_NONE)
  1222. return 0;
  1223. }
  1224. else
  1225. if (Node->Get(Node,FLOW_BUFFERED,&Buffered,sizeof(Buffered))==ERR_NONE && Buffered)
  1226. return 0;
  1228. return 1;
  1229. }
  1231. static bool_t SupportVQ(player_base* p)
  1232. {
  1233. const ref *i;
  1234. for (i=ARRAYBEGIN(p->Ref,ref);i!=ARRAYEND(p->Ref,ref);++i)
  1235. if (!SupportVQNode(i->Node))
  1236. return 0;
  1237. if (p->FlowBuffer && !SupportVQNode(p->FlowBuffer)) // flowbuffer may not be in ref array (accel. idct)
  1238. return 0;
  1239. return 1;
  1240. }
  1242. static int UpdateVideoQuality(player_base* p,node* Node)
  1243. {
  1244. if (NodeIsClass(Node->Class,IDCT_CLASS))
  1245. {
  1246. int Shift = 2-p->VideoQuality;
  1247. Node->Set(Node,IDCT_SHIFT,&Shift,sizeof(Shift));
  1248. }
  1249. return ERR_NONE;
  1250. }
  1252. static void ClearStats(player_base* p)
  1253. {
  1254. int Zero=0;
  1255. if (p->VOutput)
  1256. {
  1257. p->VOutput->Set(p->VOutput,OUT_TOTAL,&Zero,sizeof(Zero));
  1258. p->VOutput->Set(p->VOutput,OUT_DROPPED,&Zero,sizeof(Zero));
  1259. }
  1261. if (p->AOutput)
  1262. {
  1263. p->AOutput->Set(p->AOutput,OUT_TOTAL,&Zero,sizeof(Zero));
  1264. p->AOutput->Set(p->AOutput,OUT_DROPPED,&Zero,sizeof(Zero));
  1265. }
  1266. }
  1268. static void StartBench(player_base* p)
  1269. {
  1270. int Used;
  1271. p->SaveMicroDrive = p->MicroDrive;
  1272. p->MicroDrive = 0;
  1273. p->InSeek = 0;
  1275. UpdateFormat(p,0);
  1277. if (!QueryAdvanced(ADVANCED_BENCHFROMPOS))
  1278. Seek2(p,0,NULL,0);
  1280. p->BufferMax = p->CurrBufferSize2;
  1281. while (p->Format->Read(p->Format,p->BufferMax,&Used) == ERR_NONE &&
  1282. Used < p->UsedEnough2);
  1284. ClearStats(p);
  1286. p->Bench = 1;
  1287. p->BenchStart = GetTimeTick();
  1288. p->Play = 1;
  1289. p->FFwd = 0;
  1290. p->Fill = 0;
  1291. SetPlay(p,0);
  1292. }
  1294. static void SetTimerNode(player_base* p,node* Timer,bool_t SaveTime)
  1295. {
  1296. tick_t Time = 0;
  1298. if (p->Timer && SaveTime)
  1299. p->Timer->Get(p->Timer,TIMER_TIME,&Time,sizeof(Time));
  1301. p->Timer = Timer;
  1303. if (p->Timer)
  1304. {
  1305. p->Timer->Set(p->Timer,TIMER_SPEED,&p->Speed,sizeof(p->Speed));
  1306. p->Timer->Set(p->Timer,TIMER_TIME,&Time,sizeof(Time));
  1307. UpdatePlay(p);
  1308. }
  1310. UpdateRunProcess(p);
  1311. }
  1313. static node* AddRef(player_base* p,node* Node);
  1314. static void ReleaseRef(player_base* p,node* Node);
  1316. static bool_t UpdateNode(player_base* p,node* Node);
  1317. static void ReleaseNode(player_base* p,node* Node);
  1319. static bool_t UpdateOutput(player_base* p,node* From,const datadef* FromDef,int* FoundFirst);
  1321. static NOINLINE void NullPin(node* p,int No)
  1322. {
  1323. pin Pin;
  1324. Pin.Node = NULL;
  1325. Pin.No = 0;
  1326. p->Set(p,No,&Pin,sizeof(Pin));
  1327. }
  1329. static void TryComment(player_base* p,node* From,const datadef* FromDef)
  1330. {
  1331. pin Pin;
  1332. Pin.Node = (node*)p;
  1333. Pin.No = PLAYER_COMMENT+p->StreamNo;
  1334. From->Set(From,FromDef->No,&Pin,sizeof(Pin));
  1335. }
  1337. static void ReleaseOutput(player_base* p,node* Node,datadef* DataDef)
  1338. {
  1339. node* Null = NULL;
  1340. pin Pin;
  1341. node* Ptr;
  1342. bool_t RdOnly = (DataDef->Flags & DF_RDONLY)!=0;
  1344. switch (DataDef->Type)
  1345. {
  1346. case TYPE_NODE:
  1347. if (Node->Get(Node,DataDef->No,&Ptr,sizeof(Ptr))==ERR_NONE && Ptr)
  1348. {
  1349. ReleaseNode(p,Ptr);
  1350. if (!RdOnly)
  1351. {
  1352. Node->Set(Node,DataDef->No,&Null,sizeof(Null));
  1353. ReleaseRef(p,Ptr);
  1354. }
  1355. }
  1356. break;
  1358. case TYPE_COMMENT:
  1359. if (!RdOnly)
  1360. NullPin(Node,DataDef->No);
  1361. break;
  1363. case TYPE_PACKET:
  1364. if (Node->Get(Node,DataDef->No,&Pin,sizeof(Pin))==ERR_NONE && Pin.Node)
  1365. {
  1366. ReleaseNode(p,Pin.Node);
  1367. if (!RdOnly)
  1368. {
  1369. Disconnect(Node,DataDef->No,Pin.Node,Pin.No);
  1370. ReleaseRef(p,Pin.Node);
  1371. }
  1372. }
  1373. }
  1374. }
  1376. static void ReleaseNode(player_base* p,node* Node)
  1377. {
  1378. if (Node)
  1379. {
  1380. bool_t False = 0;
  1381. datadef DataDef;
  1382. int No;
  1384. if (p->VOutput == Node)
  1385. {
  1386. p->VOutput = NULL;
  1387. p->VIDCT = NULL;
  1388. }
  1390. if (p->AOutput == Node)
  1391. {
  1392. SetTimerNode(p,NodeEnumObject(NULL,SYSTIMER_ID),1); // restore system timer
  1393. p->AOutput = NULL;
  1394. }
  1396. if (p->FlowBuffer == Node)
  1397. p->FlowBuffer = NULL;
  1399. Node->Set(Node,FLOW_BACKGROUND,&False,sizeof(bool_t));
  1401. for (No=0;NodeEnum(Node,No,&DataDef)==ERR_NONE;++No)
  1402. if (DataDef.Flags & DF_OUTPUT)
  1403. ReleaseOutput(p,Node,&DataDef);
  1404. }
  1405. }
  1407. static node* GetNode(player_base* p,int Class)
  1408. {
  1409. node* Node = NULL;
  1410. bool_t ReUse = 0;
  1411. bool_t IDCT = 0;
  1413. if (Class == (int)VOUT_IDCT_CLASS(p->VOutputId) && NodeIsClass(Class,IDCT_CLASS))
  1414. {
  1415. Class = p->VOutputId;
  1416. IDCT = 1;
  1417. }
  1419. if (Class == p->AOutputId || Class == p->VOutputId)
  1420. {
  1421. ref *i;
  1422. for (i=ARRAYBEGIN(p->Ref,ref);i!=ARRAYEND(p->Ref,ref);++i)
  1423. if (i->Node->Class == Class)
  1424. {
  1425. Node = i->Node;
  1426. ReUse = 1;
  1427. break;
  1428. }
  1429. }
  1431. if (!Node)
  1432. {
  1433. Node = NodeCreate(Class);
  1434. if (Node)
  1435. {
  1436. if (NodeIsClass(Class,VOUT_CLASS))
  1437. UpdateVideoEx(p,Node,-1,0);
  1438. if (NodeIsClass(Class,AOUT_CLASS))
  1439. UpdateAudioEx(p,Node);
  1440. UpdateVideoQuality(p,Node);
  1441. }
  1442. }
  1444. if (Node)
  1445. {
  1446. pin Pin;
  1448. if (IDCT)
  1449. {
  1450. node* i;
  1451. Node->Get(Node,VOUT_IDCT,&i,sizeof(i));
  1452. if (!i)
  1453. {
  1454. if (!ReUse) 
  1455. NodeDelete(Node);
  1456. return NULL;
  1457. }
  1458. Node = i;
  1459. }
  1461. Pin.No = PLAYER_NOT_SUPPORTED_DATA;
  1462. Pin.Node = (node*)p;
  1463. Node->Set(Node,FLOW_NOT_SUPPORTED,&Pin,sizeof(Pin));
  1464. AddRef(p,Node);
  1465. }
  1467. return Node;
  1468. }
  1470. static bool_t TryPin(player_base* p,node* From,int FromNo,int ToClass,int* FoundFirst,int Failed)
  1471. {
  1472. node* To;
  1474. if (ToClass == Failed)
  1475. return 0;
  1477. To = GetNode(p,ToClass);
  1478. if (To)
  1479. {
  1480. packetformat Format;
  1481. datadef ToDef;
  1482. int No;
  1483. int Result;
  1485. for (No=0;NodeEnum(To,No,&ToDef)==ERR_NONE;++No)
  1486. if (ToDef.Type == TYPE_PACKET && (ToDef.Flags & DF_INPUT) && !(ToDef.Flags & DF_RDONLY))
  1487. {
  1488. if (To->Get(To,ToDef.No|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE && Format.Type != PACKET_NONE)
  1489. continue; // already connected
  1491. Result = ConnectionUpdate(From,FromNo,To,ToDef.No);
  1493. if (Result == ERR_NOT_SUPPORTED && FoundFirst)
  1494. *FoundFirst = 2; // found codec, but this type is not supported
  1495. else
  1496. if (Result == ERR_NONE)
  1497. {
  1498. if (FoundFirst)
  1499. *FoundFirst = 1;
  1501. if (UpdateNode(p,To))
  1502. return 1;
  1503. }
  1505. Disconnect(From,FromNo,To,ToDef.No);
  1506. }
  1508. ReleaseRef(p,To);
  1509. }
  1510. return 0;
  1511. }
  1513. static bool_t IsCodecSkip(player_base* p,int Id)
  1514. {
  1515. int i;
  1516. for (i=0;i<p->CodecSkipCount;++i)
  1517. if (p->CodecSkip[i]==Id)
  1518. return 1;
  1519. return 0;
  1520. }
  1522. static bool_t UpdateOutput(player_base* p,node* From,const datadef* FromDef,int* FoundFirst)
  1523. {
  1524. packetformat Format;
  1525. bool_t EqMissing;
  1526. node* Null = NULL;
  1527. node* To;
  1528. node* Old = NULL;
  1529. int Force = 0;
  1530. int Skip = 0;
  1531. pin Pin;
  1532. bool_t RdOnly = (FromDef->Flags & DF_RDONLY)!=0;
  1533. int Failed = 0;
  1535. if (FoundFirst)
  1536. *FoundFirst = 0;
  1538. switch (FromDef->Type)
  1539. {
  1540. case TYPE_NODE:
  1542. if (!RdOnly)
  1543. switch (FromDef->Format1)
  1544. {
  1545. case IDCT_CLASS:
  1546. if (VOutIDCT(p->VOutputId))
  1547. {
  1548. int IDCT = VOUT_IDCT_CLASS(p->VOutputId);
  1549. if (p->VideoAccel && p->Timing && p->SkipAccelFrom != From->Class)
  1550. Force = IDCT;
  1551. else
  1552. Skip = IDCT;
  1553. }
  1554. break;
  1555. case VOUT_CLASS:
  1556. Force = p->VOutputId;
  1557. break;
  1558. case AOUT_CLASS:
  1559. Force = p->AOutputId;
  1560. break;
  1561. }
  1563. // already connected pointer?
  1564. if (From->Get(From,FromDef->No,&Old,sizeof(Old))==ERR_NONE && Old)
  1565. {
  1566. if (FoundFirst)
  1567. *FoundFirst = 1;
  1569. if ((!Force || Old->Class == Force) && (!Skip || Old->Class != Skip))
  1570. {
  1571. if (UpdateNode(p,Old))
  1572. return 1;
  1574. Failed = Old->Class;
  1575. }
  1576. else
  1577. ReleaseNode(p,Old);
  1578. }
  1580. if (RdOnly)
  1581. return 0;
  1583. if (Force)
  1584. {
  1585. To = GetNode(p,Force);
  1586. if (To && From->Set(From,FromDef->No,&To,sizeof(To))==ERR_NONE)
  1587. {
  1588. ReleaseRef(p,Old);
  1589. Old = To;
  1591. if (FoundFirst)
  1592. *FoundFirst = 1;
  1594. if (UpdateNode(p,To))
  1595. return 1;
  1596. }
  1597. else
  1598. ReleaseRef(p,To);
  1600. if (FromDef->Format1 == IDCT_CLASS)
  1601. p->SkipAccelFrom = From->Class;
  1603. if (Old && !Failed && UpdateNode(p,Old))
  1604. return 1;
  1605. }
  1607. if (FromDef->Format1 != VOUT_CLASS && FromDef->Format1 != AOUT_CLASS)
  1608. {
  1609. int* i;
  1610. array List;
  1611. NodeEnumClass(&List,FromDef->Format1);
  1613. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  1614. if (Failed != *i && (To = GetNode(p,*i))!=NULL)
  1615. {
  1616. if (From->Set(From,FromDef->No,&To,sizeof(To))==ERR_NONE)
  1617. {
  1618. ReleaseRef(p,Old);
  1619. Old = To;
  1621. if (FoundFirst)
  1622. *FoundFirst = 1;
  1624. if (UpdateNode(p,To))
  1625. {
  1626. ArrayClear(&List);
  1627. return 1;
  1628. }
  1629. }
  1630. else
  1631. ReleaseRef(p,To);
  1632. }
  1634. ArrayClear(&List);
  1635. }
  1637. From->Set(From,FromDef->No,&Null,sizeof(Null));
  1638. ReleaseRef(p,Old);
  1639. break;
  1641. case TYPE_COMMENT:
  1642. if (!RdOnly)
  1643. TryComment(p,From,FromDef);
  1644. return 1;
  1646. case TYPE_PACKET:
  1648. EqMissing = p->Eq && !Used(p,p->Equalizer);
  1650. // already connected pin?
  1651. if (From->Get(From,FromDef->No,&Pin,sizeof(Pin))==ERR_NONE && Pin.Node)
  1652. {
  1653. if (!IsCodecSkip(p,Pin.Node->Class) && (!NodeIsClass(Pin.Node->Class,OUT_CLASS) || Pin.Node->Class == p->VOutputId || 
  1654. (Pin.Node->Class == p->AOutputId && !EqMissing)))
  1655. {
  1656. if (FoundFirst)
  1657. *FoundFirst = 1;
  1659. if (UpdateNode(p,Pin.Node))
  1660. return 1;
  1662. Failed = Pin.Node->Class; // don't try with class again
  1663. }
  1664. else
  1665. ReleaseNode(p,Pin.Node);
  1667. if (!RdOnly)
  1668. {
  1669. Disconnect(From,FromDef->No,Pin.Node,Pin.No);
  1670. ReleaseRef(p,Pin.Node);
  1671. }
  1672. }
  1674. if (RdOnly)
  1675. return 0;
  1677. if (From->Get(From,FromDef->No|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE)
  1678. {
  1679. array List;
  1680. const int *i;
  1682. if (Format.Type == PACKET_VIDEO)
  1683. {
  1684. if (!p->VOutputId)
  1685. {
  1686. if (FoundFirst)
  1687. *FoundFirst = 1;
  1688. return 0;
  1689. }
  1691. if (TryPin(p,From,FromDef->No,p->VOutputId,FoundFirst,Failed))
  1692. return 1;
  1693. }
  1695. if (Format.Type == PACKET_AUDIO && !EqMissing)
  1696. {
  1697. if (!p->AOutputId)
  1698. {
  1699. if (FoundFirst)
  1700. *FoundFirst = 1;
  1701. return 0;
  1702. }
  1704. if (TryPin(p,From,FromDef->No,p->AOutputId,FoundFirst,Failed))
  1705. return 1;
  1706. }
  1708. PacketFormatEnumClass(&List,&Format);
  1709. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  1710. if (!IsCodecSkip(p,*i) && TryPin(p,From,FromDef->No,*i,FoundFirst,Failed))
  1711. {
  1712. ArrayClear(&List);
  1713. return 1;
  1714. }
  1716. if (Format.Type == PACKET_AUDIO && EqMissing)
  1717. {
  1718. if (!p->AOutputId)
  1719. {
  1720. if (FoundFirst)
  1721. *FoundFirst = 1;
  1722. return 0;
  1723. }
  1725. if (TryPin(p,From,FromDef->No,p->AOutputId,FoundFirst,Failed))
  1726. return 1;
  1727. }
  1729. ArrayClear(&List);
  1730. }
  1731. break;
  1732. }
  1733. return 0;
  1734. }
  1736. static node* AddRef(player_base* p,node* Node)
  1737. {
  1738. if (Node)
  1739. {
  1740. bool_t Found;
  1741. ref Ref;
  1742. int No;
  1744. Ref.RefCount = 1;
  1745. if (Node->Get(Node,NODE_PARTOF,&Ref.Node,sizeof(node*)) != ERR_NONE)
  1746. Ref.Node = Node;
  1748. No = ArrayFind(&p->Ref,ARRAYCOUNT(p->Ref,ref),sizeof(ref),&Ref,(arraycmp)CmpRef,&Found);
  1749. if (!Found)
  1750. ArrayAdd(&p->Ref,ARRAYCOUNT(p->Ref,ref),sizeof(ref),&Ref,(arraycmp)CmpRef,64);
  1751. else
  1752. ARRAYBEGIN(p->Ref,ref)[No].RefCount++;
  1753. }
  1754. return Node;
  1755. }
  1757. static void ReleaseRef(player_base* p,node* Node)
  1758. {
  1759. if (Node)
  1760. {
  1761. int No;
  1762. ref Ref;
  1763. bool_t Found;
  1765. if (Node->Get(Node,NODE_PARTOF,&Ref.Node,sizeof(node*)) != ERR_NONE)
  1766. Ref.Node = Node;
  1768. No = ArrayFind(&p->Ref,ARRAYCOUNT(p->Ref,ref),sizeof(ref),&Ref,(arraycmp)CmpRef,&Found);
  1769. if (Found && --(ARRAYBEGIN(p->Ref,ref)[No].RefCount)==0)
  1770. {
  1771. ArrayRemove(&p->Ref,ARRAYCOUNT(p->Ref,ref),sizeof(ref),&Ref,(arraycmp)CmpRef);
  1772. NodeDelete(Ref.Node);
  1773. }
  1774. }
  1775. }
  1777. static bool_t UpdateNode(player_base* p,node* Node)
  1778. {
  1779. bool_t Buffered;
  1781. assert(NodeIsClass(Node->Class,FLOW_CLASS));
  1783. if (!NodeIsClass(Node->Class,OUT_CLASS))
  1784. {
  1785. // update output pins
  1786. datadef DataDef;
  1787. int No;
  1789. for (No=0;NodeEnum(Node,No,&DataDef)==ERR_NONE;++No)
  1790. if (DataDef.Flags & DF_OUTPUT)
  1791. if (!UpdateOutput(p,Node,&DataDef,NULL))
  1792. {
  1793. ReleaseNode(p,Node);
  1794. return 0;
  1795. }
  1796. }
  1798. if (Node->Class == p->VOutputId)
  1799. {
  1800. p->VOutput = Node;
  1801. Node->Set(Node,VOUT_PLAY,&p->TimerPlay,sizeof(bool_t));
  1802. Node->Get(Node,VOUT_IDCT,&p->VIDCT,sizeof(p->VIDCT));
  1803. if (!p->VIDCT)
  1804. p->VideoAccel = 0;
  1806. if (p->FullScreenAfterSync && !p->FullScreen)
  1807. Notify(p,PLAYER_FULLSCREEN,1);
  1808. }
  1810. if (Node->Class == p->AOutputId)
  1811. {
  1812. node* Timer;
  1813. p->AOutput = Node;
  1814. if (Node->Get(Node,AOUT_TIMER,&Timer,sizeof(Timer))==ERR_NONE)
  1815. SetTimerNode(p,Timer,1);
  1816. }
  1818. if (Node->Get(Node,FLOW_BUFFERED,&Buffered,sizeof(Buffered))==ERR_NONE && Buffered)
  1819. p->FlowBuffer = Node;
  1821. return 1;
  1822. }
  1824. static int ReleaseStreamsNotify(player_base* p,int Param,int Param2)
  1825. {
  1826. datadef DataDef; 
  1827. int No;
  1829. for (No=0;NodeEnum((node*)p->Format,No,&DataDef)==ERR_NONE;++No)
  1830. {
  1831. if (DataDef.No >= FORMAT_COMMENT && DataDef.No < FORMAT_COMMENT+MAXSTREAM)
  1832. NullPin((node*)p->Format,DataDef.No);
  1834. if (DataDef.No >= FORMAT_STREAM && DataDef.No < FORMAT_STREAM+MAXSTREAM)
  1835. ReleaseOutput(p,(node*)p->Format,&DataDef);
  1836. }
  1838. return ERR_NONE;
  1839. }
  1841. static int UpdateStreamsMask(player_base* p)
  1842. {
  1843. int Result = UpdateStreams(p,1,0);
  1844. if (Result == ERR_NONE && p->Format)
  1845. {
  1846. tick_t Time;
  1847. p->Timer->Get(p->Timer,TIMER_TIME,&Time,sizeof(tick_t));
  1848. p->Format->Set(p->Format,FORMAT_UPDATEMASK,&Time,sizeof(tick_t));
  1849. }
  1850. return Result;
  1851. }
  1853. static int UpdateStreamsNotify(player_base* p,int Param,int Param2)
  1854. {
  1855. // called by process thread
  1856. // we are inside the LockProcess so Lock/Unlock not needed
  1857. // inputprocess doesn't bother us here
  1858. UpdateStreams(p,-1,0);
  1859. return ERR_NONE;
  1860. }
  1862. static void ReleaseFormat(player_base* p)
  1863. {
  1864. NullPin((node*)p->Format,FORMAT_GLOBAL_COMMENT);
  1865. p->Format->Set(p->Format,FORMAT_INPUT,NULL,0);
  1866. NodeDelete((node*)p->Format);
  1867. p->Format = NULL;
  1868. }
  1870. static void ErrorCodec(packetformat* Format)
  1871. {
  1872. tchar_t Name[64];
  1873. int Id = 0;
  1874. switch (Format->Type)
  1875. {
  1876. case PACKET_VIDEO: 
  1877. Id = PLAYER_VIDEO_NOT_FOUND; 
  1878. break;
  1879. case PACKET_AUDIO: 
  1880. #ifdef CONFIG_GPL
  1881. if (Format->Format.Audio.Format == AUDIOFMT_AAC)
  1882. Id = PLAYER_AUDIO_NOT_FOUND2;
  1883. else
  1884. #endif
  1885. Id = PLAYER_AUDIO_NOT_FOUND; 
  1886. break;
  1887. }
  1888. if (Id && PacketFormatName(Format,Name,TSIZEOF(Name)))
  1889. ShowError(PLAYER_ID,PLAYER_ID,Id,Name);
  1890. }
  1892. static int UpdateStreams(player_base* p,int ForceRefresh,bool_t CodecSkip)
  1893. {
  1894. packetformat Format;
  1895. datadef DataDef;
  1896. int FoundCodec;
  1897. int No;
  1899. p->UpdateStreamsNeeded = 0;
  1901. if (!p->Format)
  1902. return ERR_INVALID_PARAM;
  1904. // first release unused streams
  1905. for (No=0;NodeEnum((node*)p->Format,No,&DataDef)==ERR_NONE;++No)
  1906. if (DataDef.No >= FORMAT_STREAM && DataDef.No < FORMAT_STREAM+MAXSTREAM)
  1907. {
  1908. p->StreamNo = DataDef.No - FORMAT_STREAM;
  1909. if (!p->StreamSkip[p->StreamNo] && 
  1910. p->Format->Get(p->Format,DataDef.No|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE && 
  1911. Format.Type != PACKET_NONE && p->Selected[Format.Type]>=0 && p->Selected[Format.Type] != p->StreamNo)
  1912. ReleaseOutput(p,(node*)p->Format,&DataDef);
  1913. }
  1915. for (No=0;NodeEnum((node*)p->Format,No,&DataDef)==ERR_NONE;++No)
  1916. {
  1917. if (DataDef.No >= FORMAT_COMMENT && DataDef.No < FORMAT_COMMENT+MAXSTREAM)
  1918. {
  1919. p->StreamNo = DataDef.No - FORMAT_COMMENT;
  1920. TryComment(p,(node*)p->Format,&DataDef);
  1921. }
  1923. if (DataDef.No >= FORMAT_STREAM && DataDef.No < FORMAT_STREAM+MAXSTREAM)
  1924. {
  1925. p->StreamNo = DataDef.No - FORMAT_STREAM;
  1926. if (!p->StreamSkip[p->StreamNo] && 
  1927. p->Format->Get(p->Format,DataDef.No|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE && 
  1928. Format.Type != PACKET_NONE)
  1929. {
  1930. if (p->Selected[Format.Type]<0)
  1931. p->Selected[Format.Type] = p->StreamNo;
  1933. if (p->Selected[Format.Type] == p->StreamNo && 
  1934. !UpdateOutput(p,(node*)p->Format,&DataDef,&FoundCodec) && FoundCodec!=1)
  1935. {
  1936. if (!FoundCodec && !CodecSkip)
  1937. ErrorCodec(&Format);
  1939. p->Selected[Format.Type] = -1;
  1940. p->StreamSkip[p->StreamNo] = 1;
  1941. }
  1942. }
  1943. }
  1944. }
  1946. UpdateVideo(p,ForceRefresh);
  1947. UpdateTimeouts(p);
  1948. return ERR_NONE;
  1949. }
  1951. static int UpdateFormat(player_base* p,bool_t BufferChanged)
  1952. {
  1953. if (BufferChanged)
  1954. p->BufferWarning = 0;
  1955. p->CurrBufferSize2 = p->MicroDrive ? p->MDBufferSize2 : p->BufferSize2;
  1956. p->BufferMax = p->CurrBufferSize2;
  1957. if (p->Format)
  1958. p->Format->Set(p->Format,FORMAT_BUFFERSIZE,&p->CurrBufferSize2,sizeof(int));
  1959. return ERR_NONE;
  1960. }
  1962. static void RemoveFilter(player_base* p,node* Filter,int In,int Out)
  1963. {
  1964. pin InPin;
  1965. pin OutPin;
  1966. if (Filter->Get(Filter,In,&InPin,sizeof(InPin))==ERR_NONE && InPin.Node &&
  1967. Filter->Get(Filter,Out,&OutPin,sizeof(OutPin))==ERR_NONE && OutPin.Node)
  1968. {
  1969. if (ConnectionUpdate(InPin.Node,InPin.No,OutPin.Node,OutPin.No)==ERR_NONE)
  1970. {
  1971. ConnectionUpdate(NULL,0,Filter,Out);
  1972. ConnectionUpdate(Filter,In,NULL,0);
  1973. ReleaseRef(p,Filter);
  1974. }
  1975. else
  1976. {
  1977. ConnectionUpdate(InPin.Node,InPin.No,Filter,In);
  1978. ConnectionUpdate(Filter,Out,OutPin.Node,OutPin.No);
  1979. }
  1980. }
  1981. }
  1983. static void InsertFilter(player_base* p,node* Filter,int In,int Out,node* Output,int OutputIn)
  1984. {
  1985. pin Pin;
  1986. if (Output->Get(Output,OutputIn,&Pin,sizeof(Pin))==ERR_NONE && Pin.Node)
  1987. {
  1988. if (ConnectionUpdate(Pin.Node,Pin.No,Filter,In)==ERR_NONE &&
  1989. ConnectionUpdate(Filter,Out,Output,OutputIn)==ERR_NONE)
  1990. GetNode(p,Filter->Class);
  1991. else
  1992. {
  1993. ConnectionUpdate(Pin.Node,Pin.No,Output,OutputIn); //try restoring...
  1994. ConnectionUpdate(NULL,0,Filter,Out);
  1995. ConnectionUpdate(Filter,In,NULL,0);
  1996. }
  1997. }
  1998. }
  2000. static int UpdateEqualizer(player_base* p)
  2001. {
  2002. if (p->Equalizer)
  2003. p->Equalizer->Get(p->Equalizer,EQUALIZER_ENABLED,&p->Eq,sizeof(p->Eq));
  2005. if (!p->Eq && Used(p,p->Equalizer))
  2006. RemoveFilter(p,p->Equalizer,CODEC_INPUT,CODEC_OUTPUT);
  2007. else
  2008. if (p->Eq && !Used(p,p->Equalizer) && p->AOutput)
  2009. InsertFilter(p,p->Equalizer,CODEC_INPUT,CODEC_OUTPUT,p->AOutput,OUT_INPUT);
  2011. return ERR_NONE;
  2012. }
  2014. static void Unload(player_base* p,bool_t KeepPlay,bool_t KeepStreams,bool_t Refresh) 
  2015. {
  2016. p->Sync = 0;
  2017. p->Fill = 0;
  2018. p->InSeek = 0;
  2019. p->SeekAfterSync.Num = -1;
  2021. if (!KeepPlay)
  2022. SetPlay(p,1);
  2024. if (!KeepStreams || p->Format)
  2025. {
  2026. int i;
  2027. for (i=0;i<PACKET_MAX;++i)
  2028. p->Selected[i] = -1;
  2029. }
  2031. if (p->Format)
  2032. ReleaseFormat(p);
  2034. if (p->Input)
  2035. {
  2036. NodeDelete((node*)p->Input);
  2037. p->Input = NULL;
  2038. }
  2040. if (p->InputBase)
  2041. {
  2042. NodeDelete((node*)p->InputBase);
  2043. p->InputBase = NULL;
  2044. }
  2046. p->Title[0] = 0;
  2047. Notify(p,PLAYER_TITLE,1);
  2049. assert(ARRAYEMPTY(p->Ref));
  2050. ArrayClear(&p->Ref);
  2051. ArrayClear(&p->Comment);
  2053. p->Position = -1;
  2054. p->NoMoreInput = 0;
  2055. p->CurrentChanged = 1;
  2056. p->BufferWarning = 0;
  2057. p->CodecSkipCount = 0;
  2059. if (!KeepPlay)
  2060. UpdateTimeouts(p);
  2061. UpdateRunInput(p);
  2062. UpdateRunProcess(p);
  2064. if (Refresh)
  2065. Notify(p,PLAYER_PERCENT,1);
  2066. }
  2068. static void URLToTitle(tchar_t* Title, int TitleLen, const tchar_t* URL)
  2069. {
  2070. tchar_t Ext[MAXPATH];
  2071. tchar_t *i,*j;
  2072. bool_t HasHost;
  2073. i = (tchar_t*) GetMime(URL,NULL,0,&HasHost);
  2074. if (i==URL || !HasHost || tcschr(i,'/') || tcschr(i,'\'))
  2075. SplitURL(URL,NULL,0,NULL,0,Title,TitleLen,Ext,TSIZEOF(Ext));
  2076. else
  2077. tcscpy_s(Title,TitleLen,URL);
  2079. // replace %20 and '_' with space
  2080. for (j=i=Title;*i;++i)
  2081. {
  2082. if (*i=='_')
  2083. *j++ = ' ';
  2084. else
  2085. if (i[0]=='%' && i[1]=='2' && i[2]=='0')
  2086. {
  2087. *j++ = ' ';
  2088. i += 2;
  2089. }
  2090. else
  2091. *j++ = *i;
  2092. }
  2093. *j=0;
  2094. }
  2096. static bool_t LoadPlaylist(player* Player,const array* List,stream* Input,int* Index,const tchar_t* Path,const void* Probe,int ProbeSize)
  2097. {
  2098. int *i;
  2099. bool_t SeekHead = 0;
  2101. for (i=ARRAYBEGIN(*List,int);i!=ARRAYEND(*List,int);++i)
  2102. {
  2103. playlist* Playlist = (playlist*)NodeCreate(*i);
  2104. if (Playlist)
  2105. {
  2106. tchar_t Base[MAXPATH];
  2107. tchar_t Abs[MAXPATH];
  2108. tchar_t ItemPath[MAXPATH];
  2109. tchar_t ItemTitle[256];
  2110. tick_t ItemLength;
  2111. int Pos = *Index;
  2113. if (SeekHead)
  2114. {
  2115. Input->Seek(Input,ProbeSize,SEEK_SET);
  2116. SeekHead = 0;
  2117. }
  2119. if (Probe)
  2120. Playlist->Set(Playlist,PLAYLIST_DATAFEED,Probe,ProbeSize);
  2122. if (Playlist->Set(Playlist,PLAYLIST_STREAM,&Input,sizeof(Input)) == ERR_NONE)
  2123. {
  2124. SplitURL(Path,Base,TSIZEOF(Base),Base,TSIZEOF(Base),NULL,0,NULL,0);
  2126. while (Playlist->ReadList(Playlist,ItemPath,TSIZEOF(ItemPath),ItemTitle,TSIZEOF(ItemTitle),&ItemLength)==ERR_NONE)
  2127. {
  2128. AbsPath(Abs,TSIZEOF(Abs),ItemPath,Base);
  2129. Player->Set(Player,PLAYER_LIST_URL+Pos,Abs,sizeof(Abs));
  2130. Player->Set(Player,PLAYER_LIST_TITLE+Pos,ItemTitle,sizeof(ItemTitle));
  2131. Player->Set(Player,PLAYER_LIST_LENGTH+Pos,&ItemLength,sizeof(ItemLength));
  2132. ++Pos;
  2133. }
  2135. SeekHead = 1;
  2136. }
  2138. Playlist->Set(Playlist,PLAYLIST_STREAM,NULL,0);
  2139. NodeDelete((node*)Playlist);
  2141. if (Pos != *Index)
  2142. {
  2143. *Index = Pos;
  2144. return 1;
  2145. }
  2146. }
  2147. }
  2149. if (Probe) // restore file position
  2150. Input->Seek(Input,ProbeSize,SEEK_SET);
  2152. return 0;
  2153. }
  2155. static void ListSwap(player_base* p,int a,int b)
  2156. {
  2157. #ifdef MULTITHREAD
  2158. assert(p->ProcessLocked != ThreadId() && p->InputLocked != ThreadId());
  2159. #endif
  2161. LockEnter(p->Lock);
  2162. if (a < p->PlayListCount && b < p->PlayListCount && a!=b)
  2163. {
  2164. item Tmp;
  2166. Tmp = p->PlayList[a];
  2167. p->PlayList[a] = p->PlayList[b];
  2168. p->PlayList[b] = Tmp;
  2170. if (p->Current == a)
  2171. p->Current = b;
  2172. else
  2173. if (p->Current == b)
  2174. p->Current = a;
  2176. p->PlayList[a].Changed = 1;
  2177. p->PlayList[b].Changed = 1;
  2179. NotifyList(p);
  2180. }
  2181. LockLeave(p->Lock);
  2182. }
  2184. static int Load(player_base* p,bool_t Silent,bool_t OnlyLocal,bool_t Nested);
  2186. static bool_t ReDirect(player_base* p,const tchar_t* New,const tchar_t* Orig,bool_t Silent,bool_t OnlyLocal,bool_t Nested,int* Result)
  2187. {
  2188. tchar_t Base[MAXPATH];
  2189. tchar_t Target[MAXPATH];
  2190. SplitURL(Orig,Base,TSIZEOF(Base),Base,TSIZEOF(Base),NULL,0,NULL,0);
  2191. AbsPath(Target,TSIZEOF(Target),New,Base);
  2192. if (tcsicmp(Target,Orig)==0)
  2193. return 0;
  2195. p->Player.Set(p,PLAYER_LIST_URL+p->Current,Target,sizeof(Target));
  2196. *Result = Load(p,Silent,OnlyLocal,Nested);
  2197. return 1;
  2198. }
  2200. static int Load(player_base* p,bool_t Silent,bool_t OnlyLocal,bool_t Nested)
  2201. {
  2202. tchar_t ContentType[MAXPATH];
  2203. array List;
  2204. block Probe;
  2205. tchar_t* URL;
  2206. stream* Input;
  2207. int ProbeSize;
  2208. int Result;
  2209. int No;
  2210. bool_t PosPrevKey = p->SeekAfterSyncPrevKey;
  2211. fraction Pos = p->SeekAfterSync;
  2212. p->SeekAfterSync.Num = -1;
  2213. p->InSeek = 0;
  2214. p->TemporaryHidden = Pos.Num > 0;
  2216. if (p->CurrentChanged || p->PlayList[p->Current].Changed || p->IOError)
  2217. {
  2218. tchar_t Mime[MAXMIME];
  2219. int Length;
  2220. pin Comment;
  2221. bool_t Network;
  2223. if (p->Format)
  2224. Pos.Num = -1; // invalidate last SeekAfterSync
  2226. Unload(p,1,OnlyLocal,0);
  2228. // find input
  2230. URL = p->PlayList[p->Current].URL;
  2231. if (!URL[0])
  2232. {
  2233. if (!Silent)
  2234. UpdateTimeouts(p);
  2235. return ERR_NONE;
  2236. }
  2238. GetMime(URL,Mime,TSIZEOF(Mime),&p->HasHost);
  2239. Network = p->HasHost || (URL[0]=='\' && URL[1]=='\');
  2240. if (OnlyLocal && Network)
  2241. {
  2242. if (!Silent)
  2243. UpdateTimeouts(p);
  2244. return ERR_FILE_NOT_FOUND;
  2245. }
  2247. Input = GetStream(URL,Silent);
  2248. if (!Input)
  2249. {
  2250. if (!Silent)
  2251. UpdateTimeouts(p);
  2252. return ERR_NOT_SUPPORTED;
  2253. }
  2255. if (p->PlayList[p->Current].Title[0])
  2256. tcscpy_s(p->Title,TSIZEOF(p->Title),p->PlayList[p->Current].Title);
  2257. else
  2258. URLToTitle(p->Title,TSIZEOF(p->Title),URL);
  2260. memset(p->StreamSkip,0,sizeof(p->StreamSkip));
  2262. UpdateSpeed(p);
  2263. SetTimerNode(p,NodeEnumObject(NULL,SYSTIMER_ID),0); // restore system timer
  2264. p->Input = Input;
  2266. Comment.No = PLAYER_COMMENT;
  2267. Comment.Node = (node*)p;
  2268. p->Input->Set(p->Input,STREAM_COMMENT,&Comment,sizeof(pin));
  2269. p->Input->Set(p->Input,STREAM_SILENT,&Silent,sizeof(Silent));
  2271. Result = p->Input->Set(p->Input,STREAM_URL,URL,TSIZEOF(p->PlayList[p->Current].URL));
  2273. if (Result != ERR_NONE)
  2274. {
  2275. Unload(p,Silent,0,1);
  2276. return Result;
  2277. }
  2279. newstream:
  2280. if (p->Input->Get(p->Input,STREAM_LENGTH,&Length,sizeof(int))!=ERR_NONE)
  2281. Length = -1;
  2283. // find format
  2284. if (!AllocBlock(PROBE_SIZE,&Probe,0,HEAP_ANY))
  2285. {
  2286. Unload(p,Silent,0,1);
  2287. return ERR_OUT_OF_MEMORY;
  2288. }
  2290. ProbeSize = p->Input->ReadBlock(p->Input,&Probe,0,PROBE_SIZE);
  2292. // important: get content type after probe was read 
  2293. if (p->Input->Get(p->Input,STREAM_CONTENTTYPE,ContentType,sizeof(ContentType))!=ERR_NONE)
  2294. ContentType[0] = 0;
  2296. if (ProbeSize > 0)
  2297. { 
  2298. int *i;
  2300. if (!p->InputBase)
  2301. {
  2302. node* Process = NULL;
  2304. NodeEnumClassEx(&List,STREAMPROCESS_CLASS,ContentType,URL,Probe.Ptr,ProbeSize);
  2305. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  2306. {
  2307. Process = NodeCreate(*i);
  2308. if (Process)
  2309. {
  2310. Process->Set(Process,STREAM_COMMENT,&Comment,sizeof(pin));
  2311. Process->Set(Process,STREAM_SILENT,&Silent,sizeof(Silent));
  2313. if (Process->Set(Process,STREAMPROCESS_INPUT,&p->Input,sizeof(node*)) == ERR_NONE)
  2314. break;
  2316. NodeDelete(Process);
  2317. }
  2318. }
  2320. ArrayClear(&List);
  2322. if (Process)
  2323. {
  2324. p->InputBase = p->Input;
  2325. p->Input = (stream*)Process;
  2326. FreeBlock(&Probe);
  2327. goto newstream;
  2328. }
  2329. }
  2331. NodeEnumClassEx(&List,FORMAT_CLASS,ContentType,URL,Probe.Ptr,ProbeSize);
  2332. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  2333. {
  2334. p->Format = (format*)NodeCreate(*i);
  2335. if (p->Format)
  2336. {
  2337. notify Notify;
  2338. int Align = p->HasHost?1:ALIGN_SIZE;
  2339. bool_t FindSubtitles = !p->HasHost;
  2340. UpdateFormat(p,0); // set buffersize as soon as possible
  2341. p->Format->Set(p->Format,FORMAT_AUTO_READSIZE,&Network,sizeof(bool_t));
  2342. p->Format->Set(p->Format,FORMAT_FILEALIGN,&Align,sizeof(Align));
  2343. p->Format->Set(p->Format,FORMAT_DATAFEED,Probe.Ptr,ProbeSize);
  2344. p->Format->Set(p->Format,FORMAT_FIND_SUBTITLES,&FindSubtitles,sizeof(FindSubtitles));
  2345. p->Format->Set(p->Format,FORMAT_GLOBAL_COMMENT,&Comment,sizeof(pin));
  2347. Notify.This = p;
  2348. Notify.Func = (notifyfunc)UpdateStreamsNotify;
  2349. p->Format->Set(p->Format,FORMAT_UPDATESTREAMS,&Notify,sizeof(Notify));
  2351. Notify.This = p;
  2352. Notify.Func = (notifyfunc)ReleaseStreamsNotify;
  2353. p->Format->Set(p->Format,FORMAT_RELEASESTREAMS,&Notify,sizeof(Notify));
  2355. if (p->Format->Set(p->Format,FORMAT_INPUT,&p->Input,sizeof(stream*)) == ERR_NONE)
  2356. break;
  2358. ReleaseFormat(p);
  2360. if (p->Input->Seek(p->Input,0,SEEK_CUR) > PROBE_SIZE) //maybe less if file smaller as PROBE_SIZE
  2361. p->Input->Seek(p->Input,PROBE_SIZE,SEEK_SET);
  2362. }
  2363. }
  2364. ArrayClear(&List);
  2366. if (!p->Format && !Nested)
  2367. {
  2368. NodeEnumClassEx(&List,PLAYLIST_CLASS,ContentType,URL,Probe.Ptr,ProbeSize);
  2369. if (!ARRAYEMPTY(List))
  2370. {
  2371. int Index = p->PlayListCount;
  2372. if (LoadPlaylist(&p->Player,&List,p->Input,&Index,URL,Probe.Ptr,ProbeSize))
  2373. {
  2374. FreeBlock(&Probe);
  2375. // remove this from playlist
  2376. for (No=p->Current+1;No<p->PlayListCount;++No)
  2377. ListSwap(p,No-1,No);
  2379. SetPlayListCount(p,p->PlayListCount-1);
  2380. return Load(p,Silent,OnlyLocal,1);
  2381. }
  2382. }
  2383. ArrayClear(&List);
  2384. }
  2385. }
  2387. FreeBlock(&Probe);
  2389. if (!p->Format)
  2390. {
  2391. Unload(p,0,0,1);
  2392. if (ProbeSize < 0)
  2393. ShowError(0,ERR_ID,ERR_FILE_NOT_FOUND,URL);
  2394. else
  2395. if (!CheckExts(URL,T("exe:P")))
  2396. ShowError(PLAYER_ID,PLAYER_ID,PLAYER_FORMAT_NOT_FOUND,URL);
  2397. return ERR_NOT_SUPPORTED;
  2398. }
  2400. if (p->Player.CommentByName(p,-1,PlayerComment(COMMENT_REDIRECT),ContentType,TSIZEOF(ContentType)) &&
  2401. ReDirect(p,ContentType,URL,Silent,OnlyLocal,Nested,&Result))
  2402. return Result;
  2404. // only after format initialized (may have reopened http connection with different pragma)
  2405. p->Streaming = p->HasHost && 
  2406. (p->Input->Get(p->Input,STREAM_LENGTH,&Length,sizeof(int))!=ERR_NONE || Length<0);
  2407. p->Timing = 1;
  2408. p->Format->Get(p->Format,FORMAT_TIMING,&p->Timing,sizeof(p->Timing));
  2410. p->SkipAccelFrom = 0;
  2411. p->PlayList[p->Current].Changed = 0;
  2412. p->CurrentChanged = p->HasHost; // force reload when example connection stops
  2413. p->NoMoreInput = 0;
  2414. p->Position = 0;
  2415. p->BufferMax = p->CurrBufferSize2;
  2416. p->Sync = 1; // start with syncing
  2417. p->PosNotify = -1;
  2418. p->MinBuffer = 0;
  2420. Notify(p,PLAYER_TITLE,1);
  2422. Flush(p);
  2424. if (Pos.Num > 0)
  2425. {
  2426. p->SeekAfterSync = Pos; // restore syncaftersync (now we are sure there will a synced event)
  2427. p->SeekAfterSyncPrevKey = PosPrevKey;
  2428. }
  2430. StopLoadMode(p);
  2431. UpdatePlay(p);
  2432. }
  2433. else
  2434. {
  2435. UpdateFormat(p,0);
  2436. UpdateStreams(p,0,0);
  2437. ClearStats(p);
  2439. if (Pos.Num > 0)
  2440. Result = Seek2(p,-1,&Pos,1);
  2441. else
  2442. Result = Seek2(p,0,NULL,0);
  2444. if (Result != ERR_NONE)
  2445. return Result;
  2446. }
  2448. UpdateRunInput(p);
  2449. UpdateRunProcess(p);
  2450. UpdateTimeouts(p);
  2452. #ifdef MULTITHREAD
  2453. EventSet(p->EventProcess); // wakeup input threads (if needed)
  2454. #else
  2455. p->WaitForProcess = 0;
  2456. #endif
  2458. return ERR_NONE;
  2459. }
  2461. static int InputThread(player_base* p);
  2462. static int ProcessThread(player_base* p);
  2464. static void Unlock(player_base* p, bool_t Input)
  2465. {
  2466. #ifdef MULTITHREAD
  2467. //DEBUG_MSG2(DEBUG_PLAYER,T("Unlocked %d %08x"),p->LockCount,GetCurrentThreadId());
  2468. if (Input) 
  2469. {
  2470. LockLeave(p->LockInput);
  2471. --p->LockInputCount;
  2472. assert(p->LockInputCount>=0);
  2473. }
  2474. LockLeave(p->LockProcess);
  2475. --p->LockProcessCount;
  2476. assert(p->LockProcessCount>=0);
  2477. LockLeave(p->Lock);
  2478. #endif
  2479. }
  2481. static void Lock(player_base* p, bool_t Input)
  2482. {
  2483. #ifdef MULTITHREAD
  2484. //DEBUG_MSG2(DEBUG_PLAYER,T("Locked Start %d %08x"),p->LockCount,GetCurrentThreadId());
  2485. assert(p->ProcessLocked != ThreadId() && p->InputLocked != ThreadId());
  2486. LockEnter(p->Lock);
  2487. p->LockProcessCount++;
  2488. LockEnter(p->LockProcess);
  2489. if (Input)
  2490. {
  2491. p->LockInputCount++;
  2492. LockEnter(p->LockInput);
  2493. }
  2494. //DEBUG_MSG(DEBUG_PLAYER,T("Locked End"));
  2495. #endif
  2496. }
  2498. static int UpdateWnd(player_base* p,void* Wnd)
  2499. {
  2500. if (Wnd != p->Wnd)
  2501. {
  2502. p->Wnd = Wnd;
  2503. if (p->Wnd)
  2504. {
  2505. #ifdef MULTITHREAD
  2506. p->InputThread = ThreadCreate(InputThread,p,25);
  2507. p->ProcessThread = ThreadCreate(ProcessThread,p,25);
  2508. p->InputPriority = 0;
  2509. p->ProcessPriority = 0;
  2510. #endif
  2511. Lock(p,1);
  2512. if (p->PlayListCount && !p->DiscardList)
  2513. Load(p,1,1,0);
  2514. else
  2515. {
  2516. SetPlayListCount(p,0);
  2517. p->SeekAfterSync.Num = -1;
  2518. }
  2519. Unlock(p,1);
  2520. }
  2521. else
  2522. {
  2523. Lock(p,1);
  2524. if (!p->KeepList)
  2525. SetPlayListCount(p,0);
  2527. #ifndef REGISTRY_GLOBAL
  2528. NodeRegSave((node*)p);
  2529. NodeRegSave(p->Color);
  2530. NodeRegSave(p->Equalizer);
  2531. #endif
  2532. Unlock(p,1);
  2534. #ifdef MULTITHREAD
  2535. p->RunProcess = 0;
  2536. ThreadPriority(p->ProcessThread,0);
  2537. EventSet(p->EventRunProcess);
  2538. ThreadTerminate(p->ProcessThread);
  2539. p->ProcessThread = NULL;
  2541. p->RunInput = 0;
  2542. ThreadPriority(p->InputThread,0);
  2543. EventSet(p->EventProcess);
  2544. EventSet(p->EventRunInput);
  2545. ThreadTerminate(p->InputThread);
  2546. p->InputThread = NULL;
  2547. #endif
  2548. Unload(p,0,0,0);
  2549. }
  2550. }
  2551. return ERR_NONE;
  2552. }
  2554. static int NextPrev(player_base* p,int Dir,bool_t StopIfEnd,bool_t NotTheSame)
  2555. {
  2556. if (p->PlayListCount > 0)
  2557. {
  2558. int Index = FindCurrentIndex(p);
  2559. int Tries;
  2561. for (Tries=NotTheSame?1:0;Tries<p->PlayListCount;++Tries)
  2562. {
  2563. Index += Dir;
  2564. if (Index >= p->PlayListCount || Index < 0)
  2565. {
  2566. if (StopIfEnd && p->ExitAtEnd)
  2567. Notify(p,PLAYER_EXIT_AT_END,0);
  2569. if (StopIfEnd && !p->Repeat)
  2570. {
  2571. SetPlay(p,1);
  2572. Notify(p,PLAYER_PERCENT,0);
  2573. return ERR_NONE;
  2574. }
  2575. RandomizePlayIndex(p,0);
  2576. Index -= Dir*p->PlayListCount;
  2577. }
  2578. if (p->Current != p->PlayIndex[Index])
  2579. {
  2580. p->Current = p->PlayIndex[Index];
  2581. p->CurrentChanged = 1;
  2582. }
  2583. if (Load(p,1,0,0) == ERR_NONE)
  2584. return ERR_NONE;
  2585. if (!Dir)
  2586. break;
  2587. }
  2589. SetPlay(p,1);
  2590. Notify(p,PLAYER_PERCENT,0);
  2591. }
  2592. else
  2593. Unload(p,0,0,1);
  2595. return ERR_NEED_MORE_DATA;
  2596. }
  2598. static int ProcessThread(player_base* p)
  2599. {
  2600. int Result = ERR_NONE;
  2602. #ifdef MULTITHREAD
  2603. SAFE_BEGIN
  2605. while (p->Wnd)
  2606. {
  2607. LockEnter(p->LockProcess);
  2608. #ifndef NDEBUG
  2609. p->ProcessLocked = ThreadId();
  2610. #endif
  2611. #endif
  2613. if (p->RunProcess)
  2614. {
  2615. processstate State;
  2616. State.Fill = p->Fill;
  2618. p->Timer->Get(p->Timer,TIMER_TIME,&State.Time,sizeof(tick_t));
  2620. //DEBUG_MSG1(DEBUG_PLAYER,T("Process Time:%d"),State.Time);
  2622. Result = p->Format->Process(p->Format,&State);
  2624. if (Result == ERR_SYNCED)
  2625. {
  2626. DEBUG_MSG3(DEBUG_PLAYER,T("Synced: %d (%d,%d)"),State.Time,p->SeekAfterSync.Num,p->SeekAfterSync.Den);
  2628. p->Sync = 0;
  2629. p->Position = State.Time;
  2630. if (State.Time < 0)
  2631. State.Time = 0;
  2632. p->Timer->Set(p->Timer,TIMER_TIME,&State.Time,sizeof(tick_t));
  2634. if (!p->Bench && p->SeekAfterSync.Num<0)
  2635. {
  2636. // enter fill mode (don't stop processing, even if playing if off)
  2637. p->Fill = 1;
  2638. }
  2640. UpdateBuffer(p);
  2641. UpdatePlay(p);
  2642. UpdateRunProcess(p);
  2643. UpdateTimeouts(p); // we are ready to check VOutput and update timeouts
  2644. }
  2645. else
  2646. if (p->Fill && (Result == ERR_END_OF_FILE || Result == ERR_BUFFER_FULL
  2647. || (Result == ERR_NEED_MORE_DATA && (p->NoMoreInput || State.BufferUsedAfter >= p->CurrBufferSize2-2))))
  2648. {
  2649. DEBUG_MSG1(DEBUG_PLAYER,T("Filled: %d"),State.Time);
  2651. if (Result == ERR_END_OF_FILE || Result == ERR_NEED_MORE_DATA)
  2652. Result = ERR_BUFFER_FULL;
  2654. p->Fill = 0;
  2655. UpdatePlay(p);
  2656. UpdateRunProcess(p);
  2657. }
  2659. if (Result == ERR_NEED_MORE_DATA)
  2660. {
  2661. p->BufferMax = p->CurrBufferSize2;
  2663. if (p->NoMoreInput)
  2664. {
  2665. // IOError (Format doesn't know about NoMoreInput)
  2666. Result = ERR_END_OF_FILE;
  2667. }
  2668. #ifdef MULTITHREAD
  2669. else
  2670. if (!p->LoadMode && (p->Play || p->FFwd) && !p->Bench && !p->Sync && !p->Fill)
  2671. {
  2672. if (State.BufferUsedAfter >= (p->CurrBufferSize2>>1))
  2673. {
  2674. if (!p->BufferWarning && State.BufferUsedAfter >= p->CurrBufferSize2-2)
  2675. {
  2676. p->BufferWarning = 1;
  2677. ShowError(PLAYER_ID,PLAYER_ID,PLAYER_BUFFER_WARNING);
  2678. }
  2679. }
  2680. else
  2681. {
  2682. DEBUG_MSG(DEBUG_TEST,T("LoadMode Enter"));
  2683. p->LoadMode = 1;
  2684. p->Fill = 1;
  2685. UpdatePlay(p); // UpdatetPriority(p) called too
  2686. UpdateRunProcess(p);
  2687. UpdateRunInput(p);
  2688. Notify(p,PLAYER_LOADMODE,p->LoadMode);
  2689. }
  2690. }
  2691. #endif
  2692. }
  2694. if (!p->Sync && p->Position>=0)
  2695. p->Position = State.Time;
  2697. #ifdef MULTITHREAD
  2698. LockLeave(p->LockProcess);
  2699. #ifndef NDEBUG
  2700. p->ProcessLocked = 0;
  2701. #endif
  2702. #endif
  2704. if (p->UpdateStreamsNeeded)
  2705. {
  2706. Lock(p,1);
  2707. UpdateStreams(p,-1,1);
  2708. Seek2(p,p->Position>=0?p->Position:0,NULL,0);
  2709. Unlock(p,1);
  2710. Result = ERR_NONE;
  2711. }
  2713. switch (Result)
  2714. {
  2715. case ERR_SYNCED:
  2717. Notify(p,PLAYER_TITLE,0);
  2719. if (p->Current < p->PlayListCount && !p->PlayList[p->Current].Changed && 
  2720. p->PlayList[p->Current].Length<0)
  2721. {
  2722. tick_t Duration;
  2723. Lock(p,0);
  2724. if (p->Format && p->Format->Get(p->Format,FORMAT_DURATION,&Duration,sizeof(Duration))==ERR_NONE)
  2725. UpdateListLength(p,Duration);
  2726. Unlock(p,0);
  2727. }
  2729. if (p->TemporaryHidden)
  2730. {
  2731. Lock(p,0);
  2732. p->TemporaryHidden = 0;
  2733. UpdateVideo(p,p->SeekAfterSync.Num>=0?-1:0);
  2734. Unlock(p,0);
  2735. }
  2737. if (!p->VOutput && p->FullScreen)
  2738. Notify(p,PLAYER_FULLSCREEN,0);
  2740. p->FullScreenAfterSync = 0;
  2741. p->PosNotify = State.Time;
  2743. if (p->SeekAfterSync.Num>=0)
  2744. {
  2745. Lock(p,1);
  2746. if (p->SeekAfterSync.Num>=0) // may have changed
  2747. {
  2748. fraction Pos;
  2749. Pos = p->SeekAfterSync;
  2750. p->SeekAfterSync.Num = -1;
  2751. Seek2(p,-1,&Pos,p->SeekAfterSyncPrevKey);
  2752. }
  2753. Unlock(p,1);
  2754. }
  2755. break;
  2757. case ERR_END_OF_FILE:
  2758. if ((p->Play || p->FFwd || p->Sync) && !p->InSeek)
  2759. {
  2760. Lock(p,1);
  2761. if (p->Bench || p->IOError)
  2762. SetPlay(p,1); // stop benchmarking and show results
  2763. else
  2764. {
  2765. tick_t Duration;
  2766. bool_t NotTheSame = p->Sync || 
  2767. (State.Time < TICKSPERSEC && p->Format &&
  2768. (p->Format->Get(p->Format,FORMAT_DURATION,&Duration,sizeof(Duration))!=ERR_NONE || Duration > TICKSPERSEC*2));
  2770. NextPrev(p,1,1,NotTheSame);
  2771. }
  2772. Unlock(p,1);
  2773. }
  2774. break;
  2776. case ERR_NEED_MORE_DATA:
  2777. //DEBUG_MSG(DEBUG_PLAYER,T("Process Needs More Data Sleep"));
  2779. #ifdef MULTITHREAD
  2780. if (p->InputPriority>0)
  2781. {
  2782. p->InputPriority = 0;
  2783. ThreadPriority(p->InputThread,p->InputPriority);
  2784. }
  2785. p->WaitForProcess = 0;
  2786. EventSet(p->EventProcess); // signal InputThread to coninue
  2787. ThreadSleep(p->Sync?4:25);
  2788. #else
  2789. p->WaitForProcess = 0;
  2790. InputThread(p);
  2791. Result = ERR_NONE; // should not return ERR_BUFFER_FULL
  2792. #endif
  2793. break;
  2795. case ERR_BUFFER_FULL: // no packets processed, we should wait
  2796. //DEBUG_MSG(DEBUG_PLAYER,T("Process Buffer Full Sleep"));
  2798. #ifdef MULTITHREAD
  2799. ThreadSleep(4); // this should be more intelligent...
  2800. #else
  2801. if (!p->WaitForProcess)
  2802. Result = InputThread(p);
  2803. #endif
  2804. break;
  2806. default:
  2807. #ifdef MULTITHREAD
  2808. if (p->WaitForProcess && State.BufferUsedAfter<State.BufferUsedBefore)
  2809. {
  2810. EventSet(p->EventProcess); // signal InputThread to coninue
  2811. if (p->Sync)
  2812. ThreadSleep(5); // invalid media could block everything (going through the file)
  2813. }
  2815. if (p->LockProcessCount > 0 || (!p->Sync && (State.BufferUsedAfter<p->UsedEnough2 || p->Clipping || !p->TimerPlay)))
  2816. {
  2817. DEBUG_MSG(DEBUG_PLAYER,T("Process Sleep"));
  2818. ThreadSleep(0);
  2819. }
  2820. #else
  2821. if (p->WaitForProcess && State.BufferUsedAfter<State.BufferUsedBefore)
  2822. p->WaitForProcess = 0;
  2824. if (!p->WaitForProcess && Result != ERR_DROPPING && !p->Sync && !p->Fill)
  2825. InputThread(p);
  2826. #endif
  2828. break;
  2829. }
  2831. if (State.Time >= 0 && State.Time >= p->PosNotify && !p->Sync && !p->Bench && p->SeekAfterSync.Num<0)
  2832. {
  2833. // should be last, because notify handler could call any player function (load,unload,etc...)
  2834. p->PosNotify = State.Time + p->PosNotifyStep;
  2835. Notify(p,PLAYER_PERCENT,1);
  2836. }
  2837. }
  2838. #ifdef MULTITHREAD
  2839. else
  2840. {
  2841. LockLeave(p->LockProcess);
  2842. #ifndef NDEBUG
  2843. p->ProcessLocked = 0;
  2844. #endif
  2845. EventWait(p->EventRunProcess,-1);
  2846. }
  2847. }
  2849. SAFE_END
  2850. return 0;
  2851. }
  2852. #else
  2853. else
  2854. {
  2855. if (p->RunInput && !p->WaitForProcess)
  2856. Result = InputThread(p); // no decoding process -> still read input in background
  2857. else
  2858. Result = ERR_STOPPED;
  2859. }
  2861. return Result;
  2862. }
  2863. #endif
  2865. static int InputThread(player_base* p)
  2866. {
  2867. int Result = ERR_NONE;
  2869. #ifdef MULTITHREAD
  2870. SAFE_BEGIN
  2872. p->IOError = 0;
  2873. while (p->Wnd)
  2874. {
  2875. LockEnter(p->LockInput);
  2876. #ifndef NDEBUG
  2877. p->InputLocked = ThreadId();
  2878. #endif
  2879. #else
  2881. if (!p->WaitForProcess)
  2882. #endif
  2883. if (p->RunInput)
  2884. {
  2885. int Used;
  2886. Result = p->Format->Read(p->Format,p->BufferMax,&Used);
  2888. if (Result == ERR_DEVICE_ERROR)
  2889. {
  2890. if (++p->IOError >= 20)
  2891. Result = ERR_END_OF_FILE;
  2892. }
  2893. else
  2894. p->IOError = 0;
  2896. if (Result == ERR_END_OF_FILE)
  2897. {
  2898. p->NoMoreInput = 1;
  2899. UpdateRunInput(p);
  2900. }
  2902. //DEBUG_MSG3(-1,T("Input read %d (%d) max:%d"),Used,Result,p->BufferMax);
  2904. #ifdef MULTITHREAD
  2905. LockLeave(p->LockInput);
  2906. #ifndef NDEBUG
  2907. p->InputLocked = 0;
  2908. #endif
  2909. #endif
  2911. switch (Result)
  2912. {
  2913. #ifdef MULTITHREAD
  2914. case ERR_DEVICE_ERROR:
  2915. ThreadSleep(100);
  2916. break;
  2917. #endif
  2918. case ERR_NEED_MORE_DATA:
  2919. ThreadSleep(2);
  2920. break;
  2922. case ERR_BUFFER_FULL:
  2924. if (p->LoadMode)
  2925. {
  2926. Lock(p,0);
  2927. StopLoadMode(p);
  2928. Unlock(p,0);
  2929. }
  2931. if (p->MicroDrive && p->BufferMax==p->CurrBufferSize2)
  2932. {
  2933. // buffer fully loaded, wait until it's almost empty
  2934. p->BufferMax = p->BurstStart;
  2935. //DEBUG_MSG1(-1,T("MicroDrive Full: new max:%d"),p->BufferMax);
  2936. }
  2938. DEBUG_MSG(DEBUG_PLAYER,T("Input waiting for process"));
  2940. p->WaitForProcess = 1;
  2942. #ifdef MULTITHREAD
  2943. EventWait(p->EventProcess,p->RunProcess?2000:-1);
  2944. p->WaitForProcess = 0;
  2945. DEBUG_MSG(DEBUG_PLAYER,T("Input waiting over"));
  2946. #endif
  2947. break;
  2949. case ERR_END_OF_FILE:
  2950. if (p->LoadMode)
  2951. {
  2952. Lock(p,0);
  2953. StopLoadMode(p);
  2954. Unlock(p,0);
  2955. }
  2956. Result = ERR_NONE;
  2958. //no break;
  2959. default:
  2960. if (p->BufferMax != p->CurrBufferSize2)
  2961. {
  2962. // microdrive started loading, change back to full buffer
  2963. //DEBUG_MSG(-1,T("MicroDrive needs data"));
  2964. p->BufferMax = p->CurrBufferSize2;
  2965. }
  2967. if (p->LoadMode && !p->Fill && Used >= (p->VOutput ? (p->Streaming ? VIDEO_STREAMING_UNDERRUN:((p->CurrBufferSize2 * p->UnderRun)/PERCENT_ONE)) : ((p->AudioUnderRun*1024)/BLOCKSIZE)))
  2968. {
  2969. Lock(p,0);
  2970. StopLoadMode(p);
  2971. Unlock(p,0);
  2972. }
  2974. #ifdef MULTITHREAD
  2975. if (p->MicroDrive && Used >= (MINBUFFER/BLOCKSIZE))
  2976. ThreadSleep(2); // try to give some time to ProcessThread during read bursts
  2977. else
  2978. if (p->LockInputCount > 0 || (Used>=p->UsedEnough2+p->MinBuffer*2))
  2979. ThreadSleep(0);
  2980. #endif
  2981. break;
  2982. }
  2983. }
  2984. #ifdef MULTITHREAD
  2985. else
  2986. {
  2987. LockLeave(p->LockInput);
  2988. #ifndef NDEBUG
  2989. p->InputLocked = 0;
  2990. #endif
  2991. EventWait(p->EventRunInput,-1);
  2992. }
  2993. }
  2995. SAFE_END
  2996. return 0;
  2997. }
  2998. #else
  2999. return Result;
  3000. }
  3001. #endif
  3003. static void AddComment(player_base* p,int Stream,const tchar_t* Comment)
  3004. {
  3005. const tchar_t* s = tcschr(Comment,'=');
  3006. if (s)
  3007. {
  3008. uint8_t *i;
  3009. tchar_t Null = 0;
  3010. size_t Name = s-Comment;
  3011. ++s;
  3013. LockEnter(p->LockComment);
  3015. for (i=ARRAYBEGIN(p->Comment,uint8_t);i!=ARRAYEND(p->Comment,uint8_t);i=(uint8_t*)CommentNext(i))
  3016. if (CommentStream(i) == Stream && Name==(int)tcslen(CommentName(i)) &&
  3017. tcsnicmp(CommentName(i),Comment,Name)==0)
  3018. {
  3019. const uint8_t* Next = CommentNext(i);
  3020. if (Next == ARRAYEND(p->Comment,uint8_t))
  3021. {
  3022. ArrayAppend(&p->Comment,NULL,i-Next,512); //shrink
  3023. break;
  3024. }
  3025. *(tchar_t*)i = (tchar_t)INVALID_COMMENT; //invalidate old comment
  3026. }
  3028. ArrayAppend(&p->Comment,&Stream,sizeof(tchar_t),512);
  3029. ArrayAppend(&p->Comment,Comment,sizeof(tchar_t)*Name,512);
  3030. ArrayAppend(&p->Comment,&Null,sizeof(tchar_t),512);
  3031. ArrayAppend(&p->Comment,s,sizeof(tchar_t)*(tcslen(s)+1),512);
  3032. LockLeave(p->LockComment);
  3034. if (tcsnicmp(Comment,PlayerComment(COMMENT_TITLE),Name)==0 || 
  3035. tcsnicmp(Comment,PlayerComment(COMMENT_ARTIST),Name)==0 ||
  3036. tcsnicmp(Comment,PlayerComment(COMMENT_AUTHOR),Name)==0)
  3037. UpdateListTitle(p);
  3038. }
  3039. }
  3041. static tick_t GetPosition(player_base* p,tick_t* OutDuration)
  3042. {
  3043. tick_t Duration = 1;
  3044. tick_t Time = p->Timing?p->Position:-1;
  3046. if (p->Format && p->Format->Get(p->Format,FORMAT_DURATION,&Duration,sizeof(Duration))==ERR_NONE && Duration>=0 && Time>=0)
  3047. {
  3048. if (p->InSeek && p->InSeekPos.Num>=0)
  3049. Time = Scale(Duration,p->InSeekPos.Num,p->InSeekPos.Den);
  3050. else
  3051. if (p->SeekAfterSync.Num>=0)
  3052. Time = Scale(Duration,p->SeekAfterSync.Num,p->SeekAfterSync.Den);
  3053. }
  3055. if (OutDuration)
  3056. *OutDuration = Duration;
  3058. return Time;
  3059. }
  3061. static int GetTimerString(player_base* p,tchar_t* Out,int OutLen)
  3062. {
  3063. tick_t Duration;
  3064. tick_t Time = GetPosition(p,&Duration);
  3066. if (Time<0)
  3067. Out[0] = 0;
  3068. else
  3069. {
  3070. if (p->TimerLeft)
  3071. {
  3072. Time = Time - Duration;
  3073. if (Time >= 0)
  3074. Time = -1;
  3075. }
  3077. TickToString(Out,OutLen,Time,0,0,0);
  3078. }
  3079. return ERR_NONE;
  3080. }
  3082. static int UpdateAllVideoQuality(player_base* p)
  3083. {
  3084. const ref *i;
  3085. for (i=ARRAYBEGIN(p->Ref,ref);i!=ARRAYEND(p->Ref,ref);++i)
  3086. UpdateVideoQuality(p,i->Node);
  3087. return ERR_NONE;
  3088. }
  3090. static int Get(player_base* p, int No, void* Data, int Size)
  3091. {
  3092. int Result = ERR_INVALID_PARAM;
  3094. #ifdef MULTITHREAD
  3095. assert(p->ProcessLocked != ThreadId() && p->InputLocked != ThreadId());
  3096. #endif
  3098. LockEnter(p->Lock);
  3100. if (No >= PLAYER_ARRAY)
  3101. {
  3102. if (No >= PLAYER_LIST_URL && No < PLAYER_LIST_URL+p->PlayListCount)
  3103. {
  3104. No -= PLAYER_LIST_URL;
  3105. tcscpy_s((tchar_t*)Data,Size/sizeof(tchar_t),p->PlayList[No].URL);
  3106. Result = ERR_NONE;
  3107. }
  3108. else
  3109. if (No >= PLAYER_LIST_TITLE && No < PLAYER_LIST_TITLE+p->PlayListCount)
  3110. {
  3111. No -= PLAYER_LIST_TITLE;
  3112. tcscpy_s((tchar_t*)Data,Size/sizeof(tchar_t),p->PlayList[No].Title);
  3113. Result = ERR_NONE;
  3114. }
  3115. else
  3116. if (No >= PLAYER_LIST_AUTOTITLE && No < PLAYER_LIST_AUTOTITLE+p->PlayListCount)
  3117. {
  3118. No -= PLAYER_LIST_AUTOTITLE;
  3119. if (p->PlayList[No].Title[0])
  3120. tcscpy_s((tchar_t*)Data,Size/sizeof(tchar_t),p->PlayList[No].Title);
  3121. else
  3122. URLToTitle((tchar_t*)Data,Size/sizeof(tchar_t),p->PlayList[No].URL);
  3123. Result = ERR_NONE;
  3124. }
  3125. else
  3126. if (No >= PLAYER_LIST_LENGTH && No < PLAYER_LIST_LENGTH+p->PlayListCount)
  3127. {
  3128. No -= PLAYER_LIST_LENGTH;
  3129. *(tick_t*)Data = p->PlayList[No].Length;
  3130. Result = ERR_NONE;
  3131. }
  3132. }
  3133. else
  3134. switch (No)
  3135. {
  3136. case PLAYER_VIDEO_OVERLAY: GETVALUE(p->Overlay,bool_t); break;
  3137. case PLAYER_BUFFER_SIZE: GETVALUE((p->BufferSize2*BLOCKSIZE)/1024,int); break;
  3138. case PLAYER_MD_BUFFER_SIZE: GETVALUE((p->MDBufferSize2*BLOCKSIZE)/1024,int); break;
  3139. case PLAYER_BURSTSTART: GETVALUE((p->BurstStart*BLOCKSIZE)/1024,int); break;
  3140. case PLAYER_MICRODRIVE: GETVALUE(p->MicroDrive,bool_t); break;
  3141. case PLAYER_UNDERRUN: GETVALUE(p->UnderRun,int); break;
  3142. case PLAYER_AUDIO_UNDERRUN: GETVALUE(p->AudioUnderRun,int); break;
  3143. case PLAYER_REPEAT: GETVALUE(p->Repeat,bool_t); break;
  3144. case PLAYER_SHUFFLE: GETVALUE(p->Shuffle,bool_t); break;
  3145. case PLAYER_PLAYATOPEN: GETVALUE(p->PlayAtOpen,bool_t); break;
  3146. case PLAYER_PLAYATOPEN_FULL: GETVALUE(p->PlayAtOpenFull,bool_t); break;
  3147. case PLAYER_EXIT_AT_END: GETVALUE(p->ExitAtEnd,bool_t); break;
  3148. case PLAYER_KEEPPLAY_VIDEO: GETVALUE(p->KeepPlayVideo,bool_t); break;
  3149. case PLAYER_SHOWINBACKGROUND: GETVALUE(p->ShowInBackground,bool_t); break;
  3150. case PLAYER_SINGLECLICKFULLSCREEN: GETVALUE(p->SingleClickFullScreen,bool_t); break;
  3151. case PLAYER_KEEPPLAY_AUDIO: GETVALUE(p->KeepPlayAudio,bool_t); break;
  3152. case PLAYER_KEEPLIST: GETVALUE(p->KeepList,bool_t); break;
  3153. case PLAYER_MOVEBACK_STEP: GETVALUE(p->MoveBack,tick_t); break;
  3154. case PLAYER_MOVEFFWD_STEP: GETVALUE(p->MoveFFwd,tick_t); break;
  3155. case PLAYER_PLAY: GETVALUE(p->Play,bool_t); break;
  3156. case PLAYER_FFWD: GETVALUE(p->FFwd,bool_t); break;
  3157. case PLAYER_PLAY_SPEED: GETVALUE(p->PlaySpeed,fraction); break;
  3158. case PLAYER_FFWD_SPEED: GETVALUE(p->FFwdSpeed,fraction); break;
  3159. case PLAYER_TITLE: GETSTRING(p->Title); break;
  3160. case PLAYER_INPUT: GETVALUE(p->Input,stream*); break;
  3161. case PLAYER_FORMAT: GETVALUE(p->Format,format*); break;
  3162. case PLAYER_AOUTPUTID: GETVALUE(p->AOutputId,int); break;
  3163. case PLAYER_VOUTPUTID: GETVALUE(p->VOutputId,int); break;
  3164. case PLAYER_AOUTPUTID_MAX: GETVALUE(p->AOutputIdMax,int); break;
  3165. case PLAYER_VOUTPUTID_MAX: GETVALUE(p->VOutputIdMax,int); break;
  3166. case PLAYER_AOUTPUT: GETVALUE(p->AOutput,node*); break;
  3167. case PLAYER_VOUTPUT: GETVALUE(p->VOutput,node*); break;
  3168. case PLAYER_LIST_COUNT: GETVALUE(p->PlayListCount,int); break;
  3169. case PLAYER_LIST_CURRENT: GETVALUE(p->Current,int); break;
  3170. case PLAYER_LIST_CURRIDX: GETVALUE(FindCurrentIndex(p),int); break;
  3171. case PLAYER_VIDEO_ACCEL: GETVALUE(p->VideoAccel,bool_t); break;
  3172. case PLAYER_AUDIO_QUALITY: GETVALUE(p->AudioQuality,int); break;
  3173. case PLAYER_FULLSCREEN: GETVALUE(p->FullScreen,bool_t); break;
  3174. case PLAYER_AUTOPREROTATE: GETVALUE(p->AutoPreRotate,bool_t); break;
  3175. case PLAYER_SKIN_VIEWPORT: GETVALUE(p->SkinViewport,rect); break;
  3176. case PLAYER_CLIPPING: GETVALUE(p->Clipping,bool_t); break;
  3177. case PLAYER_ASPECT: GETVALUE(p->Aspect,fraction); break;
  3178. case PLAYER_STEREO: GETVALUE(p->Stereo,int); break;
  3179. case PLAYER_FULL_ZOOM: GETVALUE(p->FullZoom,fraction); break;
  3180. case PLAYER_SKIN_ZOOM: GETVALUE(p->SkinZoom,fraction); break;
  3181. case PLAYER_SMOOTH50: GETVALUE(p->SmoothZoom50,bool_t); break;
  3182. case PLAYER_SMOOTHALWAYS: GETVALUE(p->SmoothZoomAlways,bool_t); break;
  3183. case PLAYER_FULL_DIR: GETVALUE(p->FullDir,int); break;
  3184. case PLAYER_SKIN_DIR: GETVALUE(p->SkinDir,int); break;
  3185. case PLAYER_REL_DIR: GETVALUE(p->RelDir,int); break;
  3186. case PLAYER_BENCHMARK_SRC: GETVALUE(p->BenchSrc,point); break;
  3187. case PLAYER_BENCHMARK_DST: GETVALUE(p->BenchDst,point); break;
  3188. case PLAYER_BENCHMARK: GETVALUECOND(p->BenchTime,tick_t,!p->Bench); break;
  3189. case PLAYER_POSITION: GETVALUECOND(GetPosition(p,NULL),tick_t,p->Position>=0); break;
  3190. case PLAYER_LOADMODE: GETVALUE(p->LoadMode,bool_t); break;
  3191. case PLAYER_NOTIFY: GETVALUE(p->Notify,notify); break;
  3192. case PLAYER_LIST_NOTIFY: GETVALUE(p->ListNotify,notify); break;
  3193. case PLAYER_VSTREAM: GETVALUE(p->Selected[PACKET_VIDEO],int); break;
  3194. case PLAYER_ASTREAM: GETVALUE(p->Selected[PACKET_AUDIO],int); break;
  3195. case PLAYER_SUBSTREAM: GETVALUE(p->Selected[PACKET_SUBTITLE],int); break;
  3196. case PLAYER_SYNCING: GETVALUE(p->Sync || !p->Format,bool_t); break;
  3197. case PLAYER_BACKGROUND: GETVALUE(p->Background,bool_t); break;
  3198. case PLAYER_FOREGROUND: GETVALUE(p->Foreground,bool_t); break;
  3199. case PLAYER_STREAMING: GETVALUE(p->Streaming,bool_t) break;
  3200. case PLAYER_INSEEK: GETVALUE(p->InSeek,bool_t); break;
  3201. case PLAYER_DISCARDLIST: GETVALUE(p->DiscardList,bool_t); break;
  3202. case PLAYER_VIDEO_QUALITY: GETVALUE(p->VideoQuality,int); if (!SupportVQ(p)) Result = ERR_NOT_SUPPORTED; break;
  3204. case PLAYER_PERCENT:
  3205. if (p->Format && p->Input)
  3206. {
  3207. fraction* Percent = (fraction*)Data;
  3208. tick_t Duration;
  3209. int FilePos;
  3210. int FileSize;
  3211. tick_t Position = p->Position;
  3213. if (p->InSeek && p->InSeekPos.Num>=0)
  3214. {
  3215. Percent->Num = p->InSeekPos.Num;
  3216. Percent->Den = p->InSeekPos.Den;
  3217. Result = ERR_NONE;
  3218. }
  3219. else
  3220. if (p->SeekAfterSync.Num>=0)
  3221. {
  3222. Percent->Num = p->SeekAfterSync.Num;
  3223. Percent->Den = p->SeekAfterSync.Den;
  3224. Result = ERR_NONE;
  3225. }
  3226. else
  3227. if (Position >= 0 && p->Format->Get(p->Format,FORMAT_DURATION,&Duration,sizeof(Duration))==ERR_NONE)
  3228. {
  3229. UpdateListLength(p,Duration);
  3230. Percent->Num = Position;
  3231. Percent->Den = Duration;
  3232. Result = ERR_NONE;
  3233. }
  3234. else
  3235. if (Position==0 && !p->Streaming && p->Timing)
  3236. {
  3237. Percent->Num = 0;
  3238. Percent->Den = 0;
  3239. Result = ERR_NONE;
  3240. }
  3241. else
  3242. if (p->Input->Get(p->Input,STREAM_LENGTH,&FileSize,sizeof(FileSize))==ERR_NONE &&
  3243. p->Format->Get(p->Format,FORMAT_FILEPOS,&FilePos,sizeof(FilePos))==ERR_NONE)
  3244. {
  3245. Percent->Num = FilePos;
  3246. Percent->Den = FileSize;
  3247. Result = ERR_NONE;
  3248. }
  3249. }
  3250. break;
  3252. case PLAYER_CURRENTDIR: GETSTRING(p->CurrentDir); break;
  3253. case PLAYER_MUTE: GETVALUE(RefreshAudio(p)->Mute,bool_t); break;
  3254. case PLAYER_VOLUME: GETVALUE(RefreshAudio(p)->Volume,int); break;
  3255. case PLAYER_PAN: GETVALUE(RefreshAudio(p)->Pan,int); break;
  3256. case PLAYER_PREAMP: GETVALUE(p->PreAmp,int); break;
  3257. case PLAYER_TIMER_LEFT: GETVALUE(p->TimerLeft,bool_t); break;
  3258. case PLAYER_TIMER: Result = GetTimerString(p,Data,Size/sizeof(tchar_t)); break;
  3260. case PLAYER_DURATION:
  3261. if (p->Format)
  3262. {
  3263. Result = p->Format->Get(p->Format,FORMAT_DURATION,Data,Size);
  3264. if (Result == ERR_NONE) 
  3265. UpdateListLength(p,*(tick_t*)Data);
  3266. }
  3267. break;
  3268. }
  3270. LockLeave(p->Lock);
  3271. return Result;
  3272. }
  3274. static int UpdateInSeek(player_base* p)
  3275. {
  3276. if (p->Format && p->Input && p->Timer)
  3277. {
  3278. fraction Pos = p->SeekAfterSync;
  3279. p->InSeekPos.Num = -1;
  3280. p->SeekAfterSync.Num = -1;
  3281. if (!p->InSeek)
  3282. {
  3283. if (Pos.Num>=0)
  3284. {
  3285. Lock(p,1);
  3286. Seek2(p,-1,&Pos,p->SeekAfterSyncPrevKey);
  3287. Unlock(p,1);
  3288. }
  3289. else
  3290. Notify(p,PLAYER_PERCENT,0);
  3291. }
  3292. UpdatePlay(p);
  3293. }
  3294. return ERR_NONE;
  3295. }
  3297. static int AddCodecSkip(player_base* p,const pin* Pin)
  3298. {
  3299. packetformat Format;
  3301. if (Pin->Node)
  3302. {
  3303. if (p->CodecSkipCount < MAXSKIP && 
  3304. Pin->Node->Get(Pin->Node,Pin->No|PIN_FORMAT,&Format,sizeof(Format))==ERR_NONE)
  3305. {
  3306. array List;
  3307. const int *i;
  3309. PacketFormatEnumClass(&List,&Format);
  3310. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  3311. if (!IsCodecSkip(p,*i) && *i != Pin->Node->Class)
  3312. {
  3313. // found an alternative
  3314. ArrayClear(&List);
  3316. p->CodecSkip[p->CodecSkipCount++] = Pin->Node->Class;
  3317. p->UpdateStreamsNeeded = 1;
  3318. return ERR_NONE;
  3319. }
  3321. ArrayClear(&List);
  3322. }
  3323. else
  3324. {
  3325. datadef DataDef;
  3326. if (NodeDataDef(Pin->Node,Pin->No,&DataDef) && DataDef.Type==TYPE_NODE && DataDef.Format1==IDCT_CLASS &&
  3327. p->VideoAccel && p->SkipAccelFrom != Pin->Node->Class)
  3328. {
  3329. p->SkipAccelFrom = Pin->Node->Class;
  3330. p->UpdateStreamsNeeded = 1;
  3331. return ERR_NONE;
  3332. }
  3333. }
  3335. }
  3337. return ERR_NOT_SUPPORTED;
  3338. }
  3340. static int SetCurrent(player_base* p,int i,bool_t Index)
  3341. {
  3342. if (i>=p->PlayListCount)
  3343. return ERR_INVALID_PARAM;
  3345. if (i<0)
  3346. Unload(p,0,0,1);
  3347. else
  3348. {
  3349. if (p->Current != i)
  3350. {
  3351. p->Current = i;
  3352. p->CurrentChanged = 1;
  3353. if (Index)
  3354. RandomizePlayIndex(p,1);
  3355. }
  3356. if (p->Wnd)
  3357. {
  3358. int Result = Load(p,0,0,0);
  3359. if (Result == ERR_FILE_NOT_FOUND)
  3360. Result = NextPrev(p,1,1,1);
  3362. if (Result==ERR_NONE && p->Format && (p->Streaming || p->PlayAtOpen || p->PlayAtOpenFull))
  3363. {
  3364. p->FullScreenAfterSync = p->PlayAtOpenFull;
  3365. if (p->FullScreenAfterSync && IsVideo(p) && !p->FullScreen)
  3366. Notify(p,PLAYER_FULLSCREEN,1);
  3367. p->Play = 1;
  3368. p->FFwd = 0;
  3369. SetPlay(p,0);
  3370. }
  3371. }
  3372. }
  3373. return ERR_NONE;
  3374. }
  3376. static NOINLINE bool_t CloseTo(tick_t Prev,tick_t Chapter,tick_t Pos)
  3377. {
  3378. tick_t Limit;
  3379. if (Prev<0) return 0;
  3380. Limit = abs(Chapter-Prev)/32;
  3381. if (Limit>10*TICKSPERSEC)
  3382. Limit=10*TICKSPERSEC;
  3383. return abs(Pos-Chapter)<Limit;
  3384. }
  3386. static NOINLINE tick_t FindChapter(player_base* p,int Dir)
  3387. {
  3388. int No;
  3389. if (p->Position>=0)
  3390. {
  3391. if (Dir<0)
  3392. for (No=MAXCHAPTER-1;No>=0;--No)
  3393. {
  3394. tick_t Prev = PlayerGetChapter(&p->Player,No-1,NULL,0);
  3395. tick_t Chapter = PlayerGetChapter(&p->Player,No,NULL,0);
  3396. if (Chapter >= 0 && Chapter < p->Position && !CloseTo(Prev,Chapter,p->Position))
  3397. return Chapter;
  3398. }
  3399. else
  3400. {
  3401. tick_t Prev = -1;
  3402. for (No=1;No<MAXCHAPTER;++No)
  3403. {
  3404. tick_t Chapter = PlayerGetChapter(&p->Player,No,NULL,0);
  3405. if (Chapter >= 0 && Chapter > p->Position && !CloseTo(Prev,Chapter,p->Position))
  3406. return Chapter;
  3407. Prev = Chapter;
  3408. }
  3409. }
  3410. }
  3411. return -1;
  3412. }
  3414. static int UpdateShowInBackground(player_base* p)
  3415. {
  3416. UpdateBackground(p);
  3417. return UpdateVideo(p,0);
  3418. }
  3420. static void UpdateSoftVolume(player_base* p)
  3421. {
  3422. bool_t SoftVolume = QueryAdvanced(ADVANCED_SYSTEMVOLUME);
  3423. if (p->SoftVolume != SoftVolume)
  3424. {
  3425. p->SoftVolume = SoftVolume;
  3426. Lock(p,0);
  3427. UpdateAudio(p);
  3428. Unlock(p,0);
  3429. }
  3430. }
  3432. static int Set(player_base* p, int No, const void* Data, int Size)
  3433. {
  3434. tick_t t;
  3435. int New,Old;
  3436. int Result = ERR_INVALID_PARAM;
  3438. if (No >= PLAYER_COMMENT && No < PLAYER_COMMENT+MAXSTREAM)
  3439. {
  3440. AddComment(p,No-PLAYER_COMMENT,(const tchar_t*)Data);
  3441. return ERR_NONE;
  3442. }
  3444. switch (No)
  3445. {
  3446. case NODE_HIBERNATE:
  3447. return Result;
  3449. case NODE_CRASH:
  3450. #ifdef MULTITHREAD
  3451. p->RunProcess = 0;
  3452. p->RunInput = 0;
  3453. p->Lock = NULL;
  3454. p->LockInput = NULL;
  3455. p->LockProcess = NULL;
  3456. p->EventProcess = NULL;
  3457. p->EventRunInput = NULL;
  3458. p->EventRunProcess = NULL;
  3459. #ifndef NDEBUG
  3460. p->ProcessLocked = 0;
  3461. p->InputLocked = 0;
  3462. #endif
  3463. #endif
  3464. return ERR_NONE;
  3466. case PLAYER_NOT_SUPPORTED_DATA:
  3467. // called by process thread
  3468. assert(Size == sizeof(pin));
  3469. return AddCodecSkip(p,(const pin*)Data);
  3471. case NODE_SETTINGSCHANGED:
  3472. UpdateWnd(p,Context()->Wnd);
  3473. UpdatePriority(p);
  3474. UpdateEqualizer(p);
  3475. UpdateSoftVolume(p);
  3476. return ERR_NONE;
  3478. case PLAYER_PERCENT:
  3479. assert(Size == sizeof(fraction));
  3480. return InSeek(p,-1,(const fraction*)Data,1);
  3482. case PLAYER_POSITION:
  3483. assert(Size == sizeof(tick_t));
  3484. t = *(const tick_t*)Data;
  3485. if (t<0) t=0;
  3486. return InSeek(p,t,NULL,1);
  3488. case PLAYER_BACKGROUND: SETVALUECMP(p->Background,bool_t,UpdateBackground(p),EqBool); return Result;
  3489. case PLAYER_POWEROFF: SETVALUECMP(p->PowerOff,bool_t,UpdatePowerOff(p),EqBool); return Result;
  3490. }
  3492. Lock(p,0);
  3493. if (No >= PLAYER_LIST_URL && No <= PLAYER_LIST_URL+p->PlayListCount)
  3494. {
  3495. No -= PLAYER_LIST_URL;
  3496. if (No == p->PlayListCount)
  3497. SetPlayListCount(p,No+1);
  3498. if (No < p->PlayListCount)
  3499. {
  3500. if (!Size) Data = T("");
  3501. p->PlayList[No].Changed = 1;
  3502. tcscpy_s(p->PlayList[No].URL,TSIZEOF(p->PlayList[No].URL),(tchar_t*)Data);
  3503. NotifyList(p);
  3504. Result = ERR_NONE;
  3505. }
  3506. }
  3507. else
  3508. if (No >= PLAYER_LIST_TITLE && No <= PLAYER_LIST_TITLE+p->PlayListCount)
  3509. {
  3510. No -= PLAYER_LIST_TITLE;
  3511. if (No == p->PlayListCount)
  3512. SetPlayListCount(p,No+1);
  3513. if (No < p->PlayListCount)
  3514. {
  3515. if (!Size) Data = T("");
  3516. tcscpy_s(p->PlayList[No].Title,TSIZEOF(p->PlayList[No].Title),(tchar_t*)Data);
  3517. NotifyList(p);
  3518. Result = ERR_NONE;
  3519. }
  3520. }
  3521. else
  3522. if (No >= PLAYER_LIST_LENGTH && No <= PLAYER_LIST_LENGTH+p->PlayListCount)
  3523. {
  3524. No -= PLAYER_LIST_LENGTH;
  3525. if (No == p->PlayListCount)
  3526. SetPlayListCount(p,No+1);
  3527. if (No < p->PlayListCount)
  3528. {
  3529. p->PlayList[No].Length = *(tick_t*)Data;
  3530. NotifyList(p);
  3531. Result = ERR_NONE;
  3532. }
  3533. }
  3534. else
  3535. switch (No)
  3536. {
  3537. case PLAYER_TIMER_LEFT: SETVALUE(p->TimerLeft,bool_t,ERR_NONE); break;
  3538. case PLAYER_PLAY_SPEED: SETVALUE(p->PlaySpeed,fraction,UpdateSpeed(p)); break;
  3539. case PLAYER_FFWD_SPEED: SETVALUE(p->FFwdSpeed,fraction,UpdateSpeed(p)); break;
  3540. case PLAYER_REPEAT: SETVALUE(p->Repeat,bool_t,ERR_NONE); break;
  3541. case PLAYER_PLAYATOPEN: SETVALUE(p->PlayAtOpen,bool_t,ERR_NONE); break;
  3542. case PLAYER_PLAYATOPEN_FULL: SETVALUE(p->PlayAtOpenFull,bool_t,ERR_NONE); break;
  3543. case PLAYER_EXIT_AT_END: SETVALUE(p->ExitAtEnd,bool_t,ERR_NONE); break;
  3544. case PLAYER_KEEPPLAY_AUDIO: SETVALUE(p->KeepPlayAudio,bool_t,ERR_NONE); break;
  3545. case PLAYER_KEEPPLAY_VIDEO: SETVALUE(p->KeepPlayVideo,bool_t,ERR_NONE); break;
  3546. case PLAYER_SHOWINBACKGROUND: SETVALUE(p->ShowInBackground,bool_t,UpdateShowInBackground(p)); break;
  3547. case PLAYER_SINGLECLICKFULLSCREEN: SETVALUE(p->SingleClickFullScreen,bool_t,ERR_NONE); break;
  3548. case PLAYER_KEEPLIST: SETVALUE(p->KeepList,bool_t,ERR_NONE); break;
  3549. case PLAYER_MOVEBACK_STEP: SETVALUE(p->MoveBack,tick_t,ERR_NONE); break;
  3550. case PLAYER_MOVEFFWD_STEP: SETVALUE(p->MoveFFwd,tick_t,ERR_NONE); break;
  3551. case PLAYER_SHUFFLE: SETVALUE(p->Shuffle,bool_t,RandomizePlayIndex(p,1)); break;
  3552. case PLAYER_AUDIO_QUALITY: SETVALUECMP(p->AudioQuality,int,UpdateAudio(p),EqInt); break;
  3553. case PLAYER_VIDEO_QUALITY: SETVALUE(p->VideoQuality,int,UpdateAllVideoQuality(p)); break;
  3554. case PLAYER_FULLSCREEN: SETVALUECMP(p->FullScreen,bool_t,ERR_NONE,EqBool); break;
  3555. case PLAYER_AUTOPREROTATE: SETVALUECMP(p->AutoPreRotate,bool_t,UpdateVideo(p,0),EqBool); break;
  3556. case PLAYER_SKIN_VIEWPORT: SETVALUECMP(p->SkinViewport,rect,ERR_NONE,EqRect); break;
  3557. case PLAYER_CLIPPING: SETVALUECMP(p->Clipping,bool_t,UpdateVideo(p,0),EqBool); break;
  3558. case PLAYER_ASPECT: SETVALUECMP(p->Aspect,fraction,UpdateVideo(p,0),EqFrac); break;
  3559. case PLAYER_STEREO: SETVALUECMP(p->Stereo,int,UpdateAudio(p),EqInt); break;
  3560. case PLAYER_FULL_ZOOM: SETVALUECMP(p->FullZoom,fraction,UpdateVideo(p,0),EqFrac); break;
  3561. case PLAYER_SKIN_ZOOM: SETVALUECMP(p->SkinZoom,fraction,UpdateVideo(p,0),EqFrac); break;
  3562. case PLAYER_SMOOTH50: SETVALUECMP(p->SmoothZoom50,bool_t,UpdateVideo(p,0),EqBool); break;
  3563. case PLAYER_SMOOTHALWAYS: SETVALUECMP(p->SmoothZoomAlways,bool_t,UpdateVideo(p,0),EqBool); break;
  3564. case PLAYER_FULL_DIR: SETVALUECMP(p->FullDir,int,UpdateVideo(p,0),EqInt); break;
  3565. case PLAYER_SKIN_DIR: SETVALUECMP(p->SkinDir,int,UpdateVideo(p,0),EqInt); break;
  3566. case PLAYER_VIDEO_ACCEL: SETVALUE(p->VideoAccel,bool_t,ERR_NONE); break;
  3567. case PLAYER_VSTREAM: SETVALUECMP(p->Selected[PACKET_VIDEO],int,UpdateStreamsMask(p),EqInt); break;
  3568. case PLAYER_ASTREAM: SETVALUECMP(p->Selected[PACKET_AUDIO],int,UpdateStreamsMask(p),EqInt); break;
  3569. case PLAYER_SUBSTREAM: SETVALUECMP(p->Selected[PACKET_SUBTITLE],int,UpdateStreamsMask(p),EqInt); break;
  3570. case PLAYER_NOTIFY: SETVALUENULL(p->Notify,notify,ERR_NONE,p->Notify.Func=NULL); break;
  3571. case PLAYER_LIST_NOTIFY: SETVALUENULL(p->ListNotify,notify,ERR_NONE,p->ListNotify.Func=NULL); break;
  3572. case PLAYER_FOREGROUND: SETVALUECMP(p->Foreground,bool_t,UpdateForeground(p),EqBool); break;
  3573. case PLAYER_INSEEK: SETVALUECMP(p->InSeek,bool_t,UpdateInSeek(p),EqBool); break;
  3574. case PLAYER_MUTE: SETVALUECMP(p->Mute,bool_t,UpdateAudio(p),EqBool); break;
  3575. case PLAYER_CURRENTDIR: SETSTRING(p->CurrentDir); break;
  3576. case PLAYER_DISCARDLIST: SETVALUE(p->DiscardList,bool_t,ERR_NONE); break;
  3577. case PLAYER_PREAMP: SETVALUECMP(p->PreAmp,int,UpdateAudio(p),EqInt); break;
  3578. case PLAYER_PAN: SETVALUECMP(p->Pan,int,UpdateAudio(p),EqInt); break;
  3579. case PLAYER_VOLUME: SETVALUECMP(p->Volume,int,UpdateVolume(p),EqInt); break; // need process locking for software win32 waveout pausing
  3581. case PLAYER_UPDATEVIDEO: 
  3582. Result = UpdateVideo(p,0);
  3583. break;
  3585. case PLAYER_ROTATEEND: 
  3586. p->Rotating = 0;
  3587. Result = UpdateVideo(p,0); 
  3588. break;
  3590. case PLAYER_RESETVIDEO:
  3591. if (p->VOutput)
  3592. p->VOutput->Set(p->VOutput,VOUT_RESET,NULL,0);
  3593. break;
  3595. case PLAYER_ROTATEBEGIN:
  3596. p->Rotating = 1;
  3597. if (p->VOutput)
  3598. {
  3599. bool_t Visible = 0;
  3600. p->VOutput->Set(p->VOutput,VOUT_VISIBLE,&Visible,sizeof(Visible));
  3601. }
  3602. break;
  3604. case PLAYER_VOUTPUTID: 
  3605. assert(Size==sizeof(int));
  3606. Old = p->VOutputId;
  3607. New = *(int*)Data;
  3608. if (New && !NodeEnumClass(NULL,New)) // old driver removed
  3609. {
  3610. New = p->VOutputIdMax;
  3611. p->VideoAccel = VOutIDCT(New);
  3612. }
  3613. p->VOutputId = New;
  3614. p->SkipAccelFrom = 0;
  3615. if (!VOutIDCT(New))
  3616. p->VideoAccel = 0;
  3617. UpdateStreams(p,Old==0,0);
  3618. break;
  3620. case PLAYER_AOUTPUTID: 
  3621. assert(Size==sizeof(int));
  3622. Old = p->AOutputId;
  3623. New = *(int*)Data;
  3624. if (New && !NodeEnumClass(NULL,New)) // old driver removed
  3625. New = p->AOutputIdMax;
  3626. p->AOutputId = New;
  3627. UpdateStreams(p,Old==0,0);
  3628. break;
  3630. case PLAYER_UPDATEEQUALIZER:
  3631. Result = UpdateEqualizer(p);
  3632. break;
  3634. case PLAYER_VOUTPUTID_MAX: 
  3635. assert(Size==sizeof(int));
  3636. if (p->VOutputIdMax != *(int*)Data && p->VOutputId && p->VOutputIdMax && p->VOutputId != p->VOutputIdMax)
  3637. {
  3638. // new highest priority video driver added. use it
  3639. p->VOutputId = p->VOutputIdMax;
  3640. p->VideoAccel = VOutIDCT(p->VOutputId);
  3641. UpdateStreams(p,0,0);
  3642. }
  3643. Result = ERR_NONE;
  3644. break;
  3646. case PLAYER_AOUTPUTID_MAX: 
  3647. assert(Size==sizeof(int));
  3648. if (p->AOutputIdMax != *(int*)Data && p->AOutputId && p->AOutputIdMax && p->AOutputId != p->AOutputIdMax)
  3649. {
  3650. // new highest priority audio driver added. use it
  3651. p->AOutputId = p->AOutputIdMax;
  3652. UpdateStreams(p,0,0);
  3653. }
  3654. Result = ERR_NONE;
  3655. break;
  3657. case PLAYER_MOVEBACK:
  3658. case PLAYER_MOVEFFWD:
  3659. if (p->Format && p->Input)
  3660. {
  3661. int FilePos;
  3662. int FileSize;
  3663. tick_t Position = GetPosition(p,NULL);
  3664. fraction Percent;
  3666. if (Position >= 0)
  3667. {
  3668. if (No == PLAYER_MOVEBACK)
  3669. Position -= p->MoveBack;
  3670. else
  3671. Position += p->MoveFFwd;
  3673. if (Position<0)
  3674. Position=0;
  3676. Result = InSeek(p,Position,NULL,No == PLAYER_MOVEBACK);
  3677. }
  3678. else
  3679. if (p->Input->Get(p->Input,STREAM_LENGTH,&FileSize,sizeof(FileSize))==ERR_NONE &&
  3680. p->Format->Get(p->Format,FORMAT_FILEPOS,&FilePos,sizeof(FilePos))==ERR_NONE)
  3681. {
  3682. if (No == PLAYER_MOVEBACK)
  3683. FilePos -= FileSize/256;
  3684. else
  3685. FilePos += FileSize/256;
  3687. Percent.Num = FilePos;
  3688. Percent.Den = FileSize;
  3689. if (Percent.Num<0)
  3690. Percent.Num=0;
  3692. Result = InSeek(p,-1,&Percent,No == PLAYER_MOVEBACK);
  3693. }
  3694. else
  3695. Result = p->Player.Set(&p->Player,No == PLAYER_MOVEBACK?PLAYER_PREV:PLAYER_NEXT,NULL,0);
  3696. }
  3697. break; 
  3699. default:
  3701. // inputthread locking needed for these
  3702. Lock(p,1);
  3703. switch (No)
  3704. {
  3705. case PLAYER_BUFFER_SIZE:
  3706. assert(Size==sizeof(int));
  3707. p->BufferSize2 = (*(int*)Data *1024)/BLOCKSIZE;
  3708. if (p->BufferSize2 < MINBUFFER/BLOCKSIZE)
  3709. p->BufferSize2 = MINBUFFER/BLOCKSIZE;
  3710. Result = UpdateFormat(p,1); 
  3711. break;
  3712. case PLAYER_MD_BUFFER_SIZE: 
  3713. assert(Size==sizeof(int));
  3714. p->MDBufferSize2 = (*(int*)Data *1024)/BLOCKSIZE;
  3715. if (p->MDBufferSize2 < MINBUFFER/BLOCKSIZE)
  3716. p->MDBufferSize2 = MINBUFFER/BLOCKSIZE;
  3717. Result = UpdateFormat(p,1); 
  3718. break;
  3719. case PLAYER_BURSTSTART:
  3720. assert(Size==sizeof(int));
  3721. p->BurstStart = (*(int*)Data *1024)/BLOCKSIZE;
  3722. if (p->BurstStart < MINBUFFER/BLOCKSIZE)
  3723. p->BurstStart = MINBUFFER/BLOCKSIZE;
  3724. Result = ERR_NONE; 
  3725. break;
  3726. case PLAYER_BENCHMARK:
  3727. if (p->Format && p->Input)
  3728. StartBench(p);
  3729. break;
  3731. case PLAYER_PLAY:
  3732. if (Size == sizeof(bool_t))
  3733. {
  3734. if (*(bool_t*)Data)
  3735. {
  3736. if (!p->Format && p->Wnd && p->PlayListCount)
  3737. {
  3738. if (Load(p,0,0,0) == ERR_FILE_NOT_FOUND)
  3739. NextPrev(p,1,1,1);
  3740. }
  3742. if (!p->Format)
  3743. {
  3744. Result = ERR_INVALID_DATA;
  3745. break;
  3746. }
  3748. p->Play = 1;
  3749. p->FFwd = 0;
  3750. }
  3751. else
  3752. {
  3753. p->Play = 0;
  3754. p->FFwd = 0;
  3755. p->Fill = 1;
  3756. }
  3757. Result = SetPlay(p,0);
  3758. }
  3759. break;
  3761. case PLAYER_FFWD:
  3762. if (Size == sizeof(bool_t))
  3763. {
  3764. if (*(bool_t*)Data)
  3765. {
  3766. if (!p->Format && p->Wnd && p->PlayListCount)
  3767. Load(p,0,0,0);
  3769. if (!p->Format)
  3770. {
  3771. Result = ERR_INVALID_DATA;
  3772. break;
  3773. }
  3775. p->FFwd = 1;
  3776. }
  3777. else
  3778. {
  3779. p->FFwd = 0;
  3780. if (!p->Play && !p->Bench) 
  3781. p->Fill = 1;
  3782. }
  3783. Result = SetPlay(p,0);
  3784. }
  3785. break;
  3787. case PLAYER_LIST_COUNT:
  3788. assert(Size == sizeof(int));
  3789. Result = SetPlayListCount(p,*(int*)Data);
  3790. break;
  3792. case PLAYER_LIST_CURRIDX:
  3793. assert(Size == sizeof(int));
  3794. if (*(int*)Data<p->PlayListCount && *(int*)Data>=0)
  3795. Result = SetCurrent(p,p->PlayIndex[*(int*)Data],0);
  3796. break;
  3798. case PLAYER_LIST_CURRENT:
  3799. assert(Size == sizeof(int));
  3800. Result = SetCurrent(p,*(int*)Data,1);
  3801. break;
  3803. case PLAYER_NEXT:
  3804. t = FindChapter(p,1);
  3805. if (t >= 0)
  3806. Result = Seek2(p,t,NULL,1);
  3807. else
  3808. Result = NextPrev(p,1,0,0);
  3809. break;
  3811. case PLAYER_PREV:
  3812. t = FindChapter(p,-1);
  3813. if (t >= 0)
  3814. Result = Seek2(p,t,NULL,1);
  3815. else
  3816. if (Size>0 && p->Timing && p->Position > TICKSPERSEC*2 && Seek2(p,0,NULL,0)==ERR_NONE)
  3817. {
  3818. ClearStats(p);
  3819. Result = ERR_NONE;
  3820. }
  3821. else
  3822. Result = NextPrev(p,-1,0,0);
  3823. break;
  3825. case PLAYER_STOP:
  3826. SetPlay(p,1);
  3827. if (!Size)
  3828. {
  3829. if (p->Streaming)
  3830. Unload(p,0,0,1);
  3831. else
  3832. NextPrev(p,0,0,0);
  3833. }
  3834. break;
  3836. case PLAYER_RESYNC:
  3837. ReSync(p,1);
  3838. Result = ERR_NONE;
  3839. break;
  3841. case PLAYER_MICRODRIVE: SETVALUE(p->MicroDrive,bool_t,UpdateFormat(p,1)); break;
  3842. case PLAYER_UNDERRUN: SETVALUE(p->UnderRun,int,ERR_NONE); break;
  3843. case PLAYER_AUDIO_UNDERRUN: SETVALUE(p->AudioUnderRun,int,ERR_NONE); break;
  3844. }
  3846. Unlock(p,1);
  3847. break;
  3848. }
  3850. Unlock(p,0);
  3851. return Result;
  3852. }
  3854. static bool_t CmdComment(player_base* p,int Stream,const tchar_t* Name,tchar_t* Value,int ValueLen)
  3855. {
  3856. bool_t Result = 0;
  3857. const uint8_t *i;
  3859. LockEnter(p->LockComment);
  3860. for (i=ARRAYBEGIN(p->Comment,uint8_t);i!=ARRAYEND(p->Comment,uint8_t);i=CommentNext(i))
  3861. if (CommentStream(i)!=INVALID_COMMENT &&
  3862. (Stream<0 || CommentStream(i) == Stream) && tcsicmp(CommentName(i),Name)==0)
  3863. {
  3864. if (Result)
  3865. {
  3866. Result = 0;
  3867. break;
  3868. }
  3870. if (Value)
  3871. tcscpy_s(Value,ValueLen,CommentValue(i));
  3873. Result = 1;
  3874. if (Stream>=0)
  3875. break;
  3876. }
  3878. LockLeave(p->LockComment);
  3879. return Result;
  3880. }
  3882. static void Paint(player_base* p,void* DC,int x0,int y0)
  3883. {
  3884. rect re;
  3885. rect r;
  3886. rect* Exclude = NULL;
  3887. rgbval_t ColorKey;
  3889. #ifdef MULTITHREAD
  3890. assert(p->ProcessLocked != ThreadId() && p->InputLocked != ThreadId());
  3891. #endif
  3893. LockEnter(p->Lock);
  3894. if (p->Primary)
  3895. {
  3896. if (p->VOutput && p->VOutput->Get(p->VOutput,VOUT_OUTPUTRECT,&re,sizeof(re))==ERR_NONE && 
  3897. re.Width>0 && re.Height>0 && !p->TemporaryHidden)
  3898. {
  3899. re.x -= x0;
  3900. re.y -= y0;
  3901. if (p->VOutput->Get(p->VOutput,VOUT_COLORKEY,&ColorKey,sizeof(ColorKey)) == ERR_NONE)
  3902. {
  3903. if (ColorKey != p->ColorKey)
  3904. {
  3905. BrushDelete(p->ColorKeyBrush);
  3906. p->ColorKey = ColorKey;
  3907. p->ColorKeyBrush = BrushCreate(ColorKey);
  3908. }
  3909. WinFill(DC,&re,NULL,p->ColorKeyBrush);
  3910. Exclude = &re;
  3911. }
  3912. else
  3913. if (!p->Clipping && !p->Overlay)
  3914. Exclude = &re;
  3915. }
  3917. r = p->Viewport;
  3918. }
  3919. else
  3920. r = p->SkinViewport;
  3921. LockLeave(p->Lock);
  3923. r.x -= x0;
  3924. r.y -= y0;
  3925. WinFill(DC,&r,Exclude,p->BlackBrush);
  3926. }
  3928. static int Create(player_base* p)
  3929. {
  3930. int i;
  3931. int Model;
  3932. video Desktop;
  3933. QueryDesktop(&Desktop);
  3934. Model = QueryPlatform(PLATFORM_MODEL);
  3936. // default values
  3937. if (QueryPlatform(PLATFORM_TYPENO) == TYPE_SMARTPHONE)
  3938. {
  3939. p->UsedEnough2 = (256*1024)/BLOCKSIZE;
  3940. p->BufferSize2 = (600*1024)/BLOCKSIZE;
  3941. }
  3942. else
  3943. {
  3944. p->UsedEnough2 = (512*1024)/BLOCKSIZE;
  3945. p->BufferSize2 = (2400*1024)/BLOCKSIZE;
  3946. #ifdef TARGET_WINCE
  3947. if (QueryPlatform(PLATFORM_VER) < 421)
  3948. p->BufferSize2 = (1200*1024)/BLOCKSIZE;;
  3949. #endif
  3951. #ifdef TARGET_PALMOS
  3952. p->UsedEnough2 = (256*1024)/BLOCKSIZE;
  3953. p->BufferSize2 = (2000*1024)/BLOCKSIZE;
  3954. #endif
  3955. }
  3957. p->RndSeed = (uint32_t)(GetTimeTick()+GetTimeDate());
  3958. p->Color = NodeEnumObject(NULL,COLOR_ID);
  3959. p->Equalizer = NodeEnumObject(NULL,EQUALIZER_ID);
  3961. p->Player.Enum = (nodeenum)Enum;
  3962. p->Player.Get = (nodeget)Get;
  3963. p->Player.Set = (nodeset)Set;
  3964. p->Player.Paint = (playerpaint)Paint;
  3965. p->Player.CommentByName = (playercomment)CmdComment;
  3966. p->Player.ListSwap = (playerswap)ListSwap;
  3967. p->Player.Process = (playerprocess)ProcessThread;
  3969. p->MDBufferSize2 = (16000*1024)/BLOCKSIZE;
  3970. p->BurstStart = (1500*1024)/BLOCKSIZE;
  3971. p->UnderRun = PERCENT_ONE*7/10;
  3972. p->AudioUnderRun = 64;
  3973. p->MoveFFwd = p->MoveBack = TICKSPERSEC*10;
  3974. p->PlayAtOpen = 0;
  3975. p->PlayAtOpenFull = 0;
  3976. p->KeepList = 1;
  3977. p->KeepPlayAudio = 1;
  3978. #if defined(TARGET_WIN32)
  3979. p->SingleClickFullScreen = 0;
  3980. p->KeepPlayVideo = 1;
  3981. p->ShowInBackground = 1;
  3982. p->AutoPreRotate = 0;
  3983. #else
  3984. p->SingleClickFullScreen = 1;
  3985. p->KeepPlayVideo = 0;
  3986. p->ShowInBackground = 0;
  3987. p->AutoPreRotate = Desktop.Width != Desktop.Height;
  3988. #endif
  3989. p->FullZoom.Den = 1;
  3990. p->FullZoom.Num = 0;
  3991. p->SkinZoom.Den = 1;
  3992. p->SkinZoom.Num = 0;
  3993. p->VideoQuality = 2;
  3994. #if !defined(SH3) && !defined(MIPS)
  3995. p->AudioQuality = 2;
  3996. p->SmoothZoom50 = 1;
  3997. p->SmoothZoomAlways = 0;
  3998. #else
  3999. p->AudioQuality = 1;
  4000. p->SmoothZoom50 = 0;
  4001. p->SmoothZoomAlways = 0;
  4002. #if defined(SH3)
  4003. p->FullZoom.Num = p->SkinZoom.Num = 1;
  4004. #endif
  4005. #endif
  4006. #ifdef TARGET_SYMBIAN
  4007. p->Volume = 50;
  4008. #else
  4009. p->Volume = 90;
  4010. #endif
  4011. p->Repeat = 1;
  4012. #ifdef TARGET_WIN32
  4013. p->Aspect.Num = 0;
  4014. #else
  4015. p->Aspect.Num = 1;
  4016. #ifdef ARM
  4017. // use aspect with hardware scaler overlay drivers...
  4018. if (NodeEnumClass(NULL,FOURCC('A','T','I','4')) ||
  4019. NodeEnumClass(NULL,FOURCC('G','E','2','D')) ||
  4020. NodeEnumClass(NULL,FOURCC('A','H','I','_')) ||
  4021. NodeEnumClass(NULL,FOURCC('2','7','0','G')))
  4022. p->Aspect.Num = 0;
  4023. #endif
  4024. #endif
  4025. p->Aspect.Den = 1;
  4026. p->PlaySpeed.Num = 1;
  4027. p->PlaySpeed.Den = 1;
  4028. p->FFwdSpeed.Num = 2;
  4029. p->FFwdSpeed.Den = 1;
  4030. p->SeekAfterSync.Num = -1;
  4031. p->Primary = 1;
  4032. p->SkinDir = -1;
  4033. p->Foreground = 1;
  4035. if (Model==MODEL_TUNGSTEN_T3)
  4036. p->FullDir = -1; // special case because it can be slided into square format
  4037. else
  4038. {
  4039. p->FullDir = GetOrientation();
  4040. if (Desktop.Width < Desktop.Height)
  4041. {
  4042. if (GetHandedness())
  4043. p->FullDir = CombineDir(p->FullDir,DIR_SWAPXY | DIR_MIRRORLEFTRIGHT,0);
  4044. else
  4045. p->FullDir = CombineDir(p->FullDir,DIR_SWAPXY | DIR_MIRRORUPDOWN,0);
  4046. }
  4047. }
  4049. for (i=0;i<PACKET_MAX;++i)
  4050. p->Selected[i] = -1;
  4051. p->CurrentChanged = 1;
  4052. p->Position = -1;
  4054. p->AOutputIdMax = p->AOutputId = NodeEnumClass(NULL,AOUT_CLASS);
  4055. p->VOutputIdMax = p->VOutputId = NodeEnumClass(NULL,VOUT_CLASS);
  4056. p->VideoAccel = VOutIDCT(p->VOutputId);
  4058. #ifdef MULTITHREAD
  4059. p->LockProcessCount = 0;
  4060. p->LockInputCount = 0;
  4061. p->LockComment = LockCreate();
  4062. p->Lock = LockCreate();
  4063. p->LockInput = LockCreate();
  4064. p->LockProcess = LockCreate();
  4065. p->EventProcess = EventCreate(0,0);
  4066. p->EventRunProcess = EventCreate(1,0);
  4067. p->EventRunInput = EventCreate(1,0);
  4068. #endif
  4070. p->ColorKey = RGB_NULL;
  4071. p->ColorKeyBrush = NULL;
  4072. p->BlackBrush = BrushCreate(0);
  4074. UpdateFormat(p,0);
  4075. UpdateRunProcess(p);
  4076. UpdateRunInput(p);
  4077. return ERR_NONE;
  4078. }
  4080. static void Delete(player_base* p)
  4081. {
  4082. UpdateWnd(p,NULL);
  4084. #ifdef MULTITHREAD
  4085. EventClose(p->EventRunInput);
  4086. EventClose(p->EventRunProcess);
  4087. EventClose(p->EventProcess);
  4089. LockDelete(p->Lock);
  4090. LockDelete(p->LockInput);
  4091. LockDelete(p->LockProcess);
  4092. LockDelete(p->LockComment);
  4093. #endif
  4095. BrushDelete(p->ColorKeyBrush);
  4096. BrushDelete(p->BlackBrush);
  4098. free(p->PlayList);
  4099. free(p->PlayIndex);
  4100. }
  4102. void PlayerSaveList(player* Player,const tchar_t* Path,int Class)
  4103. {
  4104. playlist* Playlist = (playlist*)NodeCreate(Class);
  4105. if (Playlist)
  4106. {
  4107. if (Playlist->WriteList)
  4108. {
  4109. stream* Input = GetStream(Path,0);
  4110. if (Input)
  4111. {
  4112. bool_t b = 1;
  4113. if (Input->Set(Input,STREAM_CREATE,&b,sizeof(b)) == ERR_NONE &&
  4114. Input->Set(Input,STREAM_URL,Path,sizeof(tchar_t)*(tcslen(Path)+1)) == ERR_NONE &&
  4115. Playlist->Set(Playlist,PLAYLIST_STREAM,&Input,sizeof(Input)) == ERR_NONE)
  4116. {
  4117. tchar_t Base[MAXPATH];
  4118. tchar_t Rel[MAXPATH];
  4119. tchar_t URL[MAXPATH];
  4120. tchar_t Title[256];
  4121. tick_t Length;
  4122. int No,Count;
  4124. SplitURL(Path,Base,TSIZEOF(Base),Base,TSIZEOF(Base),NULL,0,NULL,0);
  4125. Player->Get(Player,PLAYER_LIST_COUNT,&Count,sizeof(Count));
  4126. for (No=0;No<Count;++No)
  4127. {
  4128. if (Player->Get(Player,PLAYER_LIST_URL+No,URL,sizeof(URL))==ERR_NONE)
  4129. {
  4130. RelPath(Rel,TSIZEOF(Rel),URL,Base);
  4131. Title[0] = 0;
  4132. Length = -1;
  4134. Player->Get(Player,PLAYER_LIST_TITLE+No,Title,sizeof(Title));
  4135. Player->Get(Player,PLAYER_LIST_LENGTH+No,&Length,sizeof(Length));
  4137. Playlist->WriteList(Playlist,Rel,Title,Length);
  4138. }
  4139. }
  4141. Playlist->WriteList(Playlist,NULL,NULL,0);
  4142. Playlist->Set(Playlist,PLAYLIST_STREAM,NULL,0);
  4143. }
  4145. Input->Set(Input,STREAM_URL,NULL,0);
  4146. NodeDelete((node*)Input);
  4147. }
  4148. }
  4150. Playlist->Set(Playlist,PLAYLIST_STREAM,NULL,0);
  4151. NodeDelete((node*)Playlist);
  4152. }
  4153. }
  4155. int PlayerAddDir(player* Player,int Index, const tchar_t* Path, const tchar_t* Exts, bool_t ExtFilter, int Deep)
  4156. {
  4157. streamdir DirItem;
  4158. stream* Stream;
  4160. if (Deep < MAXDIRDEEP) // fail safe
  4161. {
  4162. Stream = GetStream(Path,1);
  4163. if (Stream)
  4164. {
  4165. tchar_t Base[MAXPATH];
  4167. int Result = Stream->EnumDir(Stream,Path,Exts,ExtFilter,&DirItem);
  4169. if (Result == ERR_NONE)
  4170. {
  4171. tcscpy_s(Base,TSIZEOF(Base),Path);
  4172. Stream->Get(Stream,STREAM_BASE,Base,sizeof(Base));
  4173. }
  4175. while (Result == ERR_NONE)
  4176. {
  4177. tchar_t PathItem[MAXPATH];
  4178. AbsPath(PathItem,TSIZEOF(PathItem),DirItem.FileName,Base);
  4180. if (tcsncmp(PathItem,Base,tcslen(Base))==0) // don't go to other sites with http
  4181. {
  4182. if (DirItem.Size < 0)
  4183. Index = PlayerAddDir(Player,Index,PathItem,Exts,ExtFilter,Deep+1);
  4184. else
  4185. Index = PlayerAdd(Player,Index,PathItem,DirItem.DisplayName);
  4186. }
  4188. Result = Stream->EnumDir(Stream,NULL,NULL,0,&DirItem);
  4189. }
  4191. NodeDelete((node*)Stream);
  4192. }
  4193. }
  4194. return Index;
  4195. }
  4197. int PlayerAdd(player* Player,int Index, const tchar_t* Path, const tchar_t* Title)
  4198. {
  4199. stream* Input;
  4200. array List;
  4202. // process playlist files
  4203. NodeEnumClassEx(&List,PLAYLIST_CLASS,NULL,Path,NULL,0);
  4204. if (!ARRAYEMPTY(List) && (Input = GetStream(Path,0))!=NULL)
  4205. {
  4206. if (Input->Set(Input,STREAM_URL,Path,sizeof(tchar_t)*(tcslen(Path)+1)) == ERR_NONE &&
  4207. LoadPlaylist(Player,&List,Input,&Index,Path,NULL,0))
  4208. Path = NULL;
  4209. Input->Set(Input,STREAM_URL,NULL,0);
  4210. NodeDelete((node*)Input);
  4211. }
  4212. ArrayClear(&List);
  4214. if (Path)
  4215. {
  4216. Player->Set(Player,PLAYER_LIST_URL+Index,Path,sizeof(tchar_t)*(tcslen(Path)+1));
  4217. Player->Set(Player,PLAYER_LIST_TITLE+Index,Title,Title?sizeof(tchar_t)*(tcslen(Title)+1):0);
  4218. ++Index;
  4219. }
  4220. return Index;
  4221. }
  4223. const tchar_t* PlayerComment(int Code)
  4224. {
  4225. switch (Code)
  4226. {
  4227. case COMMENT_TITLE: return T("TITLE");
  4228. case COMMENT_ARTIST: return T("ARTIST");
  4229. case COMMENT_ALBUM: return T("ALBUM");
  4230. case COMMENT_GENRE: return T("GENRE");
  4231. case COMMENT_LANGUAGE: return T("LANGUAGE");
  4232. case COMMENT_AUTHOR: return T("AUTHOR");
  4233. case COMMENT_COPYRIGHT: return T("COPYRIGHT");
  4234. case COMMENT_PRIORITY: return T("PRIORITY");
  4235. case COMMENT_YEAR: return T("YEAR");
  4236. case COMMENT_TRACK: return T("TRACK");
  4237. case COMMENT_COMMENT: return T("COMMENT");
  4238. case COMMENT_COVER: return T("COVER");
  4239. case COMMENT_REDIRECT: return T("REDIRECT");
  4240. }
  4241. return NULL;
  4242. }
  4244. tick_t PlayerGetChapter(player* p,int No,tchar_t* OutName,int OutNameLen)
  4245. {
  4246. tchar_t Chapter[64];
  4247. tchar_t s[64];
  4248. int Hour,Min,Sec,MSec=0;
  4250. if (No>0)
  4251. {
  4252. stprintf_s(Chapter,TSIZEOF(Chapter),T("CHAPTER%02d"),No);
  4253. if (p->CommentByName(p,-1,Chapter,s,TSIZEOF(s)) && 
  4254. stscanf(s,T("%d:%d:%d.%d"),&Hour,&Min,&Sec,&MSec)>=3)
  4255. {
  4256. if (OutName)
  4257. {
  4258. stprintf_s(Chapter,TSIZEOF(Chapter),T("CHAPTER%02dNAME"),No);
  4259. if (!p->CommentByName(p,-1,Chapter,OutName,OutNameLen))
  4260. stprintf_s(OutName,OutNameLen,T("%d"),No);
  4261. }
  4262. return Scale(((Hour*60+Min)*60+Sec)*1000+MSec,TICKSPERSEC,1000);
  4263. }
  4264. }
  4265. return -1;
  4266. }
  4268. bool_t PlayerGetStream(player* Player,int No,packetformat* OutFormat,tchar_t* OutName,int OutNameLen,int* OutPri)
  4269. {
  4270. tchar_t s[256];
  4271. node* Format;
  4272. packetformat PacketFormat;
  4273. int i;
  4275. if (Player->Get(Player,PLAYER_FORMAT,&Format,sizeof(Format))==ERR_NONE && Format)
  4276. {
  4277. int Count[PACKET_MAX];
  4278. memset(Count,0,sizeof(Count));
  4280. for (i=0;Format->Get(Format,(FORMAT_STREAM+i)|PIN_FORMAT,&PacketFormat,sizeof(PacketFormat))==ERR_NONE;++i)
  4281. {
  4282. ++Count[PacketFormat.Type];
  4283. if (i==No)
  4284. {
  4285. if (OutPri)
  4286. {
  4287. if (Player->CommentByName(Player,i,PlayerComment(COMMENT_PRIORITY),s,TSIZEOF(s)))
  4288. *OutPri = StringToInt(s,0);
  4289. else
  4290. *OutPri = 0;
  4291. }
  4292. if (OutName)
  4293. {
  4294. if (Player->CommentByName(Player,i,PlayerComment(COMMENT_LANGUAGE),s,TSIZEOF(s)) ||
  4295. Player->CommentByName(Player,i,PlayerComment(COMMENT_TITLE),s,TSIZEOF(s)))
  4296. tcscpy_s(OutName,OutNameLen,s);
  4297. else
  4298. stprintf_s(OutName,OutNameLen,T("%s %d"),LangStr(PLAYER_ID,STREAM_NAME+PacketFormat.Type),Count[PacketFormat.Type]);
  4299. }
  4300. if (OutFormat)
  4301. *OutFormat = PacketFormat;
  4302. return 1;
  4303. }
  4304. }
  4305. }
  4306. return 0;
  4307. }
  4309. static const nodedef Player =
  4310. {
  4311. sizeof(player_base)|CF_GLOBAL|CF_SETTINGS,
  4312. PLAYER_ID,
  4313. NODE_CLASS,
  4314. PRI_MAXIMUM+600,
  4315. (nodecreate)Create,
  4316. (nodedelete)Delete,
  4317. };
  4319. typedef struct playerbuffer
  4320. {
  4321. node Node;
  4322. node* Player;
  4324. } playerbuffer;
  4326. static int BufferEnum(playerbuffer* p, int* No, datadef* Param)
  4327. {
  4328. int Result = NodeEnumTable(No,Param,BufferParams);
  4329. if (Result == ERR_NONE)
  4330. Param->Name = LangStr(PLAYER_ID,Param->No);
  4331. return Result;
  4332. }
  4334. static int BufferGet(playerbuffer* p, int No, void* Data, int Size)
  4335. {
  4336. return p->Player->Get(p->Player,No,Data,Size);
  4337. }
  4339. static int BufferSet(playerbuffer* p, int No, const void* Data, int Size)
  4340. {
  4341. return p->Player->Set(p->Player,No,Data,Size);
  4342. }
  4344. static int BufferCreate(playerbuffer* p)
  4345. {
  4346. p->Player = Context()->Player;
  4347. p->Node.Enum = (nodeenum)BufferEnum;
  4348. p->Node.Get = (nodeget)BufferGet;
  4349. p->Node.Set = (nodeset)BufferSet;
  4350. return ERR_NONE;
  4351. }
  4353. static const nodedef Buffer =
  4354. {
  4355. sizeof(playerbuffer)|CF_GLOBAL|CF_SETTINGS,
  4356. PLAYER_BUFFER_ID,
  4357. NODE_CLASS,
  4358. PRI_MAXIMUM+60,
  4359. (nodecreate)BufferCreate
  4360. };
  4362. void Player_Init()
  4363. {
  4364. NodeRegisterClass(&Player);
  4365. Context()->Player = NodeEnumObject(NULL,PLAYER_ID);
  4366. NodeRegisterClass(&Buffer);
  4367. }
  4369. void Player_Done()
  4370. {
  4371. Context()->Player = NULL;
  4372. NodeUnRegisterClass(PLAYER_ID);
  4373. NodeUnRegisterClass(PLAYER_BUFFER_ID);
  4374. }