changed: move interlace method calculation into rendermanager flip, so it's constant...
[xbmc:xbmc-antiquated.git] / xbmc / cores / VideoRenderers / RenderManager.h
1 #pragma once
2
3 /*
4  *      Copyright (C) 2005-2008 Team XBMC
5  *      http://www.xbmc.org
6  *
7  *  This Program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2, or (at your option)
10  *  any later version.
11  *
12  *  This Program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with XBMC; see the file COPYING.  If not, write to
19  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20  *  http://www.gnu.org/copyleft/gpl.html
21  *
22  */
23
24 #if defined (HAS_SDL_OPENGL)
25 #include "LinuxRendererGL.h"
26 #elif defined(HAS_SDL)
27 #include "LinuxRenderer.h"
28 #elif defined (WIN32)
29 #include "WinRenderManager.h"
30 #endif
31
32 #include "utils/SharedSection.h"
33 #include "utils/Thread.h"
34
35 class CXBoxRenderManager
36 {
37 public:
38   CXBoxRenderManager();
39   ~CXBoxRenderManager();
40
41   // Functions called from the GUI
42   void GetVideoRect(RECT &rs, RECT &rd) { CSharedLock lock(m_sharedSection); if (m_pRenderer) m_pRenderer->GetVideoRect(rs, rd); };
43   float GetAspectRatio() { CSharedLock lock(m_sharedSection); if (m_pRenderer) return m_pRenderer->GetAspectRatio(); else return 1.0f; };
44   void AutoCrop(bool bCrop = true) { CSharedLock lock(m_sharedSection); if (m_pRenderer) m_pRenderer->AutoCrop(bCrop); };
45   void Update(bool bPauseDrawing);
46   void RenderUpdate(bool clear, DWORD flags = 0, DWORD alpha = 255);
47   void SetupScreenshot();
48
49 #ifndef HAS_SDL
50   void CreateThumbnail(LPDIRECT3DSURFACE8 surface, unsigned int width, unsigned int height);
51 #else
52   void CreateThumbnail(SDL_Surface *surface, unsigned int width, unsigned int height);
53 #endif
54
55   void SetViewMode(int iViewMode) { CSharedLock lock(m_sharedSection); if (m_pRenderer) m_pRenderer->SetViewMode(iViewMode); };
56
57   // Functions called from mplayer
58   bool Configure(unsigned int width, unsigned int height, unsigned int d_width, unsigned int d_height, float fps, unsigned flags);
59   bool IsConfigured();
60
61   // a call to GetImage must be followed by a call to releaseimage if getimage was successfull
62   // failure to do so will result in deadlock
63   inline int GetImage(YV12Image *image, int source = AUTOSOURCE, bool readonly = false)
64   {
65     CSharedLock lock(m_sharedSection);
66     if (m_pRenderer)
67       return m_pRenderer->GetImage(image, source, readonly);
68     return -1;
69   }
70   inline void ReleaseImage(int source = AUTOSOURCE, bool preserve = false)
71   {
72     CSharedLock lock(m_sharedSection);
73     if (m_pRenderer)
74       m_pRenderer->ReleaseImage(source, preserve);
75   }
76   inline unsigned int DrawSlice(unsigned char *src[], int stride[], int w, int h, int x, int y)
77   {
78     CSharedLock lock(m_sharedSection);
79     if (m_pRenderer)
80       return m_pRenderer->DrawSlice(src, stride, w, h, x, y);
81     return 0;
82   }
83
84   void FlipPage(volatile bool& bStop, double timestamp = 0.0, int source = -1, EFIELDSYNC sync = FS_NONE);
85   unsigned int PreInit();
86   void UnInit();
87
88   inline void DrawAlpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride)
89   {
90     CSharedLock lock(m_sharedSection);
91     if (m_pRenderer)
92       m_pRenderer->DrawAlpha(x0, y0, w, h, src, srca, stride);
93   }
94   inline void Reset()
95   {
96     CSharedLock lock(m_sharedSection);
97     if (m_pRenderer)
98       m_pRenderer->Reset();
99   }
100   RESOLUTION GetResolution()
101   {
102     CSharedLock lock(m_sharedSection);
103     if (m_pRenderer)
104       return m_pRenderer->GetResolution();
105     else
106       return INVALID;
107   }
108
109   float GetMaximumFPS();
110   inline bool Paused() { return m_bPauseDrawing; };
111   inline bool IsStarted() { return m_bIsStarted;}
112   bool SupportsBrightness();
113   bool SupportsContrast();
114   bool SupportsGamma();
115
116   double GetPresentTime();
117   void  WaitPresentTime(double presenttime);
118
119 #ifdef HAS_SDL_OPENGL
120   CLinuxRendererGL *m_pRenderer;
121 #elif defined(HAS_SDL)
122   CLinuxRenderer *m_pRenderer;
123 #else
124   CXBoxRenderer *m_pRenderer;
125 #endif
126
127   void Present();
128   void Recover(); // called after resolution switch if something special is needed
129
130   CSharedSection& GetSection() { return m_sharedSection; };
131
132 protected:
133
134   void PresentSingle();
135   void PresentWeave();
136   void PresentBob();
137   void PresentBlend();
138
139   bool m_bPauseDrawing;   // true if we should pause rendering
140
141   bool m_bIsStarted;
142   CSharedSection m_sharedSection;
143
144   int m_rendermethod;
145
146   double     m_presenttime;
147   EFIELDSYNC m_presentfield;
148   EINTERLACEMETHOD m_presentmethod;
149   int        m_presentstep;
150   CEvent     m_presentevent;
151
152 };
153
154 extern CXBoxRenderManager g_renderManager;
155
156