yum-archive/TaSTT-Whisper

High-performance GPGPU inference of OpenAI's Whisper automatic speech recognition (ASR) model

git clone https://git.yummers.dev/yum-archive/TaSTT-Whisper

KonstantinSource codes8c4603c

master
branchesmasterall refs →
3.4 KiB139 linesraw
1#pragma once
2#include <type_traits>
3#include "../comLightClient.h"
4#include "../utils/typeTraits.hpp"
5#include "../Exception.hpp"
6
7namespace ComLight
8{
9	namespace details
10	{
11		GENERATE_HAS_MEMBER( implQueryInterface );
12		GENERATE_HAS_MEMBER( implAddRef );
13		GENERATE_HAS_MEMBER( implRelease );
14	}
15
16	// Outer class of objects, implements IUnknown methods, also the class factory. The type argument must be your class implementing your interfaces, inherited from ObjectRoot<I>
17	template<class T>
18	class Object : public T
19	{
20	public:
21		Object() = default;
22
23		template<typename ... Args>
24		Object( Args&& ... args ) : T{ std::forward<Args>( args )... } {};
25
26		inline virtual ~Object() override { }
27
28		// Implement IUnknown methods
29		HRESULT COMLIGHTCALL QueryInterface( REFIID riid, void** ppvObject ) override
30		{
31			static_assert( details::has_member_implQueryInterface<T>::value, "Your object class must inherit from ComLight::ObjectRoot" );
32
33			if( nullptr == ppvObject )
34				return E_POINTER;
35
36			if( T::implQueryInterface( riid, ppvObject ) )
37				return S_OK;
38			if( T::queryExtraInterfaces( riid, ppvObject ) )
39				return S_OK;
40
41			if( riid == IUnknown::iid() )
42			{
43				ComLight::IUnknown* unk = T::getUnknown();
44				unk->AddRef();
45				*ppvObject = unk;
46				return S_OK;
47			}
48
49			return E_NOINTERFACE;
50		}
51
52		uint32_t COMLIGHTCALL AddRef() override
53		{
54			static_assert( details::has_member_implAddRef<T>::value, "Your object class must inherit from ComLight::ObjectRoot" );
55			return T::implAddRef();
56		}
57
58		uint32_t COMLIGHTCALL Release() override
59		{
60			static_assert( details::has_member_implRelease<T>::value, "Your object class must inherit from ComLight::ObjectRoot" );
61			const uint32_t ret = T::implRelease();
62			if( 0 == ret )
63			{
64				T::FinalRelease();
65				delete this;
66			}
67			return ret;
68		}
69
70		// Create a new object on the heap, store in smart pointer
71		static inline HRESULT create( CComPtr<Object<T>>& result )
72		{
73			CComPtr<Object<T>> ptr;
74			try
75			{
76				ptr = new Object<T>();	// The RefCounter constructor creates it with ref.counter 0. But then CComPtr constructor calls AddRef so we have RC=1 after this line.
77
78				HRESULT hr = ptr->internalFinalConstruct();
79				if( FAILED( hr ) )
80					return hr;
81
82				hr = ptr->FinalConstruct();
83				if( FAILED( hr ) )
84					return hr;
85
86				ptr.swap( result );
87				return S_OK;
88			}
89			catch( const Exception& ex )
90			{
91				return ex.code();
92			}
93		}
94
95		// Create a new object on the heap, store in smart pointer
96		template<typename ... Args>
97		static inline HRESULT create( CComPtr<Object<T>>& result, Args&& ... args )
98		{
99			CComPtr<Object<T>> ptr;
100			try
101			{
102				ptr = new Object<T>( std::forward<Args>( args )... );
103
104				HRESULT hr = ptr->internalFinalConstruct();
105				if( FAILED( hr ) )
106					return hr;
107
108				hr = ptr->FinalConstruct();
109				if( FAILED( hr ) )
110					return hr;
111
112				ptr.swap( result );
113				return S_OK;
114			}
115			catch( const Exception& ex )
116			{
117				return ex.code();
118			}
119			catch( HRESULT hr )
120			{
121				return hr;
122			}
123		}
124
125		// Create a new object on the heap, return one of it's interfaces. The caller is assumed to take ownership of the new object.
126		template<class I>
127		static inline HRESULT create( I** pp )
128		{
129			if( pp == nullptr )
130				return E_POINTER;
131
132			static_assert( details::pointersAssignable<I, T>(), "Object::create can't cast object to the requested interface" );
133			CComPtr<Object<T>> ptr;
134			CHECK( create( ptr ) );
135			ptr.detach( pp );
136			return S_OK;
137		}
138	};
139}