OpenCL-CTS/test_extensions/media_sharing/wrappers.h

//
// Copyright (c) 2017 The Khronos Group Inc.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef __WRAPPERS_H
#define __WRAPPERS_H

#if defined(_WIN32)
#include <d3d9.h>
#if defined (__MINGW32__)
#include <rpcsal.h>
typedef unsigned char UINT8;
#define __out
#define __in
#define __inout
#define __out_bcount(size)
#define __out_bcount_opt(size)
#define __in_opt
#define __in_ecount(size)
#define __in_ecount_opt(size)
#define __out_opt
#define __out_ecount(size)
#define __out_ecount_opt(size)
#define __in_bcount_opt(size)
#define __inout_opt
#define __inout_bcount(size)
#define __in_bcount(size)
#define __deref_out
#endif
#include <dxvahd.h>
#include <tchar.h>
#endif

enum TDeviceStatus
{
  DEVICE_NOTSUPPORTED,
  DEVICE_PASS,
  DEVICE_FAIL,
};

class CDeviceWrapper {
public:
  enum TAccelerationType
  {
    ACCELERATION_HW,
    ACCELERATION_SW,
  };

  CDeviceWrapper();
  virtual ~CDeviceWrapper();

  virtual bool AdapterNext() = 0;
  virtual unsigned int AdapterIdx() const = 0;
  virtual void *Device() const = 0;
  virtual TDeviceStatus Status() const = 0;
  virtual void *D3D() const = 0;

#if defined(_WIN32)
  HWND WindowHandle() const;
#endif
  int WindowWidth() const;
  int WindowHeight() const;
  void WindowInit();


  static TAccelerationType AccelerationType();
  static void AccelerationType(TAccelerationType accelerationTypeNew);

private:
  static LPCTSTR WINDOW_TITLE;
  static const int WINDOW_WIDTH;
  static const int WINDOW_HEIGHT;
  static TAccelerationType accelerationType;

#if defined(_WIN32)
  HMODULE _hInstance;
  HWND _hWnd;
#endif

  void WindowDestroy();
};

class CSurfaceWrapper
{
public:
  CSurfaceWrapper();
  virtual ~CSurfaceWrapper();
};

#if defined(_WIN32)
//windows specific wrappers
class CD3D9Wrapper: public CDeviceWrapper {
public:
  CD3D9Wrapper();
  ~CD3D9Wrapper();

  virtual bool AdapterNext();
  virtual unsigned int AdapterIdx() const;
  virtual void *Device() const;
  virtual TDeviceStatus Status() const;
  virtual void *D3D() const;

private:
  LPDIRECT3D9 _d3d9;
  LPDIRECT3DDEVICE9 _d3dDevice;
  D3DDISPLAYMODE _d3ddm;
  D3DADAPTER_IDENTIFIER9 _adapter;
  TDeviceStatus _status;
  unsigned int _adapterIdx;
  bool _adapterFound;

  D3DFORMAT Format();
  D3DADAPTER_IDENTIFIER9 Adapter();
  int Init();
  void Destroy();
};

class CD3D9ExWrapper: public CDeviceWrapper {
public:
  CD3D9ExWrapper();
  ~CD3D9ExWrapper();

  virtual bool AdapterNext();
  virtual unsigned int AdapterIdx() const;
  virtual void *Device() const;
  virtual TDeviceStatus Status() const;
  virtual void *D3D() const;

private:
  LPDIRECT3D9EX _d3d9Ex;
  LPDIRECT3DDEVICE9EX _d3dDeviceEx;
  D3DDISPLAYMODEEX _d3ddmEx;
  D3DADAPTER_IDENTIFIER9 _adapter;
  TDeviceStatus _status;
  unsigned int _adapterIdx;
  bool _adapterFound;

  D3DFORMAT Format();
  D3DADAPTER_IDENTIFIER9 Adapter();
  int Init();
  void Destroy();
};

class CDXVAWrapper: public CDeviceWrapper {
public:
  CDXVAWrapper();
  ~CDXVAWrapper();

  virtual bool AdapterNext();
  virtual unsigned int AdapterIdx() const;
  virtual void *Device() const;
  virtual TDeviceStatus Status() const;
  virtual void *D3D() const;
  const CD3D9ExWrapper &D3D9() const;

private:
  CD3D9ExWrapper _d3d9;
  IDXVAHD_Device *_dxvaDevice;
  TDeviceStatus _status;
  bool _adapterFound;

  static const D3DFORMAT RENDER_TARGET_FORMAT;
  static const D3DFORMAT VIDEO_FORMAT;
  static const unsigned int VIDEO_FPS;

  TDeviceStatus DXVAHDInit();
  void DXVAHDDestroy();
};

class CD3D9SurfaceWrapper: public CSurfaceWrapper
{
public:
  CD3D9SurfaceWrapper();
  CD3D9SurfaceWrapper( IDirect3DSurface9* mem );
  ~CD3D9SurfaceWrapper();

  operator IDirect3DSurface9*() { return mMem; }
  IDirect3DSurface9* * operator&() { return &mMem; }
  IDirect3DSurface9* operator->() const { return mMem; }

private:
  IDirect3DSurface9* mMem;
};
#endif

#endif  // __D3D_WRAPPERS