/*!****************************************************************************
@file Shell/PVRShell.h
@copyright Copyright (c) Imagination Technologies Limited.
@brief Makes programming for 3D APIs easier by wrapping surface
initialization, Texture allocation and other functions for use by a demo.
******************************************************************************/
#ifndef __PVRSHELL_H_
#define __PVRSHELL_H_
/*****************************************************************************/
/*! @mainpage PVRShell
******************************************************************************
@tableofcontents
@section overview Overview
*****************************
PVRShell is a C++ class used to make programming for PowerVR platforms easier and more portable.
PVRShell takes care of all API and OS initialisation for the user and handles adapters, devices, screen/windows modes,
resolution, buffering, depth-buffer, viewport creation & clearing, etc...
PVRShell consists of 3 files: PVRShell.cpp, PVRShellOS.cpp and PVRShellAPI.cpp.
PVRShellOS.cpp and PVRShellAPI.cpp are supplied per platform and contain all the code to initialise the specific
API (OpenGL ES, Direct3D Mobile, etc.) and the OS (Windows, Linux, WinCE, etc.).
PVRShell.cpp is where the common code resides and it interacts with the user application through an abstraction layer.
A new application must link to these three files and must create a class that will inherit the PVRShell class.
This class will provide five virtual functions to interface with the user.
The user also needs to register his application class through the NewDemo function:
@code
class MyApplication: public PVRShell
{
public:
virtual bool InitApplication();
virtual bool InitView();
virtual bool ReleaseView();
virtual bool QuitApplication();
virtual bool RenderScene();
};
PVRShell* NewDemo()
{
return new MyApplication();
}
@endcode
@section interface Interface
******************************
There are two functions for initialisation, two functions to release allocated resources and a render function:
InitApplication() will be called by PVRShell once per run, before the graphic context is created.
It is used to initialise variables that are not dependant on the rendering context (e.g. external modules, loading user data, etc.).
QuitApplication() will be called by PVRShell once per run, just before exiting the program.
If the graphic context is lost, QuitApplication() will not be called.
InitView() will be called by PVRShell upon creation or change in the rendering context.
It is used to initialise variables that are dependant on the rendering context (e.g. textures, vertex buffers, etc.).
ReleaseView() will be called by PVRShell before changing to a new rendering context or
when finalising the application (before calling QuitApplication).
RenderScene() is the main rendering loop function of the program. This function must return FALSE when the user wants to terminate the application.
PVRShell will call this function every frame and will manage relevant OS events.
There are other PVRShell functions which allow the user to set his/her preferences and get data back from the devices:
PVRShellSet() and PVRShellGet() are used to pass data to and from PVRShell. PVRShellSet() is recommended to be used
in InitApplication() so the user preferences are applied at the API initialisation.
There is a definition of these functions per type of data passed or returned. Please check the prefNameBoolEnum, prefNameFloatEnum,
prefNameIntEnum, prefNamePtrEnum and prefNameConstPtrEnum enumerations for a full list of the data available.
This is an example:
@code
bool MyApplication::InitApplication()
{
PVRShellSet (prefFullScreen, true);
}
bool MyApplication::RenderScene()
{
int dwCurrentWidth = PVRShellGet (prefHeight);
int dwCurrentHeight = PVRShellGet (prefWidth);
return true;
}
@endcode
@section helper Helper functions
*************************************
The user input is abstracted with the PVRShellIsKeyPressed() function. It will not work in all devices, but we have tried to map the most
relevant keys when possible. See PVRShellKeyName enumeration for the list of keys supported. This function will return true or false depending on
the specified key being pressed.
There are a few other helper functions supplied by PVRShell as well. These functions allow you to read the timer, to output debug information and to
save a screen-shot of the current frame:
PVRShellGetTime() returns time in milliseconds.
PVRShellOutputDebug() will write a debug string (same format as printf) to the platform debug output.
PVRShellScreenCaptureBuffer() and PVRShellWriteBMPFile() will be used to save the current frame as a BMP file. PVRShellScreenCaptureBuffer()
receives a pointer to an area of memory containing the screen buffer. The memory should be freed with free() when not needed any longer.
Example of screenshot:
@code
bool MyApplication::RenderScene()
{
[...]
unsigned char *pLines;
PVRShellScreenCaptureBuffer(PVRShellGet (prefWidth), PVRShellGet (prefHeight), &pLines);
PVRShellScreenSave("myfile", pLines, NULL);
free (pLines);
return true;
}
@endcode
@section cmd Command-line
*************************************
Across all platforms, PVRShell takes a set of command-line arguments which allow things like the position and size of the demo
to be controlled. The list below shows these options.
\b -width=N Sets the horizontal viewport width to N.
\b -height=N Sets the vertical viewport height to N.
\b -posx=N Sets the x coordinate of the viewport.
\b -posy=N Sets the y coordinate of the viewport.
\b -aasamples=N Sets the number of samples to use for full screen anti-aliasing. e.g 0, 2, 4, 8
\b -fullscreen=N Enable/Disable fullscreen mode. N can be: 0=Windowed 1=Fullscreen.
\b -qat=N Quits after N seconds.
\b -qaf=N Quits after N frames.
\b -powersaving=N Where available enable/disable power saving. N can be: 0=Disable power saving 1=Enable power saving.
\b -vsync=N Where available modify the apps vsync parameters.
\b -version Output the SDK version to the debug output.
\b -info Output setup information (e.g. window width) to the debug output.
\b -rotatekeys=N Sets the orientation of the keyboard input. N can be: 0-3, 0 is no rotation.
\b -c=N Save a single screenshot or a range. e.g. -c=1-10, -c=14.
\b -priority=N EGL only. Sets the priority of the EGL context.
\b -colourbpp=N EGL only. When choosing an EGL config N will be used as the value for EGL_BUFFER_SIZE.
\b -depthbpp=N EGL only. When choosing an EGL config N will be used as the value for EGL_DEPTH_SIZE.
\b -config=N EGL only. Force the shell to use the EGL config with ID N.
\b -forceframetime=N Alter the behaviour of PVRShellGetTime so its returned value is frame based (N denotes how many ms a frame should pretend to last). You can also use the shortened version of -fft and the command can be used without N being defined, e.g. just -forceframetime. This option is provided to aid in debugging time-based applications.
Example:
@code
Demo -width=160 -height=120 -qaf=300
@endcode
@section APIsOSs APIs and Operating Systems
*****************************
For information specific to each 3D API and Operating System, see the list of supported APIs and OSs on the Modules page.
******************************************************************************/
// Uncomment to enable the -fps command-line option
// #define PVRSHELL_FPS_OUTPUT
/*****************************************************************************
** Includes
*****************************************************************************/
#include
#define EXIT_NOERR_CODE 0
#define EXIT_ERR_CODE (!EXIT_NOERR_CODE)
// avoid warning about unused parameter
#define PVRSHELL_UNREFERENCED_PARAMETER(x) ((void) x)
// Keyboard mapping. //
/*!***********************************************************************
@enum PVRShellKeyName
@brief Key name.
************************************************************************/
enum PVRShellKeyName
{
PVRShellKeyNameNull, /*!< Null key value */
PVRShellKeyNameQUIT, /*!< QUIT key value */
PVRShellKeyNameSELECT, /*!< SELECT key value */
PVRShellKeyNameACTION1, /*!< ACTION1 key value */
PVRShellKeyNameACTION2, /*!< ACTION2 key value */
PVRShellKeyNameUP, /*!< UP key */
PVRShellKeyNameDOWN, /*!< DOWN key */
PVRShellKeyNameLEFT, /*!< LEFT key */
PVRShellKeyNameRIGHT, /*!< RIGHT key */
PVRShellKeyNameScreenshot /*!< SCREENSHOT key */
};
/*!***********************************************************************
@enum PVRShellKeyRotate
@brief Key rotate.
************************************************************************/
enum PVRShellKeyRotate
{
PVRShellKeyRotateNone=0, /*!< Rotate key none = 0. */
PVRShellKeyRotate90, /*!< Rotate key 90 */
PVRShellKeyRotate180, /*!< Rotate key 180 */
PVRShellKeyRotate270 /*!< Rotate key 270 */
};
// Pointer button mapping. //
/*!***********************************************************************
@enum EPVRShellButtonState
@brief Pointer button mapping.
************************************************************************/
enum EPVRShellButtonState
{
ePVRShellButtonLeft = 0x1, /*!< Left button */
ePVRShellButtonRight = 0x2, /*!< Right button */
ePVRShellButtonMiddle = 0x4 /*!< Middle button */
};
/*!***********************************************************************
@enum prefNameBoolEnum
@brief Boolean Shell preferences.
************************************************************************/
enum prefNameBoolEnum
{
prefFullScreen, /*!< Set to: 1 for full-screen rendering; 0 for windowed */
prefIsRotated, /*!< Query this to learn whether screen is rotated */
prefPBufferContext, /*!< 1 if you need pbuffer support (default is pbuffer not needed) */
prefPixmapContext, /*!< 1 to use a pixmap as a render-target (default off) */
prefPixmapDisableCopy, /*!< 1 to disable the copy if pixmaps are used */
prefZbufferContext, /*!< 1 if you wish to have zbuffer support (default to on) */
prefLockableBackBuffer, /*!< DX9 only: true to use D3DPRESENTFLAG_LOCKABLE_BACKBUFFER (default: false) */
prefSoftwareRendering, /*!< 1 to select software rendering (default: off, i.e. use hardware) */
prefStencilBufferContext, /*!< 1 if you wish to have stencil support (default: off) */
prefAlphaFormatPre, /*!< EGL only: 1 to create the EGL surface with EGL_ALPHA_FORMAT_PRE (default: 0) */
prefPowerSaving, /*!< If true then the app will go into powersaving mode (if available) when not in use. */
#ifdef PVRSHELL_FPS_OUTPUT
prefOutputFPS, /*!< If true then the FPS are output using PVRShellOutputdebug */
#endif
prefOutputInfo, /*!< If true then the app will output helpful information such as colour buffer format via PVRShellOutputDebug. */
prefNoShellSwapBuffer, /*!< EGL: If true then the shell won't call eglswapbuffers at the end of each frame. */
prefShowCursor, /*!< Set to: 1 to show the cursor; 0 to hide it. */
prefForceFrameTime, /*!< If true will alter PVRShellGetTime behaviour to be frame based. This is for debugging purposes. */
prefDiscardColor, /*!< GLES: Whether or not to discard color data at the end of a render, to save bandwidth. Requires specific functionality. (default: false) */
prefDiscardDepth, /*!< GLES: Whether or not to discard depth data at the end of a render, to save bandwidth. Requires specific functionality. (default: true) */
prefDiscardStencil /*!< GLES: Whether or not to discard stencil data at the end of a render, to save bandwidth. Requires specific functionality. (default: true) */
};
/*!***********************************************************************
@enum prefNameFloatEnum
@brief Float Shell preferences.
************************************************************************/
enum prefNameFloatEnum
{
prefQuitAfterTime /*!< Shell will quit after this number of seconds (-1 to disable) */
};
/*!***********************************************************************
@enum prefNameIntEnum
@brief Integer Shell preferences.
************************************************************************/
enum prefNameIntEnum
{
prefEGLMajorVersion, /*!< EGL: returns the major version as returned by eglInitialize() */
prefEGLMinorVersion, /*!< EGL: returns the minor version as returned by eglInitialize() */
prefWidth, /*!< Width of render target */
prefHeight, /*!< Height of render target */
prefPositionX, /*!< X position of the window */
prefPositionY, /*!< Y position of the window */
prefQuitAfterFrame, /*!< Shell will quit after this number of frames (-1 to disable) */
prefSwapInterval, /*!< 0 to preventing waiting for monitor vertical syncs */
prefInitRepeats, /*!< Number of times to reinitialise (if >0 when app returns false from RenderScene(), shell will ReleaseView(), InitView() then re-enter RenderScene() loop). Decrements on each initialisation. */
prefAASamples, /*!< Set to: 0 to disable full-screen anti-aliasing; 2 for 2x; 4 for 4x; 8 for 8x. */
prefCommandLineOptNum, /*!< Returns the length of the array returned by prefCommandLineOpts */
prefColorBPP, /*!< Allows you to specify a desired color buffer size e.g. 16, 32. */
prefDepthBPP, /*!< Allows you to specify a desired depth buffer size e.g. 16, 24. */
prefRotateKeys, /*!< Allows you to specify and retrieve how the keyboard input is transformed */
prefButtonState, /*!< pointer button state */
prefCaptureFrameStart, /*!< The frame to start capturing screenshots from */
prefCaptureFrameStop, /*!< The frame to stop capturing screenshots at */
prefCaptureFrameScale, /*!< Pixel-replicate saved screenshots this many times; default 1 for no scale */
prefPriority, /*!< EGL: If supported will set the egl context priority; 0 for low, 1 for med and 2 for high. */
prefConfig, /*!< EGL: Get the chosen EGL config. */
prefRequestedConfig, /*!< EGL: Force the shell to use a particular EGL config. */
prefNativeDisplay, /*!< EGL: Allows you to specify the native display to use if the device has more that one. */
prefFrameTimeValue /*!< An integer value to say how long you wish one frame to last for (in ms) when force frame time is enabled. */
};
/*!***********************************************************************
@enum prefNamePtrEnum
@brief Pointers/Handlers Shell preferences.
************************************************************************/
enum prefNamePtrEnum
{
prefD3DDevice, /*!< D3D: returns the device pointer */
prefEGLDisplay, /*!< EGL: returns the EGLDisplay */
prefEGLSurface, /*!< EGL: returns the EGLSurface */
prefHINSTANCE, /*!< Windows: returns the application instance handle */
prefNativeWindowType, /*!< Returns the window handle */
prefAccelerometer, /*!< Accelerometer values */
prefPointerLocation, /*!< Mouse pointer/touch location values */
prefPVR2DContext, /*!< PVR2D: returns the PVR2D context */
prefLoadFileFunc, /*!< A pointer to a function that can be used to load external files on platforms that don't allow the use of fopen.
The ptr returned is of the type PFNLoadFileFunc defined below. */
prefReleaseFileFunc, /*!< A pointer to a function that is used to release any data allocated by the load file function.
The ptr returned is of the type PFNReleaseFileFunc defined below. */
prefAndroidNativeActivity /*!< Android: A pointer to the ANativeActivity struct for the application. Your application will need to include android_native_app_glue.h to cast the pointer to ANativeActivity. */
};
/*!***********************************************************************
@typedef PFNLoadFileFunc
@brief The LoadFileFunc function pointer template.
************************************************************************/
typedef void* (*PFNLoadFileFunc)(const char*, char** pData, size_t &size);
/*!***********************************************************************
@typedef PFNReleaseFileFunc
@brief The ReleaseFileFunc function pointer template.
************************************************************************/
typedef bool (*PFNReleaseFileFunc)(void* handle);
/*!***********************************************************************
@enum prefNameConstPtrEnum
@brief Constant pointers Shell preferences.
************************************************************************/
enum prefNameConstPtrEnum
{
prefAppName, /*!< ptrValue is char* */
prefReadPath, /*!< ptrValue is char*; will include a trailing slash */
prefWritePath, /*!< ptrValue is char*; will include a trailing slash */
prefCommandLine, /*!< used to retrieve the entire application command line */
prefCommandLineOpts, /*!< ptrValue is SCmdLineOpt*; retrieves an array of arg/value pairs (parsed from the command line) */
prefExitMessage, /*!< ptrValue is char*; gives the shell a message to show on exit, typically an error */
prefVersion /*!< ptrValue is char* */
};
/*!**************************************************************************
@struct PVRShellData
@brief PVRShell implementation Prototypes and definitions
*****************************************************************************/
struct PVRShellData;
/*!***************************************************************************
@class PVRShellInit
*****************************************************************************/
class PVRShellInit;
/*!***********************************************************************
@struct SCmdLineOpt
@brief Stores a variable name/value pair for an individual command-line option.
************************************************************************/
struct SCmdLineOpt
{
const char *pArg, *pVal;
};
/*!***************************************************************************
@class PVRShell
@brief Inherited by the application; responsible for abstracting the OS and API.
@details PVRShell is the main Shell class that an application uses. An
application should supply a class which inherits PVRShell and supplies
implementations of the virtual functions of PVRShell (InitApplication(),
QuitApplication(), InitView(), ReleaseView(), RenderScene()). Default stub
functions are supplied; this means that an application is not
required to supply a particular function if it does not need to do anything
in it.
The other, non-virtual, functions of PVRShell are utility functions that the
application may call.
*****************************************************************************/
class PVRShell
{
private:
friend class PVRShellInitOS;
friend class PVRShellInit;
PVRShellData *m_pShellData;
PVRShellInit *m_pShellInit;
public:
/*!***********************************************************************
@brief Constructor
*************************************************************************/
PVRShell();
/*!***********************************************************************
@brief Destructor
*************************************************************************/
virtual ~PVRShell();
/*
PVRShell functions that the application should implement.
*/
/*!***********************************************************************
@brief Initialise the application.
@details This function can be overloaded by the application. It
will be called by PVRShell once, only at the beginning of
the PVRShell WinMain()/main() function. This function
enables the user to perform any initialisation before the
render API is initialised. From this function the user can
call PVRShellSet() to change default values, e.g.
requesting a particular resolution or device setting.
@return true for success, false to exit the application
*************************************************************************/
virtual bool InitApplication() { return true; };
/*!***********************************************************************
@brief Quit the application.
@details This function can be overloaded by the application. It
will be called by PVRShell just before finishing the
program. It enables the application to release any
memory/resources acquired in InitApplication().
@return true for success, false to exit the application
*************************************************************************/
virtual bool QuitApplication() { return true; };
/*!***********************************************************************
@brief Initialise the view.
@details This function can be overloaded by the application. It
will be called by PVRShell after the OS and rendering API
are initialised, before entering the RenderScene() loop.
It is called any time the rendering API is initialised,
i.e. once at the beginning, and possibly again if the
resolution changes, or a power management even occurs, or
if the app requests a re-initialisation.
The application should check here the configuration of
the rendering API; it is possible that requests made in
InitApplication() were not successful.
Since everything is initialised when this function is
called, you can load textures and perform rendering API functions.
@return true for success, false to exit the application
*************************************************************************/
virtual bool InitView() { return true; };
/*!***********************************************************************
@brief Release the view.
@details This function can be overloaded by the application. It
will be called after the RenderScene() loop, before
shutting down the render API. It enables the application
to release any memory/resources acquired in InitView().
@return true for success, false to exit the application
*************************************************************************/
virtual bool ReleaseView() { return true; };
/*!***********************************************************************
@brief Render the scene
@details This function can be overloaded by the application.
It is main application function in which you have to do your own rendering. Will be
called repeatedly until the application exits.
@return true for success, false to exit the application
*************************************************************************/
virtual bool RenderScene() { return true; };
/*
PVRShell functions available for the application to use.
*/
/*!***********************************************************************
@brief This function is used to pass preferences to the PVRShell.
If used, this function must be called from InitApplication().
@param[in] prefName Name of preference to set to value
@param[in] value Value
@return true for success
*************************************************************************/
bool PVRShellSet(const prefNameBoolEnum prefName, const bool value);
/*!***********************************************************************
@brief This function is used to pass preferences to the PVRShell.
If used, this function must be called from InitApplication().
@param[in] prefName Name of preference to set to value
@param[in] value Value
@return true for success
*************************************************************************/
bool PVRShellSet(const prefNameFloatEnum prefName, const float value);
/*!***********************************************************************
@brief This function is used to pass preferences to the PVRShell.
If used, this function must be called from InitApplication().
@param[in] prefName Name of preference to set to value
@param[in] value Value
@return true for success
*************************************************************************/
bool PVRShellSet(const prefNameIntEnum prefName, const int value);
/*!***********************************************************************
@brief This function is used to pass preferences to the PVRShell.
If used, this funciton must be called from InitApplication().
@param[in] prefName Name of preference to set to value
@param[in] ptrValue Value
@return true for success
*************************************************************************/
bool PVRShellSet(const prefNamePtrEnum prefName, const void * const ptrValue);
/*!***********************************************************************
@brief This function is used to pass preferences to the PVRShell.
If used, this function must be called from InitApplication().
@param[in] prefName Name of preference to set to value
@param[in] ptrValue Value
@return true for success
*************************************************************************/
bool PVRShellSet(const prefNameConstPtrEnum prefName, const void * const ptrValue);
/*!***********************************************************************
@brief This function is used to get parameters from the PVRShell.
It can be called from anywhere in the program.
@param[in] prefName Name of preference to set to value
@return The requested value.
*************************************************************************/
bool PVRShellGet(const prefNameBoolEnum prefName) const;
/*!***********************************************************************
@brief This function is used to get parameters from the PVRShell.
It can be called from anywhere in the program.
@param[in] prefName Name of preference to set to value
@return The requested value.
*************************************************************************/
float PVRShellGet(const prefNameFloatEnum prefName) const;
/*!***********************************************************************
@brief This function is used to get parameters from the PVRShell.
It can be called from anywhere in the program.
@param[in] prefName Name of preference to set to value
@return The requested value.
*************************************************************************/
int PVRShellGet(const prefNameIntEnum prefName) const;
/*!***********************************************************************
@brief This function is used to get parameters from the PVRShell.
It can be called from anywhere in the program.
@param[in] prefName Name of preference to set to value
@return The requested value.
*************************************************************************/
void *PVRShellGet(const prefNamePtrEnum prefName) const;
/*!***********************************************************************
@brief This function is used to get parameters from the PVRShell
It can be called from anywhere in the program.
@param[in] prefName Name of preference to set to value
@return The requested value.
*************************************************************************/
const void *PVRShellGet(const prefNameConstPtrEnum prefName) const;
/*!***********************************************************************
@brief It will be stored as 24-bit per pixel, 8-bit per chanel RGB.
The memory should be freed using the free() function when no longer needed.
@param[in] Width size of image to capture (relative to 0,0)
@param[in] Height size of image to capture (relative to 0,0)
@param[out] pLines receives a pointer to an area of memory containing the screen buffer.
@return true for success
*************************************************************************/
bool PVRShellScreenCaptureBuffer(const int Width, const int Height, unsigned char **pLines);
/*!***********************************************************************
@brief Writes out the image data to a BMP file with basename fname.
@details The file written will be fname suffixed with a
number to make the file unique.
For example, if fname is "abc", this function will attempt
to save to "abc0000.bmp"; if that file already exists, it
will try "abc0001.bmp", repeating until a new filename is
found. The final filename used is returned in ofname.
@param[in] fname base of file to save screen to
@param[in] Width size of image
@param[in] Height size of image
@param[in] pLines image data to write out (24bpp, 8-bit per channel RGB)
@param[in] ui32PixelReplicate expand pixels through replication (1 = no scale)
@param[out] ofname If non-NULL, receives the filename actually used
@return true for success
*************************************************************************/
int PVRShellScreenSave(
const char * const fname,
const int Width,
const int Height,
const unsigned char * const pLines,
const unsigned int ui32PixelReplicate = 1,
char * const ofname = NULL);
/*!***********************************************************************
@brief Writes out the image data to a BMP file with name fname.
@param[in] pszFilename file to save screen to
@param[in] ui32Width the width of the data
@param[in] ui32Height the height of the data
@param[in] pImageData image data to write out (24bpp, 8-bit per channel RGB)
@param[in] ui32PixelReplicate expand pixels through replication (1 = no scale)
@return 0 on success
*************************************************************************/
int PVRShellWriteBMPFile(
const char * const pszFilename,
const unsigned int ui32Width,
const unsigned int ui32Height,
const void * const pImageData,
const unsigned int ui32PixelReplicate = 1);
/*!***********************************************************************
@brief Writes the resultant string to the debug output (e.g. using
printf(), OutputDebugString(), ...). Check the SDK release notes for
details on how the string is output.
@param[in] format printf style format followed by arguments it requires
*************************************************************************/
void PVRShellOutputDebug(char const * const format, ...) const;
/*!***********************************************************************
@brief The number itself should be considered meaningless; an
application should use this function to determine how much
time has passed between two points (e.g. between each frame).
@return A value which increments once per millisecond.
*************************************************************************/
unsigned long PVRShellGetTime();
/*!***********************************************************************
@brief Check if a key was pressed.
@details The keys on various devices
are mapped to the PVRShell-supported keys (listed in @a PVRShellKeyName) in
a platform-dependent manner, since most platforms have different input
devices. Check the Modules page for your OS
for details on how the enum values map to your device's key code input.
@param[in] key Code of the key to test
@return true if key was pressed
*************************************************************************/
bool PVRShellIsKeyPressed(const PVRShellKeyName key);
};
/****************************************************************************
** Declarations for functions that the scene file must supply
****************************************************************************/
/*!***************************************************************************
@brief This function must be implemented by the user of the shell.
@details The user should return its PVRShell object defining the
behaviour of the application.
@return The demo supplied by the user
*****************************************************************************/
PVRShell* NewDemo();
#endif /* __PVRSHELL_H_ */
/*****************************************************************************
End of file (PVRShell.h)
*****************************************************************************/