obs-ffmpeg: Replace external/AMF folder by obs-deps headers

plugins/obs-ffmpeg/external/AMF/include/components/Ambisonic2SRenderer.h

@@ -1,79 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// interface declaration;  Ambisonic to Stereo Renderer
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_Ambisonic2SRenderer_h
-#define AMF_Ambisonic2SRenderer_h
-#pragma once
-
-#include "public/include/components/Component.h"
-
-#define AMFAmbisonic2SRendererHW L"AMFAmbisonic2SRenderer"
-
-enum AMF_AMBISONIC2SRENDERER_MODE_ENUM 
-{
-    AMF_AMBISONIC2SRENDERER_MODE_SIMPLE            = 0,
-    AMF_AMBISONIC2SRENDERER_MODE_HRTF_AMD0         = 1,
-    AMF_AMBISONIC2SRENDERER_MODE_HRTF_MIT1         = 2,
-};
-
-
-// static properties 
-#define AMF_AMBISONIC2SRENDERER_IN_AUDIO_SAMPLE_RATE        L"InSampleRate"         // amf_int64 (default = 0)
-#define AMF_AMBISONIC2SRENDERER_IN_AUDIO_CHANNELS           L"InChannels"           // amf_int64 (only = 4)
-#define AMF_AMBISONIC2SRENDERER_IN_AUDIO_SAMPLE_FORMAT      L"InSampleFormat"       // amf_int64(AMF_AUDIO_FORMAT) (default = AMFAF_FLTP)
-
-#define AMF_AMBISONIC2SRENDERER_OUT_AUDIO_CHANNELS          L"OutChannels"          // amf_int64 (only = 2 - stereo)
-#define AMF_AMBISONIC2SRENDERER_OUT_AUDIO_SAMPLE_FORMAT     L"OutSampleFormat"      // amf_int64(AMF_AUDIO_FORMAT) (only = AMFAF_FLTP)
-#define AMF_AMBISONIC2SRENDERER_OUT_AUDIO_CHANNEL_LAYOUT    L"OutChannelLayout"     // amf_int64 (only = 3 - defalut stereo L R)
-
-#define AMF_AMBISONIC2SRENDERER_MODE                        L"StereoMode"               //TODO: AMF_AMBISONIC2SRENDERER_MODE_ENUM(default=AMF_AMBISONIC2SRENDERER_MODE_HRTF)
-
-
-// dynamic properties
-#define AMF_AMBISONIC2SRENDERER_W                           L"w"                        //amf_int64 (default=0)
-#define AMF_AMBISONIC2SRENDERER_X                           L"x"                        //amf_int64 (default=1)
-#define AMF_AMBISONIC2SRENDERER_Y                           L"y"                        //amf_int64 (default=2)
-#define AMF_AMBISONIC2SRENDERER_Z                           L"z"                        //amf_int64 (default=3)
-
-#define AMF_AMBISONIC2SRENDERER_THETA                       L"Theta"                    //double (default=0.0)
-#define AMF_AMBISONIC2SRENDERER_PHI                         L"Phi"                      //double (default=0.0)
-#define AMF_AMBISONIC2SRENDERER_RHO                         L"Rho"                      //double (default=0.0)
-
-extern "C"
-{
-    AMF_RESULT AMF_CDECL_CALL AMFCreateComponentAmbisonic(amf::AMFContext* pContext, void* reserved, amf::AMFComponent** ppComponent);
-}
-#endif //#ifndef AMF_Ambisonic2SRenderer_h

plugins/obs-ffmpeg/external/AMF/include/components/AudioCapture.h

@@ -1,86 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// Audio session  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_AudioCapture_h
-#define AMF_AudioCapture_h
-
-#pragma once
-
-#include "Component.h"
-
-// Set to capture from either a microphone or desktop
-#define AUDIOCAPTURE_SOURCE                L"AudioCaptureSource"           // amf_bool true for microphone, false for desktop;
-
-// In the case of capturing a microphone, the AUDIOCAPTURE_DEVICE_ACTIVE property
-// can be set to -1 so that the active input devices are looked up. If the initialization
-// is successful then the AUDIOCAPTURE_DEVICE_NAME and AUDIOCAPTURE_DEVICE_COUNT
-// properties will be set.
-#define AUDIOCAPTURE_DEVICE_ACTIVE          L"AudioCaptureDeviceActive"   // amf_int64
-#define AUDIOCAPTURE_DEVICE_COUNT           L"AudioCaptureDeviceCount"    // amf_int64
-#define AUDIOCAPTURE_DEVICE_NAME            L"AudioCaptureDeviceName"     // String
-
-// Codec used for audio capture
-#define AUDIOCAPTURE_CODEC                  L"AudioCaptureCodec"           // amf_int64, AV_CODEC_ID_PCM_F32LE
-// Sample rate used for audio capture
-#define AUDIOCAPTURE_SAMPLERATE             L"AudioCaptureSampleRate"      // amf_int64, 44100 in samples
-// Sample count used for audio capture
-#define AUDIOCAPTURE_SAMPLES                L"AudioCaptureSampleCount"     // amf_int64, 1024
-// Bitrate used for audio capture
-#define AUDIOCAPTURE_BITRATE                L"AudioCaptureBitRate"         // amf_int64, in bits
-// Channel count used for audio capture
-#define AUDIOCAPTURE_CHANNELS               L"AudioCaptureChannelCount"    // amf_int64, 2
-// Channel layout used for audio capture
-#define AUDIOCAPTURE_CHANNEL_LAYOUT         L"AudioCaptureChannelLayout"   // amf_int64, AMF_AUDIO_CHANNEL_LAYOUT
-// Format used for audio capture
-#define AUDIOCAPTURE_FORMAT                 L"AudioCaptureFormat"          // amf_int64, AMFAF_U8
-// Block alignment
-#define AUDIOCAPTURE_BLOCKALIGN             L"AudioCaptureBlockAlign"      // amf_int64, bytes
-// Audio frame size
-#define AUDIOCAPTURE_FRAMESIZE              L"AudioCaptureFrameSize"       // amf_int64, bytes
-// Audio low latency state
-#define AUDIOCAPTURE_LOWLATENCY             L"AudioCaptureLowLatency"      // amf_int64;
-
-// Optional interface that provides current time
-#define AUDIOCAPTURE_CURRENT_TIME_INTERFACE	L"CurrentTimeInterface"        // interface to current time object
-
-extern "C"
-{
-	// Component that allows the recording of inputs such as microphones or the audio that is being
-	// rendered.  The direction that is captured is controlled by the AUDIOCAPTURE_CAPTURE property
-	//
-	AMF_RESULT AMF_CDECL_CALL AMFCreateComponentAudioCapture(amf::AMFContext* pContext, amf::AMFComponent** ppComponent);
-}
-
-#endif // #ifndef AMF_AudioCapture_h

plugins/obs-ffmpeg/external/AMF/include/components/Capture.h

@@ -1,198 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// Capture interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef __Capture_h__
-#define __Capture_h__
-#pragma once
-
-#include "../../../public/include/components/Component.h"
-
-typedef enum AMF_CAPTURE_DEVICE_TYPE_ENUM
-{
-    AMF_CAPTURE_DEVICE_UNKNOWN              = 0,
-    AMF_CAPTURE_DEVICE_MEDIAFOUNDATION      = 1,
-    AMF_CAPTURE_DEVICE_WASAPI               = 2,
-    AMF_CAPTURE_DEVICE_SDI                  = 3,
-    AMF_CAPTURE_DEVICE_SCREEN_DUPLICATION   = 4,
-} AMF_CAPTURE_DEVICE_TYPE_ENUM;
-
-// device properties
-#define AMF_CAPTURE_DEVICE_TYPE                     L"DeviceType"               // amf_int64( AMF_CAPTURE_DEVICE_TYPE_ENUM )
-#define AMF_CAPTURE_DEVICE_NAME                     L"DeviceName"               // wchar_t* : name of the device
-
-
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-
-    //----------------------------------------------------------------------------------------------
-    // AMFCaptureDevice interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFCaptureDevice : public AMFComponentEx
-    {
-    public:
-        AMF_DECLARE_IID (0x5bfd1b17, 0x9f2a, 0x43c4, 0x9c, 0xdd, 0x2c, 0x3, 0x88, 0x43, 0xb5, 0xf3)
-
-        virtual AMF_RESULT          AMF_STD_CALL Start() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL Stop() = 0;
-
-        // TODO add callback interface for disconnected / lost / changed device notification
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFCaptureDevice> AMFCaptureDevicePtr;
-    //----------------------------------------------------------------------------------------------
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFCaptureDevice, 0x5bfd1b17, 0x9f2a, 0x43c4, 0x9c, 0xdd, 0x2c, 0x3, 0x88, 0x43, 0xb5, 0xf3)
-
-    typedef struct AMFCaptureDeviceVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFCaptureDevice* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFCaptureDevice* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFCaptureDevice* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFCaptureDevice* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFCaptureDevice* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFCaptureDevice* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFCaptureDevice* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFCaptureDevice* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFCaptureDevice* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFCaptureDevice* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFCaptureDevice* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFPropertyStorageEx interface
-
-        amf_size            (AMF_STD_CALL *GetPropertiesInfoCount)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfoAt)(AMFCaptureDevice* pThis, amf_size index, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfo)(AMFCaptureDevice* pThis, const wchar_t* name, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *ValidateProperty)(AMFCaptureDevice* pThis, const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated);
-
-        // AMFComponent interface
-
-        AMF_RESULT          (AMF_STD_CALL *Init)(AMFCaptureDevice* pThis, AMF_SURFACE_FORMAT format,amf_int32 width,amf_int32 height);
-        AMF_RESULT          (AMF_STD_CALL *ReInit)(AMFCaptureDevice* pThis, amf_int32 width,amf_int32 height);
-        AMF_RESULT          (AMF_STD_CALL *Terminate)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *Drain)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *Flush)(AMFCaptureDevice* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *SubmitInput)(AMFCaptureDevice* pThis, AMFData* pData);
-        AMF_RESULT          (AMF_STD_CALL *QueryOutput)(AMFCaptureDevice* pThis, AMFData** ppData);
-        AMFContext*         (AMF_STD_CALL *GetContext)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *SetOutputDataAllocatorCB)(AMFCaptureDevice* pThis, AMFDataAllocatorCB* callback);
-
-        AMF_RESULT          (AMF_STD_CALL *GetCaps)(AMFCaptureDevice* pThis, AMFCaps** ppCaps);
-        AMF_RESULT          (AMF_STD_CALL *Optimize)(AMFCaptureDevice* pThis, AMFComponentOptimizationCallback* pCallback);
-
-        // AMFComponentEx interface
-
-        amf_int32           (AMF_STD_CALL *GetInputCount)(AMFCaptureDevice* pThis);
-        amf_int32           (AMF_STD_CALL *GetOutputCount)(AMFCaptureDevice* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *GetInput)(AMFCaptureDevice* pThis, amf_int32 index, AMFInput** ppInput);
-        AMF_RESULT          (AMF_STD_CALL *GetOutput)(AMFCaptureDevice* pThis, amf_int32 index, AMFOutput** ppOutput);
-
-        // AMFCaptureDevice interface
-
-        AMF_RESULT          (AMF_STD_CALL *Start)(AMFCaptureDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *Stop)(AMFCaptureDevice* pThis);
-
-    } AMFCaptureVtbl;
-
-    struct AMFCapture
-    {
-        const AMFCaptureVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFCaptureManager interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFCaptureManager : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID ( 0xf64d2f0d, 0xad16, 0x4ce7, 0x80, 0x5f, 0xa1, 0xe7, 0x3b, 0x0, 0xf4, 0x28)
-
-        virtual AMF_RESULT          AMF_STD_CALL Update() = 0;
-        virtual amf_int32           AMF_STD_CALL GetDeviceCount() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetDevice(amf_int32 index,AMFCaptureDevice **pDevice) = 0;
-
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFCaptureManager> AMFCaptureManagerPtr;
-    //----------------------------------------------------------------------------------------------
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFCaptureManager, 0xf64d2f0d, 0xad16, 0x4ce7, 0x80, 0x5f, 0xa1, 0xe7, 0x3b, 0x0, 0xf4, 0x28)
-
-    typedef struct AMFCaptureManagerVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFCaptureManager* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFCaptureManager* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFCaptureManager* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-
-        // AMFCaptureManager interface
-        AMF_RESULT          (AMF_STD_CALL *Update)((AMFCaptureManager* pThis);
-        amf_int32           (AMF_STD_CALL *GetDeviceCount)(AMFCaptureManager* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetDevice)(AMFCaptureManager* pThis, amf_int32 index,AMFCaptureDevice **pDevice);
-
-    } AMFCaptureManagerVtbl;
-
-    struct AMFCaptureManager
-    {
-        const AMFCaptureManagerVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-#if defined(__cplusplus)
-} // namespace
-#endif
-
-extern "C"
-{
-    AMF_RESULT AMF_CDECL_CALL AMFCreateCaptureManager(amf::AMFContext* pContext, amf::AMFCaptureManager** ppManager);
-}
-
-#endif // __Capture_h__

plugins/obs-ffmpeg/external/AMF/include/components/ChromaKey.h

@@ -1,76 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-//
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-/**
- ***************************************************************************************************
- * @file  ChromaKey.h
- * @brief AMFChromaKey interface declaration
- ***************************************************************************************************
- */
-#ifndef __AMFChromaKey_h__
-#define __AMFChromaKey_h__
-#pragma once
-
-#include "public/include/components/Component.h"
-
-#define AMFChromaKey                  L"AMFChromaKey"
-
-// static properties 
-#define AMF_CHROMAKEY_COLOR           L"ChromaKeyColor"         // amf_uint64 (default=0x992A1E), YUV Green key Color
-#define AMF_CHROMAKEY_COLOR_EX        L"ChromaKeyColorEX"       // amf_uint64 (default=0), YUV Green key Color, secondary
-#define AMF_CHROMAKEY_RANGE_MIN       L"ChromaKeyRangeMin"      // amf_uint64 (default=20)   color tolerance low, 0~255
-#define AMF_CHROMAKEY_RANGE_MAX       L"ChromaKeyRangeMax"      // amf_uint64 (default=22)   color tolerance high, 0~255
-#define AMF_CHROMAKEY_RANGE_EXT       L"ChromaKeyRangeExt"      // amf_uint64 (default=40)   color tolerance extended, 0~255
-#define AMF_CHROMAKEY_SPILL_MODE      L"ChromaKeySpillMode"     // amf_uint64 (default=0)    spill suppression mode
-#define AMF_CHROMAKEY_RANGE_SPILL     L"ChromaKeyRangeSpill"    // amf_uint64 (default=5)    spill suppression threshold
-#define AMF_CHROMAKEY_LUMA_LOW        L"ChromaKeyLumaLow"       // amf_uint64 (default=16)   minimum luma value for processing
-#define AMF_CHROMAKEY_INPUT_COUNT     L"InputCount"             // amf_uint64 (default=2)    number of inputs
-#define AMF_CHROMAKEY_COLOR_POS       L"KeyColorPos"            // amf_uint64 (default=0)    key color position from the surface
-#define AMF_CHROMAKEY_OUT_FORMAT      L"ChromaKeyOutFormat"     // amf_uint64 (default=RGBA) output format
-#define AMF_CHROMAKEY_MEMORY_TYPE     L"ChromaKeyMemoryType"    // amf_uint64 (default=DX11) mmeory type
-#define AMF_CHROMAKEY_COLOR_ADJ       L"ChromaKeyColorAdj"      // amf_uint64 (default=0)    endble color adjustment
-#define AMF_CHROMAKEY_COLOR_ADJ_THRE  L"ChromaKeyColorAdjThre"  // amf_uint64 (default=0)    color adjustment threshold
-#define AMF_CHROMAKEY_COLOR_ADJ_THRE2 L"ChromaKeyColorAdjThre2" // amf_uint64 (default=0)    color adjustment threshold
-#define AMF_CHROMAKEY_BYPASS          L"ChromaKeyBypass"        // amf_uint64 (default=0)    disable chromakey
-#define AMF_CHROMAKEY_EDGE            L"ChromaKeyEdge"          // amf_uint64 (default=0)    endble edge detection
-#define AMF_CHROMAKEY_BOKEH           L"ChromaKeyBokeh"         // amf_uint64 (default=0)    endble background bokeh
-#define AMF_CHROMAKEY_BOKEH_RADIUS    L"ChromaKeyBokehRadius"   // amf_uint64 (default=7)    background bokeh radius
-#define AMF_CHROMAKEY_DEBUG           L"ChromaKeyDebug"         // amf_uint64 (default=0)    endble debug mode
-
-#define AMF_CHROMAKEY_POSX            L"ChromaKeyPosX"          // amf_uint64 (default=0)    positionX
-#define AMF_CHROMAKEY_POSY            L"ChromaKeyPosY"          // amf_uint64 (default=0)    positionY
-
-extern "C"
-{
-    AMF_RESULT AMF_CDECL_CALL AMFCreateComponentChromaKey(amf::AMFContext* pContext, amf::AMFComponentEx** ppComponent);
-}
-#endif //#ifndef __AMFChromaKey_h__

plugins/obs-ffmpeg/external/AMF/include/components/ColorSpace.h

@@ -1,138 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// Color Spacedeclaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_ColorSpace_h
-#define AMF_ColorSpace_h
-#pragma once
-
-// YUV <--> RGB conversion matrix with range
-typedef enum AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM
-{
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN   =-1,
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_601       = 0,    // studio range 
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_709       = 1,    // studio range 
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_2020      = 2,    // studio range 
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_JPEG      = 3,    // full range 601
-//    AMF_VIDEO_CONVERTER_COLOR_PROFILE_G22_BT709 = AMF_VIDEO_CONVERTER_COLOR_PROFILE_709,
-//    AMF_VIDEO_CONVERTER_COLOR_PROFILE_G10_SCRGB = 4,
-//    AMF_VIDEO_CONVERTER_COLOR_PROFILE_G10_BT709 = 5,
-//    AMF_VIDEO_CONVERTER_COLOR_PROFILE_G10_BT2020 = AMF_VIDEO_CONVERTER_COLOR_PROFILE_2020,
-//    AMF_VIDEO_CONVERTER_COLOR_PROFILE_G2084_BT2020 = 6,
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_FULL_601  = AMF_VIDEO_CONVERTER_COLOR_PROFILE_JPEG,    // full range
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_FULL_709  = 7,                                         // full range
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_FULL_2020 = 8,                                        // full range
-    AMF_VIDEO_CONVERTER_COLOR_PROFILE_COUNT
-} AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM;
-
-typedef enum AMF_COLOR_PRIMARIES_ENUM // as in VUI color_primaries AVC and HEVC
-{
-    AMF_COLOR_PRIMARIES_UNDEFINED   = 0,
-    AMF_COLOR_PRIMARIES_BT709       = 1,
-    AMF_COLOR_PRIMARIES_UNSPECIFIED = 2,
-    AMF_COLOR_PRIMARIES_RESERVED    = 3,
-    AMF_COLOR_PRIMARIES_BT470M      = 4,
-    AMF_COLOR_PRIMARIES_BT470BG     = 5,
-    AMF_COLOR_PRIMARIES_SMPTE170M   = 6,
-    AMF_COLOR_PRIMARIES_SMPTE240M   = 7,
-    AMF_COLOR_PRIMARIES_FILM        = 8,
-    AMF_COLOR_PRIMARIES_BT2020      = 9,
-    AMF_COLOR_PRIMARIES_SMPTE428    = 10,
-    AMF_COLOR_PRIMARIES_SMPTE431    = 11,
-    AMF_COLOR_PRIMARIES_SMPTE432    = 12,
-    AMF_COLOR_PRIMARIES_JEDEC_P22   = 22,
-    AMF_COLOR_PRIMARIES_CCCS        = 1000, // Common Composition Color Space or scRGB
-} AMF_COLOR_PRIMARIES_ENUM;
-
-typedef enum AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM // as in VUI transfer_characteristic AVC and HEVC
-{
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED     = 0,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_BT709         = 1, //BT709
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_UNSPECIFIED   = 2,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_RESERVED      = 3,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_GAMMA22       = 4, //BT470_M
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_GAMMA28       = 5, //BT470
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_SMPTE170M     = 6, //BT601
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_SMPTE240M     = 7, //SMPTE 240M
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_LINEAR        = 8,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_LOG           = 9, //LOG10
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_LOG_SQRT      = 10,//LOG10 SQRT
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_IEC61966_2_4  = 11,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_BT1361_ECG    = 12,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_IEC61966_2_1  = 13,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_BT2020_10     = 14, //BT709
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_BT2020_12     = 15, //BT709
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_SMPTE2084     = 16, //PQ
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_SMPTE428      = 17,
-    AMF_COLOR_TRANSFER_CHARACTERISTIC_ARIB_STD_B67  = 18, //HLG
-} AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM;
-
-typedef enum AMF_COLOR_BIT_DEPTH_ENUM
-{
-    AMF_COLOR_BIT_DEPTH_UNDEFINED   = 0,
-    AMF_COLOR_BIT_DEPTH_8           = 8,
-    AMF_COLOR_BIT_DEPTH_10          = 10,
-} AMF_COLOR_BIT_DEPTH_ENUM;
-
-typedef struct AMFHDRMetadata
-{
-    amf_uint16  redPrimary[2];              // normalized to 50000
-    amf_uint16  greenPrimary[2];            // normalized to 50000
-    amf_uint16  bluePrimary[2];             // normalized to 50000
-    amf_uint16  whitePoint[2];              // normalized to 50000
-    amf_uint32  maxMasteringLuminance;      // normalized to 10000
-    amf_uint32  minMasteringLuminance;      // normalized to 10000
-    amf_uint16  maxContentLightLevel;       // nit value 
-    amf_uint16  maxFrameAverageLightLevel;  // nit value 
-} AMFHDRMetadata;
-
-
-typedef enum AMF_COLOR_RANGE_ENUM
-{
-    AMF_COLOR_RANGE_UNDEFINED   = 0,
-    AMF_COLOR_RANGE_STUDIO      = 1,
-    AMF_COLOR_RANGE_FULL        = 2,
-} AMF_COLOR_RANGE_ENUM;
-
-
-// these properties can be set on input or outout surface
-// IDs are the same as in decoder properties
-// can be used to dynamically pass color data between components:
-// Decoder, Capture, Encoder. Presenter etc.
-#define AMF_VIDEO_COLOR_TRANSFER_CHARACTERISTIC         L"ColorTransferChar"    // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 Section 7.2 See ColorSpace.h for enum 
-#define AMF_VIDEO_COLOR_PRIMARIES                       L"ColorPrimaries"       // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 Section 7.1 See ColorSpace.h for enum 
-#define AMF_VIDEO_COLOR_RANGE                           L"ColorRange"           // amf_int64(AMF_COLOR_RANGE_ENUM) default = AMF_COLOR_RANGE_UNDEFINED
-#define AMF_VIDEO_COLOR_HDR_METADATA                    L"HdrMetadata"          // AMFBuffer containing AMFHDRMetadata; default NULL
-
-#endif //#ifndef AMF_ColorSpace_h

plugins/obs-ffmpeg/external/AMF/include/components/Component.h

@@ -1,444 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-/**
- ***************************************************************************************************
- * @file  Component.h
- * @brief AMFComponent interface declaration
- ***************************************************************************************************
- */
-#ifndef AMF_Component_h
-#define AMF_Component_h
-#pragma once
-
-#include "../core/Data.h"
-#include "../core/PropertyStorageEx.h"
-#include "../core/Surface.h"
-#include "../core/Context.h"
-#include "ComponentCaps.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // AMFDataAllocatorCB interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFDataAllocatorCB : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x4bf46198, 0x8b7b, 0x49d0, 0xaa, 0x72, 0x48, 0xd4, 0x7, 0xce, 0x24, 0xc5 )
-
-        virtual AMF_RESULT AMF_STD_CALL AllocBuffer(AMF_MEMORY_TYPE type, amf_size size, AMFBuffer** ppBuffer) = 0;
-        virtual AMF_RESULT AMF_STD_CALL AllocSurface(AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format,
-            amf_int32 width, amf_int32 height, amf_int32 hPitch, amf_int32 vPitch, AMFSurface** ppSurface) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFDataAllocatorCB> AMFDataAllocatorCBPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFDataAllocatorCB, 0x4bf46198, 0x8b7b, 0x49d0, 0xaa, 0x72, 0x48, 0xd4, 0x7, 0xce, 0x24, 0xc5 )
-    typedef struct AMFDataAllocatorCB AMFDataAllocatorCB;
-
-    typedef struct AMFDataAllocatorCBVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFDataAllocatorCB* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFDataAllocatorCB* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFDataAllocatorCB* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-        // AMFDataAllocatorCB interface 
-        AMF_RESULT (AMF_STD_CALL *AllocBuffer)(AMFDataAllocatorCB* pThis, AMF_MEMORY_TYPE type, amf_size size, AMFBuffer** ppBuffer);
-        AMF_RESULT (AMF_STD_CALL *AllocSurface)(AMFDataAllocatorCB* pThis, AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format,
-            amf_int32 width, amf_int32 height, amf_int32 hPitch, amf_int32 vPitch, AMFSurface** ppSurface);
-    } AMFDataAllocatorCBVtbl;
-
-    struct AMFDataAllocatorCB
-    {
-        const AMFDataAllocatorCBVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComponentOptimizationCallback
-    {
-    public:
-        virtual AMF_RESULT AMF_STD_CALL OnComponentOptimizationProgress(amf_uint percent) = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFComponentOptimizationCallback AMFComponentOptimizationCallback;
-    typedef struct AMFComponentOptimizationCallbackVtbl
-    {
-        // AMFDataAllocatorCB interface 
-        AMF_RESULT (AMF_STD_CALL *OnComponentOptimizationProgress)(AMFComponentOptimizationCallback* pThis, amf_uint percent);
-    } AMFComponentOptimizationCallbackVtbl;
-
-    struct AMFComponentOptimizationCallback
-    {
-        const AMFComponentOptimizationCallbackVtbl *pVtbl;
-    };
-
-#endif //#if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AMFComponent interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComponent : public AMFPropertyStorageEx
-    {
-    public:
-        AMF_DECLARE_IID(0x8b51e5e4, 0x455d, 0x4034, 0xa7, 0x46, 0xde, 0x1b, 0xed, 0xc3, 0xc4, 0x6)
-
-        virtual AMF_RESULT  AMF_STD_CALL Init(AMF_SURFACE_FORMAT format,amf_int32 width,amf_int32 height) = 0;
-        virtual AMF_RESULT  AMF_STD_CALL ReInit(amf_int32 width,amf_int32 height) = 0;
-        virtual AMF_RESULT  AMF_STD_CALL Terminate() = 0;
-        virtual AMF_RESULT  AMF_STD_CALL Drain() = 0;
-        virtual AMF_RESULT  AMF_STD_CALL Flush() = 0;
-
-        virtual AMF_RESULT  AMF_STD_CALL SubmitInput(AMFData* pData) = 0;
-        virtual AMF_RESULT  AMF_STD_CALL QueryOutput(AMFData** ppData) = 0;
-        virtual AMFContext* AMF_STD_CALL GetContext() = 0;
-        virtual AMF_RESULT  AMF_STD_CALL SetOutputDataAllocatorCB(AMFDataAllocatorCB* callback) = 0;
-
-        virtual AMF_RESULT  AMF_STD_CALL GetCaps(AMFCaps** ppCaps) = 0;
-        virtual AMF_RESULT  AMF_STD_CALL Optimize(AMFComponentOptimizationCallback* pCallback) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFComponent> AMFComponentPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFComponent, 0x8b51e5e4, 0x455d, 0x4034, 0xa7, 0x46, 0xde, 0x1b, 0xed, 0xc3, 0xc4, 0x6)
-    typedef struct AMFComponent AMFComponent;
-
-    typedef struct AMFComponentVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFComponent* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFComponent* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFComponent* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFComponent* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFComponent* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFComponent* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFComponent* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFComponent* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFComponent* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFComponent* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFComponent* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFComponent* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFComponent* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFPropertyStorageEx interface
-
-        amf_size            (AMF_STD_CALL *GetPropertiesInfoCount)(AMFComponent* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfoAt)(AMFComponent* pThis, amf_size index, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfo)(AMFComponent* pThis, const wchar_t* name, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *ValidateProperty)(AMFComponent* pThis, const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated);
-
-        // AMFComponent interface
-
-        AMF_RESULT  (AMF_STD_CALL *Init)(AMFComponent* pThis, AMF_SURFACE_FORMAT format,amf_int32 width,amf_int32 height);
-        AMF_RESULT  (AMF_STD_CALL *ReInit)(AMFComponent* pThis, amf_int32 width,amf_int32 height);
-        AMF_RESULT  (AMF_STD_CALL *Terminate)(AMFComponent* pThis);
-        AMF_RESULT  (AMF_STD_CALL *Drain)(AMFComponent* pThis);
-        AMF_RESULT  (AMF_STD_CALL *Flush)(AMFComponent* pThis);
-
-        AMF_RESULT  (AMF_STD_CALL *SubmitInput)(AMFComponent* pThis, AMFData* pData);
-        AMF_RESULT  (AMF_STD_CALL *QueryOutput)(AMFComponent* pThis, AMFData** ppData);
-        AMFContext* (AMF_STD_CALL *GetContext)(AMFComponent* pThis);
-        AMF_RESULT  (AMF_STD_CALL *SetOutputDataAllocatorCB)(AMFComponent* pThis, AMFDataAllocatorCB* callback);
-
-        AMF_RESULT  (AMF_STD_CALL *GetCaps)(AMFComponent* pThis, AMFCaps** ppCaps);
-        AMF_RESULT  (AMF_STD_CALL *Optimize)(AMFComponent* pThis, AMFComponentOptimizationCallback* pCallback);
-    } AMFComponentVtbl;
-
-    struct AMFComponent
-    {
-        const AMFComponentVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AMFInput interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFInput : public AMFPropertyStorageEx
-    {
-    public:
-        AMF_DECLARE_IID(0x1181eee7, 0x95f2, 0x434a, 0x9b, 0x96, 0xea, 0x55, 0xa, 0xa7, 0x84, 0x89)
-
-        virtual AMF_RESULT  AMF_STD_CALL SubmitInput(AMFData* pData) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFInput> AMFInputPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFInput, 0x1181eee7, 0x95f2, 0x434a, 0x9b, 0x96, 0xea, 0x55, 0xa, 0xa7, 0x84, 0x89)
-    typedef struct AMFInput AMFInput;
-
-    typedef struct AMFInputVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFInput* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFInput* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFInput* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFInput* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFInput* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFInput* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFInput* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFInput* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFInput* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFInput* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFInput* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFInput* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFInput* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFPropertyStorageEx interface
-
-        amf_size            (AMF_STD_CALL *GetPropertiesInfoCount)(AMFInput* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfoAt)(AMFInput* pThis, amf_size index, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfo)(AMFInput* pThis, const wchar_t* name, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *ValidateProperty)(AMFInput* pThis, const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated);
-
-        // AMFInput interface
-        AMF_RESULT          (AMF_STD_CALL *SubmitInput)(AMFInput* pThis, AMFData* pData);
-
-    } AMFInputVtbl;
-
-    struct AMFInput
-    {
-        const AMFInputVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFOutput interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFOutput : public AMFPropertyStorageEx
-    {
-    public:
-        AMF_DECLARE_IID(0x86a8a037, 0x912c, 0x4698, 0xb0, 0x46, 0x7, 0x5a, 0x1f, 0xac, 0x6b, 0x97)
-
-        virtual AMF_RESULT  AMF_STD_CALL QueryOutput(AMFData** ppData) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFOutput> AMFOutputPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFOutput, 0x86a8a037, 0x912c, 0x4698, 0xb0, 0x46, 0x7, 0x5a, 0x1f, 0xac, 0x6b, 0x97)
-    typedef struct AMFOutput AMFOutput;
-
-    typedef struct AMFOutputVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFOutput* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFOutput* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFOutput* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFOutput* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFOutput* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFOutput* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFOutput* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFOutput* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFOutput* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFOutput* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFOutput* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFOutput* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFOutput* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFPropertyStorageEx interface
-
-        amf_size            (AMF_STD_CALL *GetPropertiesInfoCount)(AMFOutput* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfoAt)(AMFOutput* pThis, amf_size index, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfo)(AMFOutput* pThis, const wchar_t* name, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *ValidateProperty)(AMFOutput* pThis, const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated);
-
-        // AMFOutput interface
-        AMF_RESULT          (AMF_STD_CALL *QueryOutput)(AMFOutput* pThis, AMFData** ppData);
-
-    } AMFOutputVtbl;
-
-    struct AMFOutput
-    {
-        const AMFOutputVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AMFComponent interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComponentEx : public AMFComponent
-    {
-    public:
-        AMF_DECLARE_IID(0xfda792af, 0x8712, 0x44df, 0x8e, 0xa0, 0xdf, 0xfa, 0xad, 0x2c, 0x80, 0x93)
-
-        virtual amf_int32   AMF_STD_CALL GetInputCount() = 0;
-        virtual amf_int32   AMF_STD_CALL GetOutputCount() = 0;
-
-        virtual AMF_RESULT  AMF_STD_CALL GetInput(amf_int32 index, AMFInput** ppInput) = 0;
-        virtual AMF_RESULT  AMF_STD_CALL GetOutput(amf_int32 index, AMFOutput** ppOutput) = 0;
-
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFComponentEx> AMFComponentExPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFComponentEx, 0xfda792af, 0x8712, 0x44df, 0x8e, 0xa0, 0xdf, 0xfa, 0xad, 0x2c, 0x80, 0x93)
-    typedef struct AMFComponentEx AMFComponentEx;
-
-    typedef struct AMFComponentExVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFComponentEx* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFComponentEx* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFComponentEx* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFComponentEx* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFComponentEx* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFComponentEx* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFComponentEx* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFComponentEx* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFComponentEx* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFComponentEx* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFComponentEx* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFComponentEx* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFComponentEx* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFPropertyStorageEx interface
-
-        amf_size            (AMF_STD_CALL *GetPropertiesInfoCount)(AMFComponentEx* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfoAt)(AMFComponentEx* pThis, amf_size index, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfo)(AMFComponentEx* pThis, const wchar_t* name, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *ValidateProperty)(AMFComponentEx* pThis, const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated);
-
-        // AMFComponent interface
-
-        AMF_RESULT  (AMF_STD_CALL *Init)(AMFComponentEx* pThis, AMF_SURFACE_FORMAT format,amf_int32 width,amf_int32 height);
-        AMF_RESULT  (AMF_STD_CALL *ReInit)(AMFComponentEx* pThis, amf_int32 width,amf_int32 height);
-        AMF_RESULT  (AMF_STD_CALL *Terminate)(AMFComponentEx* pThis);
-        AMF_RESULT  (AMF_STD_CALL *Drain)(AMFComponentEx* pThis);
-        AMF_RESULT  (AMF_STD_CALL *Flush)(AMFComponentEx* pThis);
-
-        AMF_RESULT  (AMF_STD_CALL *SubmitInput)(AMFComponentEx* pThis, AMFData* pData);
-        AMF_RESULT  (AMF_STD_CALL *QueryOutput)(AMFComponentEx* pThis, AMFData** ppData);
-        AMFContext* (AMF_STD_CALL *GetContext)(AMFComponentEx* pThis);
-        AMF_RESULT  (AMF_STD_CALL *SetOutputDataAllocatorCB)(AMFComponentEx* pThis, AMFDataAllocatorCB* callback);
-
-        AMF_RESULT  (AMF_STD_CALL *GetCaps)(AMFComponentEx* pThis, AMFCaps** ppCaps);
-        AMF_RESULT  (AMF_STD_CALL *Optimize)(AMFComponentEx* pThis, AMFComponentOptimizationCallback* pCallback);
-
-        // AMFComponentEx interface
-
-        amf_int32   (AMF_STD_CALL *GetInputCount)(AMFComponentEx* pThis);
-        amf_int32   (AMF_STD_CALL *GetOutputCount)(AMFComponentEx* pThis);
-
-        AMF_RESULT  (AMF_STD_CALL *GetInput)(AMFComponentEx* pThis, amf_int32 index, AMFInput** ppInput);
-        AMF_RESULT  (AMF_STD_CALL *GetOutput)(AMFComponentEx* pThis, amf_int32 index, AMFOutput** ppOutput);
-
-
-    } AMFComponentExVtbl;
-
-    struct AMFComponentEx
-    {
-        const AMFComponentExVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-
-#if defined(__cplusplus)
-} // namespace
-#endif
-
-typedef enum AMF_STREAM_TYPE_ENUM
-{
-    AMF_STREAM_UNKNOWN              = 0,
-    AMF_STREAM_VIDEO                = 1,
-    AMF_STREAM_AUDIO                = 2,
-    AMF_STREAM_DATA                 = 3,
-} AMF_STREAM_TYPE_ENUM;
-
-typedef enum AMF_STREAM_CODEC_ID_ENUM     // matched codecs from VideoDecoxcderUVD.h
-{
-    AMF_STREAM_CODEC_ID_UNKNOWN     = 0,
-    AMF_STREAM_CODEC_ID_MPEG2       = 1,  // AMFVideoDecoderUVD_MPEG2      
-    AMF_STREAM_CODEC_ID_MPEG4       = 2,  // AMFVideoDecoderUVD_MPEG4      
-    AMF_STREAM_CODEC_ID_WMV3        = 3,  // AMFVideoDecoderUVD_WMV3       
-    AMF_STREAM_CODEC_ID_VC1         = 4,  // AMFVideoDecoderUVD_VC1        
-    AMF_STREAM_CODEC_ID_H264_AVC    = 5,  // AMFVideoDecoderUVD_H264_AVC   
-    AMF_STREAM_CODEC_ID_H264_MVC    = 6,  // AMFVideoDecoderUVD_H264_MVC   
-    AMF_STREAM_CODEC_ID_H264_SVC    = 7,  // AMFVideoDecoderUVD_H264_SVC   
-    AMF_STREAM_CODEC_ID_MJPEG       = 8,  // AMFVideoDecoderUVD_MJPEG      
-    AMF_STREAM_CODEC_ID_H265_HEVC   = 9,  // AMFVideoDecoderHW_H265_HEVC   
-    AMF_STREAM_CODEC_ID_H265_MAIN10 = 10, // AMFVideoDecoderHW_H265_MAIN10 
-    AMF_STREAM_CODEC_ID_VP9         = 11, // AMFVideoDecoderHW_VP9
-    AMF_STREAM_CODEC_ID_VP9_10BIT   = 12, // AMFVideoDecoderHW_VP9_10BIT   
-    AMF_STREAM_CODEC_ID_AV1         = 13, // AMFVideoDecoderHW_AV1 
-    AMF_STREAM_CODEC_ID_AV1_12BIT   = 14, // AMFVideoDecoderHW_AV1_12BIT
-} AMF_STREAM_CODEC_ID_ENUM;
-
-// common stream properties
-#define AMF_STREAM_TYPE                     L"StreamType"           // amf_int64( AMF_STREAM_TYPE_ENUM )
-#define AMF_STREAM_ENABLED                  L"Enabled"              // bool( default = false )
-#define AMF_STREAM_CODEC_ID                 L"CodecID"              // amf_int64(Video: AMF_STREAM_CODEC_ID_ENUM, Audio: AVCodecID) (default = 0 - uncompressed)
-#define AMF_STREAM_BIT_RATE                 L"BitRate"              // amf_int64 (default = codec->bit_rate)
-#define AMF_STREAM_EXTRA_DATA               L"ExtraData"            // interface to AMFBuffer - as is from FFMPEG
-
-// video stream properties
-#define AMF_STREAM_VIDEO_MEMORY_TYPE        L"VideoMemoryType"      // amf_int64(AMF_MEMORY_TYPE); default = AMF_MEMORY_DX11
-#define AMF_STREAM_VIDEO_FORMAT             L"VideoFormat"          // amf_int64(AMF_SURFACE_FORMAT); default = AMF_SURFACE_NV12 (used if AMF_STREAM_CODEC_ID == 0)
-#define AMF_STREAM_VIDEO_FRAME_RATE         L"VideoFrameRate"       // AMFRate; default = (30,1) - video frame rate
-#define AMF_STREAM_VIDEO_FRAME_SIZE         L"VideoFrameSize"       // AMFSize; default = (1920,1080) - video frame rate
-#define AMF_STREAM_VIDEO_SURFACE_POOL       L"VideoSurfacePool"     // amf_int64; default = 5, number of allocated output surfaces
-//TODO support interlaced frames
-
-// audio stream properties
-#define AMF_STREAM_AUDIO_FORMAT             L"AudioFormat"          // amf_int64(AMF_AUDIO_FORMAT); default = AMFAF_S16
-#define AMF_STREAM_AUDIO_SAMPLE_RATE        L"AudioSampleRate"      // amf_int64; default = 48000
-#define AMF_STREAM_AUDIO_CHANNELS           L"AudioChannels"        // amf_int64; default = 2
-#define AMF_STREAM_AUDIO_CHANNEL_LAYOUT     L"AudioChannelLayout"   // amf_int64 (default = codec->channel_layout)
-#define AMF_STREAM_AUDIO_BLOCK_ALIGN        L"AudioBlockAlign"      // amf_int64 (default = codec->block_align)
-#define AMF_STREAM_AUDIO_FRAME_SIZE         L"AudioFrameSize"       // amf_int64 (default = codec->frame_size)
-
-
-#endif //#ifndef AMF_Component_h

plugins/obs-ffmpeg/external/AMF/include/components/ComponentCaps.h

@@ -1,172 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_ComponentCaps_h
-#define AMF_ComponentCaps_h
-
-#pragma once
-
-#include "../core/Interface.h"
-#include "../core/PropertyStorage.h"
-#include "../core/Surface.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    typedef enum AMF_ACCELERATION_TYPE
-    {
-        AMF_ACCEL_NOT_SUPPORTED = -1,
-        AMF_ACCEL_HARDWARE,
-        AMF_ACCEL_GPU,
-        AMF_ACCEL_SOFTWARE
-    } AMF_ACCELERATION_TYPE;
-    //----------------------------------------------------------------------------------------------
-    // AMFIOCaps interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFIOCaps : public AMFInterface
-    {
-    public:
-        //  Get supported resolution ranges in pixels/lines:
-        virtual void AMF_STD_CALL GetWidthRange(amf_int32* minWidth, amf_int32* maxWidth) const = 0;
-        virtual void AMF_STD_CALL GetHeightRange(amf_int32* minHeight, amf_int32* maxHeight) const = 0;
-
-        //  Get memory alignment in lines: Vertical aligmnent should be multiples of this number
-        virtual amf_int32 AMF_STD_CALL GetVertAlign() const = 0;
-        
-        //  Enumerate supported surface pixel formats
-        virtual amf_int32 AMF_STD_CALL GetNumOfFormats() const = 0;
-        virtual  AMF_RESULT AMF_STD_CALL GetFormatAt(amf_int32 index, AMF_SURFACE_FORMAT* format, amf_bool* native) const = 0;
-
-        //  Enumerate supported memory types
-        virtual amf_int32 AMF_STD_CALL GetNumOfMemoryTypes() const = 0;
-        virtual AMF_RESULT AMF_STD_CALL GetMemoryTypeAt(amf_int32 index, AMF_MEMORY_TYPE* memType, amf_bool* native) const = 0;
-
-        virtual amf_bool AMF_STD_CALL IsInterlacedSupported() const = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFIOCaps>    AMFIOCapsPtr;
-#else // #if defined(__cplusplus)
-    typedef struct AMFIOCaps AMFIOCaps;
-
-    typedef struct AMFIOCapsVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFIOCaps* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFIOCaps* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFIOCaps* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFIOCaps interface
-        //  Get supported resolution ranges in pixels/lines:
-        void (AMF_STD_CALL *GetWidthRange)(AMFIOCaps* pThis, amf_int32* minWidth, amf_int32* maxWidth);
-        void (AMF_STD_CALL *GetHeightRange)(AMFIOCaps* pThis, amf_int32* minHeight, amf_int32* maxHeight);
-
-        //  Get memory alignment in lines: Vertical aligmnent should be multiples of this number
-        amf_int32 (AMF_STD_CALL *GetVertAlign)(AMFIOCaps* pThis);
-        
-        //  Enumerate supported surface pixel formats
-        amf_int32 (AMF_STD_CALL *GetNumOfFormats)(AMFIOCaps* pThis);
-        AMF_RESULT (AMF_STD_CALL *GetFormatAt)(AMFIOCaps* pThis, amf_int32 index, AMF_SURFACE_FORMAT* format, amf_bool* native);
-
-        //  Enumerate supported memory types
-        amf_int32 (AMF_STD_CALL *GetNumOfMemoryTypes)(AMFIOCaps* pThis);
-        AMF_RESULT (AMF_STD_CALL *GetMemoryTypeAt)(AMFIOCaps* pThis, amf_int32 index, AMF_MEMORY_TYPE* memType, amf_bool* native);
-
-        amf_bool (AMF_STD_CALL *IsInterlacedSupported)(AMFIOCaps* pThis);
-    } AMFIOCapsVtbl;
-
-    struct AMFIOCaps
-    {
-        const AMFIOCapsVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-   
-    //----------------------------------------------------------------------------------------------
-    // AMFCaps interface - base interface for every h/w module supported by Capability Manager
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFCaps : public AMFPropertyStorage
-    {
-    public:
-        virtual AMF_ACCELERATION_TYPE AMF_STD_CALL GetAccelerationType() const = 0;
-        virtual AMF_RESULT AMF_STD_CALL GetInputCaps(AMFIOCaps** input) = 0;
-        virtual AMF_RESULT AMF_STD_CALL GetOutputCaps(AMFIOCaps** output) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFCaps>  AMFCapsPtr;
-#else // #if defined(__cplusplus)
-    typedef struct AMFCaps AMFCaps;
-
-    typedef struct AMFCapsVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFCaps* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFCaps* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFCaps* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFCaps* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFCaps* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFCaps* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFCaps* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFCaps* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFCaps* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFCaps* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFCaps* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFCaps* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFCaps* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFCaps interface
-
-        AMF_ACCELERATION_TYPE (AMF_STD_CALL *GetAccelerationType)(AMFCaps* pThis);
-        AMF_RESULT (AMF_STD_CALL *GetInputCaps)(AMFCaps* pThis, AMFIOCaps** input);
-        AMF_RESULT (AMF_STD_CALL *GetOutputCaps)(AMFCaps* pThis, AMFIOCaps** output);
-    } AMFCapsVtbl;
-
-    struct AMFCaps
-    {
-        const AMFCapsVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-}
-#endif
-
-#endif //#ifndef AMF_ComponentCaps_h

plugins/obs-ffmpeg/external/AMF/include/components/CursorCapture.h

@@ -1,54 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// Cursor capture interface declaration
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_CursorCapture_h
-#define AMF_CursorCapture_h
-#pragma once
-
-namespace amf
-{
-    class AMFCursorCapture : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x166efa1a, 0x19b8, 0x42f2, 0x86, 0x0f, 0x56, 0x69, 0xca, 0x7a, 0x85, 0x4c)
-        virtual AMF_RESULT AMF_STD_CALL AcquireCursor(amf::AMFSurface** pSurface) = 0;
-        virtual AMF_RESULT AMF_STD_CALL Reset() = 0;
-    };
-
-    typedef AMFInterfacePtr_T<AMFCursorCapture> AMFCursorCapturePtr;
-}
-
-#endif // #ifndef AMF_CursorCapture_h

plugins/obs-ffmpeg/external/AMF/include/components/DisplayCapture.h

@@ -1,81 +0,0 @@
-//
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-//
-// MIT license
-//
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// Desktop duplication interface declaration
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_DisplayCapture_h
-#define AMF_DisplayCapture_h
-#pragma once
-
-#include "Component.h"
-
-extern "C"
-{
-    // To create capture component with Desktop Duplication API use this function
-    AMF_RESULT AMF_CDECL_CALL AMFCreateComponentDisplayCapture(amf::AMFContext* pContext, void* reserved, amf::AMFComponent** ppComponent);
-}
-
-// To create AMD Direct Capture component use this component ID with AMFFactory::CreateComponent()
-#define AMFDisplayCapture L"AMFDisplayCapture"
-
-// Static properties
-//
-typedef enum AMF_DISPLAYCAPTURE_MODE_ENUM
-{
-    AMF_DISPLAYCAPTURE_MODE_KEEP_FRAMERATE      = 0, // capture component maintains the frame rate and returns current visible surface
-    AMF_DISPLAYCAPTURE_MODE_WAIT_FOR_PRESENT    = 1, // capture component waits for flip (present) event
-    AMF_DISPLAYCAPTURE_MODE_GET_CURRENT_SURFACE = 2, // returns current visible surface immediately
-} AMF_DISPLAYCAPTURE_MODE_ENUM;
-
-
-#define AMF_DISPLAYCAPTURE_MONITOR_INDEX            L"MonitorIndex"             // amf_int64, default = 0, Index of the display monitor; is determined by using EnumAdapters() in DXGI.
-#define AMF_DISPLAYCAPTURE_MODE                     L"CaptureMode"              // amf_int64(AMF_DISPLAYCAPTURE_MODE_ENUM), default =  AMF_DISPLAYCAPTURE_MODE_FRAMERATE, controls wait logic
-#define AMF_DISPLAYCAPTURE_FRAMERATE                L"FrameRate"                // AMFRate,  default = (0, 1) Capture framerate, if 0 - capture rate will be driven by flip event from fullscreen app or DWM
-#define AMF_DISPLAYCAPTURE_CURRENT_TIME_INTERFACE   L"CurrentTimeInterface"     // AMFInterface(AMFCurrentTime) Optional interface object for providing  timestamps.
-#define AMF_DISPLAYCAPTURE_FORMAT                   L"CurrentFormat"            // amf_int64(AMF_SURFACE_FORMAT) Capture format - read-only
-#define AMF_DISPLAYCAPTURE_RESOLUTION               L"Resolution"               // AMFSize - screen resolution - read-only
-#define AMF_DISPLAYCAPTURE_DUPLICATEOUTPUT          L"DuplicateOutput"          // amf_bool, default = false, output AMF surface is a copy of captured
-#define AMF_DISPLAYCAPTURE_DESKTOP_RECT             L"DesktopRect"              // AMFRect - rect of the capture desktop - read-only
-#define AMF_DISPLAYCAPTURE_ENABLE_DIRTY_RECTS       L"EnableDirtyRects"         // amf_bool, default = false, enable dirty rectangles attached to output as AMF_DISPLAYCAPTURE_DIRTY_RECTS
-#define AMF_DISPLAYCAPTURE_DRAW_DIRTY_RECTS         L"DrawDirtyRects"           // amf_bool, default = false, copies capture output and draws dirty rectangles with red - for debugging only
-#define AMF_DISPLAYCAPTURE_ROTATION                 L"Rotation"                 // amf_int64(AMF_ROTATION_ENUM); default = AMF_ROTATION_NONE, monitor rotation state
-
-// Properties that can be set on output AMFSurface
-#define AMF_DISPLAYCAPTURE_DIRTY_RECTS              L"DirtyRects"               // AMFInterface*(AMFBuffer*) - array of AMFRect(s)
-#define AMF_DISPLAYCAPTURE_FRAME_INDEX              L"FrameIndex"               // amf_int64; default = 0, index of presented frame since capture started
-#define AMF_DISPLAYCAPTURE_FRAME_FLIP_TIMESTAMP     L"FlipTimesamp"             // amf_int64; default = 0, flip timestmap of presented frame
-// see Surface.h
-//#define AMF_SURFACE_ROTATION         L"Rotation"    // amf_int64(AMF_ROTATION_ENUM); default = AMF_ROTATION_NONE, can be set on surfaces - the same value as AMF_DISPLAYCAPTURE_ROTATION
-
-#endif // #ifndef AMF_DisplayCapture_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGAudioConverter.h

@@ -1,62 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// AMFFAudioConverterFFMPEG  interface declaration
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_AudioConverterFFMPEG_h
-#define AMF_AudioConverterFFMPEG_h
-
-#pragma once
-
-
-#define FFMPEG_AUDIO_CONVERTER    L"AudioConverterFFMPEG"
-
-
-#define AUDIO_CONVERTER_IN_AUDIO_BIT_RATE             L"In_BitRate"                 // amf_int64 (default = 128000)
-#define AUDIO_CONVERTER_IN_AUDIO_SAMPLE_RATE          L"In_SampleRate"              // amf_int64 (default = 0)
-#define AUDIO_CONVERTER_IN_AUDIO_CHANNELS             L"In_Channels"                // amf_int64 (default = 2)
-#define AUDIO_CONVERTER_IN_AUDIO_SAMPLE_FORMAT        L"In_SampleFormat"            // amf_int64 (default = AMFAF_UNKNOWN)  (AMF_AUDIO_FORMAT)
-#define AUDIO_CONVERTER_IN_AUDIO_CHANNEL_LAYOUT       L"In_ChannelLayout"           // amf_int64 (default = 0)
-#define AUDIO_CONVERTER_IN_AUDIO_BLOCK_ALIGN          L"In_BlockAlign"              // amf_int64 (default = 0)
-
-#define AUDIO_CONVERTER_OUT_AUDIO_BIT_RATE            L"Out_BitRate"                // amf_int64 (default = 128000)
-#define AUDIO_CONVERTER_OUT_AUDIO_SAMPLE_RATE         L"Out_SampleRate"             // amf_int64 (default = 0)
-#define AUDIO_CONVERTER_OUT_AUDIO_CHANNELS            L"Out_Channels"               // amf_int64 (default = 2)
-#define AUDIO_CONVERTER_OUT_AUDIO_SAMPLE_FORMAT       L"Out_SampleFormat"           // amf_int64 (default = AMFAF_UNKNOWN)  (AMF_AUDIO_FORMAT)
-#define AUDIO_CONVERTER_OUT_AUDIO_CHANNEL_LAYOUT      L"Out_ChannelLayout"          // amf_int64 (default = 0)
-#define AUDIO_CONVERTER_OUT_AUDIO_BLOCK_ALIGN         L"Out_BlockAlign"             // amf_int64 (default = 0)
-
-
-
-#endif //#ifndef AMF_AudioConverterFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGAudioDecoder.h

@@ -1,68 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// AudioDecoderFFMPEG  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_AudioDecoderFFMPEG_h
-#define AMF_AudioDecoderFFMPEG_h
-
-#pragma once
-
-
-#define FFMPEG_AUDIO_DECODER    L"AudioDecoderFFMPEG"
-
-
-#define AUDIO_DECODER_ENABLE_DEBUGGING              L"EnableDebug"                  // bool (default = false) - trace some debug information if set to true
-#define AUDIO_DECODER_ENABLE_DECODING               L"EnableDecoding"               // bool (default = true) - if false, component will not decode anything
-
-#define AUDIO_DECODER_IN_AUDIO_CODEC_ID             L"In_CodecID"                   // amf_int64 (default = AV_CODEC_ID_NONE) - FFMPEG codec ID
-#define AUDIO_DECODER_IN_AUDIO_BIT_RATE             L"In_BitRate"                   // amf_int64 (default = 128000)
-#define AUDIO_DECODER_IN_AUDIO_EXTRA_DATA           L"In_ExtraData"                 // interface to AMFBuffer
-#define AUDIO_DECODER_IN_AUDIO_SAMPLE_RATE          L"In_SampleRate"                // amf_int64 (default = 0)
-#define AUDIO_DECODER_IN_AUDIO_CHANNELS             L"In_Channels"                  // amf_int64 (default = 2)
-#define AUDIO_DECODER_IN_AUDIO_SAMPLE_FORMAT        L"In_SampleFormat"              // amf_int64 (default = AMFAF_UNKNOWN)  (AMF_AUDIO_FORMAT)
-#define AUDIO_DECODER_IN_AUDIO_CHANNEL_LAYOUT       L"In_ChannelLayout"             // amf_int64 (default = 0)
-#define AUDIO_DECODER_IN_AUDIO_BLOCK_ALIGN          L"In_BlockAlign"                // amf_int64 (default = 0)
-#define AUDIO_DECODER_IN_AUDIO_FRAME_SIZE           L"In_FrameSize"                 // amf_int64 (default = 0)
-#define AUDIO_DECODER_IN_AUDIO_SEEK_POSITION        L"In_SeekPosition"              // amf_int64 (default = 0)
-
-#define AUDIO_DECODER_OUT_AUDIO_BIT_RATE            L"Out_BitRate"                  // amf_int64 (default = 128000)
-#define AUDIO_DECODER_OUT_AUDIO_SAMPLE_RATE         L"Out_SampleRate"               // amf_int64 (default = 0)
-#define AUDIO_DECODER_OUT_AUDIO_CHANNELS            L"Out_Channels"                 // amf_int64 (default = 2)
-#define AUDIO_DECODER_OUT_AUDIO_SAMPLE_FORMAT       L"Out_SampleFormat"             // amf_int64 (default = AMFAF_UNKNOWN)  (AMF_AUDIO_FORMAT)
-#define AUDIO_DECODER_OUT_AUDIO_CHANNEL_LAYOUT      L"Out_ChannelLayout"            // amf_int64 (default = 0)
-#define AUDIO_DECODER_OUT_AUDIO_BLOCK_ALIGN         L"Out_BlockAlign"               // amf_int64 (default = 0)
-
-
-
-#endif //#ifndef AMF_AudioDecoderFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGAudioEncoder.h

@@ -1,66 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// AudioEncoderFFMPEG  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_AudioEncoderFFMPEG_h
-#define AMF_AudioEncoderFFMPEG_h
-
-#pragma once
-
-
-#define FFMPEG_AUDIO_ENCODER    L"AudioEncoderFFMPEG"
-
-
-#define AUDIO_ENCODER_ENABLE_DEBUGGING              L"EnableDebug"                  // bool (default = false) - trace some debug information if set to true
-#define AUDIO_ENCODER_ENABLE_ENCODING               L"EnableEncoding"               // bool (default = true) - if false, component will not encode anything
-#define AUDIO_ENCODER_AUDIO_CODEC_ID                L"CodecID"                      // amf_int64 (default = AV_CODEC_ID_NONE) - FFMPEG codec ID
-
-#define AUDIO_ENCODER_IN_AUDIO_SAMPLE_RATE          L"In_SampleRate"                // amf_int64 (default = 44100)
-#define AUDIO_ENCODER_IN_AUDIO_CHANNELS             L"In_Channels"                  // amf_int64 (default = 2)
-#define AUDIO_ENCODER_IN_AUDIO_SAMPLE_FORMAT        L"In_SampleFormat"              // amf_int64 (default = AMFAF_S16)  (AMF_AUDIO_FORMAT)
-#define AUDIO_ENCODER_IN_AUDIO_CHANNEL_LAYOUT       L"In_ChannelLayout"             // amf_int64 (default = 3)
-#define AUDIO_ENCODER_IN_AUDIO_BLOCK_ALIGN          L"In_BlockAlign"                // amf_int64 (default = 0)
-
-#define AUDIO_ENCODER_OUT_AUDIO_BIT_RATE            L"Out_BitRate"                  // amf_int64 (default = 128000)
-#define AUDIO_ENCODER_OUT_AUDIO_EXTRA_DATA          L"Out_ExtraData"                // interface to AMFBuffer
-#define AUDIO_ENCODER_OUT_AUDIO_SAMPLE_RATE         L"Out_SampleRate"               // amf_int64 (default = 44100)
-#define AUDIO_ENCODER_OUT_AUDIO_CHANNELS            L"Out_Channels"                 // amf_int64 (default = 2)
-#define AUDIO_ENCODER_OUT_AUDIO_SAMPLE_FORMAT       L"Out_SampleFormat"             // amf_int64 (default = AMFAF_S16)  (AMF_AUDIO_FORMAT)
-#define AUDIO_ENCODER_OUT_AUDIO_CHANNEL_LAYOUT      L"Out_ChannelLayout"            // amf_int64 (default = 0)
-#define AUDIO_ENCODER_OUT_AUDIO_BLOCK_ALIGN         L"Out_BlockAlign"               // amf_int64 (default = 0)
-#define AUDIO_ENCODER_OUT_AUDIO_FRAME_SIZE          L"Out_FrameSize"                // amf_int64 (default = 0)
-
-
-
-#endif //#ifndef AMF_AudioEncoderFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGComponents.h

@@ -1,54 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// FFMPEG components definitions
-//-------------------------------------------------------------------------------------------------
- 
-#ifndef AMF_ComponentsFFMPEG_h
-#define AMF_ComponentsFFMPEG_h
-
-#pragma once
-
-
-#if defined(_WIN32)
-    #if defined(_M_AMD64)
-        #define FFMPEG_DLL_NAME    L"amf-component-ffmpeg64.dll"
-    #else
-        #define FFMPEG_DLL_NAME    L"amf-component-ffmpeg32.dll"
-    #endif
-#elif defined(__linux)
-    #define FFMPEG_DLL_NAME    L"amf-component-ffmpeg.so"
-#endif
-
-
-#endif //#ifndef AMF_ComponentsFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGFileDemuxer.h

@@ -1,66 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// DemuxerFFMPEG  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_FileDemuxerFFMPEG_h
-#define AMF_FileDemuxerFFMPEG_h
-
-#pragma once
-
-#define FFMPEG_DEMUXER L"DemuxerFFMPEG"
-
-
-// component properties
-#define FFMPEG_DEMUXER_PATH                     L"Path"                     // string - the file to open
-#define FFMPEG_DEMUXER_URL                      L"Url"                      // string - the stream url to open
-#define FFMPEG_DEMUXER_START_FRAME              L"StartFrame"               // amf_int64 (default = 0)
-#define FFMPEG_DEMUXER_FRAME_COUNT              L"FramesNumber"             // amf_int64 (default = 0)
-#define FFMPEG_DEMUXER_DURATION                 L"Duration"                 // amf_int64 (default = 0)
-#define FFMPEG_DEMUXER_CHECK_MVC                L"CheckMVC"                 // bool (default = true)
-//#define FFMPEG_DEMUXER_SYNC_AV                  L"SyncAV"                   // bool (default = false)
-#define FFMPEG_DEMUXER_INDIVIDUAL_STREAM_MODE   L"StreamMode"               // bool (default = true)
-#define FFMPEG_DEMUXER_LISTEN                   L"Listen"                   // bool (default = false)
-
-// for common, video and audio properties see Component.h
-
-
-// video stream properties
-#define FFMPEG_DEMUXER_VIDEO_PIXEL_ASPECT_RATIO L"PixelAspectRatio"         // double (default = calculated)
-#define FFMPEG_DEMUXER_VIDEO_CODEC              L"FFmpegCodec"              // enum (from source)
-
-
-// buffer properties
-#define FFMPEG_DEMUXER_BUFFER_TYPE              L"BufferType"               // amf_int64 ( AMF_STREAM_TYPE_ENUM )
-#define FFMPEG_DEMUXER_BUFFER_STREAM_INDEX      L"BufferStreamIndexType"    // amf_int64 ( stream index )
-#endif //#ifndef AMF_FileDemuxerFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGFileMuxer.h

@@ -1,54 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// MuxerFFMPEG  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_FileMuxerFFMPEG_h
-#define AMF_FileMuxerFFMPEG_h
-
-#pragma once
-
-#define FFMPEG_MUXER L"MuxerFFMPEG"
-
-
-// component properties
-#define FFMPEG_MUXER_PATH                     L"Path"                     // string - the file to open
-#define FFMPEG_MUXER_URL                      L"Url"                      // string - the stream url to open
-#define FFMPEG_MUXER_LISTEN                   L"Listen"                   // bool (default = false)
-#define FFMPEG_MUXER_ENABLE_VIDEO             L"EnableVideo"              // bool (default = true)
-#define FFMPEG_MUXER_ENABLE_AUDIO             L"EnableAudio"              // bool (default = false)
-#define FFMPEG_MUXER_CURRENT_TIME_INTERFACE   L"CurrentTimeInterface"
-#define FFMPEG_MUXER_VIDEO_ROTATION           L"VideoRotation"            // amf_int64 (0, 90, 180, 270, default = 0)
-#define FFMPEG_MUXER_USAGE_IS_TRIM            L"UsageIsTrim"              // bool (default = false)
-
-#endif //#ifndef AMF_FileMuxerFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGVideoDecoder.h

@@ -1,53 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// VideoDecoderFFMPEG  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_VideoDecoderFFMPEG_h
-#define AMF_VideoDecoderFFMPEG_h
-
-#pragma once
-
-#define FFMPEG_VIDEO_DECODER    L"VideoDecoderFFMPEG"
-
-#define VIDEO_DECODER_ENABLE_DECODING      L"EnableDecoding"   // bool (default = true) - if false, component will not decode anything
-#define VIDEO_DECODER_CODEC_ID             L"CodecID"          // amf_int64 (AMF_STREAM_CODEC_ID_ENUM) codec ID
-#define VIDEO_DECODER_EXTRA_DATA           L"ExtraData"        // interface to AMFBuffer
-#define VIDEO_DECODER_RESOLUTION           L"Resolution"       // AMFSize 
-#define VIDEO_DECODER_BITRATE              L"BitRate"          // amf_int64 (default = 0)
-#define VIDEO_DECODER_FRAMERATE            L"FrameRate"        // AMFRate
-#define VIDEO_DECODER_SEEK_POSITION        L"SeekPosition"     // amf_int64 (default = 0)
-
-#define VIDEO_DECODER_COLOR_TRANSFER_CHARACTERISTIC L"ColorTransferChar"    // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013   7.2
-
-#endif //#ifndef AMF_VideoDecoderFFMPEG_h

plugins/obs-ffmpeg/external/AMF/include/components/HQScaler.h

@@ -1,69 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMFHQScaler_h
-#define AMFHQScaler_h
-
-#pragma once
-
-#define AMFHQScaler L"AMFHQScaler"
-
-
-// various types of algorithms supported by the high-quality scaler
-enum  AMF_HQ_SCALER_ALGORITHM_ENUM
-{
-    AMF_HQ_SCALER_ALGORITHM_BILINEAR = 0,
-    AMF_HQ_SCALER_ALGORITHM_BICUBIC = 1,
-    AMF_HQ_SCALER_ALGORITHM_FSR = 2, // deprecated
-    AMF_HQ_SCALER_ALGORITHM_VIDEOSR1_0 = 2,
-    AMF_HQ_SCALER_ALGORITHM_POINT = 3,
-    AMF_HQ_SCALER_ALGORITHM_VIDEOSR1_1 = 4,
-
-};
-
-
-// PA object properties
-#define AMF_HQ_SCALER_ALGORITHM         L"HQScalerAlgorithm"        // amf_int64(AMF_HQ_SCALER_ALGORITHM_ENUM) (Bi-linear, Bi-cubic, RCAS, Auto)"      - determines which scaling algorithm will be used
-                                                                    //                                                                                   auto will chose best option between algorithms available
-#define AMF_HQ_SCALER_ENGINE_TYPE       L"HQScalerEngineType"       // AMF_MEMORY_TYPE (DX11, DX12, OPENCL, VULKAN default : DX11)"                    - determines how the object is initialized and what kernels to use
-
-#define AMF_HQ_SCALER_OUTPUT_SIZE       L"HQSOutputSize"            // AMFSize                                                                         - output scaling width/hieight
-
-#define AMF_HQ_SCALER_KEEP_ASPECT_RATIO  L"KeepAspectRatio"         // bool (default=false) Keep aspect ratio if scaling. 
-#define AMF_HQ_SCALER_FILL               L"Fill"                    // bool (default=false) fill area out of ROI. 
-#define AMF_HQ_SCALER_FILL_COLOR         L"FillColor"               // AMFColor 
-#define AMF_HQ_SCALER_FROM_SRGB          L"FromSRGB"                   //  bool (default=true) Convert to SRGB. 
-
-#define AMF_HQ_SCALER_SHARPNESS          L"HQScalerSharpness"   // Float in the range of [0.0, 2.0]
-#define AMF_HQ_SCALER_FRAME_RATE         L"HQScalerFrameRate"   // Frame rate (off, 15, 30, 60)
-
-#endif //#ifndef AMFHQScaler_h

plugins/obs-ffmpeg/external/AMF/include/components/MediaSource.h

@@ -1,79 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_MediaSource_h
-#define AMF_MediaSource_h
-
-#pragma once
-
-#include "public/include/core/Interface.h"
-
-namespace amf
-{
-    enum AMF_SEEK_TYPE
-    {
-        AMF_SEEK_PREV = 0,           // nearest packet before pts
-        AMF_SEEK_NEXT = 1,           // nearest packet after pts
-        AMF_SEEK_PREV_KEYFRAME = 2,  // nearest keyframe packet before pts
-        AMF_SEEK_NEXT_KEYFRAME = 3,  // nearest keyframe packet after pts
-    };
-
-    //----------------------------------------------------------------------------------------------
-    // media source interface.  
-    //----------------------------------------------------------------------------------------------
-    class AMFMediaSource : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0xb367695a, 0xdbd0, 0x4430, 0x95, 0x3b, 0xbc, 0x7d, 0xbd, 0x2a, 0xa7, 0x66)
-
-        // interface
-        virtual AMF_RESULT  AMF_STD_CALL Seek(amf_pts pos, AMF_SEEK_TYPE seekType, amf_int32 whichStream) = 0;
-        virtual amf_pts     AMF_STD_CALL GetPosition() = 0;
-        virtual amf_pts     AMF_STD_CALL GetDuration() = 0;
-
-        virtual void        AMF_STD_CALL SetMinPosition(amf_pts pts) = 0;
-        virtual amf_pts     AMF_STD_CALL GetMinPosition() = 0;
-        virtual void        AMF_STD_CALL SetMaxPosition(amf_pts pts) = 0;
-        virtual amf_pts     AMF_STD_CALL GetMaxPosition() = 0;
-
-        virtual amf_uint64  AMF_STD_CALL GetFrameFromPts(amf_pts pts) = 0;
-        virtual amf_pts     AMF_STD_CALL GetPtsFromFrame(amf_uint64 frame) = 0;
-
-        virtual bool        AMF_STD_CALL SupportFramesAccess() = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFMediaSource> AMFMediaSourcePtr;
-} //namespace amf
-
-#endif //#ifndef AMF_MediaSource_h

plugins/obs-ffmpeg/external/AMF/include/components/PreAnalysis.h

@@ -1,133 +0,0 @@
-//
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-//
-// MIT license
-//
-// Copyright (c) 2019 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMFPreAnalysis_h
-#define AMFPreAnalysis_h
-
-#pragma once
-
-#define AMFPreAnalysis L"AMFPreAnalysis"
-
-
-
-enum  AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_ENUM
-{
-    AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_LOW    = 0,
-    AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_MEDIUM = 1,
-    AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_HIGH   = 2
-};
-
-
-enum  AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_ENUM
-{
-	AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_LOW    = 0,
-	AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_MEDIUM = 1,
-	AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_HIGH   = 2
-};
-
-
-enum  AMF_PA_ACTIVITY_TYPE_ENUM
-{
-    AMF_PA_ACTIVITY_Y   = 0,
-    AMF_PA_ACTIVITY_YUV = 1
-};
-
-
-enum  AMF_PA_CAQ_STRENGTH_ENUM
-{
-    AMF_PA_CAQ_STRENGTH_LOW    = 0,
-    AMF_PA_CAQ_STRENGTH_MEDIUM = 1,
-    AMF_PA_CAQ_STRENGTH_HIGH   = 2
-};
-
-// Perceptual adaptive quantization mode
-enum AMF_PA_PAQ_MODE_ENUM
-{
-    AMF_PA_PAQ_MODE_NONE = 0,
-    AMF_PA_PAQ_MODE_CAQ = 1
-};
-
-// Temporal adaptive quantization mode
-enum  AMF_PA_TAQ_MODE_ENUM
-{
-    AMF_PA_TAQ_MODE_NONE = 0,
-    AMF_PA_TAQ_MODE_1 = 1,
-    AMF_PA_TAQ_MODE_2 = 2
-};
-
-enum AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE_ENUM
-{
-    AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE_NONE = 0, //default
-    AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE_AUTO = 1
-};
-
-
-// PA object properties
-#define AMF_PA_ENGINE_TYPE                          L"PAEngineType"                         // AMF_MEMORY_TYPE (Host, DX11, OpenCL, Vulkan, Auto default : UNKNOWN (Auto))" - determines how the object is initialized and what kernels to use
-                                                                                            //                                                                        by default it is Auto (DX11, OpenCL and Vulkan are currently available)
-
-#define AMF_PA_SCENE_CHANGE_DETECTION_ENABLE        L"PASceneChangeDetectionEnable"         // bool       (default : True)                                          - Enable Scene Change Detection GPU algorithm
-#define AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY   L"PASceneChangeDetectionSensitivity"	// AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_ENUM (default : Medium)    - Scene Change Detection Sensitivity
-#define AMF_PA_STATIC_SCENE_DETECTION_ENABLE        L"PAStaticSceneDetectionEnable"         // bool       (default : False)                                         - Enable Skip Detection GPU algorithm
-#define AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY   L"PAStaticSceneDetectionSensitivity"	// AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_ENUM (default : High)      - Allowable absolute difference between pixels (sample counts)
-#define AMF_PA_FRAME_SAD_ENABLE                     L"PAFrameSadEnable"	                    // bool       (default : True)                                          - Enable Frame SAD algorithm
-#define AMF_PA_ACTIVITY_TYPE                        L"PAActivityType"                       // AMF_PA_ACTIVITY_TYPE_ENUM (default : Calculate on Y)                 - Block activity calculation mode
-#define AMF_PA_LTR_ENABLE                           L"PALongTermReferenceEnable"            // bool       (default : False)                                         - Enable Automatic Long Term Reference frame management
-#define AMF_PA_LOOKAHEAD_BUFFER_DEPTH               L"PALookAheadBufferDepth"               // amf_uint64 (default : 0)           Values: [0, MAX_LOOKAHEAD_DEPTH]  - PA lookahead buffer size
-#define AMF_PA_PAQ_MODE                             L"PAPerceptualAQMode"                   // AMF_PA_PAQ_MODE_ENUM     (default : AMF_PA_PAQ_MODE_NONE)            - Perceptual AQ mode
-#define AMF_PA_TAQ_MODE                             L"PATemporalAQMode"                     // AMF_PA_TAQ_MODE_ENUM (default: AMF_PA_TAQ_MODE_NONE)                 - Temporal AQ mode
-#define AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE       L"PAHighMotionQualityBoostMode"         // AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE_ENUM (default: None)           - High motion quality boost mode
-
-///////////////////////////////////////////
-// the following properties are available
-// only through the Encoder - trying to
-// access/set them when PA is standalone
-// will fail
-
-
-#define AMF_PA_INITIAL_QP_AFTER_SCENE_CHANGE        L"PAInitialQPAfterSceneChange"          // amf_uint64 (default : 0)           Values: [0, 51]                   - Base QP to be used immediately after scene change. If this value is not set, PA will choose a proper QP value
-#define AMF_PA_MAX_QP_BEFORE_FORCE_SKIP             L"PAMaxQPBeforeForceSkip"               // amf_uint64 (default : 35)          Values: [0, 51]                   - When a static scene is detected, a skip frame is inserted only if the previous encoded frame average QP <= this value
-
-
-#define AMF_PA_CAQ_STRENGTH                         L"PACAQStrength"                        // AMF_PA_CAQ_STRENGTH_ENUM (default : Medium)                          - Content Adaptive Quantization (CAQ) strength
-
-
-
-
-//////////////////////////////////////////////////
-// properties set by PA on output buffer interface
-#define AMF_PA_ACTIVITY_MAP                         L"PAActivityMap"                        // AMFInterface* -> AMFSurface*;       Values: int32                    - When PA is standalone, there will be a 2D Activity map generated for each frame
-#define AMF_PA_SCENE_CHANGE_DETECT                  L"PASceneChangeDetect"                  // bool                                                                 - True/False - available if AMF_PA_SCENE_CHANGE_DETECTION_ENABLE was set to True
-#define AMF_PA_STATIC_SCENE_DETECT                  L"PAStaticSceneDetect"                  // bool                                                                 - True/False - available if AMF_PA_STATIC_SCENE_DETECTION_ENABLE was set to True
-
-
-#endif //#ifndef AMFPreAnalysis_h

plugins/obs-ffmpeg/external/AMF/include/components/PreProcessing.h

@@ -1,59 +0,0 @@
-//
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-//
-// MIT license
-//
-// Copyright (c) 2020 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMFPreProcessing_h
-#define AMFPreProcessing_h
-
-#pragma once
-
-#define AMFPreProcessing L"AMFPreProcessing"
-
-
-// Pre-processing object properties
-#define AMF_PP_ENGINE_TYPE                   L"PPEngineType"                   // AMF_MEMORY_TYPE (Host, DX11, OPENCL, Auto default : OPENCL)   - determines how the object is initialized and what kernels to use
-                                                                               //                                                                 by default it is OpenCL (Host, DX11 and OpenCL are currently available)
-// add a property that will determine the output format
-// by default we output in the same format as input
-// but in some cases we might need to change the output
-// format to be different than input
-#define AMF_PP_OUTPUT_MEMORY_TYPE            L"PPOutputFormat"                 // AMF_MEMORY_TYPE (Host, DX11, OPENCL    default : Unknown)     - determines format of frame going out
-
-
-#define AMF_PP_ADAPTIVE_FILTER_STRENGTH      L"PPAdaptiveFilterStrength"       // int       (default : 4)                                       - strength:    0 - 10: the higher the value, the stronger the filtering
-#define AMF_PP_ADAPTIVE_FILTER_SENSITIVITY   L"PPAdaptiveFilterSensitivity"	   // int       (default : 4)                                       - sensitivity: 0 - 10: the lower the value, the more sensitive to edge (preserve more details)
-
-// Encoder parameters used for adaptive filtering
-#define AMF_PP_TARGET_BITRATE                L"PPTargetBitrate"                // int64     (default: 2000000)                                  - target bit rate
-#define AMF_PP_FRAME_RATE                    L"PPFrameRate"                    // AMFRate   (default: 30, 1)                                    - frame rate
-#define AMF_PP_ADAPTIVE_FILTER_ENABLE        L"PPAdaptiveFilterEnable"         // bool      (default: false)                                    - turn on/off adaptive filtering
-
-#endif //#ifndef AMFPreProcessing_h

plugins/obs-ffmpeg/external/AMF/include/components/SupportedCodecs.h

@@ -1,61 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// An interface available on some components to provide information on supported input and output codecs 
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_SupportedCodecs_h
-#define AMF_SupportedCodecs_h
-
-#pragma once
-
-#include "public/include/core/Interface.h"
-
-//properties on the returned AMFPropertyStorage
-#define SUPPORTEDCODEC_ID L"CodecId" //amf_int64
-#define SUPPORTEDCODEC_SAMPLERATE L"SampleRate" //amf_int32
-
-namespace amf
-{
-    class AMFSupportedCodecs : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0xc1003a83, 0x7934, 0x408a, 0x95, 0x5b, 0xc4, 0xdd, 0x85, 0x9d, 0xf5, 0x61)
-
-        //call with increasing values until it returns AMF_OUT_OF_RANGE
-        virtual AMF_RESULT     AMF_STD_CALL GetInputCodecAt(amf_size index, AMFPropertyStorage** codec) const = 0;
-        virtual AMF_RESULT     AMF_STD_CALL GetOutputCodecAt(amf_size index, AMFPropertyStorage** codec) const = 0;
-    };
-    typedef AMFInterfacePtr_T<AMFSupportedCodecs> AMFSupportedCodecsPtr;
-}
-
-#endif

plugins/obs-ffmpeg/external/AMF/include/components/VQEnhancer.h

@@ -1,48 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMFVQEnhancer_h
-#define AMFVQEnhancer_h
-
-#pragma once
-
-#define VE_FCR_DEFAULT_ATTENUATION 0.1
-
-#define AMFVQEnhancer L"AMFVQEnhancer"
-
-#define AMF_VIDEO_ENHANCER_ENGINE_TYPE       L"AMF_VIDEI_ENHANCER_ENGINE_TYPE"        // AMF_MEMORY_TYPE (DX11, DX12, OPENCL, VULKAN default : DX11)"                    - determines how the object is initialized and what kernels to use
-#define AMF_VIDEO_ENHANCER_OUTPUT_SIZE       L"AMF_VIDEO_ENHANCER_OUTPUT_SIZE"        // AMFSize                       
-#define AMF_VE_FCR_ATTENUATION               L"AMF_VE_FCR_ATTENUATION"                // Float in the range of [0.02, 0.4], default : 0.1
-#define AMF_VE_FCR_RADIUS                    L"AMF_VE_FCR_RADIUS"                     // int  in the range of [1, 4]
-#define AMF_VE_FCR_SPLIT_VIEW                L"AMF_VE_FCR_SPLIT_VIEW"                 // FCR View split window
-
-#endif //#ifndef AMFVQEnhancer_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoCapture.h

@@ -1,52 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// ZCamLive  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_VideoCapture_h
-#define AMF_VideoCapture_h
-
-#pragma once
-
-#define VIDEOCAP_DEVICE_COUNT           L"VideoCapDeviceCount"    // amf_int64, (default=2), number of video capture devices
-#define VIDEOCAP_DEVICE_NAME            L"VideoCapDeviceName"     // WString, (default=""), name of the video capture device
-#define VIDEOCAP_DEVICE_ACTIVE          L"VideoCapDeviceActive"   // WString, (default=""), name of the selected video capture device
-
-#define VIDEOCAP_CODEC                   L"CodecID"               // WString (default = "AMFVideoDecoderUVD_H264_AVC"), UVD codec ID
-#define VIDEOCAP_FRAMESIZE               L"FrameSize"             // AMFSize, (default=AMFConstructSize(1920, 1080)), frame size in pixels
-
-extern "C"
-{
-    AMF_RESULT AMF_CDECL_CALL AMFCreateComponentVideoCapture(amf::AMFContext* pContext, amf::AMFComponentEx** ppComponent);
-}
-#endif // AMF_VideoCapture_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoConverter.h

@@ -1,121 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// AMFFVideoConverter interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_VideoConverter_h
-#define AMF_VideoConverter_h
-#pragma once
-
-#include "Component.h"
-#include "ColorSpace.h"
-
-#define AMFVideoConverter L"AMFVideoConverter"
-
-enum AMF_VIDEO_CONVERTER_SCALE_ENUM
-{
-    AMF_VIDEO_CONVERTER_SCALE_INVALID          = -1,
-    AMF_VIDEO_CONVERTER_SCALE_BILINEAR          = 0,
-    AMF_VIDEO_CONVERTER_SCALE_BICUBIC           = 1
-};
-
-enum AMF_VIDEO_CONVERTER_TONEMAPPING_ENUM
-{
-    AMF_VIDEO_CONVERTER_TONEMAPPING_COPY = 0,
-    AMF_VIDEO_CONVERTER_TONEMAPPING_AMD = 1,
-    AMF_VIDEO_CONVERTER_TONEMAPPING_LINEAR = 2,
-    AMF_VIDEO_CONVERTER_TONEMAPPING_GAMMA = 3,
-    AMF_VIDEO_CONVERTER_TONEMAPPING_REINHARD = 4,
-    AMF_VIDEO_CONVERTER_TONEMAPPING_2390 = 5,
-};
-
-
-
-#define AMF_VIDEO_CONVERTER_OUTPUT_FORMAT                   L"OutputFormat"             // Values : AMF_SURFACE_NV12 or AMF_SURFACE_BGRA or AMF_SURFACE_YUV420P
-#define AMF_VIDEO_CONVERTER_MEMORY_TYPE                     L"MemoryType"               // Values : AMF_MEMORY_DX11 or AMF_MEMORY_DX9 or AMF_MEMORY_UNKNOWN (get from input type)
-#define AMF_VIDEO_CONVERTER_COMPUTE_DEVICE                  L"ComputeDevice"            // Values : AMF_MEMORY_COMPUTE_FOR_DX9 enumeration
-
-#define AMF_VIDEO_CONVERTER_OUTPUT_SIZE                     L"OutputSize"               // AMFSize  (default=0,0) width in pixels. default means no scaling
-#define AMF_VIDEO_CONVERTER_OUTPUT_RECT                     L"OutputRect"               // AMFRect  (default=0, 0, 0, 0) rectangle in pixels. default means no rect
-#define AMF_VIDEO_CONVERTER_SCALE                           L"ScaleType"            // amf_int64(AMF_VIDEO_CONVERTER_SCALE_ENUM); default = AMF_VIDEO_CONVERTER_SCALE_BILINEAR
-#define AMF_VIDEO_CONVERTER_FORCE_OUTPUT_SURFACE_SIZE       L"ForceOutputSurfaceSize" // bool (default=false) Force output size from output surface 
-
-#define AMF_VIDEO_CONVERTER_KEEP_ASPECT_RATIO               L"KeepAspectRatio"          // bool (default=false) Keep aspect ratio if scaling. 
-#define AMF_VIDEO_CONVERTER_FILL                            L"Fill"                     // bool (default=false) fill area out of ROI. 
-#define AMF_VIDEO_CONVERTER_FILL_COLOR                      L"FillColor"                // AMFColor 
-
-//-------------------------------------------------------------------------------------------------
-// SDR color conversion
-//-------------------------------------------------------------------------------------------------
-#define AMF_VIDEO_CONVERTER_COLOR_PROFILE                   L"ColorProfile"         // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO
-#define AMF_VIDEO_CONVERTER_LINEAR_RGB                      L"LinearRGB"             // bool (default=false) Convert to/from linear RGB instead of sRGB using AMF_VIDEO_DECODER_COLOR_TRANSFER_CHARACTERISTIC or by default AMF_VIDEO_CONVERTER_TRANSFER_CHARACTERISTIC
-
-//-------------------------------------------------------------------------------------------------
-// HDR color conversion
-//-------------------------------------------------------------------------------------------------
-// AMF_VIDEO_CONVERTER_COLOR_PROFILE is used to define color space conversion
-
-// HDR data - can be set on converter or respectively on input and output surfaces (output surface via custom allocator) 
-// if present, HDR_METADATA primary color overwrites COLOR_PRIMARIES
-
-// these properties can be set on converter component to configure input and output 
-// these properties overwrite properties set on surface - see below
-#define AMF_VIDEO_CONVERTER_INPUT_TRANSFER_CHARACTERISTIC   L"InputTransferChar"    // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013   7.2 See ColorSpace.h for enum 
-#define AMF_VIDEO_CONVERTER_INPUT_COLOR_PRIMARIES           L"InputColorPrimaries"  // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013   7.1 See ColorSpace.h for enum 
-#define AMF_VIDEO_CONVERTER_INPUT_COLOR_RANGE               L"InputColorRange"      // amf_int64(AMF_COLOR_RANGE_ENUM) default = AMF_COLOR_RANGE_UNDEFINED
-#define AMF_VIDEO_CONVERTER_INPUT_HDR_METADATA              L"InputHdrMetadata"     // AMFBuffer containing AMFHDRMetadata; default NULL
-#define AMF_VIDEO_CONVERTER_INPUT_TONEMAPPING               L"InputTonemapping"   // amf_int64(AMF_VIDEO_CONVERTER_TONEMAPPING_ENUM) default = AMF_VIDEO_CONVERTER_TONEMAPPING_LINEAR
-
-#define AMF_VIDEO_CONVERTER_OUTPUT_TRANSFER_CHARACTERISTIC  L"OutputTransferChar"   // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013   7.2 See ColorSpace.h for enum 
-#define AMF_VIDEO_CONVERTER_OUTPUT_COLOR_PRIMARIES          L"OutputColorPrimaries" // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013   7.1 See ColorSpace.h for enum 
-#define AMF_VIDEO_CONVERTER_OUTPUT_COLOR_RANGE              L"OutputColorRange"     // amf_int64(AMF_COLOR_RANGE_ENUM) default = AMF_COLOR_RANGE_UNDEFINED
-#define AMF_VIDEO_CONVERTER_OUTPUT_HDR_METADATA             L"OutputHdrMetadata"    // AMFBuffer containing AMFHDRMetadata; default NULL
-#define AMF_VIDEO_CONVERTER_OUTPUT_TONEMAPPING              L"OutputTonemapping"  // amf_int64(AMF_VIDEO_CONVERTER_TONEMAPPING_ENUM) default = AMF_VIDEO_CONVERTER_TONEMAPPING_AMD
-
-// these properties can be set on input or outout surface See ColorSpace.h
-// the same as decoder properties set on input surface - see below
-//#define AMF_VIDEO_COLOR_TRANSFER_CHARACTERISTIC         L"ColorTransferChar"      // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013   7.2 See ColorSpace.h for enum 
-//#define AMF_VIDEO_COLOR_PRIMARIES                       L"ColorPrimaries"         // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013   7.1 See ColorSpace.h for enum 
-//#define AMF_VIDEO_COLOR_RANGE                           L"ColorRange"           // amf_int64(AMF_COLOR_RANGE_ENUM) default = AMF_COLOR_RANGE_UNDEFINED
-//#define AMF_VIDEO_COLOR_HDR_METADATA                    L"HdrMetadata"            // AMFBuffer containing AMFHDRMetadata; default NULL
-
-// If decoder properties can be set on input see VideoDecoder.h
-// AMF_VIDEO_DECODER_COLOR_TRANSFER_CHARACTERISTIC
-// AMF_VIDEO_DECODER_COLOR_PRIMARIES
-// AMF_VIDEO_DECODER_COLOR_RANGE
-// AMF_VIDEO_DECODER_HDR_METADATA
-
-#define AMF_VIDEO_CONVERTER_USE_DECODER_HDR_METADATA    L"UseDecoderHDRMetadata" // bool (default=true) enables use of decoder / surface input color properties above
-
-
-#endif //#ifndef AMF_VideoConverter_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoDecoderUVD.h

@@ -1,126 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-//  VideoDecoderUVD interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_VideoDecoderUVD_h
-#define AMF_VideoDecoderUVD_h
-#pragma once
-
-#include "Component.h"
-#include "ColorSpace.h"
-
-#define AMFVideoDecoderUVD_MPEG2                     L"AMFVideoDecoderUVD_MPEG2"
-#define AMFVideoDecoderUVD_MPEG4                     L"AMFVideoDecoderUVD_MPEG4"
-#define AMFVideoDecoderUVD_WMV3                      L"AMFVideoDecoderUVD_WMV3"
-#define AMFVideoDecoderUVD_VC1                       L"AMFVideoDecoderUVD_VC1"
-#define AMFVideoDecoderUVD_H264_AVC                  L"AMFVideoDecoderUVD_H264_AVC"
-#define AMFVideoDecoderUVD_H264_MVC                  L"AMFVideoDecoderUVD_H264_MVC"
-#define AMFVideoDecoderUVD_H264_SVC                  L"AMFVideoDecoderUVD_H264_SVC"
-#define AMFVideoDecoderUVD_MJPEG                     L"AMFVideoDecoderUVD_MJPEG"
-#define AMFVideoDecoderHW_H265_HEVC                  L"AMFVideoDecoderHW_H265_HEVC"
-#define AMFVideoDecoderHW_H265_MAIN10                L"AMFVideoDecoderHW_H265_MAIN10"
-#define AMFVideoDecoderHW_VP9                        L"AMFVideoDecoderHW_VP9"
-#define AMFVideoDecoderHW_VP9_10BIT                  L"AMFVideoDecoderHW_VP9_10BIT"
-#define AMFVideoDecoderHW_AV1                        L"AMFVideoDecoderHW_AV1"
-#define AMFVideoDecoderHW_AV1_12BIT                  L"AMFVideoDecoderHW_AV1_12BIT"
-
-enum AMF_VIDEO_DECODER_MODE_ENUM
-{
-    AMF_VIDEO_DECODER_MODE_REGULAR = 0,     // DPB delay is based on number of reference frames + 1 (from SPS)
-    AMF_VIDEO_DECODER_MODE_COMPLIANT,       // DPB delay is based on profile - up to 16
-    AMF_VIDEO_DECODER_MODE_LOW_LATENCY,     // DPB delay is 0. Expect stream with no reordering in P-Frames or B-Frames. B-frames can be present as long as they do not introduce any frame re-ordering 
-};
-enum AMF_TIMESTAMP_MODE_ENUM
-{
-    AMF_TS_PRESENTATION = 0, // default. decoder will preserve timestamps from input to output
-       AMF_TS_SORT,             // decoder will resort PTS list 
-    AMF_TS_DECODE            // timestamps reflect decode order - decoder will reuse them
-};
-
-#define AMF_VIDEO_DECODER_SURFACE_COPY                 L"SurfaceCopy"           // amf_bool; default = false; return output surfaces as a copy
-#define AMF_VIDEO_DECODER_EXTRADATA                    L"ExtraData"             // AMFInterface* -> AMFBuffer* - AVCC - size length + SPS/PPS; or as Annex B. Optional if stream is Annex B
-#define AMF_VIDEO_DECODER_FRAME_RATE                   L"FrameRate"             // amf_double; default = 0.0, optional property to restore duration in the output if needed
-#define AMF_TIMESTAMP_MODE                             L"TimestampMode"         // amf_int64(AMF_TIMESTAMP_MODE_ENUM)  - default AMF_TS_PRESENTATION - how input timestamps are treated
-
-// dynamic/adaptive resolution change
-#define AMF_VIDEO_DECODER_ADAPTIVE_RESOLUTION_CHANGE   L"AdaptiveResolutionChange" // amf_bool; default = false; reuse allocated surfaces if new resolution is smaller
-#define AMF_VIDEO_DECODER_ALLOC_SIZE                   L"AllocSize"             // AMFSize; default (1920,1088); size of allocated surface if AdaptiveResolutionChange is true
-#define AMF_VIDEO_DECODER_CURRENT_SIZE                 L"CurrentSize"           // AMFSize; default = (0,0); current size of the video
-
-// reference frame management
-#define AMF_VIDEO_DECODER_REORDER_MODE                 L"ReorderMode"           // amf_int64(AMF_VIDEO_DECODER_MODE_ENUM); default = AMF_VIDEO_DECODER_MODE_REGULAR;  defines number of surfaces in DPB list.
-#define AMF_VIDEO_DECODER_SURFACE_POOL_SIZE            L"SurfacePoolSize"       // amf_int64; number of surfaces in the decode pool = DPB list size + number of surfaces for presentation
-#define AMF_VIDEO_DECODER_DPB_SIZE                     L"DPBSize"               // amf_int64; minimum number of surfaces for reordering
-
-#define AMF_VIDEO_DECODER_DEFAULT_SURFACES_FOR_TRANSIT  5                      // if AMF_VIDEO_DECODER_SURFACE_POOL_SIZE is 0 , AMF_VIDEO_DECODER_SURFACE_POOL_SIZE=AMF_VIDEO_DECODER_DEFAULT_SURFACES_FOR_TRANSIT+AMF_VIDEO_DECODER_DPB_SIZE
-
-// Decoder capabilities - exposed in AMFCaps interface
-#define AMF_VIDEO_DECODER_CAP_NUM_OF_STREAMS            L"NumOfStreams"               // amf_int64; maximum number of decode streams supported 
-
-
-// metadata information: can be set on output surface
-
-// Properties could be set on surface based on HDR SEI or VUI header
-#define AMF_VIDEO_DECODER_COLOR_TRANSFER_CHARACTERISTIC L"ColorTransferChar"    // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013   7.2
-#define AMF_VIDEO_DECODER_COLOR_PRIMARIES               L"ColorPrimaries"       // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013   7.1
-#define AMF_VIDEO_DECODER_HDR_METADATA                  L"HdrMetadata"          // AMFBuffer containing AMFHDRMetadata; default NULL
-
-/////// AMF_VIDEO_DECODER_FULL_RANGE_COLOR deprecated, use AMF_VIDEO_DECODER_COLOR_RANGE
-#define AMF_VIDEO_DECODER_FULL_RANGE_COLOR              L"FullRangeColor"       // bool; default = false; false =  studio range, true = full range 
-///////
-#define AMF_VIDEO_DECODER_COLOR_RANGE                   L"ColorRange"           // amf_int64(AMF_COLOR_RANGE_ENUM) default = AMF_COLOR_RANGE_UNDEFINED
-
-// can be set on output surface if YUV outout or on component to overwrite VUI
-#define AMF_VIDEO_DECODER_COLOR_PROFILE                 L"ColorProfile"         // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO
-
-// properties to be set on decoder if internal converter is used
-#define AMF_VIDEO_DECODER_OUTPUT_TRANSFER_CHARACTERISTIC        L"OutColorTransferChar"     // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013   7.2 See VideoDecoderUVD.h for enum 
-#define AMF_VIDEO_DECODER_OUTPUT_COLOR_PRIMARIES                L"OutputColorPrimaries"     // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013   7.1 See ColorSpace.h for enum 
-#define AMF_VIDEO_DECODER_OUTPUT_HDR_METADATA                   L"OutHDRMetadata"           // AMFBuffer containing AMFHDRMetadata; default NULL
-
-#define AMF_VIDEO_DECODER_LOW_LATENCY                           L"LowLatencyDecode"         // amf_bool; default = false; true = low latency decode, false = regular decode
-
-#if defined(__ANDROID__)
-#define AMF_VIDEO_DECODER_NATIVEWINDOW                  L"AndroidNativeWindow"  // amf_int64; default = 0; pointer to native window
-#endif //__ANDROID__
-
-
-#if defined(__APPLE__)
-#define AMF_VIDEO_DECODER_NATIVEWINDOW                  L"AppleNativeWindow"  // amf_int64; default = 0; pointer to native window
-#endif //__APPLE__
-
-#define AMF_VIDEO_DECODER_ENABLE_SMART_ACCESS_VIDEO             L"EnableDecoderSmartAccessVideo"     // amf_bool; default = false; true = enables smart access video feature
-#define AMF_VIDEO_DECODER_SKIP_TRANSFER_SMART_ACCESS_VIDEO      L"SkipTransferSmartAccessVideo"      // amf_bool; default = false; true = keeps output on GPU where it ran
-
-#endif //#ifndef AMF_VideoDecoderUVD_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoEncoderAV1.h

@@ -1,300 +0,0 @@
-//
-// Copyright (c) 2021-2022 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-//  VideoEncoderHW_AV1 interface declaration
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_VideoEncoderAV1_h
-#define AMF_VideoEncoderAV1_h
-#pragma once
-
-#include "Component.h"
-#include "ColorSpace.h"
-#include "PreAnalysis.h"
-
-#define AMFVideoEncoder_AV1 L"AMFVideoEncoderHW_AV1"
-
-enum AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE_NONE                    = 0,    // No encoding latency requirement. Encoder will balance encoding time and power consumption.
-    AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE_POWER_SAVING_REAL_TIME  = 1,    // Try the best to finish encoding a frame within 1/framerate sec. This mode may cause more power consumption
-    AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE_REAL_TIME               = 2,    // Try the best to finish encoding a frame within 1/(2 x framerate) sec. This mode will cause more power consumption than POWER_SAVING_REAL_TIME
-    AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE_LOWEST_LATENCY          = 3     // Encoding as fast as possible. This mode causes highest power consumption.
-};
-
-enum AMF_VIDEO_ENCODER_AV1_USAGE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_USAGE_TRANSCODING     = 0,
-    AMF_VIDEO_ENCODER_AV1_USAGE_LOW_LATENCY     = 1
-};
-
-enum AMF_VIDEO_ENCODER_AV1_PROFILE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN = 1
-};
-
-enum AMF_VIDEO_ENCODER_AV1_LEVEL_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_LEVEL_2_0 = 0,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_2_1 = 1,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_2_2 = 2,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_2_3 = 3,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_3_0 = 4,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_3_1 = 5,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_3_2 = 6,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_3_3 = 7,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_4_0 = 8,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_4_1 = 9,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_4_2 = 10,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_4_3 = 11,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_5_0 = 12,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_5_1 = 13,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_5_2 = 14,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_5_3 = 15,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_6_0 = 16,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_6_1 = 17,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_6_2 = 18,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_6_3 = 19,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_7_0 = 20,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_7_1 = 21,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_7_2 = 22,
-    AMF_VIDEO_ENCODER_AV1_LEVEL_7_3 = 23
-};
-
-enum AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_UNKNOWN                   = -1,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CONSTANT_QP               = 0,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_LATENCY_CONSTRAINED_VBR   = 1,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR      = 2,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CBR                       = 3,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_QUALITY_VBR               = 4,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_HIGH_QUALITY_VBR          = 5,
-    AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_HIGH_QUALITY_CBR          = 6
-};
-
-enum AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_ONLY               = 1,
-    AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_1080P_CODED_1082   = 2,
-    AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_NO_RESTRICTIONS          = 3
-};
-
-enum AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_NONE             = 0,
-    AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_KEY              = 1,
-    AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_INTRA_ONLY       = 2,
-    AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_SWITCH           = 3,
-    AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_SHOW_EXISTING    = 4
-};
-
-enum AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_KEY             = 0,
-    AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_INTRA_ONLY      = 1,
-    AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_INTER           = 2,
-    AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_SWITCH          = 3,
-    AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_SHOW_EXISTING   = 4
-};
-
-enum AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_HIGH_QUALITY   = 0,    
-    AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_QUALITY        = 30,    
-    AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_BALANCED       = 70,
-    AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_SPEED          = 100
-};
-
-enum AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_NONE                = 0,
-    AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_GOP_ALIGNED         = 1,
-    AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_KEY_FRAME_ALIGNED   = 2
-};
-
-enum AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE_NONE              = 0,
-    AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE_FIXED_INTERVAL    = 1
-};
-
-enum AMF_VIDEO_ENCODER_AV1_CDEF_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_CDEF_DISABLE          = 0,
-    AMF_VIDEO_ENCODER_AV1_CDEF_ENABLE_DEFAULT   = 1
-};
-
-enum AMF_VIDEO_ENCODER_AV1_CDF_FRAME_END_UPDATE_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_CDF_FRAME_END_UPDATE_MODE_DISABLE         = 0,
-    AMF_VIDEO_ENCODER_AV1_CDF_FRAME_END_UPDATE_MODE_ENABLE_DEFAULT  = 1
-};
-
-enum AMF_VIDEO_ENCODER_AV1_AQ_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_AQ_MODE_NONE = 0,
-    AMF_VIDEO_ENCODER_AV1_AQ_MODE_CAQ  = 1              // Content adaptive quantization mode
-};
-
-enum AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE__DISABLED = 0,
-    AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE__GOP_ALIGNED = 1,
-    AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE__CONTINUOUS = 2
-};
-enum AMF_VIDEO_ENCODER_AV1_LTR_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_AV1_LTR_MODE_RESET_UNUSED     = 0,
-    AMF_VIDEO_ENCODER_AV1_LTR_MODE_KEEP_UNUSED      = 1
-};
-
-
-// *** Static properties - can be set only before Init() *** 
-
-// Encoder Engine Settings
-#define AMF_VIDEO_ENCODER_AV1_ENCODER_INSTANCE_INDEX                L"Av1EncoderInstanceIndex"          // amf_int64; default = 0; selected HW instance idx. The number of instances is queried by using AMF_VIDEO_ENCODER_AV1_CAP_NUM_OF_HW_INSTANCES
-#define AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE                 L"Av1EncodingLatencyMode"           // amf_int64(AMF_VIDEO_ENCODER_AV1_ENCODING_LATENCY_MODE_ENUM); default = depends on USAGE; The encoding latency mode. 
-#define AMF_VIDEO_ENCODER_AV1_QUERY_TIMEOUT                         L"Av1QueryTimeout"                  // amf_int64; default = 0 (no wait); timeout for QueryOutput call in ms.
-
-// Usage Settings
-#define AMF_VIDEO_ENCODER_AV1_USAGE                                 L"Av1Usage"                         // amf_int64(AMF_VIDEO_ENCODER_AV1_USAGE_ENUM); default = N/A; Encoder usage. fully configures parameter set.
-
-// Session Configuration
-#define AMF_VIDEO_ENCODER_AV1_FRAMESIZE                             L"Av1FrameSize"                     // AMFSize; default = 0,0; Frame size
-#define AMF_VIDEO_ENCODER_AV1_COLOR_BIT_DEPTH                       L"Av1ColorBitDepth"                 // amf_int64(AMF_COLOR_BIT_DEPTH_ENUM); default = AMF_COLOR_BIT_DEPTH_8
-#define AMF_VIDEO_ENCODER_AV1_PROFILE                               L"Av1Profile"                       // amf_int64(AMF_VIDEO_ENCODER_AV1_PROFILE_ENUM) ; default = depends on USAGE; the codec profile of the coded bitstream
-#define AMF_VIDEO_ENCODER_AV1_LEVEL                                 L"Av1Level"                         // amf_int64 (AMF_VIDEO_ENCODER_AV1_LEVEL_ENUM); default = depends on USAGE; the codec level of the coded bitstream
-#define AMF_VIDEO_ENCODER_AV1_TILES_PER_FRAME                       L"Av1NumTilesPerFrame"              // amf_int64; default = 1; Number of tiles Per Frame. This is treated as suggestion. The actual number of tiles might be different due to compliance or encoder limitation.
-#define AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET                        L"Av1QualityPreset"                 // amf_int64(AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_ENUM); default = depends on USAGE; Quality Preset
-
-// Codec Configuration
-#define AMF_VIDEO_ENCODER_AV1_SCREEN_CONTENT_TOOLS                  L"Av1ScreenContentTools"            // bool; default = depends on USAGE; If true, allow enabling screen content tools by AMF_VIDEO_ENCODER_AV1_PALETTE_MODE and AMF_VIDEO_ENCODER_AV1_FORCE_INTEGER_MV; if false, all screen content tools are disabled.
-#define AMF_VIDEO_ENCODER_AV1_ORDER_HINT                            L"Av1OrderHint"                     // bool; default = depends on USAGE; If true, code order hint; if false, don't code order hint
-#define AMF_VIDEO_ENCODER_AV1_FRAME_ID                              L"Av1FrameId"                       // bool; default = depends on USAGE; If true, code frame id; if false, don't code frame id
-#define AMF_VIDEO_ENCODER_AV1_TILE_GROUP_OBU                        L"Av1TileGroupObu"                  // bool; default = depends on USAGE; If true, code FrameHeaderObu + TileGroupObu and each TileGroupObu contains one tile; if false, code FrameObu.
-#define AMF_VIDEO_ENCODER_AV1_CDEF_MODE                             L"Av1CdefMode"                      // amd_int64(AMF_VIDEO_ENCODER_AV1_CDEF_MODE_ENUM); default = depends on USAGE; Cdef mode
-#define AMF_VIDEO_ENCODER_AV1_ERROR_RESILIENT_MODE                  L"Av1ErrorResilientMode"            // bool; default = depends on USAGE; If true, enable error resilient mode; if false, disable error resilient mode
-
-// Rate Control and Quality Enhancement
-#define AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD                   L"Av1RateControlMethod"             // amf_int64(AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_ENUM); default = depends on USAGE; Rate Control Method
-#define AMF_VIDEO_ENCODER_AV1_QVBR_QUALITY_LEVEL                    L"Av1QvbrQualityLevel"              // amf_int64; default = 23; QVBR quality level; range = 1-51
-#define AMF_VIDEO_ENCODER_AV1_INITIAL_VBV_BUFFER_FULLNESS           L"Av1InitialVBVBufferFullness"      // amf_int64; default = depends on USAGE; Initial VBV Buffer Fullness 0=0% 64=100%
-
-// Alignment Mode Configuration
-#define AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE                        L"Av1AlignmentMode"                 // amf_int64(AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_ENUM); default = AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_ONLY; Alignment Mode.
-
-#define AMF_VIDEO_ENCODER_AV1_PRE_ANALYSIS_ENABLE                   L"Av1EnablePreAnalysis"             // bool; default = depends on USAGE; If true, enables the pre-analysis module. Refer to AMF Video PreAnalysis API reference for more details. If false, disable the pre-analysis module.
-#define AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_PREENCODE                L"Av1RateControlPreEncode"          // bool; default = depends on USAGE; If true, enables pre-encode assist in rate control; if false, disables pre-encode assist in rate control.
-#define AMF_VIDEO_ENCODER_AV1_HIGH_MOTION_QUALITY_BOOST             L"Av1HighMotionQualityBoost"        // bool; default = depends on USAGE; If true, enable high motion quality boost mode; if false, disable high motion quality boost mode.
-#define AMF_VIDEO_ENCODER_AV1_AQ_MODE                               L"Av1AQMode"                        // amd_int64(AMF_VIDEO_ENCODER_AV1_AQ_MODE_ENUM); default = depends on USAGE; AQ mode
-
-// Picture Management Configuration
-#define AMF_VIDEO_ENCODER_AV1_MAX_NUM_TEMPORAL_LAYERS               L"Av1MaxNumOfTemporalLayers"        // amf_int64; default = depends on USAGE; Max number of temporal layers might be enabled. The maximum value can be queried from AMF_VIDEO_ENCODER_AV1_CAP_MAX_NUM_TEMPORAL_LAYERS
-#define AMF_VIDEO_ENCODER_AV1_MAX_LTR_FRAMES                        L"Av1MaxNumLTRFrames"               // amf_int64; default = depends on USAGE; Max number of LTR frames. The maximum value can be queried from AMF_VIDEO_ENCODER_AV1_CAP_MAX_NUM_LTR_FRAMES
-#define AMF_VIDEO_ENCODER_AV1_LTR_MODE                              L"Av1LTRMode"                       // amf_int64(AMF_VIDEO_ENCODER_AV1_LTR_MODE_ENUM); default = AMF_VIDEO_ENCODER_AV1_LTR_MODE_RESET_UNUSED; remove/keep unused LTRs (not specified in property AMF_VIDEO_ENCODER_AV1_FORCE_LTR_REFERENCE_BITFIELD)
-#define AMF_VIDEO_ENCODER_AV1_MAX_NUM_REFRAMES                      L"Av1MaxNumRefFrames"               // amf_int64; default = 1; Maximum number of reference frames
-
-// color conversion
-#define AMF_VIDEO_ENCODER_AV1_INPUT_HDR_METADATA                    L"Av1InHDRMetadata"                 // AMFBuffer containing AMFHDRMetadata; default NULL
-
-// Miscellaneous
-#define AMF_VIDEO_ENCODER_AV1_EXTRA_DATA                            L"Av1ExtraData"                     // AMFInterface* - > AMFBuffer*; buffer to retrieve coded sequence header
-
-
-// *** Dynamic properties - can be set anytime *** 
-
-// Codec Configuration
-#define AMF_VIDEO_ENCODER_AV1_PALETTE_MODE                          L"Av1PaletteMode"                   // bool; default = depends on USAGE; If true, enable palette mode; if false, disable palette mode. Valid only when AMF_VIDEO_ENCODER_AV1_SCREEN_CONTENT_TOOLS is true.
-#define AMF_VIDEO_ENCODER_AV1_FORCE_INTEGER_MV                      L"Av1ForceIntegerMv"                // bool; default = depends on USAGE; If true, enable force integer MV; if false, disable force integer MV. Valid only when AMF_VIDEO_ENCODER_AV1_SCREEN_CONTENT_TOOLS is true.
-#define AMF_VIDEO_ENCODER_AV1_CDF_UPDATE                            L"Av1CdfUpdate"                     // bool; default = depends on USAGE; If true, enable CDF update; if false, disable CDF update.
-#define AMF_VIDEO_ENCODER_AV1_CDF_FRAME_END_UPDATE_MODE             L"Av1CdfFrameEndUpdateMode"         // amd_int64(AMF_VIDEO_ENCODER_AV1_CDF_FRAME_END_UPDATE_MODE_ENUM); default = depends on USAGE; CDF frame end update mode
-
-
-// Rate Control and Quality Enhancement
-#define AMF_VIDEO_ENCODER_AV1_VBV_BUFFER_SIZE                       L"Av1VBVBufferSize"                 // amf_int64; default = depends on USAGE; VBV Buffer Size in bits
-#define AMF_VIDEO_ENCODER_AV1_FRAMERATE                             L"Av1FrameRate"                     // AMFRate; default = depends on usage; Frame Rate
-#define AMF_VIDEO_ENCODER_AV1_ENFORCE_HRD                           L"Av1EnforceHRD"                    // bool; default = depends on USAGE; If true, enforce HRD; if false, HRD is not enforced.
-#define AMF_VIDEO_ENCODER_AV1_FILLER_DATA                           L"Av1FillerData"                    // bool; default = depends on USAGE; If true, code filler data when needed; if false, don't code filler data.
-#define AMF_VIDEO_ENCODER_AV1_TARGET_BITRATE                        L"Av1TargetBitrate"                 // amf_int64; default = depends on USAGE; Target bit rate in bits
-#define AMF_VIDEO_ENCODER_AV1_PEAK_BITRATE                          L"Av1PeakBitrate"                   // amf_int64; default = depends on USAGE; Peak bit rate in bits
-
-#define AMF_VIDEO_ENCODER_AV1_MAX_COMPRESSED_FRAME_SIZE             L"Av1MaxCompressedFrameSize"        // amf_int64; default = 0; Max compressed frame Size in bits. 0 - no limit
-#define AMF_VIDEO_ENCODER_AV1_MIN_Q_INDEX_INTRA                     L"Av1MinQIndex_Intra"               // amf_int64; default = depends on USAGE; Min QIndex for intra frames; range = 0-255
-#define AMF_VIDEO_ENCODER_AV1_MAX_Q_INDEX_INTRA                     L"Av1MaxQIndex_Intra"               // amf_int64; default = depends on USAGE; Max QIndex for intra frames; range = 0-255
-#define AMF_VIDEO_ENCODER_AV1_MIN_Q_INDEX_INTER                     L"Av1MinQIndex_Inter"               // amf_int64; default = depends on USAGE; Min QIndex for inter frames; range = 0-255
-#define AMF_VIDEO_ENCODER_AV1_MAX_Q_INDEX_INTER                     L"Av1MaxQIndex_Inter"               // amf_int64; default = depends on USAGE; Max QIndex for inter frames; range = 0-255
-
-#define AMF_VIDEO_ENCODER_AV1_Q_INDEX_INTRA                         L"Av1QIndex_Intra"                  // amf_int64; default = depends on USAGE; intra-frame QIndex; range = 0-255
-#define AMF_VIDEO_ENCODER_AV1_Q_INDEX_INTER                         L"Av1QIndex_Inter"                  // amf_int64; default = depends on USAGE; inter-frame QIndex; range = 0-255
-
-#define AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_SKIP_FRAME               L"Av1RateControlSkipFrameEnable"    // bool; default = depends on USAGE; If true, rate control may code skip frame when needed; if false, rate control will not code skip frame.
-
-
-// Picture Management Configuration
-#define AMF_VIDEO_ENCODER_AV1_GOP_SIZE                              L"Av1GOPSize"                       // amf_int64; default = depends on USAGE; GOP Size (distance between automatically inserted key frames). If 0, key frame will be inserted at first frame only. Note that GOP may be interrupted by AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE.
-#define AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE                 L"Av1HeaderInsertionMode"           // amf_int64(AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_ENUM); default = depends on USAGE; sequence header insertion mode
-#define AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE           L"Av1SwitchFrameInsertionMode"      // amf_int64(AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE_ENUM); default = depends on USAGE; switch frame insertin mode
-#define AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INTERVAL                 L"Av1SwitchFrameInterval"           // amf_int64; default = depends on USAGE; the interval between two inserted switch frames. Valid only when AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE is AMF_VIDEO_ENCODER_AV1_SWITCH_FRAME_INSERTION_MODE_FIXED_INTERVAL.
-#define AMF_VIDEO_ENCODER_AV1_NUM_TEMPORAL_LAYERS                   L"Av1NumTemporalLayers"             // amf_int64; default = depends on USAGE; Number of temporal layers. Can be changed at any time but the change is only applied when encoding next base layer frame.
-
-#define AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE					L"Av1IntraRefreshMode"              // amf_int64(AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE_ENUM); default AMF_VIDEO_ENCODER_AV1_INTRA_REFRESH_MODE__DISABLED
-#define AMF_VIDEO_ENCODER_AV1_INTRAREFRESH_STRIPES					L"Av1IntraRefreshNumOfStripes"      // amf_int64; default = N/A; Valid only when intra refresh is enabled.
-
-// color conversion
-#define AMF_VIDEO_ENCODER_AV1_INPUT_COLOR_PROFILE                   L"Av1InputColorProfile"             // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO by size
-#define AMF_VIDEO_ENCODER_AV1_INPUT_TRANSFER_CHARACTERISTIC         L"Av1InputColorTransferChar"        // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 section 7.2 See VideoDecoderUVD.h for enum
-#define AMF_VIDEO_ENCODER_AV1_INPUT_COLOR_PRIMARIES                 L"Av1InputColorPrimaries"           // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 section 7.1 See ColorSpace.h for enum
-
-#define AMF_VIDEO_ENCODER_AV1_OUTPUT_COLOR_PROFILE                  L"Av1OutputColorProfile"            // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO by size
-#define AMF_VIDEO_ENCODER_AV1_OUTPUT_TRANSFER_CHARACTERISTIC        L"Av1OutputColorTransferChar"       // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 ?7.2 See VideoDecoderUVD.h for enum
-#define AMF_VIDEO_ENCODER_AV1_OUTPUT_COLOR_PRIMARIES                L"Av1OutputColorPrimaries"          // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 section 7.1 See ColorSpace.h for enum
-
-
-// Frame encode parameters
-#define AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE                      L"Av1ForceFrameType"                // amf_int64(AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_ENUM); default = AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_NONE; generate particular frame type
-#define AMF_VIDEO_ENCODER_AV1_FORCE_INSERT_SEQUENCE_HEADER          L"Av1ForceInsertSequenceHeader"     // bool; default = false; If true, force insert sequence header with current frame;
-#define AMF_VIDEO_ENCODER_AV1_MARK_CURRENT_WITH_LTR_INDEX           L"Av1MarkCurrentWithLTRIndex"       // amf_int64; default = N/A; Mark current frame with LTR index
-#define AMF_VIDEO_ENCODER_AV1_FORCE_LTR_REFERENCE_BITFIELD          L"Av1ForceLTRReferenceBitfield"     // amf_int64; default = 0; force LTR bit-field
-#define AMF_VIDEO_ENCODER_AV1_ROI_DATA                              L"Av1ROIData"					    // 2D AMFSurface, surface format: AMF_SURFACE_GRAY32
-
-// Encode output parameters
-#define AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE                     L"Av1OutputFrameType"               // amf_int64(AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_ENUM); default = N/A
-#define AMF_VIDEO_ENCODER_AV1_OUTPUT_MARKED_LTR_INDEX               L"Av1MarkedLTRIndex"                // amf_int64; default = N/A; Marked LTR index
-#define AMF_VIDEO_ENCODER_AV1_OUTPUT_REFERENCED_LTR_INDEX_BITFIELD  L"Av1ReferencedLTRIndexBitfield"    // amf_int64; default = N/A; referenced LTR bit-field
-
-// AV1 Encoder capabilities - exposed in AMFCaps interface
-#define AMF_VIDEO_ENCODER_AV1_CAP_NUM_OF_HW_INSTANCES               L"Av1CapNumOfHwInstances"           // amf_int64; default = N/A; number of HW encoder instances
-#define AMF_VIDEO_ENCODER_AV1_CAP_MAX_THROUGHPUT                    L"Av1CapMaxThroughput"              // amf_int64; default = N/A; MAX throughput for AV1 encoder in MB (16 x 16 pixel)
-#define AMF_VIDEO_ENCODER_AV1_CAP_REQUESTED_THROUGHPUT              L"Av1CapRequestedThroughput"        // amf_int64; default = N/A; Currently total requested throughput for AV1 encode in MB (16 x 16 pixel)
-#define AMF_VIDEO_ENCODER_AV1_CAP_COLOR_CONVERSION                  L"Av1CapColorConversion"            // amf_int64(AMF_ACCELERATION_TYPE); default = N/A; type of supported color conversion. default AMF_ACCEL_GPU
-#define AMF_VIDEO_ENCODER_AV1_CAP_PRE_ANALYSIS                      L"Av1PreAnalysis"                    // amf_bool - pre analysis module is available for AV1 UVE encoder, n/a for the other encoders
-#define AMF_VIDEO_ENCODER_AV1_CAP_MAX_BITRATE                       L"Av1MaxBitrate"                    // amf_int64; default = N/A; Maximum bit rate in bits
-#define AMF_VIDEO_ENCODER_AV1_CAP_MAX_PROFILE                       L"Av1MaxProfile"                    // amf_int64(AMF_VIDEO_ENCODER_AV1_PROFILE_ENUM); default = N/A; max value of code profile
-#define AMF_VIDEO_ENCODER_AV1_CAP_MAX_LEVEL                         L"Av1MaxLevel"                      // amf_int64(AMF_VIDEO_ENCODER_AV1_LEVEL_ENUM); default = N/A; max value of codec level
-#define AMF_VIDEO_ENCODER_AV1_CAP_MAX_NUM_TEMPORAL_LAYERS           L"Av1CapMaxNumTemporalLayers"       // amf_int64; default = N/A; The cap of maximum number of temporal layers
-#define AMF_VIDEO_ENCODER_AV1_CAP_MAX_NUM_LTR_FRAMES                L"Av1CapMaxNumLTRFrames"            // amf_int64; default = N/A; The cap of maximum number of LTR frames. This value is calculated based on current value of AMF_VIDEO_ENCODER_AV1_MAX_NUM_TEMPORAL_LAYERS.
-
-#define AMF_VIDEO_ENCODER_AV1_ENABLE_SMART_ACCESS_VIDEO             L"Av1EnableEncoderSmartAccessVideo" // amf_bool; default = false; true = enables smart access video feature
-
-#endif //#ifndef AMF_VideoEncoderAV1_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoEncoderHEVC.h

@@ -1,307 +0,0 @@
-//
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-//  VideoEncoderHW_HEVC interface declaration
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_VideoEncoderHEVC_h
-#define AMF_VideoEncoderHEVC_h
-#pragma once
-
-#include "Component.h"
-#include "ColorSpace.h"
-#include "PreAnalysis.h"
-
-#define AMFVideoEncoder_HEVC L"AMFVideoEncoderHW_HEVC"
-
-enum AMF_VIDEO_ENCODER_HEVC_USAGE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_USAGE_TRANSCONDING = 0, // kept for backwards compatability
-    AMF_VIDEO_ENCODER_HEVC_USAGE_TRANSCODING = 0, // fixed typo
-    AMF_VIDEO_ENCODER_HEVC_USAGE_ULTRA_LOW_LATENCY,
-    AMF_VIDEO_ENCODER_HEVC_USAGE_LOW_LATENCY,
-    AMF_VIDEO_ENCODER_HEVC_USAGE_WEBCAM,
-    AMF_VIDEO_ENCODER_HEVC_USAGE_HIGH_QUALITY,
-    AMF_VIDEO_ENCODER_HEVC_USAGE_LOW_LATENCY_HIGH_QUALITY
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_PROFILE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_PROFILE_MAIN = 1,
-    AMF_VIDEO_ENCODER_HEVC_PROFILE_MAIN_10 = 2
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_TIER_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_TIER_MAIN    = 0,
-    AMF_VIDEO_ENCODER_HEVC_TIER_HIGH    = 1
-};
-
-enum AMF_VIDEO_ENCODER_LEVEL_ENUM
-{
-    AMF_LEVEL_1     = 30,
-    AMF_LEVEL_2     = 60,
-    AMF_LEVEL_2_1   = 63,
-    AMF_LEVEL_3     = 90,
-    AMF_LEVEL_3_1   = 93,
-    AMF_LEVEL_4     = 120,
-    AMF_LEVEL_4_1   = 123,
-    AMF_LEVEL_5     = 150,
-    AMF_LEVEL_5_1   = 153,
-    AMF_LEVEL_5_2   = 156,
-    AMF_LEVEL_6     = 180,
-    AMF_LEVEL_6_1   = 183,
-    AMF_LEVEL_6_2   = 186
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_UNKNOWN = -1,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_CONSTANT_QP = 0,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_LATENCY_CONSTRAINED_VBR,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_CBR,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_QUALITY_VBR,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_HIGH_QUALITY_VBR,
-    AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_HIGH_QUALITY_CBR
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_NONE = 0,
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_SKIP,
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_IDR,
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_I,
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_P
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE_IDR,
-    AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE_I,
-    AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE_P
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET_QUALITY    = 0,
-    AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET_BALANCED   = 5,
-    AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET_SPEED      = 10
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_HEADER_INSERTION_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_HEADER_INSERTION_MODE_NONE = 0,
-    AMF_VIDEO_ENCODER_HEVC_HEADER_INSERTION_MODE_GOP_ALIGNED,
-    AMF_VIDEO_ENCODER_HEVC_HEADER_INSERTION_MODE_IDR_ALIGNED
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_PICTURE_TRANSFER_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TRANSFER_MODE_OFF = 0,
-    AMF_VIDEO_ENCODER_HEVC_PICTURE_TRANSFER_MODE_ON
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_NOMINAL_RANGE
-{
-    AMF_VIDEO_ENCODER_HEVC_NOMINAL_RANGE_STUDIO = 0,
-    AMF_VIDEO_ENCODER_HEVC_NOMINAL_RANGE_FULL   = 1
-};
-
-enum AMF_VIDEO_ENCODER_HEVC_LTR_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_HEVC_LTR_MODE_RESET_UNUSED    = 0,
-    AMF_VIDEO_ENCODER_HEVC_LTR_MODE_KEEP_UNUSED
-};
-
-// Static properties - can be set before Init()
-#define AMF_VIDEO_ENCODER_HEVC_INSTANCE_INDEX                       L"HevcEncoderInstance"          // amf_int64; selected instance idx
-#define AMF_VIDEO_ENCODER_HEVC_FRAMESIZE                            L"HevcFrameSize"                // AMFSize; default = 0,0; Frame size
-
-#define AMF_VIDEO_ENCODER_HEVC_USAGE                                L"HevcUsage"                    // amf_int64(AMF_VIDEO_ENCODER_HEVC_USAGE_ENUM); default = N/A; Encoder usage type. fully configures parameter set.
-#define AMF_VIDEO_ENCODER_HEVC_PROFILE                              L"HevcProfile"                  // amf_int64(AMF_VIDEO_ENCODER_HEVC_PROFILE_ENUM) ; default = AMF_VIDEO_ENCODER_HEVC_PROFILE_MAIN;
-#define AMF_VIDEO_ENCODER_HEVC_TIER                                 L"HevcTier"                     // amf_int64(AMF_VIDEO_ENCODER_HEVC_TIER_ENUM) ; default = AMF_VIDEO_ENCODER_HEVC_TIER_MAIN;
-#define AMF_VIDEO_ENCODER_HEVC_PROFILE_LEVEL                        L"HevcProfileLevel"             // amf_int64 (AMF_VIDEO_ENCODER_LEVEL_ENUM, default depends on HW capabilities);
-#define AMF_VIDEO_ENCODER_HEVC_MAX_LTR_FRAMES                       L"HevcMaxOfLTRFrames"           // amf_int64; default = 0; Max number of LTR frames
-#define AMF_VIDEO_ENCODER_HEVC_LTR_MODE                             L"HevcLTRMode"                  // amf_int64(AMF_VIDEO_ENCODER_HEVC_LTR_MODE_ENUM); default = AMF_VIDEO_ENCODER_HEVC_LTR_MODE_RESET_UNUSED; remove/keep unused LTRs (not specified in property AMF_VIDEO_ENCODER_HEVC_FORCE_LTR_REFERENCE_BITFIELD)
-#define AMF_VIDEO_ENCODER_HEVC_MAX_NUM_REFRAMES                     L"HevcMaxNumRefFrames"          // amf_int64; default = 1; Maximum number of reference frames
-#define AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET                       L"HevcQualityPreset"            // amf_int64(AMF_VIDEO_ENCODER_HEVC_QUALITY_PRESET_ENUM); default = depends on USAGE; Quality Preset
-#define AMF_VIDEO_ENCODER_HEVC_EXTRADATA                            L"HevcExtraData"                // AMFInterface* - > AMFBuffer*; SPS/PPS buffer - read-only
-#define AMF_VIDEO_ENCODER_HEVC_ASPECT_RATIO                         L"HevcAspectRatio"              // AMFRatio; default = 1, 1
-#define AMF_VIDEO_ENCODER_HEVC_LOWLATENCY_MODE                      L"LowLatencyInternal"           // bool; default = false, enables low latency mode
-#define AMF_VIDEO_ENCODER_HEVC_PRE_ANALYSIS_ENABLE                  L"HevcEnablePreAnalysis"        // bool; default = false; enables the pre-analysis module. Currently only works in AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR mode. Refer to AMF Video PreAnalysis API reference for more details.
-#define AMF_VIDEO_ENCODER_HEVC_NOMINAL_RANGE                        L"HevcNominalRange"				// amf_int64(AMF_VIDEO_ENCODER_HEVC_NOMINAL_RANGE); default = amf_int64(AMF_VIDEO_ENCODER_HEVC_NOMINAL_RANGE_STUDIO); property is bool but amf_int64 also works for backward compatibility.
-#define AMF_VIDEO_ENCODER_HEVC_MAX_NUM_TEMPORAL_LAYERS              L"HevcMaxNumOfTemporalLayers"   // amf_int64; default = 1; Max number of temporal layers.
-
-// Picture control properties
-#define AMF_VIDEO_ENCODER_HEVC_NUM_GOPS_PER_IDR                     L"HevcGOPSPerIDR"               // amf_int64; default = 1; The frequency to insert IDR as start of a GOP. 0 means no IDR will be inserted.
-#define AMF_VIDEO_ENCODER_HEVC_GOP_SIZE                             L"HevcGOPSize"                  // amf_int64; default = 60; GOP Size, in frames
-#define AMF_VIDEO_ENCODER_HEVC_DE_BLOCKING_FILTER_DISABLE           L"HevcDeBlockingFilter"         // bool; default = depends on USAGE; De-blocking Filter
-#define AMF_VIDEO_ENCODER_HEVC_SLICES_PER_FRAME                     L"HevcSlicesPerFrame"           // amf_int64; default = 1; Number of slices Per Frame
-#define AMF_VIDEO_ENCODER_HEVC_HEADER_INSERTION_MODE                L"HevcHeaderInsertionMode"      // amf_int64(AMF_VIDEO_ENCODER_HEVC_HEADER_INSERTION_MODE_ENUM); default = NONE
-#define AMF_VIDEO_ENCODER_HEVC_INTRA_REFRESH_NUM_CTBS_PER_SLOT      L"HevcIntraRefreshCTBsNumberPerSlot" // amf_int64; default = depends on USAGE; Intra Refresh CTBs Number Per Slot in 64x64 CTB
-
-// Rate control properties
-#define AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD                  L"HevcRateControlMethod"        // amf_int64(AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_METHOD_ENUM); default = depends on USAGE; Rate Control Method
-#define AMF_VIDEO_ENCODER_HEVC_QVBR_QUALITY_LEVEL                   L"HevcQvbrQualityLevel"         // amf_int64; default = 23; QVBR quality level; range = 1-51
-#define AMF_VIDEO_ENCODER_HEVC_VBV_BUFFER_SIZE                      L"HevcVBVBufferSize"            // amf_int64; default = depends on USAGE; VBV Buffer Size in bits
-#define AMF_VIDEO_ENCODER_HEVC_INITIAL_VBV_BUFFER_FULLNESS          L"HevcInitialVBVBufferFullness" // amf_int64; default =  64; Initial VBV Buffer Fullness 0=0% 64=100%
-#define AMF_VIDEO_ENCODER_HEVC_ENABLE_VBAQ                          L"HevcEnableVBAQ"               // // bool; default = depends on USAGE; Enable auto VBAQ
-#define AMF_VIDEO_ENCODER_HEVC_HIGH_MOTION_QUALITY_BOOST_ENABLE     L"HevcHighMotionQualityBoostEnable"// bool; default = depends on USAGE; Enable High motion quality boost mode
-
-#define AMF_VIDEO_ENCODER_HEVC_PREENCODE_ENABLE                     L"HevcRateControlPreAnalysisEnable"  // bool; default =  depends on USAGE; enables pre-encode assisted rate control
-#define AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_PREANALYSIS_ENABLE      L"HevcRateControlPreAnalysisEnable"  // bool; default =  depends on USAGE; enables pre-encode assisted rate control. Deprecated, please use AMF_VIDEO_ENCODER_PREENCODE_ENABLE instead.
-#ifdef _MSC_VER
-    #ifndef __clang__
-        #pragma deprecated("AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_PREANALYSIS_ENABLE")
-    #endif
-#endif
-
-// Motion estimation
-#define AMF_VIDEO_ENCODER_HEVC_MOTION_HALF_PIXEL                    L"HevcHalfPixel"                // bool; default= true; Half Pixel
-#define AMF_VIDEO_ENCODER_HEVC_MOTION_QUARTERPIXEL                  L"HevcQuarterPixel"             // bool; default= true; Quarter Pixel
-
-// color conversion
-#define AMF_VIDEO_ENCODER_HEVC_COLOR_BIT_DEPTH                      L"HevcColorBitDepth"            // amf_int64(AMF_COLOR_BIT_DEPTH_ENUM); default = AMF_COLOR_BIT_DEPTH_8
-
-#define AMF_VIDEO_ENCODER_HEVC_INPUT_COLOR_PROFILE                  L"HevcInColorProfile"           // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO by size
-#define AMF_VIDEO_ENCODER_HEVC_INPUT_TRANSFER_CHARACTERISTIC        L"HevcInColorTransferChar"      // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 section 7.2 See VideoDecoderUVD.h for enum
-#define AMF_VIDEO_ENCODER_HEVC_INPUT_COLOR_PRIMARIES                L"HevcInColorPrimaries"         // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 section 7.1 See ColorSpace.h for enum
-
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_COLOR_PROFILE                 L"HevcOutColorProfile"          // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO by size
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_TRANSFER_CHARACTERISTIC       L"HevcOutColorTransferChar"     // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 ?7.2 See VideoDecoderUVD.h for enum
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_COLOR_PRIMARIES               L"HevcOutColorPrimaries"        // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 section 7.1 See ColorSpace.h for enum
-
-// Dynamic properties - can be set at any time
-
-// Rate control properties
-#define AMF_VIDEO_ENCODER_HEVC_FRAMERATE                            L"HevcFrameRate"                // AMFRate; default = depends on usage; Frame Rate
-
-#define AMF_VIDEO_ENCODER_HEVC_ENFORCE_HRD                          L"HevcEnforceHRD"               // bool; default = depends on USAGE; Enforce HRD
-#define AMF_VIDEO_ENCODER_HEVC_FILLER_DATA_ENABLE                   L"HevcFillerDataEnable"         // bool; default = depends on USAGE; Enforce HRD
-#define AMF_VIDEO_ENCODER_HEVC_TARGET_BITRATE                       L"HevcTargetBitrate"            // amf_int64; default = depends on USAGE; Target bit rate in bits
-#define AMF_VIDEO_ENCODER_HEVC_PEAK_BITRATE                         L"HevcPeakBitrate"              // amf_int64; default = depends on USAGE; Peak bit rate in bits
-
-#define AMF_VIDEO_ENCODER_HEVC_MAX_AU_SIZE                          L"HevcMaxAUSize"                // amf_int64; default = 60; Max AU Size in bits
-
-#define AMF_VIDEO_ENCODER_HEVC_MIN_QP_I                             L"HevcMinQP_I"                  // amf_int64; default = depends on USAGE; Min QP; range =
-#define AMF_VIDEO_ENCODER_HEVC_MAX_QP_I                             L"HevcMaxQP_I"                  // amf_int64; default = depends on USAGE; Max QP; range =
-#define AMF_VIDEO_ENCODER_HEVC_MIN_QP_P                             L"HevcMinQP_P"                  // amf_int64; default = depends on USAGE; Min QP; range =
-#define AMF_VIDEO_ENCODER_HEVC_MAX_QP_P                             L"HevcMaxQP_P"                  // amf_int64; default = depends on USAGE; Max QP; range =
-
-#define AMF_VIDEO_ENCODER_HEVC_QP_I                                 L"HevcQP_I"                     // amf_int64; default = 26; P-frame QP; range = 0-51
-#define AMF_VIDEO_ENCODER_HEVC_QP_P                                 L"HevcQP_P"                     // amf_int64; default = 26; P-frame QP; range = 0-51
-
-#define AMF_VIDEO_ENCODER_HEVC_RATE_CONTROL_SKIP_FRAME_ENABLE       L"HevcRateControlSkipFrameEnable" // bool; default =  depends on USAGE; Rate Control Based Frame Skip
-
-// color conversion
-#define AMF_VIDEO_ENCODER_HEVC_INPUT_HDR_METADATA                   L"HevcInHDRMetadata"            // AMFBuffer containing AMFHDRMetadata; default NULL
-//#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_HDR_METADATA                  L"HevcOutHDRMetadata"            // AMFBuffer containing AMFHDRMetadata; default NULL
-
-// SVC
-#define AMF_VIDEO_ENCODER_HEVC_NUM_TEMPORAL_LAYERS                  L"HevcNumOfTemporalLayers"      // amf_int64; default = 1; Number of temporal layers. Can be changed at any time but the change is only applied when encoding next base layer frame.
-
-// DPB management
-#define AMF_VIDEO_ENCODER_HEVC_PICTURE_TRANSFER_MODE                L"HevcPicTransferMode"          // amf_int64(AMF_VIDEO_ENCODER_HEVC_PICTURE_TRANSFER_MODE_ENUM); default = AMF_VIDEO_ENCODER_HEVC_PICTURE_TRANSFER_MODE_OFF - whether to exchange reference/reconstructed pic between encoder and application
-
-// misc
-#define AMF_VIDEO_ENCODER_HEVC_QUERY_TIMEOUT                        L"HevcQueryTimeout"             // amf_int64; default = 0 (no wait); timeout for QueryOutput call in ms.
-
-// Per-submittion properties - can be set on input surface interface
-#define AMF_VIDEO_ENCODER_HEVC_END_OF_SEQUENCE                      L"HevcEndOfSequence"            // bool; default = false; generate end of sequence
-#define AMF_VIDEO_ENCODER_HEVC_FORCE_PICTURE_TYPE                   L"HevcForcePictureType"         // amf_int64(AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_ENUM); default = AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_NONE; generate particular picture type
-#define AMF_VIDEO_ENCODER_HEVC_INSERT_AUD                           L"HevcInsertAUD"                // bool; default = false; insert AUD
-#define AMF_VIDEO_ENCODER_HEVC_INSERT_HEADER                        L"HevcInsertHeader"             // bool; default = false; insert header(SPS, PPS, VPS)
-
-#define AMF_VIDEO_ENCODER_HEVC_MARK_CURRENT_WITH_LTR_INDEX          L"HevcMarkCurrentWithLTRIndex"  // amf_int64; default = N/A; Mark current frame with LTR index
-#define AMF_VIDEO_ENCODER_HEVC_FORCE_LTR_REFERENCE_BITFIELD         L"HevcForceLTRReferenceBitfield"// amf_int64; default = 0; force LTR bit-field
-#define AMF_VIDEO_ENCODER_HEVC_ROI_DATA                             L"HevcROIData"					// 2D AMFSurface, surface format: AMF_SURFACE_GRAY32
-#define AMF_VIDEO_ENCODER_HEVC_REFERENCE_PICTURE                    L"HevcReferencePicture"         // AMFInterface(AMFSurface); surface used for frame injection
-#define AMF_VIDEO_ENCODER_HEVC_PSNR_FEEDBACK                        L"HevcPSNRFeedback"             // amf_bool; default = false; Signal encoder to calculate PSNR score
-#define AMF_VIDEO_ENCODER_HEVC_SSIM_FEEDBACK                        L"HevcSSIMFeedback"             // amf_bool; default = false; Signal encoder to calculate SSIM score
-#define AMF_VIDEO_ENCODER_HEVC_STATISTICS_FEEDBACK                  L"HevcStatisticsFeedback"       // amf_bool; default = false; Signal encoder to collect and feedback encoder statistics
-#define AMF_VIDEO_ENCODER_HEVC_BLOCK_QP_FEEDBACK                    L"HevcBlockQpFeedback"          // amf_bool; default = false; Signal encoder to collect and feedback block level QP values
-
-// Properties set by encoder on output buffer interface
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE                     L"HevcOutputDataType"           // amf_int64(AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE_ENUM); default = N/A
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_MARKED_LTR_INDEX              L"HevcMarkedLTRIndex"           // amf_int64; default = -1; Marked LTR index
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_REFERENCED_LTR_INDEX_BITFIELD L"HevcReferencedLTRIndexBitfield"// amf_int64; default = 0; referenced LTR bit-field
-#define AMF_VIDEO_ENCODER_HEVC_OUTPUT_TEMPORAL_LAYER                L"HevcOutputTemporalLayer"      // amf_int64; Temporal layer
-#define AMF_VIDEO_ENCODER_HEVC_RECONSTRUCTED_PICTURE                L"HevcReconstructedPicture"     // AMFInterface(AMFSurface); returns reconstructed picture as an AMFSurface attached to the output buffer as property AMF_VIDEO_ENCODER_RECONSTRUCTED_PICTURE of AMFInterface type
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PSNR_Y                     L"PSNRY"                        // double; PSNR Y
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PSNR_U                     L"PSNRU"                        // double; PSNR U
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PSNR_V                     L"PSNRV"                        // double; PSNR V
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PSNR_ALL                   L"PSNRALL"                      // double; PSNR All
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SSIM_Y                     L"SSIMY"                        // double; SSIM Y
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SSIM_U                     L"SSIMU"                        // double; SSIM U
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SSIM_V                     L"SSIMV"                        // double; SSIM V
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SSIM_ALL                   L"SSIMALL"                      // double; SSIM ALL
-
-    // Encoder statistics feedback
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_FRAME_QP                   L"HevcStatisticsFeedbackFrameQP"                // amf_int64; Rate control base frame/initial QP
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_AVERAGE_QP                 L"HevcStatisticsFeedbackAvgQP"                  // amf_int64; Average QP of all encoded CTBs in a picture. Value may be different from the one reported by bitstream analyzer when there are skipped CTBs.
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_MAX_QP                     L"HevcStatisticsFeedbackMaxQP"                  // amf_int64; Max QP among all encoded CTBs in a picture. Value may be different from the one reported by bitstream analyzer when there are skipped CTBs.
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_MIN_QP                     L"HevcStatisticsFeedbackMinQP"                  // amf_int64; Min QP among all encoded CTBs in a picture. Value may be different from the one reported by bitstream analyzer when there are skipped CTBs.
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PIX_NUM_INTRA              L"HevcStatisticsFeedbackPixNumIntra"            // amf_int64; Number of the intra encoded pixels
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PIX_NUM_INTER              L"HevcStatisticsFeedbackPixNumInter"            // amf_int64; Number of the inter encoded pixels
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_PIX_NUM_SKIP               L"HevcStatisticsFeedbackPixNumSkip"             // amf_int64; Number of the skip mode pixels
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_BITCOUNT_RESIDUAL          L"HevcStatisticsFeedbackBitcountResidual"       // amf_int64; The bit count that corresponds to residual data
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_BITCOUNT_MOTION            L"HevcStatisticsFeedbackBitcountMotion"         // amf_int64; The bit count that corresponds to motion vectors
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_BITCOUNT_INTER             L"HevcStatisticsFeedbackBitcountInter"          // amf_int64; The bit count that are assigned to inter CTBs
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_BITCOUNT_INTRA             L"HevcStatisticsFeedbackBitcountIntra"          // amf_int64; The bit count that are assigned to intra CTBs
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_BITCOUNT_ALL_MINUS_HEADER  L"HevcStatisticsFeedbackBitcountAllMinusHeader" // amf_int64; The bit count of the bitstream excluding header
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_MV_X                       L"HevcStatisticsFeedbackMvX"                    // amf_int64; Accumulated absolute values of horizontal MV's
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_MV_Y                       L"HevcStatisticsFeedbackMvY"                    // amf_int64; Accumulated absolute values of vertical MV's
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_RD_COST_FINAL              L"HevcStatisticsFeedbackRdCostFinal"            // amf_int64; Frame level final RD cost for full encoding
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_RD_COST_INTRA              L"HevcStatisticsFeedbackRdCostIntra"            // amf_int64; Frame level intra RD cost for full encoding
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_RD_COST_INTER              L"HevcStatisticsFeedbackRdCostInter"            // amf_int64; Frame level inter RD cost for full encoding
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SAD_FINAL                  L"HevcStatisticsFeedbackSadFinal"               // amf_int64; Frame level final SAD for full encoding
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SAD_INTRA                  L"HevcStatisticsFeedbackSadIntra"               // amf_int64; Frame level intra SAD for full encoding
-#define AMF_VIDEO_ENCODER_HEVC_STATISTIC_SAD_INTER                  L"HevcStatisticsFeedbackSadInter"               // amf_int64; Frame level inter SAD for full encoding
-
-    // Encoder block level feedback
-#define AMF_VIDEO_ENCODER_HEVC_BLOCK_QP_MAP                         L"HevcBlockQpMap"                               // AMFInterface(AMFSurface); AMFSurface of format AMF_SURFACE_GRAY32 containing block level QP values
-
-// HEVC Encoder capabilities - exposed in AMFCaps interface
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_BITRATE                      L"HevcMaxBitrate"               // amf_int64; Maximum bit rate in bits
-#define AMF_VIDEO_ENCODER_HEVC_CAP_NUM_OF_STREAMS                   L"HevcNumOfStreams"             // amf_int64; maximum number of encode streams supported
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_PROFILE                      L"HevcMaxProfile"               // amf_int64(AMF_VIDEO_ENCODER_HEVC_PROFILE_ENUM)
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_TIER                         L"HevcMaxTier"                  // amf_int64(AMF_VIDEO_ENCODER_HEVC_TIER_ENUM) maximum profile tier
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_LEVEL                        L"HevcMaxLevel"                 // amf_int64 maximum profile level
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MIN_REFERENCE_FRAMES             L"HevcMinReferenceFrames"       // amf_int64 minimum number of reference frames
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_REFERENCE_FRAMES             L"HevcMaxReferenceFrames"       // amf_int64 maximum number of reference frames
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_TEMPORAL_LAYERS              L"HevcMaxTemporalLayers"        // amf_int64 maximum number of temporal layers
-#define AMF_VIDEO_ENCODER_HEVC_CAP_NUM_OF_HW_INSTANCES              L"HevcNumOfHwInstances"         // amf_int64 number of HW encoder instances
-#define AMF_VIDEO_ENCODER_HEVC_CAP_COLOR_CONVERSION                 L"HevcColorConversion"          // amf_int64(AMF_ACCELERATION_TYPE) - type of supported color conversion. default AMF_ACCEL_GPU
-#define AMF_VIDEO_ENCODER_HEVC_CAP_PRE_ANALYSIS                     L"HevcPreAnalysis"              // amf_bool - pre analysis module is available for HEVC UVE encoder, n/a for the other encoders
-#define AMF_VIDEO_ENCODER_HEVC_CAP_ROI                              L"HevcROIMap"                   // amf_bool - ROI map support is available for HEVC UVE encoder, n/a for the other encoders
-#define AMF_VIDEO_ENCODER_HEVC_CAP_MAX_THROUGHPUT                   L"HevcMaxThroughput"            // amf_int64 - MAX throughput for HEVC encoder in MB (16 x 16 pixel)
-#define AMF_VIDEO_ENCODER_HEVC_CAP_REQUESTED_THROUGHPUT             L"HevcRequestedThroughput"      // amf_int64 - Currently total requested throughput for HEVC encode in MB (16 x 16 pixel)
-#define AMF_VIDEO_ENCODER_CAPS_HEVC_QUERY_TIMEOUT_SUPPORT           L"HevcQueryTimeoutSupport"      // amf_bool - Timeout supported for QueryOutout call
-
-// properties set on AMFComponent to control component creation
-#define AMF_VIDEO_ENCODER_HEVC_MEMORY_TYPE                          L"HevcEncoderMemoryType"        // amf_int64(AMF_MEMORY_TYPE) , default is AMF_MEMORY_UNKNOWN, Values : AMF_MEMORY_DX11, AMF_MEMORY_DX9, AMF_MEMORY_UNKNOWN (auto)
-
-#define AMF_VIDEO_ENCODER_HEVC_ENABLE_SMART_ACCESS_VIDEO            L"HevcEnableEncoderSmartAccessVideo"         // amf_bool; default = false; true = enables smart access video feature
-
-#endif //#ifndef AMF_VideoEncoderHEVC_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoEncoderVCE.h

@@ -1,354 +0,0 @@
-//
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-//
-// MIT license
-//
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// AMFVideoEncoderHW_AVC interface declaration
-//-------------------------------------------------------------------------------------------------
-
-#ifndef AMF_VideoEncoderVCE_h
-#define AMF_VideoEncoderVCE_h
-#pragma once
-
-#include "Component.h"
-#include "ColorSpace.h"
-#include "PreAnalysis.h"
-
-#define AMFVideoEncoderVCE_AVC L"AMFVideoEncoderVCE_AVC"
-#define AMFVideoEncoderVCE_SVC L"AMFVideoEncoderVCE_SVC"
-
-enum AMF_VIDEO_ENCODER_USAGE_ENUM
-{
-    AMF_VIDEO_ENCODER_USAGE_TRANSCONDING = 0, // kept for backwards compatability
-    AMF_VIDEO_ENCODER_USAGE_TRANSCODING = 0, // fixed typo
-    AMF_VIDEO_ENCODER_USAGE_ULTRA_LOW_LATENCY,
-    AMF_VIDEO_ENCODER_USAGE_LOW_LATENCY,
-    AMF_VIDEO_ENCODER_USAGE_WEBCAM,
-    AMF_VIDEO_ENCODER_USAGE_HIGH_QUALITY,
-    AMF_VIDEO_ENCODER_USAGE_LOW_LATENCY_HIGH_QUALITY
-};
-
-enum AMF_VIDEO_ENCODER_PROFILE_ENUM
-{
-    AMF_VIDEO_ENCODER_PROFILE_UNKNOWN = 0,
-    AMF_VIDEO_ENCODER_PROFILE_BASELINE = 66,
-    AMF_VIDEO_ENCODER_PROFILE_MAIN = 77,
-    AMF_VIDEO_ENCODER_PROFILE_HIGH = 100,
-    AMF_VIDEO_ENCODER_PROFILE_CONSTRAINED_BASELINE = 256,
-    AMF_VIDEO_ENCODER_PROFILE_CONSTRAINED_HIGH = 257
-};
-
-enum AMF_VIDEO_ENCODER_H264_LEVEL_ENUM
-{
-    AMF_H264_LEVEL__1   = 10,
-    AMF_H264_LEVEL__1_1 = 11,
-    AMF_H264_LEVEL__1_2 = 12,
-    AMF_H264_LEVEL__1_3 = 13,
-    AMF_H264_LEVEL__2   = 20,
-    AMF_H264_LEVEL__2_1 = 21,
-    AMF_H264_LEVEL__2_2 = 22,
-    AMF_H264_LEVEL__3   = 30,
-    AMF_H264_LEVEL__3_1 = 31,
-    AMF_H264_LEVEL__3_2 = 32,
-    AMF_H264_LEVEL__4   = 40,
-    AMF_H264_LEVEL__4_1 = 41,
-    AMF_H264_LEVEL__4_2 = 42,
-    AMF_H264_LEVEL__5   = 50,
-    AMF_H264_LEVEL__5_1 = 51,
-    AMF_H264_LEVEL__5_2 = 52,
-    AMF_H264_LEVEL__6   = 60,
-    AMF_H264_LEVEL__6_1 = 61,
-    AMF_H264_LEVEL__6_2 = 62
-};
-
-enum AMF_VIDEO_ENCODER_SCANTYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_SCANTYPE_PROGRESSIVE = 0,
-    AMF_VIDEO_ENCODER_SCANTYPE_INTERLACED
-};
-
-enum AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_ENUM
-{
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_UNKNOWN = -1,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_CONSTANT_QP = 0,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_CBR,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_LATENCY_CONSTRAINED_VBR,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_QUALITY_VBR,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_HIGH_QUALITY_VBR,
-    AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_HIGH_QUALITY_CBR
-};
-
-enum AMF_VIDEO_ENCODER_QUALITY_PRESET_ENUM
-{
-    AMF_VIDEO_ENCODER_QUALITY_PRESET_BALANCED = 0,
-    AMF_VIDEO_ENCODER_QUALITY_PRESET_SPEED,
-    AMF_VIDEO_ENCODER_QUALITY_PRESET_QUALITY
-};
-
-enum AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_ENUM
-{
-    AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_NONE = 0,
-    AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_FRAME,
-    AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_TOP_FIELD,
-    AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_BOTTOM_FIELD
-};
-
-enum AMF_VIDEO_ENCODER_PICTURE_TYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_PICTURE_TYPE_NONE = 0,
-    AMF_VIDEO_ENCODER_PICTURE_TYPE_SKIP,
-    AMF_VIDEO_ENCODER_PICTURE_TYPE_IDR,
-    AMF_VIDEO_ENCODER_PICTURE_TYPE_I,
-    AMF_VIDEO_ENCODER_PICTURE_TYPE_P,
-    AMF_VIDEO_ENCODER_PICTURE_TYPE_B
-};
-
-enum AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_ENUM
-{
-    AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_IDR,
-    AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_I,
-    AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_P,
-    AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_B
-};
-
-enum AMF_VIDEO_ENCODER_PREENCODE_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_PREENCODE_DISABLED = 0,
-    AMF_VIDEO_ENCODER_PREENCODE_ENABLED  = 1,
-};
-
-enum AMF_VIDEO_ENCODER_CODING_ENUM
-{
-    AMF_VIDEO_ENCODER_UNDEFINED = 0, // BASELINE = CALV; MAIN, HIGH = CABAC
-    AMF_VIDEO_ENCODER_CABAC,
-    AMF_VIDEO_ENCODER_CALV,
-
-};
-
-enum AMF_VIDEO_ENCODER_PICTURE_TRANSFER_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_PICTURE_TRANSFER_MODE_OFF = 0,
-    AMF_VIDEO_ENCODER_PICTURE_TRANSFER_MODE_ON
-};
-
-enum AMF_VIDEO_ENCODER_LTR_MODE_ENUM
-{
-    AMF_VIDEO_ENCODER_LTR_MODE_RESET_UNUSED = 0,
-    AMF_VIDEO_ENCODER_LTR_MODE_KEEP_UNUSED
-};
-
-
-// Static properties - can be set before Init()
-#define AMF_VIDEO_ENCODER_INSTANCE_INDEX                        L"EncoderInstance"          // amf_int64; selected HW instance idx
-#define AMF_VIDEO_ENCODER_FRAMESIZE                             L"FrameSize"                // AMFSize; default = 0,0; Frame size
-
-#define AMF_VIDEO_ENCODER_EXTRADATA                             L"ExtraData"                // AMFInterface* - > AMFBuffer*; SPS/PPS buffer in Annex B format - read-only
-#define AMF_VIDEO_ENCODER_USAGE                                 L"Usage"                    // amf_int64(AMF_VIDEO_ENCODER_USAGE_ENUM); default = N/A; Encoder usage type. fully configures parameter set.
-#define AMF_VIDEO_ENCODER_PROFILE                               L"Profile"                  // amf_int64(AMF_VIDEO_ENCODER_PROFILE_ENUM) ; default = AMF_VIDEO_ENCODER_PROFILE_MAIN;  H264 profile
-#define AMF_VIDEO_ENCODER_PROFILE_LEVEL                         L"ProfileLevel"             // amf_int64(AMF_VIDEO_ENCODER_H264_LEVEL_ENUM); default = AMF_H264_LEVEL__4_2; H264 level
-#define AMF_VIDEO_ENCODER_MAX_LTR_FRAMES                        L"MaxOfLTRFrames"           // amf_int64; default = 0; Max number of LTR frames
-#define AMF_VIDEO_ENCODER_LTR_MODE                              L"LTRMode"                  // amf_int64(AMF_VIDEO_ENCODER_LTR_MODE_ENUM); default = AMF_VIDEO_ENCODER_LTR_MODE_RESET_UNUSED; remove/keep unused LTRs (not specified in property AMF_VIDEO_ENCODER_FORCE_LTR_REFERENCE_BITFIELD)
-#define AMF_VIDEO_ENCODER_SCANTYPE                              L"ScanType"                 // amf_int64(AMF_VIDEO_ENCODER_SCANTYPE_ENUM); default = AMF_VIDEO_ENCODER_SCANTYPE_PROGRESSIVE; indicates input stream type
-#define AMF_VIDEO_ENCODER_MAX_NUM_REFRAMES                      L"MaxNumRefFrames"          // amf_int64; Maximum number of reference frames
-#define AMF_VIDEO_ENCODER_MAX_CONSECUTIVE_BPICTURES             L"MaxConsecutiveBPictures"  // amf_int64; Maximum number of consecutive B Pictures
-#define AMF_VIDEO_ENCODER_ADAPTIVE_MINIGOP                      L"AdaptiveMiniGOP"          // bool; default = false; Disable/Enable Adaptive MiniGOP
-#define AMF_VIDEO_ENCODER_ASPECT_RATIO                          L"AspectRatio"              // AMFRatio; default = 1, 1
-#define AMF_VIDEO_ENCODER_FULL_RANGE_COLOR                      L"FullRangeColor"           // bool; default = false; inidicates that YUV input is (0,255)
-#define AMF_VIDEO_ENCODER_LOWLATENCY_MODE                       L"LowLatencyInternal"       // bool; default = false, enables low latency mode and POC mode 2 in the encoder
-#define AMF_VIDEO_ENCODER_PRE_ANALYSIS_ENABLE                   L"EnablePreAnalysis"        // bool; default = false; enables the pre-analysis module. Currently only works in AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR mode. Refer to AMF Video PreAnalysis API reference for more details.
-#define AMF_VIDEO_ENCODER_PREENCODE_ENABLE                      L"RateControlPreanalysisEnable"     // amf_int64(AMF_VIDEO_ENCODER_PREENCODE_MODE_ENUM); default =  AMF_VIDEO_ENCODER_PREENCODE_DISABLED; enables pre-encode assisted rate control
-#define AMF_VIDEO_ENCODER_RATE_CONTROL_PREANALYSIS_ENABLE       L"RateControlPreanalysisEnable"     // amf_int64(AMF_VIDEO_ENCODER_PREENCODE_MODE_ENUM); default =  AMF_VIDEO_ENCODER_PREENCODE_DISABLED; enables pre-encode assisted rate control. Deprecated, please use AMF_VIDEO_ENCODER_PREENCODE_ENABLE instead.
-#define AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD                   L"RateControlMethod"        // amf_int64(AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_ENUM); default = depends on USAGE; Rate Control Method
-#define AMF_VIDEO_ENCODER_QVBR_QUALITY_LEVEL                    L"QvbrQualityLevel"         // amf_int64; default = 23; QVBR quality level; range = 1-51
-#define AMF_VIDEO_ENCODER_MAX_NUM_TEMPORAL_LAYERS               L"MaxNumOfTemporalLayers"   // amf_int64; default = 1; Max number of temporal layers.
-#if !defined(__GNUC__) && !defined(__clang__)
-    #pragma deprecated("AMF_VIDEO_ENCODER_RATE_CONTROL_PREANALYSIS_ENABLE")
-#endif
-
-
-    // Quality preset property
-#define AMF_VIDEO_ENCODER_QUALITY_PRESET                        L"QualityPreset"            // amf_int64(AMF_VIDEO_ENCODER_QUALITY_PRESET_ENUM); default = depends on USAGE; Quality Preset
-
-    // color conversion
-#define AMF_VIDEO_ENCODER_COLOR_BIT_DEPTH                       L"ColorBitDepth"            // amf_int64(AMF_COLOR_BIT_DEPTH_ENUM); default = AMF_COLOR_BIT_DEPTH_8
-
-#define AMF_VIDEO_ENCODER_INPUT_COLOR_PROFILE                   L"InColorProfile"           // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO by size
-#define AMF_VIDEO_ENCODER_INPUT_TRANSFER_CHARACTERISTIC         L"InColorTransferChar"      // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 ?7.2 See VideoDecoderUVD.h for enum
-#define AMF_VIDEO_ENCODER_INPUT_COLOR_PRIMARIES                 L"InColorPrimaries"         // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 Section 7.1 See ColorSpace.h for enum
-#define AMF_VIDEO_ENCODER_INPUT_HDR_METADATA                    L"InHDRMetadata"            // AMFBuffer containing AMFHDRMetadata; default NULL
-
-#define AMF_VIDEO_ENCODER_OUTPUT_COLOR_PROFILE                  L"OutColorProfile"          // amf_int64(AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM); default = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN - mean AUTO by size
-#define AMF_VIDEO_ENCODER_OUTPUT_TRANSFER_CHARACTERISTIC        L"OutColorTransferChar"     // amf_int64(AMF_COLOR_TRANSFER_CHARACTERISTIC_ENUM); default = AMF_COLOR_TRANSFER_CHARACTERISTIC_UNDEFINED, ISO/IEC 23001-8_2013 Section 7.2 See VideoDecoderUVD.h for enum
-#define AMF_VIDEO_ENCODER_OUTPUT_COLOR_PRIMARIES                L"OutColorPrimaries"        // amf_int64(AMF_COLOR_PRIMARIES_ENUM); default = AMF_COLOR_PRIMARIES_UNDEFINED, ISO/IEC 23001-8_2013 Section 7.1 See ColorSpace.h for enum
-#define AMF_VIDEO_ENCODER_OUTPUT_HDR_METADATA                   L"OutHDRMetadata"           // AMFBuffer containing AMFHDRMetadata; default NULL
-
-
-// Dynamic properties - can be set at any time
-   // Rate control properties
-#define AMF_VIDEO_ENCODER_FRAMERATE                             L"FrameRate"                // AMFRate; default = depends on usage; Frame Rate
-#define AMF_VIDEO_ENCODER_B_PIC_DELTA_QP                        L"BPicturesDeltaQP"         // amf_int64; default = depends on USAGE; B-picture Delta
-#define AMF_VIDEO_ENCODER_REF_B_PIC_DELTA_QP                    L"ReferenceBPicturesDeltaQP"// amf_int64; default = depends on USAGE; Reference B-picture Delta
-
-#define AMF_VIDEO_ENCODER_ENFORCE_HRD                           L"EnforceHRD"               // bool; default = depends on USAGE; Enforce HRD
-#define AMF_VIDEO_ENCODER_FILLER_DATA_ENABLE                    L"FillerDataEnable"         // bool; default = false; Filler Data Enable
-#define AMF_VIDEO_ENCODER_ENABLE_VBAQ                           L"EnableVBAQ"               // bool; default = depends on USAGE; Enable VBAQ
-#define AMF_VIDEO_ENCODER_HIGH_MOTION_QUALITY_BOOST_ENABLE      L"HighMotionQualityBoostEnable"// bool; default = depends on USAGE; Enable High motion quality boost mode
-
-
-#define AMF_VIDEO_ENCODER_VBV_BUFFER_SIZE                       L"VBVBufferSize"            // amf_int64; default = depends on USAGE; VBV Buffer Size in bits
-#define AMF_VIDEO_ENCODER_INITIAL_VBV_BUFFER_FULLNESS           L"InitialVBVBufferFullness" // amf_int64; default =  64; Initial VBV Buffer Fullness 0=0% 64=100%
-
-#define AMF_VIDEO_ENCODER_MAX_AU_SIZE                           L"MaxAUSize"                // amf_int64; default = 0; Max AU Size in bits
-
-#define AMF_VIDEO_ENCODER_MIN_QP                                L"MinQP"                    // amf_int64; default = depends on USAGE; Min QP; range = 0-51
-#define AMF_VIDEO_ENCODER_MAX_QP                                L"MaxQP"                    // amf_int64; default = depends on USAGE; Max QP; range = 0-51
-#define AMF_VIDEO_ENCODER_QP_I                                  L"QPI"                      // amf_int64; default = 22; I-frame QP; range = 0-51
-#define AMF_VIDEO_ENCODER_QP_P                                  L"QPP"                      // amf_int64; default = 22; P-frame QP; range = 0-51
-#define AMF_VIDEO_ENCODER_QP_B                                  L"QPB"                      // amf_int64; default = 22; B-frame QP; range = 0-51
-#define AMF_VIDEO_ENCODER_TARGET_BITRATE                        L"TargetBitrate"            // amf_int64; default = depends on USAGE; Target bit rate in bits
-#define AMF_VIDEO_ENCODER_PEAK_BITRATE                          L"PeakBitrate"              // amf_int64; default = depends on USAGE; Peak bit rate in bits
-#define AMF_VIDEO_ENCODER_RATE_CONTROL_SKIP_FRAME_ENABLE        L"RateControlSkipFrameEnable"   // bool; default =  depends on USAGE; Rate Control Based Frame Skip
-
-    // Picture control properties
-#define AMF_VIDEO_ENCODER_HEADER_INSERTION_SPACING              L"HeaderInsertionSpacing"   // amf_int64; default = depends on USAGE; Header Insertion Spacing; range 0-1000
-#define AMF_VIDEO_ENCODER_B_PIC_PATTERN                         L"BPicturesPattern"         // amf_int64; default = 3; B-picture Pattern (number of B-Frames)
-#define AMF_VIDEO_ENCODER_DE_BLOCKING_FILTER                    L"DeBlockingFilter"         // bool; default = depends on USAGE; De-blocking Filter
-#define AMF_VIDEO_ENCODER_B_REFERENCE_ENABLE                    L"BReferenceEnable"         // bool; default = true; Enable Refrence to B-frames
-#define AMF_VIDEO_ENCODER_IDR_PERIOD                            L"IDRPeriod"                // amf_int64; default = depends on USAGE; IDR Period in frames
-#define AMF_VIDEO_ENCODER_INTRA_REFRESH_NUM_MBS_PER_SLOT        L"IntraRefreshMBsNumberPerSlot" // amf_int64; default = depends on USAGE; Intra Refresh MBs Number Per Slot in Macroblocks
-#define AMF_VIDEO_ENCODER_SLICES_PER_FRAME                      L"SlicesPerFrame"           // amf_int64; default = 1; Number of slices Per Frame
-#define AMF_VIDEO_ENCODER_CABAC_ENABLE                          L"CABACEnable"              // amf_int64(AMF_VIDEO_ENCODER_CODING_ENUM) default = AMF_VIDEO_ENCODER_UNDEFINED
-
-    // Motion estimation
-#define AMF_VIDEO_ENCODER_MOTION_HALF_PIXEL                     L"HalfPixel"                // bool; default= true; Half Pixel
-#define AMF_VIDEO_ENCODER_MOTION_QUARTERPIXEL                   L"QuarterPixel"             // bool; default= true; Quarter Pixel
-
-    // SVC
-#define AMF_VIDEO_ENCODER_NUM_TEMPORAL_ENHANCMENT_LAYERS        L"NumOfTemporalEnhancmentLayers" // amf_int64; default = 1; range = 1-MaxTemporalLayers; Number of temporal Layers (SVC)
-
-
-    // DPB management
-#define AMF_VIDEO_ENCODER_PICTURE_TRANSFER_MODE                 L"PicTransferMode"               // amf_int64(AMF_VIDEO_ENCODER_PICTURE_TRANSFER_MODE_ENUM); default = AMF_VIDEO_ENCODER_PICTURE_TRANSFER_MODE_OFF - whether to exchange reference/reconstructed pic between encoder and application
-    // misc
-#define AMF_VIDEO_ENCODER_QUERY_TIMEOUT                         L"QueryTimeout"             // amf_int64; default = 0 (no wait); timeout for QueryOutput call in ms.
-
-// Per-submittion properties - can be set on input surface interface
-#define AMF_VIDEO_ENCODER_END_OF_SEQUENCE                       L"EndOfSequence"            // bool; default = false; generate end of sequence
-#define AMF_VIDEO_ENCODER_END_OF_STREAM                         L"EndOfStream"              // bool; default = false; generate end of stream
-#define AMF_VIDEO_ENCODER_FORCE_PICTURE_TYPE                    L"ForcePictureType"         // amf_int64(AMF_VIDEO_ENCODER_PICTURE_TYPE_ENUM); default = AMF_VIDEO_ENCODER_PICTURE_TYPE_NONE; generate particular picture type
-#define AMF_VIDEO_ENCODER_INSERT_AUD                            L"InsertAUD"                // bool; default = false; insert AUD
-#define AMF_VIDEO_ENCODER_INSERT_SPS                            L"InsertSPS"                // bool; default = false; insert SPS
-#define AMF_VIDEO_ENCODER_INSERT_PPS                            L"InsertPPS"                // bool; default = false; insert PPS
-#define AMF_VIDEO_ENCODER_PICTURE_STRUCTURE                     L"PictureStructure"         // amf_int64(AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_ENUM); default = AMF_VIDEO_ENCODER_PICTURE_STRUCTURE_FRAME; indicate picture type
-#define AMF_VIDEO_ENCODER_MARK_CURRENT_WITH_LTR_INDEX           L"MarkCurrentWithLTRIndex"  // //amf_int64; default = N/A; Mark current frame with LTR index
-#define AMF_VIDEO_ENCODER_FORCE_LTR_REFERENCE_BITFIELD          L"ForceLTRReferenceBitfield"// amf_int64; default = 0; force LTR bit-field
-#define AMF_VIDEO_ENCODER_ROI_DATA                              L"ROIData"                  // 2D AMFSurface, surface format: AMF_SURFACE_GRAY32
-#define AMF_VIDEO_ENCODER_REFERENCE_PICTURE                     L"ReferencePicture"         // AMFInterface(AMFSurface); surface used for frame injection
-#define AMF_VIDEO_ENCODER_PSNR_FEEDBACK                         L"PSNRFeedback"             // amf_bool; default = false; Signal encoder to calculate PSNR score
-#define AMF_VIDEO_ENCODER_SSIM_FEEDBACK                         L"SSIMFeedback"             // amf_bool; default = false; Signal encoder to calculate SSIM score
-#define AMF_VIDEO_ENCODER_STATISTICS_FEEDBACK                   L"StatisticsFeedback"       // amf_bool; default = false; Signal encoder to collect and feedback statistics
-#define AMF_VIDEO_ENCODER_BLOCK_QP_FEEDBACK                     L"BlockQpFeedback"          // amf_bool; default = false; Signal encoder to collect and feedback block level QP values
-
-
-// properties set by encoder on output buffer interface
-#define AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE                      L"OutputDataType"           // amf_int64(AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_ENUM); default = N/A
-#define AMF_VIDEO_ENCODER_OUTPUT_MARKED_LTR_INDEX               L"MarkedLTRIndex"           //amf_int64; default = -1; Marked LTR index
-#define AMF_VIDEO_ENCODER_OUTPUT_REFERENCED_LTR_INDEX_BITFIELD  L"ReferencedLTRIndexBitfield" // amf_int64; default = 0; referenced LTR bit-field
-#define AMF_VIDEO_ENCODER_OUTPUT_TEMPORAL_LAYER                 L"OutputTemporalLayer"      // amf_int64; Temporal layer
-#define AMF_VIDEO_ENCODER_PRESENTATION_TIME_STAMP               L"PresentationTimeStamp"    // amf_int64; Presentation time stamp (PTS)
-#define AMF_VIDEO_ENCODER_RECONSTRUCTED_PICTURE                 L"ReconstructedPicture"     // AMFInterface(AMFSurface); returns reconstructed picture as an AMFSurface attached to the output buffer as property AMF_VIDEO_ENCODER_RECONSTRUCTED_PICTURE of AMFInterface type
-#define AMF_VIDEO_ENCODER_STATISTIC_PSNR_Y                      L"PSNRY"                    // double; PSNR Y
-#define AMF_VIDEO_ENCODER_STATISTIC_PSNR_U                      L"PSNRU"                    // double; PSNR U
-#define AMF_VIDEO_ENCODER_STATISTIC_PSNR_V                      L"PSNRV"                    // double; PSNR V
-#define AMF_VIDEO_ENCODER_STATISTIC_PSNR_ALL                    L"PSNRALL"                  // double; PSNR All
-#define AMF_VIDEO_ENCODER_STATISTIC_SSIM_Y                      L"SSIMY"                    // double; SSIM Y
-#define AMF_VIDEO_ENCODER_STATISTIC_SSIM_U                      L"SSIMU"                    // double; SSIM U
-#define AMF_VIDEO_ENCODER_STATISTIC_SSIM_V                      L"SSIMV"                    // double; SSIM V
-#define AMF_VIDEO_ENCODER_STATISTIC_SSIM_ALL                    L"SSIMALL"                  // double; SSIM ALL
-
-    // Encoder statistics feedback
-#define AMF_VIDEO_ENCODER_STATISTIC_FRAME_QP                    L"StatisticsFeedbackFrameQP"                // amf_int64; Rate control base frame/initial QP
-#define AMF_VIDEO_ENCODER_STATISTIC_AVERAGE_QP                  L"StatisticsFeedbackAvgQP"                  // amf_int64; Average calculated QP of all encoded MBs in a picture. Value may be different from the one reported by bitstream analyzer when there are skipped MBs.
-#define AMF_VIDEO_ENCODER_STATISTIC_MAX_QP                      L"StatisticsFeedbackMaxQP"                  // amf_int64; Max calculated QP among all encoded MBs in a picture. Value may be different from the one reported by bitstream analyzer when there are skipped MBs.
-#define AMF_VIDEO_ENCODER_STATISTIC_MIN_QP                      L"StatisticsFeedbackMinQP"                  // amf_int64; Min calculated QP among all encoded MBs in a picture. Value may be different from the one reported by bitstream analyzer when there are skipped MBs.
-#define AMF_VIDEO_ENCODER_STATISTIC_PIX_NUM_INTRA               L"StatisticsFeedbackPixNumIntra"            // amf_int64; Number of the intra encoded pixels
-#define AMF_VIDEO_ENCODER_STATISTIC_PIX_NUM_INTER               L"StatisticsFeedbackPixNumInter"            // amf_int64; Number of the inter encoded pixels
-#define AMF_VIDEO_ENCODER_STATISTIC_PIX_NUM_SKIP                L"StatisticsFeedbackPixNumSkip"             // amf_int64; Number of the skip mode pixels
-#define AMF_VIDEO_ENCODER_STATISTIC_BITCOUNT_RESIDUAL           L"StatisticsFeedbackBitcountResidual"       // amf_int64; The bit count that corresponds to residual data
-#define AMF_VIDEO_ENCODER_STATISTIC_BITCOUNT_MOTION             L"StatisticsFeedbackBitcountMotion"         // amf_int64; The bit count that corresponds to motion vectors
-#define AMF_VIDEO_ENCODER_STATISTIC_BITCOUNT_INTER              L"StatisticsFeedbackBitcountInter"          // amf_int64; The bit count that are assigned to inter MBs
-#define AMF_VIDEO_ENCODER_STATISTIC_BITCOUNT_INTRA              L"StatisticsFeedbackBitcountIntra"          // amf_int64; The bit count that are assigned to intra MBs
-#define AMF_VIDEO_ENCODER_STATISTIC_BITCOUNT_ALL_MINUS_HEADER   L"StatisticsFeedbackBitcountAllMinusHeader" // amf_int64; The bit count of the bitstream excluding header
-#define AMF_VIDEO_ENCODER_STATISTIC_MV_X                        L"StatisticsFeedbackMvX"                    // amf_int64; Accumulated absolute values of horizontal MV's
-#define AMF_VIDEO_ENCODER_STATISTIC_MV_Y                        L"StatisticsFeedbackMvY"                    // amf_int64; Accumulated absolute values of vertical MV's
-#define AMF_VIDEO_ENCODER_STATISTIC_RD_COST_FINAL               L"StatisticsFeedbackRdCostFinal"            // amf_int64; Frame level final RD cost for full encoding
-#define AMF_VIDEO_ENCODER_STATISTIC_RD_COST_INTRA               L"StatisticsFeedbackRdCostIntra"            // amf_int64; Frame level intra RD cost for full encoding
-#define AMF_VIDEO_ENCODER_STATISTIC_RD_COST_INTER               L"StatisticsFeedbackRdCostInter"            // amf_int64; Frame level inter RD cost for full encoding
-#define AMF_VIDEO_ENCODER_STATISTIC_SATD_FINAL                  L"StatisticsFeedbackSatdFinal"              // amf_int64; Frame level final SATD for full encoding
-#define AMF_VIDEO_ENCODER_STATISTIC_SATD_INTRA                  L"StatisticsFeedbackSatdIntra"              // amf_int64; Frame level intra SATD for full encoding
-#define AMF_VIDEO_ENCODER_STATISTIC_SATD_INTER                  L"StatisticsFeedbackSatdInter"              // amf_int64; Frame level inter SATD for full encoding
-
-    // Encoder block level feedback
-#define AMF_VIDEO_ENCODER_BLOCK_QP_MAP                          L"BlockQpMap"                               // AMFInterface(AMFSurface); AMFSurface of format AMF_SURFACE_GRAY32 containing block level QP values
-
-#define AMF_VIDEO_ENCODER_HDCP_COUNTER                          L"HDCPCounter"              //  const void*
-
-// Properties for multi-instance cloud gaming
-#define AMF_VIDEO_ENCODER_MAX_INSTANCES                         L"EncoderMaxInstances"      // deprecated.  amf_int64; default = 1; max number of encoder instances
-#define AMF_VIDEO_ENCODER_MULTI_INSTANCE_MODE                   L"MultiInstanceMode"        // deprecated.  bool; default = false;
-#define AMF_VIDEO_ENCODER_CURRENT_QUEUE                         L"MultiInstanceCurrentQueue"// deprecated.  amf_int64; default = 0;
-
-
-// VCE Encoder capabilities - exposed in AMFCaps interface
-#define AMF_VIDEO_ENCODER_CAP_MAX_BITRATE                       L"MaxBitrate"               // amf_int64; Maximum bit rate in bits
-#define AMF_VIDEO_ENCODER_CAP_NUM_OF_STREAMS                    L"NumOfStreams"             // amf_int64; maximum number of encode streams supported
-#define AMF_VIDEO_ENCODER_CAP_MAX_PROFILE                       L"MaxProfile"               // AMF_VIDEO_ENCODER_PROFILE_ENUM
-#define AMF_VIDEO_ENCODER_CAP_MAX_LEVEL                         L"MaxLevel"                 // amf_int64 maximum profile level
-#define AMF_VIDEO_ENCODER_CAP_BFRAMES                           L"BFrames"                  // bool  is B-Frames supported
-#define AMF_VIDEO_ENCODER_CAP_MIN_REFERENCE_FRAMES              L"MinReferenceFrames"       // amf_int64 minimum number of reference frames
-#define AMF_VIDEO_ENCODER_CAP_MAX_REFERENCE_FRAMES              L"MaxReferenceFrames"       // amf_int64 maximum number of reference frames
-#define AMF_VIDEO_ENCODER_CAP_MAX_TEMPORAL_LAYERS               L"MaxTemporalLayers"        // amf_int64 maximum number of temporal layers
-#define AMF_VIDEO_ENCODER_CAP_FIXED_SLICE_MODE                  L"FixedSliceMode"           // bool  is fixed slice mode supported
-#define AMF_VIDEO_ENCODER_CAP_NUM_OF_HW_INSTANCES               L"NumOfHwInstances"         // amf_int64 number of HW encoder instances
-#define AMF_VIDEO_ENCODER_CAP_COLOR_CONVERSION                  L"ColorConversion"          // amf_int64(AMF_ACCELERATION_TYPE) - type of supported color conversion. default AMF_ACCEL_GPU
-#define AMF_VIDEO_ENCODER_CAP_PRE_ANALYSIS                      L"PreAnalysis"              // amf_bool - pre analysis module is available for H264 UVE encoder, n/a for the other encoders
-#define AMF_VIDEO_ENCODER_CAP_ROI                               L"ROIMap"                   // amf_bool - ROI map support is available for H264 UVE encoder, n/a for the other encoders
-#define AMF_VIDEO_ENCODER_CAP_MAX_THROUGHPUT                    L"MaxThroughput"            // amf_int64 - MAX throughput for H264 encoder in MB (16 x 16 pixel)
-#define AMF_VIDEO_ENCODER_CAP_REQUESTED_THROUGHPUT              L"RequestedThroughput"      // amf_int64 - Currently total requested throughput for H264 encoder in MB (16 x 16 pixel)
-#define AMF_VIDEO_ENCODER_CAPS_QUERY_TIMEOUT_SUPPORT            L"QueryTimeoutSupport"      // amf_bool - Timeout supported for QueryOutout call
-
-// properties set on AMFComponent to control component creation
-#define AMF_VIDEO_ENCODER_MEMORY_TYPE                           L"EncoderMemoryType"        // amf_int64(AMF_MEMORY_TYPE) , default is AMF_MEMORY_UNKNOWN, Values : AMF_MEMORY_DX11, AMF_MEMORY_DX9, AMF_MEMORY_VULKAN or AMF_MEMORY_UNKNOWN (auto)
-
-#define AMF_VIDEO_ENCODER_ENABLE_SMART_ACCESS_VIDEO             L"EnableEncoderSmartAccessVideo"         // amf_bool; default = false; true = enables smart access video feature
-
-#endif //#ifndef AMF_VideoEncoderVCE_h

plugins/obs-ffmpeg/external/AMF/include/components/VideoStitch.h

@@ -1,124 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-//
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-/**
- ***************************************************************************************************
- * @file  VideoStitch.h
- * @brief AMFVideoStitch interface declaration
- ***************************************************************************************************
- */
-#ifndef AMF_VideoStitch_h
-#define AMF_VideoStitch_h
-#pragma once
-
-#include "public/include/components/Component.h"
-
-#define AMFVideoStitch       L"AMFVideoStitch"                  //Component name
-
-// static properties 
-#define AMF_VIDEO_STITCH_OUTPUT_FORMAT       L"OutputFormat"    // Values, AMF_SURFACE_BGRA or AMF_SURFACE_RGBA
-#define AMF_VIDEO_STITCH_MEMORY_TYPE         L"MemoryType"      // Values, only AMF_MEMORY_DX11 is supported for now.
-#define AMF_VIDEO_STITCH_OUTPUT_SIZE         L"OutputSize"      // AMFSize, (width, height) in pixels. default= (0,0), will be the same size as input.
-#define AMF_VIDEO_STITCH_INPUTCOUNT          L"InputCount"      // amf_uint64, number of camera inputs.
-
-// individual camera direction and location
-#define AMF_VIDEO_CAMERA_ANGLE_PITCH        L"CameraPitch"      // double, in radians, default = 0, camera pitch orientation 
-#define AMF_VIDEO_CAMERA_ANGLE_YAW          L"CameraYaw"        // double, in radians, default = 0, camera yaw orientation 
-#define AMF_VIDEO_CAMERA_ANGLE_ROLL         L"CameraRoll"       // double, in radians, default = 0, camera roll orientation 
-
-#define AMF_VIDEO_CAMERA_OFFSET_X           L"CameraOffsetX"    // double, in pixels, default = 0, X offset of camera center of the lens from the center of the rig.
-#define AMF_VIDEO_CAMERA_OFFSET_Y           L"CameraOffsetY"    // double, in pixels, default = 0, Y offset of camera center of the lens from the center of the rig.
-#define AMF_VIDEO_CAMERA_OFFSET_Z           L"CameraOffsetZ"    // double, in pixels, default = 0, Z offset of camera center of the lens from the center of the rig.
-#define AMF_VIDEO_CAMERA_HFOV               L"CameraHFOV"       // double, in radians, default = PI, - horizontal field of view
-#define AMF_VIDEO_CAMERA_SCALE              L"CameraScale"      // double, default = 1, scale coeff
-
-// lens correction parameters
-#define AMF_VIDEO_STITCH_LENS_CORR_K1       L"LensK1"           // double, default = 0.
-#define AMF_VIDEO_STITCH_LENS_CORR_K2       L"LensK2"           // double, default = 0.
-#define AMF_VIDEO_STITCH_LENS_CORR_K3       L"LensK3"           // double, default = 0.
-#define AMF_VIDEO_STITCH_LENS_CORR_OFFX     L"LensOffX"         // double, default = 0.
-#define AMF_VIDEO_STITCH_LENS_CORR_OFFY     L"LensOffY"         // double, default = 0.
-#define AMF_VIDEO_STITCH_CROP               L"Crop"             //AMFRect, in pixels default = (0,0,0,0).
-
-#define AMF_VIDEO_STITCH_LENS_MODE          L"LensMode"         // Values, AMF_VIDEO_STITCH_LENS_CORR_MODE_ENUM, (default = AMF_VIDEO_STITCH_LENS_CORR_MODE_RADIAL)
-
-#define AMF_VIDEO_STITCH_OUTPUT_MODE        L"OutputMode"       // AMF_VIDEO_STITCH_OUTPUT_MODE_ENUM (default=AMF_VIDEO_STITCH_OUTPUT_MODE_PREVIEW) 
-#define AMF_VIDEO_STITCH_COMBINED_SOURCE    L"CombinedSource"   // bool, (default=false) video sources are combined in one stream
-
-#define AMF_VIDEO_STITCH_COMPUTE_DEVICE     L"ComputeDevice"    // amf_int64(AMF_MEMORY_TYPE) Values, AMF_MEMORY_DX11, AMF_MEMORY_COMPUTE_FOR_DX11, AMF_MEMORY_OPENCL
-
-//for debug
-#define AMF_VIDEO_STITCH_WIRE_RENDER        L"Wire"             // bool (default=false) reder wireframe
-
-//view angle 
-#define AMF_VIDEO_STITCH_VIEW_ROTATE_X      L"AngleX"           // double, in radians, default = 0 - delta from current position / automatilcally reset to 0 inside SetProperty() call
-#define AMF_VIDEO_STITCH_VIEW_ROTATE_Y      L"AngleY"           // double, in radians, default = 0 - delta from current position / automatilcally reset to 0 inside SetProperty() call
-#define AMF_VIDEO_STITCH_VIEW_ROTATE_Z      L"AngleZ"           // double, in radians, default = 0 - delta from current position / automatilcally reset to 0 inside SetProperty() call
-
-#define AMF_VIDEO_STITCH_COLOR_BALANCE      L"ColorBalance"     // bool (default=true) enables color balance
-
-//lens mode
-enum AMF_VIDEO_STITCH_LENS_ENUM
-{
-    AMF_VIDEO_STITCH_LENS_RECTILINEAR        = 0,   //rect linear lens
-    AMF_VIDEO_STITCH_LENS_FISHEYE_FULLFRAME  = 1,   //fisheye full frame
-    AMF_VIDEO_STITCH_LENS_FISHEYE_CIRCULAR   = 2,   //fisheye, circular
-};
-
-//Output Mode
-enum AMF_VIDEO_STITCH_OUTPUT_MODE_ENUM
-{
-    AMF_VIDEO_STITCH_OUTPUT_MODE_PREVIEW          = 0,    //preview mode
-    AMF_VIDEO_STITCH_OUTPUT_MODE_EQUIRECTANGULAR  = 1,    //equirectangular mode
-    AMF_VIDEO_STITCH_OUTPUT_MODE_CUBEMAP          = 2,    //cubemap mode
-    AMF_VIDEO_STITCH_OUTPUT_MODE_LAST = AMF_VIDEO_STITCH_OUTPUT_MODE_CUBEMAP,
-};
-
-//audio mode
-enum AMF_VIDEO_STITCH_AUDIO_MODE_ENUM
-{
-    AMF_VIDEO_STITCH_AUDIO_MODE_NONE        = 0,    //no audio
-    AMF_VIDEO_STITCH_AUDIO_MODE_VIDEO       = 1,    //using audio from video stream
-    AMF_VIDEO_STITCH_AUDIO_MODE_FILE        = 2,    //using audio from file
-    AMF_VIDEO_STITCH_AUDIO_MODE_CAPTURE     = 3,    //using audio from capture device
-    AMF_VIDEO_STITCH_AUDIO_MODE_INVALID = -1,       //invalid
-};
-
-
-#if defined(_M_AMD64)
-    #define STITCH_DLL_NAME    L"amf-stitch-64.dll"
-#else
-    #define STITCH_DLL_NAME    L"amf-stitch-32.dll"
-#endif
-
-#endif //#ifndef AMF_VideoStitch_h

plugins/obs-ffmpeg/external/AMF/include/components/ZCamLiveStream.h

@@ -1,83 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-//-------------------------------------------------------------------------------------------------
-// ZCamLive  interface declaration
-//-------------------------------------------------------------------------------------------------
-#ifndef AMF_ZCamLiveStream_h
-#define AMF_ZCamLiveStream_h
-
-#pragma once
-#define ZCAMLIVE_STREAMCOUNT             L"StreamCount"          // amf_int64 (default = 4),  number of streams
-#define ZCAMLIVE_VIDEO_FRAMESIZE         L"FrameSize"            // AMFSize   (default = AMFConstructSize(2704, 1520)), frame size
-#define ZCAMLIVE_VIDEO_FRAMERATE         L"FrameRate"            // AMFRate   (default = 30.0), video frame rate
-#define ZCAMLIVE_VIDEO_BIT_RATE          L"BitRate"              // amf_int64 (default = 3000000), video bitrate
-#define ZCAMLIVE_STREAM_ACTIVE_CAMERA    L"ActiveCamera"         // amf_int64 (default = -1, all the cameras), the index of the camera to capture
-#define ZCAMLIVE_STREAM_FRAMECOUNT       L"FrameCount"           // amf_int64 (default = 0), number of frames captured
-#define ZCAMLIVE_CODEC_ID                L"CodecID"              // WString (default = "AMFVideoDecoderUVD_H264_AVC"), UVD codec ID
-#define ZCAMLIVE_VIDEO_MODE              L"VideoMode"            // Enum (default = 0, 2K7P30), ZCam mode
-#define ZCAMLIVE_AUDIO_MODE              L"AudioMode"            // Enum (default = 0, Silent) - Audio mode
-#define ZCAMLIVE_LOWLATENCY              L"LowLatency"           // amf_int64 (default = 1, LowLatency), low latency flag
-#define ZCAMLIVE_IP_0                    L"ZCamIP_00"               // WString, IP address of the #1 stream, default "10.98.32.1"
-#define ZCAMLIVE_IP_1                    L"ZCamIP_01"             // WString, IP address of the #2 stream, default "10.98.32.2"
-#define ZCAMLIVE_IP_2                    L"ZCamIP_02"             // WString, IP address of the #3 stream, default "10.98.32.3"
-#define ZCAMLIVE_IP_3                    L"ZCamIP_03"             // WString, IP address of the #4 stream, default "10.98.32.4"
-
-//Camera live capture Mode
-enum CAMLIVE_MODE_ENUM
-{
-    CAMLIVE_MODE_ZCAM_1080P24 = 0,  //1920x1080, 24FPS
-    CAMLIVE_MODE_ZCAM_1080P30,      //1920x1080, 30FPS
-    CAMLIVE_MODE_ZCAM_1080P60,      //1920x1080, 60FPS
-    CAMLIVE_MODE_ZCAM_2K7P24,       //2704x1520, 24FPS
-    CAMLIVE_MODE_ZCAM_2K7P30,       //2704x1520, 24FPS
-    CAMLIVE_MODE_ZCAM_2K7P60,       //2704x1520, 24FPS
-    CAMLIVE_MODE_ZCAM_2544P24,      //3392x2544, 24FPS
-    CAMLIVE_MODE_ZCAM_2544P30,      //3392x2544, 24FPS
-    CAMLIVE_MODE_ZCAM_2544P60,      //3392x2544, 24FPS
-    CAMLIVE_MODE_THETAS,            //Ricoh TheataS
-    CAMLIVE_MODE_THETAV,            //Ricoh TheataV
-    CAMLIVE_MODE_INVALID = -1,
-};
- 
-enum CAM_AUDIO_MODE_ENUM
-{
-    CAM_AUDIO_MODE_NONE = 0,   //None
-    CAM_AUDIO_MODE_SILENT,     //Silent audio
-    CAM_AUDIO_MODE_CAMERA      //Capture from camera, not supported yet
-};
-
-extern "C"
-{
-    AMF_RESULT AMF_CDECL_CALL AMFCreateComponentZCamLiveStream(amf::AMFContext* pContext, amf::AMFComponentEx** ppComponent);
-}
-#endif // AMF_ZCamLiveStream_h

plugins/obs-ffmpeg/external/AMF/include/core/AudioBuffer.h

@@ -1,234 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_AudioBuffer_h
-#define AMF_AudioBuffer_h
-#pragma once
-
-#include "Data.h"
-#if defined(_MSC_VER)
-    #pragma warning( push )
-    #pragma warning(disable : 4263)
-    #pragma warning(disable : 4264)
-#endif
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    typedef enum AMF_AUDIO_FORMAT
-    {
-        AMFAF_UNKNOWN   =-1,
-        AMFAF_U8        = 0,               // amf_uint8
-        AMFAF_S16       = 1,               // amf_int16
-        AMFAF_S32       = 2,               // amf_int32
-        AMFAF_FLT       = 3,               // amf_float
-        AMFAF_DBL       = 4,               // amf_double
-
-        AMFAF_U8P       = 5,               // amf_uint8
-        AMFAF_S16P      = 6,               // amf_int16
-        AMFAF_S32P      = 7,               // amf_int32
-        AMFAF_FLTP      = 8,               // amf_float
-        AMFAF_DBLP      = 9,               // amf_double
-        AMFAF_FIRST     = AMFAF_U8,
-        AMFAF_LAST      = AMFAF_DBLP,
-    } AMF_AUDIO_FORMAT;
-
-    typedef enum AMF_AUDIO_CHANNEL_LAYOUT
-    {
-        AMFACL_SPEAKER_FRONT_LEFT            = 0x1,
-        AMFACL_SPEAKER_FRONT_RIGHT           = 0x2,
-        AMFACL_SPEAKER_FRONT_CENTER          = 0x4,
-        AMFACL_SPEAKER_LOW_FREQUENCY         = 0x8,
-        AMFACL_SPEAKER_BACK_LEFT             = 0x10,
-        AMFACL_SPEAKER_BACK_RIGHT            = 0x20,
-        AMFACL_SPEAKER_FRONT_LEFT_OF_CENTER  = 0x40,
-        AMFACL_SPEAKER_FRONT_RIGHT_OF_CENTER = 0x80,
-        AMFACL_SPEAKER_BACK_CENTER           = 0x100,
-        AMFACL_SPEAKER_SIDE_LEFT             = 0x200,
-        AMFACL_SPEAKER_SIDE_RIGHT            = 0x400,
-        AMFACL_SPEAKER_TOP_CENTER            = 0x800,
-        AMFACL_SPEAKER_TOP_FRONT_LEFT        = 0x1000,
-        AMFACL_SPEAKER_TOP_FRONT_CENTER      = 0x2000,
-        AMFACL_SPEAKER_TOP_FRONT_RIGHT       = 0x4000,
-        AMFACL_SPEAKER_TOP_BACK_LEFT         = 0x8000,
-        AMFACL_SPEAKER_TOP_BACK_CENTER       = 0x10000,
-        AMFACL_SPEAKER_TOP_BACK_RIGHT        = 0x20000
-    } AMF_AUDIO_CHANNEL_LAYOUT;
-
-    // get the most common layout for a given number of speakers
-    inline int GetDefaultChannelLayout(int channels)
-    {
-        switch (channels)
-        {
-        case 1:
-            return (AMFACL_SPEAKER_FRONT_CENTER);
-        case 2:
-            return (AMFACL_SPEAKER_FRONT_LEFT | AMFACL_SPEAKER_FRONT_RIGHT);
-        case 4:
-            return (AMFACL_SPEAKER_FRONT_LEFT | AMFACL_SPEAKER_FRONT_RIGHT | AMFACL_SPEAKER_BACK_LEFT | AMFACL_SPEAKER_BACK_RIGHT);
-        case 6:
-            return (AMFACL_SPEAKER_FRONT_LEFT | AMFACL_SPEAKER_FRONT_RIGHT | AMFACL_SPEAKER_FRONT_CENTER | AMFACL_SPEAKER_LOW_FREQUENCY | AMFACL_SPEAKER_BACK_LEFT | AMFACL_SPEAKER_BACK_RIGHT);
-        case 8:
-            return (AMFACL_SPEAKER_FRONT_LEFT | AMFACL_SPEAKER_FRONT_RIGHT | AMFACL_SPEAKER_FRONT_CENTER | AMFACL_SPEAKER_LOW_FREQUENCY | AMFACL_SPEAKER_BACK_LEFT | AMFACL_SPEAKER_BACK_RIGHT | AMFACL_SPEAKER_FRONT_LEFT_OF_CENTER | AMFACL_SPEAKER_FRONT_RIGHT_OF_CENTER);
-        }
-
-        return AMFACL_SPEAKER_FRONT_LEFT | AMFACL_SPEAKER_FRONT_RIGHT;
-    }
-
-    //----------------------------------------------------------------------------------------------
-    // AMFAudioBufferObserver interface - callback
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMFAudioBuffer;
-    class AMF_NO_VTABLE AMFAudioBufferObserver
-    {
-    public:
-        virtual void                AMF_STD_CALL OnBufferDataRelease(AMFAudioBuffer* pBuffer) = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFAudioBuffer AMFAudioBuffer;
-    typedef struct AMFAudioBufferObserver AMFAudioBufferObserver;
-    typedef struct AMFAudioBufferObserverVtbl
-    {
-        void                (AMF_STD_CALL *OnBufferDataRelease)(AMFAudioBufferObserver* pThis, AMFAudioBuffer* pBuffer);
-    } AMFAudioBufferObserverVtbl;
-
-    struct AMFAudioBufferObserver
-    {
-        const AMFAudioBufferObserverVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AudioBuffer interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFAudioBuffer : public AMFData
-    {
-    public:
-        AMF_DECLARE_IID(0x2212ff8, 0x6107, 0x430b, 0xb6, 0x3c, 0xc7, 0xe5, 0x40, 0xe5, 0xf8, 0xeb)
-
-        virtual amf_int32           AMF_STD_CALL GetSampleCount() = 0;
-        virtual amf_int32           AMF_STD_CALL GetSampleRate() = 0;
-        virtual amf_int32           AMF_STD_CALL GetChannelCount() = 0;
-        virtual AMF_AUDIO_FORMAT    AMF_STD_CALL GetSampleFormat() = 0;
-        virtual amf_int32           AMF_STD_CALL GetSampleSize() = 0;
-        virtual amf_uint32          AMF_STD_CALL GetChannelLayout() = 0;
-        virtual void*               AMF_STD_CALL GetNative() = 0;
-        virtual amf_size            AMF_STD_CALL GetSize() = 0;
-
-        // Observer management
-#ifdef __clang__
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Woverloaded-virtual"
-#endif
-        virtual void                AMF_STD_CALL AddObserver(AMFAudioBufferObserver* pObserver) = 0;
-        virtual void                AMF_STD_CALL RemoveObserver(AMFAudioBufferObserver* pObserver) = 0;
-#ifdef __clang__
-    #pragma clang diagnostic pop
-#endif
-
-
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFAudioBuffer> AMFAudioBufferPtr;
-    //----------------------------------------------------------------------------------------------
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFAudioBuffer, 0x2212ff8, 0x6107, 0x430b, 0xb6, 0x3c, 0xc7, 0xe5, 0x40, 0xe5, 0xf8, 0xeb)
-
-    typedef struct AMFAudioBufferVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFAudioBuffer* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFAudioBuffer* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFAudioBuffer* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFAudioBuffer* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFAudioBuffer* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFAudioBuffer* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFAudioBuffer* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFAudioBuffer* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFAudioBuffer* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFAudioBuffer* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFAudioBuffer* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFAudioBuffer* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFAudioBuffer* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFData interface
-
-        AMF_MEMORY_TYPE     (AMF_STD_CALL *GetMemoryType)(AMFAudioBuffer* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *Duplicate)(AMFAudioBuffer* pThis, AMF_MEMORY_TYPE type, AMFData** ppData);
-        AMF_RESULT          (AMF_STD_CALL *Convert)(AMFAudioBuffer* pThis, AMF_MEMORY_TYPE type); // optimal interop if possilble. Copy through host memory if needed
-        AMF_RESULT          (AMF_STD_CALL *Interop)(AMFAudioBuffer* pThis, AMF_MEMORY_TYPE type); // only optimal interop if possilble. No copy through host memory for GPU objects
-
-        AMF_DATA_TYPE       (AMF_STD_CALL *GetDataType)(AMFAudioBuffer* pThis);
-
-        amf_bool            (AMF_STD_CALL *IsReusable)(AMFAudioBuffer* pThis);
-
-        void                (AMF_STD_CALL *SetPts)(AMFAudioBuffer* pThis, amf_pts pts);
-        amf_pts             (AMF_STD_CALL *GetPts)(AMFAudioBuffer* pThis);
-        void                (AMF_STD_CALL *SetDuration)(AMFAudioBuffer* pThis, amf_pts duration);
-        amf_pts             (AMF_STD_CALL *GetDuration)(AMFAudioBuffer* pThis);
-
-        // AMFAudioBuffer interface
-
-        amf_int32           (AMF_STD_CALL *GetSampleCount)(AMFAudioBuffer* pThis);
-        amf_int32           (AMF_STD_CALL *GetSampleRate)(AMFAudioBuffer* pThis);
-        amf_int32           (AMF_STD_CALL *GetChannelCount)(AMFAudioBuffer* pThis);
-        AMF_AUDIO_FORMAT    (AMF_STD_CALL *GetSampleFormat)(AMFAudioBuffer* pThis);
-        amf_int32           (AMF_STD_CALL *GetSampleSize)(AMFAudioBuffer* pThis);
-        amf_uint32          (AMF_STD_CALL *GetChannelLayout)(AMFAudioBuffer* pThis);
-        void*               (AMF_STD_CALL *GetNative)(AMFAudioBuffer* pThis);
-        amf_size            (AMF_STD_CALL *GetSize)(AMFAudioBuffer* pThis);
-
-        // Observer management
-        void                (AMF_STD_CALL *AddObserver_AudioBuffer)(AMFAudioBuffer* pThis, AMFAudioBufferObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver_AudioBuffer)(AMFAudioBuffer* pThis, AMFAudioBufferObserver* pObserver);
-
-    } AMFAudioBufferVtbl;
-
-    struct AMFAudioBuffer
-    {
-        const AMFAudioBufferVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-#if defined(__cplusplus)
-} // namespace
-#endif
-#if defined(_MSC_VER)
-    #pragma warning( pop )
-#endif
-#endif //#ifndef AMF_AudioBuffer_h

plugins/obs-ffmpeg/external/AMF/include/core/Buffer.h

@@ -1,187 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Buffer_h
-#define AMF_Buffer_h
-#pragma once
-
-#include "Data.h"
-
-#if defined(_MSC_VER)
-    #pragma warning( push )
-    #pragma warning(disable : 4263)
-    #pragma warning(disable : 4264)
-#endif
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-
-    //----------------------------------------------------------------------------------------------
-    // AMF_BUFFER_USAGE translates to D3D11_BIND_FLAG or VkBufferUsageFlagBits
-    // bit mask
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_BUFFER_USAGE_BITS
-    {                                                      // D3D11                         D3D12                                       Vulkan 
-        AMF_BUFFER_USAGE_DEFAULT           = 0x80000000,   // D3D11_USAGE_STAGING,                                                      VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT 
-        AMF_BUFFER_USAGE_NONE              = 0x00000000,   // 0                  ,          D3D12_RESOURCE_FLAG_NONE,                   0
-        AMF_BUFFER_USAGE_CONSTANT          = 0x00000001,   // D3D11_BIND_CONSTANT_BUFFER,   											VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT 
-        AMF_BUFFER_USAGE_SHADER_RESOURCE   = 0x00000002,   // D3D11_BIND_SHADER_RESOURCE,   D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET,    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
-        AMF_BUFFER_USAGE_UNORDERED_ACCESS  = 0x00000004,   // D3D11_BIND_UNORDERED_ACCESS,  D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
-        AMF_BUFFER_USAGE_TRANSFER_SRC      = 0x00000008,   //                               								            VK_BUFFER_USAGE_TRANSFER_SRC_BIT
-        AMF_BUFFER_USAGE_TRANSFER_DST      = 0x00000010,   //                               								            VK_BUFFER_USAGE_TRANSFER_DST_BIT
-    } AMF_BUFFER_USAGE_BITS;
-    typedef amf_flags AMF_BUFFER_USAGE;
-    //----------------------------------------------------------------------------------------------
-
-
-    //----------------------------------------------------------------------------------------------
-    // AMFBufferObserver interface - callback
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMFBuffer;
-    class AMF_NO_VTABLE AMFBufferObserver
-    {
-    public:
-        virtual void                AMF_STD_CALL OnBufferDataRelease(AMFBuffer* pBuffer) = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFBuffer AMFBuffer;
-    typedef struct AMFBufferObserver AMFBufferObserver;
-
-    typedef struct AMFBufferObserverVtbl
-    {
-        void                (AMF_STD_CALL *OnBufferDataRelease)(AMFBufferObserver* pThis, AMFBuffer* pBuffer);
-    } AMFBufferObserverVtbl;
-
-    struct AMFBufferObserver
-    {
-        const AMFBufferObserverVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFBuffer interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFBuffer : public AMFData
-    {
-    public:
-        AMF_DECLARE_IID(0xb04b7248, 0xb6f0, 0x4321, 0xb6, 0x91, 0xba, 0xa4, 0x74, 0xf, 0x9f, 0xcb)
-
-        virtual AMF_RESULT          AMF_STD_CALL SetSize(amf_size newSize) = 0;
-        virtual amf_size            AMF_STD_CALL GetSize() = 0;
-        virtual void*               AMF_STD_CALL GetNative() = 0;
-
-        // Observer management
-#ifdef __clang__
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Woverloaded-virtual"
-#endif
-        virtual void                AMF_STD_CALL AddObserver(AMFBufferObserver* pObserver) = 0;
-        virtual void                AMF_STD_CALL RemoveObserver(AMFBufferObserver* pObserver) = 0;
-#ifdef __clang__
-    #pragma clang diagnostic pop
-#endif
-
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFBuffer> AMFBufferPtr;
-    //----------------------------------------------------------------------------------------------
-
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFBuffer, 0xb04b7248, 0xb6f0, 0x4321, 0xb6, 0x91, 0xba, 0xa4, 0x74, 0xf, 0x9f, 0xcb)
-
-    typedef struct AMFBufferVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFBuffer* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFBuffer* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFBuffer* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFBuffer* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFBuffer* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFBuffer* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFBuffer* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFBuffer* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFBuffer* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFBuffer* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFBuffer* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFBuffer* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFBuffer* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFData interface
-
-        AMF_MEMORY_TYPE     (AMF_STD_CALL *GetMemoryType)(AMFBuffer* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *Duplicate)(AMFBuffer* pThis, AMF_MEMORY_TYPE type, AMFData** ppData);
-        AMF_RESULT          (AMF_STD_CALL *Convert)(AMFBuffer* pThis, AMF_MEMORY_TYPE type); // optimal interop if possilble. Copy through host memory if needed
-        AMF_RESULT          (AMF_STD_CALL *Interop)(AMFBuffer* pThis, AMF_MEMORY_TYPE type); // only optimal interop if possilble. No copy through host memory for GPU objects
-
-        AMF_DATA_TYPE       (AMF_STD_CALL *GetDataType)(AMFBuffer* pThis);
-
-        amf_bool            (AMF_STD_CALL *IsReusable)(AMFBuffer* pThis);
-
-        void                (AMF_STD_CALL *SetPts)(AMFBuffer* pThis, amf_pts pts);
-        amf_pts             (AMF_STD_CALL *GetPts)(AMFBuffer* pThis);
-        void                (AMF_STD_CALL *SetDuration)(AMFBuffer* pThis, amf_pts duration);
-        amf_pts             (AMF_STD_CALL *GetDuration)(AMFBuffer* pThis);
-
-        // AMFBuffer interface
-
-        AMF_RESULT          (AMF_STD_CALL *SetSize)(AMFBuffer* pThis, amf_size newSize);
-        amf_size            (AMF_STD_CALL *GetSize)(AMFBuffer* pThis);
-        void*               (AMF_STD_CALL *GetNative)(AMFBuffer* pThis);
-
-        // Observer management
-        void                (AMF_STD_CALL *AddObserver_Buffer)(AMFBuffer* pThis, AMFBufferObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver_Buffer)(AMFBuffer* pThis, AMFBufferObserver* pObserver);
-
-    } AMFBufferVtbl;
-
-    struct AMFBuffer
-    {
-        const AMFBufferVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-#if defined(__cplusplus)
-} // namespace
-#endif
-#if defined(_MSC_VER)
-    #pragma warning( pop )
-#endif
-#endif //#ifndef AMF_Buffer_h

plugins/obs-ffmpeg/external/AMF/include/core/Compute.h

@@ -1,302 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-/**
- ***************************************************************************************************
- * @file  Compute.h
- * @brief AMFCompute interface declaration
- ***************************************************************************************************
- */
-#ifndef AMF_Compute_h
-#define AMF_Compute_h
-#pragma once
-
-#include "Buffer.h"
-#include "Surface.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    typedef amf_uint64 AMF_KERNEL_ID;
-
-    //----------------------------------------------------------------------------------------------
-    // enumerations for plane conversion
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_CHANNEL_ORDER
-    {
-        AMF_CHANNEL_ORDER_INVALID       = 0,
-        AMF_CHANNEL_ORDER_R             = 1,
-        AMF_CHANNEL_ORDER_RG            = 2,
-        AMF_CHANNEL_ORDER_BGRA          = 3,
-        AMF_CHANNEL_ORDER_RGBA          = 4,
-        AMF_CHANNEL_ORDER_ARGB          = 5,
-        AMF_CHANNEL_ORDER_YUY2          = 6,
-    } AMF_CHANNEL_ORDER;
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_CHANNEL_TYPE
-    {
-        AMF_CHANNEL_INVALID             = 0,
-        AMF_CHANNEL_UNSIGNED_INT8       = 1,
-        AMF_CHANNEL_UNSIGNED_INT32      = 2,
-        AMF_CHANNEL_UNORM_INT8          = 3,
-        AMF_CHANNEL_UNORM_INT16         = 4,
-        AMF_CHANNEL_SNORM_INT16         = 5,
-        AMF_CHANNEL_FLOAT               = 6,
-        AMF_CHANNEL_FLOAT16             = 7,
-        AMF_CHANNEL_UNSIGNED_INT16      = 8,
-        AMF_CHANNEL_UNORM_INT_101010    = 9,
-} AMF_CHANNEL_TYPE;
-    //----------------------------------------------------------------------------------------------
-#define AMF_STRUCTURED_BUFFER_FORMAT        L"StructuredBufferFormat"                                                             // amf_int64(AMF_CHANNEL_TYPE), default - AMF_CHANNEL_UNSIGNED_INT32; to be set on AMFBuffer objects
-#if defined(_WIN32)
-    AMF_WEAK GUID  AMFStructuredBufferFormatGUID = { 0x90c5d674, 0xe90, 0x4181, {0xbd, 0xef, 0x26, 0x13, 0xc1, 0xdf, 0xa3, 0xbd} }; // UINT(DXGI_FORMAT), default - DXGI_FORMAT_R32_UINT; to be set on ID3D11Buffer or ID3D11Texture2D objects when used natively
-#endif
-    //----------------------------------------------------------------------------------------------
-    // enumeration argument type
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_ARGUMENT_ACCESS_TYPE
-    {
-        AMF_ARGUMENT_ACCESS_READ        = 0,
-        AMF_ARGUMENT_ACCESS_WRITE       = 1,
-        AMF_ARGUMENT_ACCESS_READWRITE   = 2,
-        AMF_ARGUMENT_ACCESS_READWRITE_MASK  = 0xFFFF,
-        //Sampler parameters
-        AMF_ARGUMENT_SAMPLER_LINEAR        = 0x10000000, 
-        AMF_ARGUMENT_SAMPLER_NORM_COORD    = 0x20000000, 
-        AMF_ARGUMENT_SAMPLER_POINT         = 0x40000000,
-        AMF_ARGUMENT_SAMPLER_MASK          = 0xFFFF0000,
-    } AMF_ARGUMENT_ACCESS_TYPE;
-    //----------------------------------------------------------------------------------------------
-    // AMFComputeKernel interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComputeKernel : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x94815701, 0x6c84, 0x4ba6, 0xa9, 0xfe, 0xe9, 0xad, 0x40, 0xf8, 0x8, 0x8)
-
-        virtual void*               AMF_STD_CALL GetNative() = 0;
-        virtual const wchar_t*      AMF_STD_CALL GetIDName() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetArgPlaneNative(amf_size index, void* pPlane, AMF_ARGUMENT_ACCESS_TYPE eAccess) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetArgBufferNative(amf_size index, void* pBuffer, AMF_ARGUMENT_ACCESS_TYPE eAccess) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL SetArgPlane(amf_size index, AMFPlane* pPlane, AMF_ARGUMENT_ACCESS_TYPE eAccess) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetArgBuffer(amf_size index, AMFBuffer* pBuffer, AMF_ARGUMENT_ACCESS_TYPE eAccess) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL SetArgInt32(amf_size index, amf_int32 data) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetArgInt64(amf_size index, amf_int64 data) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetArgFloat(amf_size index, amf_float data) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetArgBlob(amf_size index, amf_size dataSize, const void* pData) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL GetCompileWorkgroupSize(amf_size workgroupSize[3]) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL Enqueue(amf_size dimension, amf_size globalOffset[3], amf_size globalSize[3], amf_size localSize[3]) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFComputeKernel> AMFComputeKernelPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFComputeKernel, 0x94815701, 0x6c84, 0x4ba6, 0xa9, 0xfe, 0xe9, 0xad, 0x40, 0xf8, 0x8, 0x8)
-    typedef struct AMFComputeKernel AMFComputeKernel;
-
-    typedef struct AMFComputeKernelVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFComputeKernel* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFComputeKernel* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFComputeKernel* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFComputeKernel interface 
-
-    } AMFComputeKernelVtbl;
-
-    struct AMFComputeKernel
-    {
-        const AMFComputeKernelVtbl *pVtbl;
-    };
-
-#endif //#if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFComputeSyncPoint interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComputeSyncPoint : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x66f33fe6, 0xaae, 0x4e65, 0xba, 0x3, 0xea, 0x8b, 0xa3, 0x60, 0x11, 0x2)
-
-        virtual amf_bool            AMF_STD_CALL IsCompleted() = 0;
-        virtual void                AMF_STD_CALL Wait() = 0;
-    };
-    typedef AMFInterfacePtr_T<AMFComputeSyncPoint> AMFComputeSyncPointPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFComputeSyncPoint, 0x66f33fe6, 0xaae, 0x4e65, 0xba, 0x3, 0xea, 0x8b, 0xa3, 0x60, 0x11, 0x2)
-    typedef struct AMFComputeSyncPoint AMFComputeSyncPoint;
-
-    typedef struct AMFComputeSyncPointVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFComputeSyncPoint* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFComputeSyncPoint* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFComputeSyncPoint* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFComputeSyncPoint interface 
-        amf_bool            (AMF_STD_CALL *IsCompleted)(AMFComputeSyncPoint* pThis);
-        void                (AMF_STD_CALL *Wait)(AMFComputeSyncPoint* pThis);
-
-    } AMFComputeSyncPointVtbl;
-
-    struct AMFComputeSyncPoint
-    {
-        const AMFComputeSyncPointVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFCompute interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFCompute : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x3846233a, 0x3f43, 0x443f, 0x8a, 0x45, 0x75, 0x22, 0x11, 0xa9, 0xfb, 0xd5)
-
-        virtual AMF_MEMORY_TYPE     AMF_STD_CALL GetMemoryType() = 0;
-
-        virtual void*               AMF_STD_CALL GetNativeContext() = 0;
-        virtual void*               AMF_STD_CALL GetNativeDeviceID() = 0;
-        virtual void*               AMF_STD_CALL GetNativeCommandQueue() = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL GetKernel(AMF_KERNEL_ID kernelID, AMFComputeKernel** kernel) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL PutSyncPoint(AMFComputeSyncPoint** ppSyncPoint) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL FinishQueue() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL FlushQueue() = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL FillPlane(AMFPlane *pPlane, const amf_size origin[3], const amf_size region[3], const void* pColor) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL FillBuffer(AMFBuffer* pBuffer, amf_size dstOffset, amf_size dstSize, const void* pSourcePattern, amf_size patternSize) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL ConvertPlaneToBuffer(AMFPlane *pSrcPlane, AMFBuffer** ppDstBuffer) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL CopyBuffer(AMFBuffer* pSrcBuffer, amf_size srcOffset, amf_size size, AMFBuffer* pDstBuffer, amf_size dstOffset) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CopyPlane(AMFPlane *pSrcPlane, const amf_size srcOrigin[3], const amf_size region[3], AMFPlane *pDstPlane, const amf_size dstOrigin[3]) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL CopyBufferToHost(AMFBuffer* pSrcBuffer, amf_size srcOffset, amf_size size, void* pDest, amf_bool blocking) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CopyBufferFromHost(const void* pSource, amf_size size, AMFBuffer* pDstBuffer, amf_size dstOffsetInBytes, amf_bool blocking) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL CopyPlaneToHost(AMFPlane *pSrcPlane, const amf_size origin[3], const amf_size region[3], void* pDest, amf_size dstPitch, amf_bool blocking) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CopyPlaneFromHost(void* pSource, const amf_size origin[3], const amf_size region[3], amf_size srcPitch, AMFPlane *pDstPlane, amf_bool blocking) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL ConvertPlaneToPlane(AMFPlane* pSrcPlane, AMFPlane** ppDstPlane, AMF_CHANNEL_ORDER order, AMF_CHANNEL_TYPE type) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFCompute> AMFComputePtr;
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFCompute, 0x3846233a, 0x3f43, 0x443f, 0x8a, 0x45, 0x75, 0x22, 0x11, 0xa9, 0xfb, 0xd5)
-    typedef struct AMFCompute AMFCompute;
-
-    typedef struct AMFComputeVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFCompute* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFCompute* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFCompute* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFCompute interface 
-        AMF_MEMORY_TYPE     (AMF_STD_CALL *GetMemoryType)(AMFCompute* pThis);
-        void*               (AMF_STD_CALL *GetNativeContext)(AMFCompute* pThis);
-        void*               (AMF_STD_CALL *GetNativeDeviceID)(AMFCompute* pThis);
-        void*               (AMF_STD_CALL *GetNativeCommandQueue)(AMFCompute* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetKernel)(AMFCompute* pThis, AMF_KERNEL_ID kernelID, AMFComputeKernel** kernel);
-        AMF_RESULT          (AMF_STD_CALL *PutSyncPoint)(AMFCompute* pThis, AMFComputeSyncPoint** ppSyncPoint);
-        AMF_RESULT          (AMF_STD_CALL *FinishQueue)(AMFCompute* pThis);
-        AMF_RESULT          (AMF_STD_CALL *FlushQueue)(AMFCompute* pThis);
-        AMF_RESULT          (AMF_STD_CALL *FillPlane)(AMFCompute* pThis, AMFPlane *pPlane, const amf_size origin[3], const amf_size region[3], const void* pColor);
-        AMF_RESULT          (AMF_STD_CALL *FillBuffer)(AMFCompute* pThis, AMFBuffer* pBuffer, amf_size dstOffset, amf_size dstSize, const void* pSourcePattern, amf_size patternSize);
-        AMF_RESULT          (AMF_STD_CALL *ConvertPlaneToBuffer)(AMFCompute* pThis, AMFPlane *pSrcPlane, AMFBuffer** ppDstBuffer);
-        AMF_RESULT          (AMF_STD_CALL *CopyBuffer)(AMFCompute* pThis, AMFBuffer* pSrcBuffer, amf_size srcOffset, amf_size size, AMFBuffer* pDstBuffer, amf_size dstOffset);
-        AMF_RESULT          (AMF_STD_CALL *CopyPlane)(AMFCompute* pThis, AMFPlane *pSrcPlane, const amf_size srcOrigin[3], const amf_size region[3], AMFPlane *pDstPlane, const amf_size dstOrigin[3]);
-        AMF_RESULT          (AMF_STD_CALL *CopyBufferToHost)(AMFCompute* pThis, AMFBuffer* pSrcBuffer, amf_size srcOffset, amf_size size, void* pDest, amf_bool blocking);
-        AMF_RESULT          (AMF_STD_CALL *CopyBufferFromHost)(AMFCompute* pThis, const void* pSource, amf_size size, AMFBuffer* pDstBuffer, amf_size dstOffsetInBytes, amf_bool blocking);
-        AMF_RESULT          (AMF_STD_CALL *CopyPlaneToHost)(AMFCompute* pThis, AMFPlane *pSrcPlane, const amf_size origin[3], const amf_size region[3], void* pDest, amf_size dstPitch, amf_bool blocking);
-        AMF_RESULT          (AMF_STD_CALL *CopyPlaneFromHost)(AMFCompute* pThis, void* pSource, const amf_size origin[3], const amf_size region[3], amf_size srcPitch, AMFPlane *pDstPlane, amf_bool blocking);
-        AMF_RESULT          (AMF_STD_CALL *ConvertPlaneToPlane)(AMFCompute* pThis, AMFPlane* pSrcPlane, AMFPlane** ppDstPlane, AMF_CHANNEL_ORDER order, AMF_CHANNEL_TYPE type);
-    } AMFComputeVtbl;
-
-    struct AMFCompute
-    {
-        const AMFComputeVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFPrograms interface - singleton
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFPrograms
-    {
-    public:
-        virtual AMF_RESULT          AMF_STD_CALL RegisterKernelSourceFile(AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, const wchar_t* filepath, const char* options) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL RegisterKernelSource(AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL RegisterKernelBinary(AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL RegisterKernelSource1(AMF_MEMORY_TYPE eMemoryType, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL RegisterKernelBinary1(AMF_MEMORY_TYPE eMemoryType, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options) = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFPrograms AMFPrograms;
-    typedef struct AMFProgramsVtbl
-    {
-        AMF_RESULT          (AMF_STD_CALL *RegisterKernelSourceFile)(AMFPrograms* pThis, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, const wchar_t* filepath, const char* options);
-        AMF_RESULT          (AMF_STD_CALL *RegisterKernelSource)(AMFPrograms* pThis, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options);
-        AMF_RESULT          (AMF_STD_CALL *RegisterKernelBinary)(AMFPrograms* pThis, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options);
-        AMF_RESULT          (AMF_STD_CALL *RegisterKernelSource1)(AMFPrograms* pThis, AMF_MEMORY_TYPE eMemoryType, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options);
-        AMF_RESULT          (AMF_STD_CALL *RegisterKernelBinary1)(AMFPrograms* pThis, AMF_MEMORY_TYPE eMemoryType, AMF_KERNEL_ID* pKernelID, const wchar_t* kernelid_name, const char* kernelName, amf_size dataSize, const amf_uint8* data, const char* options);
-    } AMFProgramsVtbl;
-
-    struct AMFPrograms
-    {
-        const AMFProgramsVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-
-#if defined(__cplusplus)
-} // namespace amf
-#endif
-
-#endif // AMF_Compute_h

plugins/obs-ffmpeg/external/AMF/include/core/ComputeFactory.h

@@ -1,147 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_ComputeFactory_h
-#define AMF_ComputeFactory_h
-#pragma once
-
-#include "Compute.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-// compute device audio capabilities accessed via GetProperties() from AMFComputeDevice
-#define AMF_DEVICE_NAME                         L"DeviceName"                       // char*, string, device name
-#define AMF_DRIVER_VERSION_NAME                 L"DriverVersion"                       // char*, string, driver version
-#define AMF_AUDIO_CONVOLUTION_MAX_STREAMS       L"ConvolutionMaxStreams"            // amf_int64, maximum number of audio streams supported in realtime
-#define AMF_AUDIO_CONVOLUTION_LENGTH            L"ConvolutionLength"                // amf_int64, length of convolution in samples
-#define AMF_AUDIO_CONVOLUTION_BUFFER_SIZE       L"ConvolutionBufferSize"            // amf_int64, buffer size in samples
-#define AMF_AUDIO_CONVOLUTION_SAMPLE_RATE       L"ConvolutionSampleRate"            // amf_int64, sample rate
-
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComputeDevice  : public AMFPropertyStorage
-    {
-    public:
-        AMF_DECLARE_IID(0xb79d7cf6, 0x2c5c, 0x4deb, 0xb8, 0x96, 0xa2, 0x9e, 0xbe, 0xa6, 0xe3, 0x97)
-
-        virtual void*               AMF_STD_CALL GetNativePlatform() = 0;
-        virtual void*               AMF_STD_CALL GetNativeDeviceID() = 0;
-        virtual void*               AMF_STD_CALL GetNativeContext() = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL CreateCompute(void *reserved, AMFCompute **ppCompute) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateComputeEx(void* pCommandQueue, AMFCompute **ppCompute) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFComputeDevice> AMFComputeDevicePtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFComputeDevice, 0xb79d7cf6, 0x2c5c, 0x4deb, 0xb8, 0x96, 0xa2, 0x9e, 0xbe, 0xa6, 0xe3, 0x97)
-    typedef struct AMFComputeDevice AMFComputeDevice;
-
-    typedef struct AMFComputeDeviceVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFComputeDevice* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFComputeDevice* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFComputeDevice* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFComputeDevice* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFComputeDevice* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFComputeDevice* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFComputeDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFComputeDevice* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFComputeDevice* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFComputeDevice* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFComputeDevice* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFComputeDevice* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFComputeDevice* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFComputeDevice interface
-       void*               (AMF_STD_CALL *GetNativePlatform)(AMFComputeDevice* pThis);
-       void*               (AMF_STD_CALL *GetNativeDeviceID)(AMFComputeDevice* pThis);
-       void*               (AMF_STD_CALL *GetNativeContext)(AMFComputeDevice* pThis);
-
-       AMF_RESULT          (AMF_STD_CALL *CreateCompute)(AMFComputeDevice* pThis, void *reserved, AMFCompute **ppCompute);
-       AMF_RESULT          (AMF_STD_CALL *CreateComputeEx)(AMFComputeDevice* pThis, void* pCommandQueue, AMFCompute **ppCompute);
-
-    } AMFComputeDeviceVtbl;
-
-    struct AMFComputeDevice
-    {
-        const AMFComputeDeviceVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFComputeFactory : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0xe3c24bd7, 0x2d83, 0x416c, 0x8c, 0x4e, 0xfd, 0x13, 0xca, 0x86, 0xf4, 0xd0)
-
-        virtual amf_int32           AMF_STD_CALL GetDeviceCount() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetDeviceAt(amf_int32 index, AMFComputeDevice **ppDevice) = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFComputeFactory> AMFComputeFactoryPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFComputeFactory, 0xe3c24bd7, 0x2d83, 0x416c, 0x8c, 0x4e, 0xfd, 0x13, 0xca, 0x86, 0xf4, 0xd0)
-    typedef struct AMFComputeFactory AMFComputeFactory;
-
-    typedef struct AMFComputeFactoryVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFComputeFactory* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFComputeFactory* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFComputeFactory* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFComputeFactory interface
-        amf_int32           (AMF_STD_CALL *GetDeviceCount)(AMFComputeFactory* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetDeviceAt)(AMFComputeFactory* pThis, amf_int32 index, AMFComputeDevice **ppDevice);
-    } AMFComputeFactoryVtbl;
-
-    struct AMFComputeFactory
-    {
-        const AMFComputeFactoryVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-} // namespace amf
-#endif
-
-#endif // AMF_ComputeFactory_h

plugins/obs-ffmpeg/external/AMF/include/core/Context.h

@@ -1,786 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Context_h
-#define AMF_Context_h
-#pragma once
-
-#include "Buffer.h"
-#include "AudioBuffer.h"
-#include "Surface.h"
-#include "Compute.h"
-#include "ComputeFactory.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // AMFContext interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFContext : public AMFPropertyStorage
-    {
-    public:
-        AMF_DECLARE_IID(0xa76a13f0, 0xd80e, 0x4fcc, 0xb5, 0x8, 0x65, 0xd0, 0xb5, 0x2e, 0xd9, 0xee)
-        
-        // Cleanup
-        virtual AMF_RESULT          AMF_STD_CALL Terminate() = 0;
-
-        // DX9
-        virtual AMF_RESULT          AMF_STD_CALL InitDX9(void* pDX9Device) = 0;
-        virtual void*               AMF_STD_CALL GetDX9Device(AMF_DX_VERSION dxVersionRequired = AMF_DX9) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockDX9() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockDX9() = 0;
-        class AMFDX9Locker;
-
-        // DX11
-        virtual AMF_RESULT          AMF_STD_CALL InitDX11(void* pDX11Device, AMF_DX_VERSION dxVersionRequired = AMF_DX11_0) = 0;
-        virtual void*               AMF_STD_CALL GetDX11Device(AMF_DX_VERSION dxVersionRequired = AMF_DX11_0) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockDX11() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockDX11() = 0;
-        class AMFDX11Locker;
-
-        // OpenCL
-        virtual AMF_RESULT          AMF_STD_CALL InitOpenCL(void* pCommandQueue = NULL) = 0;
-        virtual void*               AMF_STD_CALL GetOpenCLContext() = 0;
-        virtual void*               AMF_STD_CALL GetOpenCLCommandQueue() = 0;
-        virtual void*               AMF_STD_CALL GetOpenCLDeviceID() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetOpenCLComputeFactory(AMFComputeFactory **ppFactory) = 0; // advanced compute - multiple queries
-        virtual AMF_RESULT          AMF_STD_CALL InitOpenCLEx(AMFComputeDevice *pDevice) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockOpenCL() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockOpenCL() = 0;
-        class AMFOpenCLLocker;
-
-        // OpenGL
-        virtual AMF_RESULT          AMF_STD_CALL InitOpenGL(amf_handle hOpenGLContext, amf_handle hWindow, amf_handle hDC) = 0;
-        virtual amf_handle          AMF_STD_CALL GetOpenGLContext() = 0;
-        virtual amf_handle          AMF_STD_CALL GetOpenGLDrawable() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockOpenGL() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockOpenGL() = 0;
-        class AMFOpenGLLocker;
-
-        // XV - Linux
-        virtual AMF_RESULT          AMF_STD_CALL InitXV(void* pXVDevice) = 0;
-        virtual void*               AMF_STD_CALL GetXVDevice() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockXV() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockXV() = 0;
-        class AMFXVLocker;
-
-        // Gralloc - Android
-        virtual AMF_RESULT          AMF_STD_CALL InitGralloc(void* pGrallocDevice) = 0;
-        virtual void*               AMF_STD_CALL GetGrallocDevice() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockGralloc() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockGralloc() = 0;
-        class AMFGrallocLocker;
-
-        // Allocation
-        virtual AMF_RESULT          AMF_STD_CALL AllocBuffer(AMF_MEMORY_TYPE type, amf_size size, AMFBuffer** ppBuffer) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL AllocSurface(AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMFSurface** ppSurface) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL AllocAudioBuffer(AMF_MEMORY_TYPE type, AMF_AUDIO_FORMAT format, amf_int32 samples, amf_int32 sampleRate, amf_int32 channels, 
-                                                    AMFAudioBuffer** ppAudioBuffer) = 0;
-
-        // Wrap existing objects
-        virtual AMF_RESULT          AMF_STD_CALL CreateBufferFromHostNative(void* pHostBuffer, amf_size size, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromHostNative(AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, amf_int32 hPitch, amf_int32 vPitch, void* pData, 
-                                                     AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromDX9Native(void* pDX9Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromDX11Native(void* pDX11Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromOpenGLNative(AMF_SURFACE_FORMAT format, amf_handle hGLTextureID, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromGrallocNative(amf_handle hGrallocSurface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromOpenCLNative(AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, void** pClPlanes, 
-                                                     AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateBufferFromOpenCLNative(void* pCLBuffer, amf_size size, AMFBuffer** ppBuffer) = 0;
-
-        // Access to AMFCompute interface - AMF_MEMORY_OPENCL, AMF_MEMORY_COMPUTE_FOR_DX9, AMF_MEMORY_COMPUTE_FOR_DX11 are currently supported
-        virtual AMF_RESULT          AMF_STD_CALL GetCompute(AMF_MEMORY_TYPE eMemType, AMFCompute** ppCompute) = 0;
-    };
-
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFContext> AMFContextPtr;
-
-    //----------------------------------------------------------------------------------------------
-    // AMFContext1 interface
-    //----------------------------------------------------------------------------------------------
-
-    class AMF_NO_VTABLE AMFContext1 : public AMFContext
-    {
-    public:
-        AMF_DECLARE_IID(0xd9e9f868, 0x6220, 0x44c6, 0xa2, 0x2f, 0x7c, 0xd6, 0xda, 0xc6, 0x86, 0x46)
-
-        virtual AMF_RESULT          AMF_STD_CALL CreateBufferFromDX11Native(void* pHostBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL AllocBufferEx(AMF_MEMORY_TYPE type, amf_size size, AMF_BUFFER_USAGE usage, AMF_MEMORY_CPU_ACCESS access, AMFBuffer** ppBuffer) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL AllocSurfaceEx(AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMF_SURFACE_USAGE usage, AMF_MEMORY_CPU_ACCESS access, AMFSurface** ppSurface) = 0;
-
-        // Vulkan - Windows, Linux
-        virtual AMF_RESULT          AMF_STD_CALL InitVulkan(void* pVulkanDevice) = 0;
-        virtual void*               AMF_STD_CALL GetVulkanDevice() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockVulkan() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockVulkan() = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromVulkanNative(void* pVulkanImage, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateBufferFromVulkanNative(void* pVulkanBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetVulkanDeviceExtensions(amf_size *pCount, const char **ppExtensions) = 0;
-
-        
-        class AMFVulkanLocker;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFContext1> AMFContext1Ptr;
-
-    class AMF_NO_VTABLE AMFContext2 : public AMFContext1
-    {
-    public:
-        AMF_DECLARE_IID(0x726241d3, 0xbd46, 0x4e90, 0x99, 0x68, 0x93, 0xe0, 0x7e, 0xa2, 0x98, 0x4d)
-
-        // DX12
-        virtual AMF_RESULT          AMF_STD_CALL InitDX12(void* pDX11Device, AMF_DX_VERSION dxVersionRequired = AMF_DX12) = 0;
-        virtual void*               AMF_STD_CALL GetDX12Device(AMF_DX_VERSION dxVersionRequired = AMF_DX12) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL LockDX12() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL UnlockDX12() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateSurfaceFromDX12Native(void* pResourceTexture, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateBufferFromDX12Native(void* pResourceBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver) = 0;
-
-        class AMFDX12Locker;
-    };
-    typedef AMFInterfacePtr_T<AMFContext2> AMFContext2Ptr;
-#else
-    typedef struct AMFContext AMFContext;
-    AMF_DECLARE_IID(AMFContext, 0xa76a13f0, 0xd80e, 0x4fcc, 0xb5, 0x8, 0x65, 0xd0, 0xb5, 0x2e, 0xd9, 0xee)
-
-    typedef struct AMFContextVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFContext* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFContext* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFContext* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-        
-        // AMFInterface AMFPropertyStorage
-
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFContext* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFContext* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFContext* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFContext* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFContext* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFContext* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFContext* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFContext* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFContext interface
-       
-        // Cleanup
-        AMF_RESULT          (AMF_STD_CALL *Terminate)(AMFContext* pThis);
-
-        // DX9
-        AMF_RESULT          (AMF_STD_CALL *InitDX9)(AMFContext* pThis, void* pDX9Device);
-        void*               (AMF_STD_CALL *GetDX9Device)(AMFContext* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX9)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX9)(AMFContext* pThis);
-        // DX11
-        AMF_RESULT          (AMF_STD_CALL *InitDX11)(AMFContext* pThis, void* pDX11Device, AMF_DX_VERSION dxVersionRequired);
-        void*               (AMF_STD_CALL *GetDX11Device)(AMFContext* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX11)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX11)(AMFContext* pThis);
-
-        // OpenCL
-        AMF_RESULT          (AMF_STD_CALL *InitOpenCL)(AMFContext* pThis, void* pCommandQueue);
-        void*               (AMF_STD_CALL *GetOpenCLContext)(AMFContext* pThis);
-        void*               (AMF_STD_CALL *GetOpenCLCommandQueue)(AMFContext* pThis);
-        void*               (AMF_STD_CALL *GetOpenCLDeviceID)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetOpenCLComputeFactory)(AMFContext* pThis, AMFComputeFactory **ppFactory); // advanced compute - multiple queries
-        AMF_RESULT          (AMF_STD_CALL *InitOpenCLEx)(AMFContext* pThis, AMFComputeDevice *pDevice);
-        AMF_RESULT          (AMF_STD_CALL *LockOpenCL)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockOpenCL)(AMFContext* pThis);
-
-        // OpenGL
-        AMF_RESULT          (AMF_STD_CALL *InitOpenGL)(AMFContext* pThis, amf_handle hOpenGLContext, amf_handle hWindow, amf_handle hDC);
-        amf_handle          (AMF_STD_CALL *GetOpenGLContext)(AMFContext* pThis);
-        amf_handle          (AMF_STD_CALL *GetOpenGLDrawable)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockOpenGL)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockOpenGL)(AMFContext* pThis);
-        // XV - Linux
-        AMF_RESULT          (AMF_STD_CALL *InitXV)(AMFContext* pThis, void* pXVDevice);
-        void*               (AMF_STD_CALL *GetXVDevice)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockXV)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockXV)(AMFContext* pThis);
-
-        // Gralloc - Android
-        AMF_RESULT          (AMF_STD_CALL *InitGralloc)(AMFContext* pThis, void* pGrallocDevice);
-        void*               (AMF_STD_CALL *GetGrallocDevice)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockGralloc)(AMFContext* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockGralloc)(AMFContext* pThis);
-        // Allocation
-        AMF_RESULT          (AMF_STD_CALL *AllocBuffer)(AMFContext* pThis, AMF_MEMORY_TYPE type, amf_size size, AMFBuffer** ppBuffer);
-        AMF_RESULT          (AMF_STD_CALL *AllocSurface)(AMFContext* pThis, AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMFSurface** ppSurface);
-        AMF_RESULT          (AMF_STD_CALL *AllocAudioBuffer)(AMFContext* pThis, AMF_MEMORY_TYPE type, AMF_AUDIO_FORMAT format, amf_int32 samples, amf_int32 sampleRate, amf_int32 channels, 
-                                                    AMFAudioBuffer** ppAudioBuffer);
-
-        // Wrap existing objects
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromHostNative)(AMFContext* pThis, void* pHostBuffer, amf_size size, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromHostNative)(AMFContext* pThis, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, amf_int32 hPitch, amf_int32 vPitch, void* pData, 
-                                                     AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX9Native)(AMFContext* pThis, void* pDX9Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX11Native)(AMFContext* pThis, void* pDX11Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromOpenGLNative)(AMFContext* pThis, AMF_SURFACE_FORMAT format, amf_handle hGLTextureID, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromGrallocNative)(AMFContext* pThis, amf_handle hGrallocSurface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromOpenCLNative)(AMFContext* pThis, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, void** pClPlanes, 
-                                                     AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromOpenCLNative)(AMFContext* pThis, void* pCLBuffer, amf_size size, AMFBuffer** ppBuffer);
-
-        // Access to AMFCompute interface - AMF_MEMORY_OPENCL, AMF_MEMORY_COMPUTE_FOR_DX9, AMF_MEMORY_COMPUTE_FOR_DX11 are currently supported
-        AMF_RESULT          (AMF_STD_CALL *GetCompute)(AMFContext* pThis, AMF_MEMORY_TYPE eMemType, AMFCompute** ppCompute);
-
-    } AMFContextVtbl;
-
-    struct AMFContext
-    {
-        const AMFContextVtbl *pVtbl;
-    };
-
-
-    typedef struct AMFContext1 AMFContext1;
-    AMF_DECLARE_IID(AMFContext1, 0xd9e9f868, 0x6220, 0x44c6, 0xa2, 0x2f, 0x7c, 0xd6, 0xda, 0xc6, 0x86, 0x46)
-
-    typedef struct AMFContext1Vtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFContext1* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFContext1* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFContext1* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-        
-        // AMFInterface AMFPropertyStorage
-
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFContext1* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFContext1* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFContext1* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFContext1* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFContext1* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFContext1* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFContext1* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFContext1* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFContext interface
-       
-        // Cleanup
-        AMF_RESULT          (AMF_STD_CALL *Terminate)(AMFContext1* pThis);
-
-        // DX9
-        AMF_RESULT          (AMF_STD_CALL *InitDX9)(AMFContext1* pThis, void* pDX9Device);
-        void*               (AMF_STD_CALL *GetDX9Device)(AMFContext1* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX9)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX9)(AMFContext1* pThis);
-        // DX11
-        AMF_RESULT          (AMF_STD_CALL *InitDX11)(AMFContext1* pThis, void* pDX11Device, AMF_DX_VERSION dxVersionRequired);
-        void*               (AMF_STD_CALL *GetDX11Device)(AMFContext1* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX11)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX11)(AMFContext1* pThis);
-
-        // OpenCL
-        AMF_RESULT          (AMF_STD_CALL *InitOpenCL)(AMFContext1* pThis, void* pCommandQueue);
-        void*               (AMF_STD_CALL *GetOpenCLContext)(AMFContext1* pThis);
-        void*               (AMF_STD_CALL *GetOpenCLCommandQueue)(AMFContext1* pThis);
-        void*               (AMF_STD_CALL *GetOpenCLDeviceID)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetOpenCLComputeFactory)(AMFContext1* pThis, AMFComputeFactory **ppFactory); // advanced compute - multiple queries
-        AMF_RESULT          (AMF_STD_CALL *InitOpenCLEx)(AMFContext1* pThis, AMFComputeDevice *pDevice);
-        AMF_RESULT          (AMF_STD_CALL *LockOpenCL)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockOpenCL)(AMFContext1* pThis);
-
-        // OpenGL
-        AMF_RESULT          (AMF_STD_CALL *InitOpenGL)(AMFContext1* pThis, amf_handle hOpenGLContext, amf_handle hWindow, amf_handle hDC);
-        amf_handle          (AMF_STD_CALL *GetOpenGLContext)(AMFContext1* pThis);
-        amf_handle          (AMF_STD_CALL *GetOpenGLDrawable)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockOpenGL)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockOpenGL)(AMFContext1* pThis);
-        // XV - Linux
-        AMF_RESULT          (AMF_STD_CALL *InitXV)(AMFContext1* pThis, void* pXVDevice);
-        void*               (AMF_STD_CALL *GetXVDevice)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockXV)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockXV)(AMFContext1* pThis);
-
-        // Gralloc - Android
-        AMF_RESULT          (AMF_STD_CALL *InitGralloc)(AMFContext1* pThis, void* pGrallocDevice);
-        void*               (AMF_STD_CALL *GetGrallocDevice)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockGralloc)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockGralloc)(AMFContext1* pThis);
-        // Allocation
-        AMF_RESULT          (AMF_STD_CALL *AllocBuffer)(AMFContext1* pThis, AMF_MEMORY_TYPE type, amf_size size, AMFBuffer** ppBuffer);
-        AMF_RESULT          (AMF_STD_CALL *AllocSurface)(AMFContext1* pThis, AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMFSurface** ppSurface);
-        AMF_RESULT          (AMF_STD_CALL *AllocAudioBuffer)(AMFContext1* pThis, AMF_MEMORY_TYPE type, AMF_AUDIO_FORMAT format, amf_int32 samples, amf_int32 sampleRate, amf_int32 channels, 
-                                                    AMFAudioBuffer** ppAudioBuffer);
-
-        // Wrap existing objects
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromHostNative)(AMFContext1* pThis, void* pHostBuffer, amf_size size, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromHostNative)(AMFContext1* pThis, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, amf_int32 hPitch, amf_int32 vPitch, void* pData, 
-                                                     AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX9Native)(AMFContext1* pThis, void* pDX9Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX11Native)(AMFContext1* pThis, void* pDX11Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromOpenGLNative)(AMFContext1* pThis, AMF_SURFACE_FORMAT format, amf_handle hGLTextureID, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromGrallocNative)(AMFContext1* pThis, amf_handle hGrallocSurface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromOpenCLNative)(AMFContext1* pThis, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, void** pClPlanes, 
-                                                     AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromOpenCLNative)(AMFContext1* pThis, void* pCLBuffer, amf_size size, AMFBuffer** ppBuffer);
-
-        // Access to AMFCompute interface - AMF_MEMORY_OPENCL, AMF_MEMORY_COMPUTE_FOR_DX9, AMF_MEMORY_COMPUTE_FOR_DX11 are currently supported
-        AMF_RESULT          (AMF_STD_CALL *GetCompute)(AMFContext1* pThis, AMF_MEMORY_TYPE eMemType, AMFCompute** ppCompute);
-
-        // AMFContext1 interface
-
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromDX11Native)(AMFContext1* pThis, void* pHostBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *AllocBufferEx)(AMFContext1* pThis, AMF_MEMORY_TYPE type, amf_size size, AMF_BUFFER_USAGE usage, AMF_MEMORY_CPU_ACCESS access, AMFBuffer** ppBuffer);
-        AMF_RESULT          (AMF_STD_CALL *AllocSurfaceEx)(AMFContext1* pThis, AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMF_SURFACE_USAGE usage, AMF_MEMORY_CPU_ACCESS access, AMFSurface** ppSurface);
-
-        // Vulkan - Windows, Linux
-        AMF_RESULT          (AMF_STD_CALL *InitVulkan)(AMFContext1* pThis, void* pVulkanDevice);
-        void*               (AMF_STD_CALL *GetVulkanDevice)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockVulkan)(AMFContext1* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockVulkan)(AMFContext1* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromVulkanNative)(AMFContext1* pThis, void* pVulkanImage, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromVulkanNative)(AMFContext1* pThis, void* pVulkanBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *GetVulkanDeviceExtensions)(AMFContext1* pThis, amf_size *pCount, const char **ppExtensions);
-
-    } AMFContext1Vtbl;
-
-    struct AMFContext1
-    {
-        const AMFContext1Vtbl *pVtbl;
-    };
-
-    typedef struct AMFContext2 AMFContext2;
-    AMF_DECLARE_IID(AMFContext2, 0xd9e9f868, 0x6220, 0x44c6, 0xa2, 0x2f, 0x7c, 0xd6, 0xda, 0xc6, 0x86, 0x46)
-
-        typedef struct AMFContext2Vtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFContext2* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFContext2* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFContext2* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFInterface AMFPropertyStorage
-
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFContext2* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFContext2* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFContext2* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFContext2* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFContext2* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFContext2* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFContext2* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFContext2* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFContext interface
-
-        // Cleanup
-        AMF_RESULT          (AMF_STD_CALL *Terminate)(AMFContext2* pThis);
-
-        // DX9
-        AMF_RESULT          (AMF_STD_CALL *InitDX9)(AMFContext2* pThis, void* pDX9Device);
-        void*                         (AMF_STD_CALL *GetDX9Device)(AMFContext2* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX9)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX9)(AMFContext2* pThis);
-        // DX11
-        AMF_RESULT          (AMF_STD_CALL *InitDX11)(AMFContext2* pThis, void* pDX11Device, AMF_DX_VERSION dxVersionRequired);
-        void*                         (AMF_STD_CALL *GetDX11Device)(AMFContext2* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX11)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX11)(AMFContext2* pThis);
-
-        // OpenCL
-        AMF_RESULT          (AMF_STD_CALL *InitOpenCL)(AMFContext2* pThis, void* pCommandQueue);
-        void*               (AMF_STD_CALL *GetOpenCLContext)(AMFContext2* pThis);
-        void*               (AMF_STD_CALL *GetOpenCLCommandQueue)(AMFContext2* pThis);
-        void*               (AMF_STD_CALL *GetOpenCLDeviceID)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetOpenCLComputeFactory)(AMFContext2* pThis, AMFComputeFactory **ppFactory); // advanced compute - multiple queries
-        AMF_RESULT          (AMF_STD_CALL *InitOpenCLEx)(AMFContext2* pThis, AMFComputeDevice *pDevice);
-        AMF_RESULT          (AMF_STD_CALL *LockOpenCL)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockOpenCL)(AMFContext2* pThis);
-
-        // OpenGL
-        AMF_RESULT          (AMF_STD_CALL *InitOpenGL)(AMFContext2* pThis, amf_handle hOpenGLContext, amf_handle hWindow, amf_handle hDC);
-        amf_handle          (AMF_STD_CALL *GetOpenGLContext)(AMFContext2* pThis);
-        amf_handle          (AMF_STD_CALL *GetOpenGLDrawable)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockOpenGL)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockOpenGL)(AMFContext2* pThis);
-        // XV - Linux
-        AMF_RESULT          (AMF_STD_CALL *InitXV)(AMFContext2* pThis, void* pXVDevice);
-        void*               (AMF_STD_CALL *GetXVDevice)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockXV)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockXV)(AMFContext2* pThis);
-
-        // Gralloc - Android
-        AMF_RESULT          (AMF_STD_CALL *InitGralloc)(AMFContext2* pThis, void* pGrallocDevice);
-        void*               (AMF_STD_CALL *GetGrallocDevice)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockGralloc)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockGralloc)(AMFContext2* pThis);
-        // Allocation
-        AMF_RESULT          (AMF_STD_CALL *AllocBuffer)(AMFContext2* pThis, AMF_MEMORY_TYPE type, amf_size size, AMFBuffer** ppBuffer);
-        AMF_RESULT          (AMF_STD_CALL *AllocSurface)(AMFContext2* pThis, AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMFSurface** ppSurface);
-        AMF_RESULT          (AMF_STD_CALL *AllocAudioBuffer)(AMFContext2* pThis, AMF_MEMORY_TYPE type, AMF_AUDIO_FORMAT format, amf_int32 samples, amf_int32 sampleRate, amf_int32 channels, AMFAudioBuffer** ppAudioBuffer);
-
-        // Wrap existing objects
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromHostNative)(AMFContext2* pThis, void* pHostBuffer, amf_size size, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromHostNative)(AMFContext2* pThis, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, amf_int32 hPitch, amf_int32 vPitch, void* pData,AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX9Native)(AMFContext2* pThis, void* pDX9Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX11Native)(AMFContext2* pThis, void* pDX11Surface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromOpenGLNative)(AMFContext2* pThis, AMF_SURFACE_FORMAT format, amf_handle hGLTextureID, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromGrallocNative)(AMFContext2* pThis, amf_handle hGrallocSurface, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromOpenCLNative)(AMFContext2* pThis, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, void** pClPlanes, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromOpenCLNative)(AMFContext2* pThis, void* pCLBuffer, amf_size size, AMFBuffer** ppBuffer);
-
-        // Access to AMFCompute interface - AMF_MEMORY_OPENCL, AMF_MEMORY_COMPUTE_FOR_DX9, AMF_MEMORY_COMPUTE_FOR_DX11 are currently supported
-        AMF_RESULT          (AMF_STD_CALL *GetCompute)(AMFContext2* pThis, AMF_MEMORY_TYPE eMemType, AMFCompute** ppCompute);
-
-        // AMFContext1 interface
-
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromDX11Native)(AMFContext2* pThis, void* pHostBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *AllocBufferEx)(AMFContext2* pThis, AMF_MEMORY_TYPE type, amf_size size, AMF_BUFFER_USAGE usage, AMF_MEMORY_CPU_ACCESS access, AMFBuffer** ppBuffer);
-        AMF_RESULT          (AMF_STD_CALL *AllocSurfaceEx)(AMFContext2* pThis, AMF_MEMORY_TYPE type, AMF_SURFACE_FORMAT format, amf_int32 width, amf_int32 height, AMF_SURFACE_USAGE usage, AMF_MEMORY_CPU_ACCESS access, AMFSurface** ppSurface);
-
-        // Vulkan - Windows, Linux
-        AMF_RESULT          (AMF_STD_CALL *InitVulkan)(AMFContext2* pThis, void* pVulkanDevice);
-        void*               (AMF_STD_CALL *GetVulkanDevice)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *LockVulkan)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockVulkan)(AMFContext2* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromVulkanNative)(AMFContext2* pThis, void* pVulkanImage, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromVulkanNative)(AMFContext2* pThis, void* pVulkanBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *GetVulkanDeviceExtensions)(AMFContext2* pThis, amf_size *pCount, const char **ppExtensions);
-
-        // AMFContext2 interface
-        AMF_RESULT          (AMF_STD_CALL *InitDX12)(AMFContext2* pThis, void* pDX11Device, AMF_DX_VERSION dxVersionRequired);
-        void*               (AMF_STD_CALL *GetDX12Device)(AMFContext2* pThis, AMF_DX_VERSION dxVersionRequired);
-        AMF_RESULT          (AMF_STD_CALL *LockDX12)(AMFContext2* pThis);
-        AMF_RESULT          (AMF_STD_CALL *UnlockDX12)(AMFContext2* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *CreateSurfaceFromDX12Native)(AMFContext2* pThis, void* pResourceTexture, AMFSurface** ppSurface, AMFSurfaceObserver* pObserver);
-        AMF_RESULT          (AMF_STD_CALL *CreateBufferFromDX12Native)(AMFContext2* pThis, void* pResourceBuffer, AMFBuffer** ppBuffer, AMFBufferObserver* pObserver);
-
-
-    } AMFContext2Vtbl;
-
-    struct AMFContext2
-    {
-        const AMFContext2Vtbl *pVtbl;
-    };
-#endif
-
-#if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // Lockers
-    //----------------------------------------------------------------------------------------------
-    class AMFContext::AMFDX9Locker
-    {
-    public:
-        AMFDX9Locker() : m_Context(NULL)
-        {}
-        AMFDX9Locker(AMFContext* resources) : m_Context(NULL)
-        {
-            Lock(resources);
-        }
-        ~AMFDX9Locker()
-        {
-            if(m_Context != NULL)
-            {
-                m_Context->UnlockDX9();
-            }
-        }
-        void Lock(AMFContext* resources)
-        {
-            if(m_Context != NULL)
-            {
-                m_Context->UnlockDX9();
-            }
-            m_Context = resources;
-            if(m_Context != NULL)
-            {
-                m_Context->LockDX9();
-            }
-        }
-    protected:
-        AMFContext* m_Context;
-
-    private:
-        AMFDX9Locker(const AMFDX9Locker&);
-        AMFDX9Locker& operator=(const AMFDX9Locker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext::AMFDX11Locker
-    {
-    public:
-        AMFDX11Locker() : m_Context(NULL)
-        {}
-        AMFDX11Locker(AMFContext* resources) : m_Context(NULL)
-        {
-            Lock(resources);
-        }
-        ~AMFDX11Locker()
-        {
-            if(m_Context != NULL)
-            {
-                m_Context->UnlockDX11();
-            }
-        }
-        void Lock(AMFContext* resources)
-        {
-            if(m_Context != NULL)
-            {
-                m_Context->UnlockDX11();
-            }
-            m_Context = resources;
-            if(m_Context != NULL)
-            {
-                m_Context->LockDX11();
-            }
-        }
-    protected:
-        AMFContext* m_Context;
-
-    private:
-        AMFDX11Locker(const AMFDX11Locker&);
-        AMFDX11Locker& operator=(const AMFDX11Locker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext::AMFOpenCLLocker
-    {
-    public:
-        AMFOpenCLLocker() : m_Context(NULL)
-        {}
-        AMFOpenCLLocker(AMFContext* resources) : m_Context(NULL)
-        {
-            Lock(resources);
-        }
-        ~AMFOpenCLLocker()
-        {
-            if(m_Context != NULL)
-            {
-                m_Context->UnlockOpenCL();
-            }
-        }
-        void Lock(AMFContext* resources)
-        {
-            if(m_Context != NULL)
-            {
-                m_Context->UnlockOpenCL();
-            }
-            m_Context = resources;
-            if(m_Context != NULL)
-            {
-                m_Context->LockOpenCL();
-            }
-        }
-    protected:
-        AMFContext* m_Context;
-    private:
-        AMFOpenCLLocker(const AMFOpenCLLocker&);
-        AMFOpenCLLocker& operator=(const AMFOpenCLLocker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext::AMFOpenGLLocker
-    {
-    public:
-        AMFOpenGLLocker(AMFContext* pContext) : m_pContext(pContext),
-            m_GLLocked(false)
-        {
-            if(m_pContext != NULL)
-            {
-                if(m_pContext->LockOpenGL() == AMF_OK)
-                {
-                    m_GLLocked = true;
-                }
-            }
-        }
-        ~AMFOpenGLLocker()
-        {
-            if(m_GLLocked)
-            {
-                m_pContext->UnlockOpenGL();
-            }
-        }
-    private:
-        AMFContext* m_pContext;
-        amf_bool m_GLLocked; ///< AMFOpenGLLocker can be called when OpenGL is not initialized yet
-                             ///< in this case don't call UnlockOpenGL
-        AMFOpenGLLocker(const AMFOpenGLLocker&);
-        AMFOpenGLLocker& operator=(const AMFOpenGLLocker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext::AMFXVLocker
-    {
-    public:
-        AMFXVLocker() : m_pContext(NULL)
-        {}
-        AMFXVLocker(AMFContext* pContext) : m_pContext(NULL)
-        {
-            Lock(pContext);
-        }
-        ~AMFXVLocker()
-        {
-            if(m_pContext != NULL)
-            {
-                m_pContext->UnlockXV();
-            }
-        }
-        void Lock(AMFContext* pContext)
-        {
-            if((pContext != NULL) && (pContext->GetXVDevice() != NULL))
-            {
-                m_pContext = pContext;
-                m_pContext->LockXV();
-            }
-        }
-    protected:
-        AMFContext* m_pContext;
-    private:
-        AMFXVLocker(const AMFXVLocker&);
-        AMFXVLocker& operator=(const AMFXVLocker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext::AMFGrallocLocker
-    {
-    public:
-        AMFGrallocLocker() : m_pContext(NULL)
-        {}
-        AMFGrallocLocker(AMFContext* pContext) : m_pContext(NULL)
-        {
-            Lock(pContext);
-        }
-        ~AMFGrallocLocker()
-        {
-            if(m_pContext != NULL)
-            {
-                m_pContext->UnlockGralloc();
-            }
-        }
-        void Lock(AMFContext* pContext)
-        {
-            if((pContext != NULL) && (pContext->GetGrallocDevice() != NULL))
-            {
-                m_pContext = pContext;
-                m_pContext->LockGralloc();
-            }
-        }
-    protected:
-        AMFContext* m_pContext;
-    private:
-        AMFGrallocLocker(const AMFGrallocLocker&);
-        AMFGrallocLocker& operator=(const AMFGrallocLocker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext1::AMFVulkanLocker
-    {
-    public:
-        AMFVulkanLocker() : m_pContext(NULL)
-        {}
-        AMFVulkanLocker(AMFContext1* pContext) : m_pContext(NULL)
-        {
-            Lock(pContext);
-        }
-        ~AMFVulkanLocker()
-        {
-            if(m_pContext != NULL)
-            {
-                m_pContext->UnlockVulkan();
-            }
-        }
-        void Lock(AMFContext1* pContext)
-        {
-            if((pContext != NULL) && (pContext->GetVulkanDevice() != NULL))
-            {
-                m_pContext = pContext;
-                m_pContext->LockVulkan();
-            }
-        }
-    protected:
-        AMFContext1* m_pContext;
-    private:
-        AMFVulkanLocker(const AMFVulkanLocker&);
-        AMFVulkanLocker& operator=(const AMFVulkanLocker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    class AMFContext2::AMFDX12Locker
-    {
-    public:
-        AMFDX12Locker() : m_Context(NULL)
-        {}
-        AMFDX12Locker(AMFContext2* resources) : m_Context(NULL)
-        {
-            Lock(resources);
-        }
-        ~AMFDX12Locker()
-        {
-            if (m_Context != NULL)
-            {
-                m_Context->UnlockDX12();
-            }
-        }
-        void Lock(AMFContext2* resources)
-        {
-            if (m_Context != NULL)
-            {
-                m_Context->UnlockDX12();
-            }
-            m_Context = resources;
-            if (m_Context != NULL)
-            {
-                m_Context->LockDX12();
-            }
-        }
-    protected:
-        AMFContext2* m_Context;
-
-    private:
-        AMFDX12Locker(const AMFDX12Locker&);
-        AMFDX12Locker& operator=(const AMFDX12Locker&);
-    };
-    //----------------------------------------------------------------------------------------------
-    //----------------------------------------------------------------------------------------------
-    //----------------------------------------------------------------------------------------------
-#endif
-#if defined(__cplusplus)
-}
-#endif
-enum AMF_CONTEXT_DEVICETYPE_ENUM
-{
-    AMF_CONTEXT_DEVICE_TYPE_GPU = 0,
-    AMF_CONTEXT_DEVICE_TYPE_CPU
-};
-#define AMF_CONTEXT_DEVICE_TYPE  L"AMF_Context_DeviceType" //Value type: amf_int64; Values : AMF_CONTEXT_DEVICE_TYPE_GPU for GPU (default) , AMF_CONTEXT_DEVICE_TYPE_CPU for CPU.
-#endif //#ifndef AMF_Context_h

plugins/obs-ffmpeg/external/AMF/include/core/CurrentTime.h

@@ -1,52 +0,0 @@
-//
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_CurrentTime_h
-#define AMF_CurrentTime_h
-
-#include "Platform.h"
-#include "Interface.h"
-
-namespace amf
-{
-	// Current time interface class. This interface object can be passed
-	// as a property to components requiring synchronized timing. The
-	// implementation is:
-	// - first call to Get() starts time and returns 0
-	// - subsequent calls to Get() returns values relative to 0
-	// - Reset() puts time back at 0 at next Get() call
-	//
-	class AMF_NO_VTABLE AMFCurrentTime : public AMFInterface
-	{
-	public:
-		virtual amf_pts AMF_STD_CALL Get() = 0;
-
-		virtual void AMF_STD_CALL Reset() = 0;
-	};
-
-	//----------------------------------------------------------------------------------------------
-	// smart pointer
-	//----------------------------------------------------------------------------------------------
-	typedef AMFInterfacePtr_T<AMFCurrentTime> AMFCurrentTimePtr;
-	//----------------------------------------------------------------------------------------------}
-}
-#endif // AMF_CurrentTime_h

plugins/obs-ffmpeg/external/AMF/include/core/D3D12AMF.h

@@ -1,49 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef __D3D12AMF_h__
-#define __D3D12AMF_h__
-#pragma once 
-#include "Platform.h"
-#if defined(_WIN32)||(defined(__linux) && defined(AMF_WSL))
-// syncronization properties set via SetPrivateData()
-AMF_WEAK GUID  AMFResourceStateGUID = { 0x452da9bf, 0x4ad7, 0x47a5, { 0xa6, 0x9b, 0x96, 0xd3, 0x23, 0x76, 0xf2, 0xf3 } };   // Current resource state value (D3D12_RESOURCE_STATES ), sizeof(UINT), set on ID3D12Resource 
-AMF_WEAK GUID  AMFFenceGUID         = { 0x910a7928, 0x57bd, 0x4b04, { 0x91, 0xa3, 0xe7, 0xb8, 0x04, 0x12, 0xcd, 0xa5 } };   // IUnknown (ID3D12Fence), set on ID3D12Resource  syncronization fence for this resource
-AMF_WEAK GUID  AMFFenceValueGUID    = { 0x62a693d3, 0xbb4a, 0x46c9, { 0xa5, 0x04, 0x9a, 0x8e, 0x97, 0xbf, 0xf0, 0x56 } };   // The last value to wait on the fence from AMFFenceGUID; sizeof(UINT64), set on ID3D12Fence 
-
-AMF_WEAK GUID  AMFFenceD3D11GUID    = { 0xdffdf6e0, 0x85e0, 0x4645, { 0x9d, 0x7, 0xe6, 0x4a, 0x19, 0x6b, 0xc9, 0xbf } };   // IUnknown (ID3D11Fence) OpenSharedFence for interop
-AMF_WEAK GUID  AMFFenceValueD3D11GUID    = { 0x86581b71, 0x699f, 0x484b, { 0xb8, 0x75, 0x24, 0xda, 0x49, 0x8a, 0x74, 0xcf } };   // last value to wait on in d3d11
-AMF_WEAK GUID  AMFSharedHandleFenceGUID = { 0xca60dcc8, 0x76d1, 0x4088, 0xad, 0xd, 0x97, 0x71, 0xe7, 0xb0, 0x92, 0x49 };   // ID3D12Fence shared handle for D3D11 interop
-
-#endif
-
-#endif // __D3D12AMF_h__

plugins/obs-ffmpeg/external/AMF/include/core/Data.h

@@ -1,177 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Data_h
-#define AMF_Data_h
-#pragma once
-
-#include "PropertyStorage.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_DATA_TYPE
-    {
-        AMF_DATA_BUFFER             = 0,
-        AMF_DATA_SURFACE            = 1,
-        AMF_DATA_AUDIO_BUFFER       = 2,
-        AMF_DATA_USER               = 1000,
-        // all extensions will be AMF_DATA_USER+i
-    } AMF_DATA_TYPE;
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_MEMORY_TYPE
-    {
-        AMF_MEMORY_UNKNOWN          = 0,
-        AMF_MEMORY_HOST             = 1,
-        AMF_MEMORY_DX9              = 2,
-        AMF_MEMORY_DX11             = 3,
-		AMF_MEMORY_OPENCL           = 4,
-        AMF_MEMORY_OPENGL           = 5,
-        AMF_MEMORY_XV               = 6,
-        AMF_MEMORY_GRALLOC          = 7,
-        AMF_MEMORY_COMPUTE_FOR_DX9  = 8, // deprecated, the same as AMF_MEMORY_OPENCL
-        AMF_MEMORY_COMPUTE_FOR_DX11 = 9, // deprecated, the same as AMF_MEMORY_OPENCL
-        AMF_MEMORY_VULKAN           = 10,
-        AMF_MEMORY_DX12             = 11,
-    } AMF_MEMORY_TYPE;
-
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_DX_VERSION
-    {
-        AMF_DX9                     = 90,
-        AMF_DX9_EX                  = 91,
-        AMF_DX11_0                  = 110,
-        AMF_DX11_1                  = 111,
-		AMF_DX12                    = 120,
-    } AMF_DX_VERSION;
-
-    //----------------------------------------------------------------------------------------------
-    // AMF_MEMORY_CPU_ACCESS translates to D3D11_CPU_ACCESS_FLAG or VkImageUsageFlags
-    // bit mask
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_MEMORY_CPU_ACCESS_BITS
-    {                                           // D3D11                    D3D12                      Vulkan 
-        AMF_MEMORY_CPU_DEFAULT  = 0x80000000,   // 0                     ,  D3D12_HEAP_TYPE_DEFAULT ,  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
-        AMF_MEMORY_CPU_NONE     = 0x00000000,   // 0                     ,  D3D12_HEAP_TYPE_DEFAULT ,
-        AMF_MEMORY_CPU_READ     = 0x00000001,   // D3D11_CPU_ACCESS_READ ,  D3D12_HEAP_TYPE_READBACK,  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
-        AMF_MEMORY_CPU_WRITE    = 0x00000002,   // D3D11_CPU_ACCESS_WRITE,  D3D12_HEAP_TYPE_UPLOAD  ,  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
-        AMF_MEMORY_CPU_LOCAL    = 0x00000004,   //                       ,  D3D12_HEAP_TYPE_DEFAULT ,  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
-        AMF_MEMORY_CPU_PINNED   = 0x00000008,   //                       ,                          ,  VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR
-    } AMF_MEMORY_CPU_ACCESS_BITS;
-    typedef amf_flags AMF_MEMORY_CPU_ACCESS;
-    //----------------------------------------------------------------------------------------------
-    // AMFData interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFData : public AMFPropertyStorage
-    {
-    public:
-        AMF_DECLARE_IID(0xa1159bf6, 0x9104, 0x4107, 0x8e, 0xaa, 0xc5, 0x3d, 0x5d, 0xba, 0xc5, 0x11)
-
-        virtual AMF_MEMORY_TYPE     AMF_STD_CALL GetMemoryType() = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL Duplicate(AMF_MEMORY_TYPE type, AMFData** ppData) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL Convert(AMF_MEMORY_TYPE type) = 0; // optimal interop if possilble. Copy through host memory if needed
-        virtual AMF_RESULT          AMF_STD_CALL Interop(AMF_MEMORY_TYPE type) = 0; // only optimal interop if possilble. No copy through host memory for GPU objects
-
-        virtual AMF_DATA_TYPE       AMF_STD_CALL GetDataType() = 0;
-
-        virtual amf_bool            AMF_STD_CALL IsReusable() = 0;
-
-        virtual void                AMF_STD_CALL SetPts(amf_pts pts) = 0;
-        virtual amf_pts             AMF_STD_CALL GetPts() = 0;
-        virtual void                AMF_STD_CALL SetDuration(amf_pts duration) = 0;
-        virtual amf_pts             AMF_STD_CALL GetDuration() = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFData> AMFDataPtr;
-    //----------------------------------------------------------------------------------------------
-
-#else // #if defined(__cplusplus)
-    typedef struct AMFData AMFData;
-    AMF_DECLARE_IID(AMFData, 0xa1159bf6, 0x9104, 0x4107, 0x8e, 0xaa, 0xc5, 0x3d, 0x5d, 0xba, 0xc5, 0x11)
-
-    typedef struct AMFDataVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFData* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFData* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFData* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFData* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFData* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFData* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFData* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFData* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFData* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFData* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFData* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFData* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFData* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFData interface
-
-        AMF_MEMORY_TYPE     (AMF_STD_CALL *GetMemoryType)(AMFData* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *Duplicate)(AMFData* pThis, AMF_MEMORY_TYPE type, AMFData** ppData);
-        AMF_RESULT          (AMF_STD_CALL *Convert)(AMFData* pThis, AMF_MEMORY_TYPE type); // optimal interop if possilble. Copy through host memory if needed
-        AMF_RESULT          (AMF_STD_CALL *Interop)(AMFData* pThis, AMF_MEMORY_TYPE type); // only optimal interop if possilble. No copy through host memory for GPU objects
-
-        AMF_DATA_TYPE       (AMF_STD_CALL *GetDataType)(AMFData* pThis);
-
-        amf_bool            (AMF_STD_CALL *IsReusable)(AMFData* pThis);
-
-        void                (AMF_STD_CALL *SetPts)(AMFData* pThis, amf_pts pts);
-        amf_pts             (AMF_STD_CALL *GetPts)(AMFData* pThis);
-        void                (AMF_STD_CALL *SetDuration)(AMFData* pThis, amf_pts duration);
-        amf_pts             (AMF_STD_CALL *GetDuration)(AMFData* pThis);
-
-    } AMFDataVtbl;
-
-    struct AMFData
-    {
-        const AMFDataVtbl *pVtbl;
-    };
-
-
-#endif // #if defined(__cplusplus)
-
-#if defined(__cplusplus)
-} // namespace
-#endif
-
-#endif //#ifndef AMF_Data_h

plugins/obs-ffmpeg/external/AMF/include/core/Debug.h

@@ -1,78 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Debug_h
-#define AMF_Debug_h
-#pragma once
-
-#include "Platform.h"
-#include "Result.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // AMFDebug interface - singleton
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFDebug
-    {
-    public:
-        virtual  void               AMF_STD_CALL EnablePerformanceMonitor(amf_bool enable) = 0;
-        virtual  amf_bool           AMF_STD_CALL PerformanceMonitorEnabled() = 0;
-        virtual  void               AMF_STD_CALL AssertsEnable(amf_bool enable) = 0;
-        virtual  amf_bool           AMF_STD_CALL AssertsEnabled() = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFDebug AMFDebug;
-    typedef struct AMFDebugVtbl
-    {
-        // AMFDebug interface
-        void               (AMF_STD_CALL *EnablePerformanceMonitor)(AMFDebug* pThis, amf_bool enable);
-        amf_bool           (AMF_STD_CALL *PerformanceMonitorEnabled)(AMFDebug* pThis);
-        void               (AMF_STD_CALL *AssertsEnable)(AMFDebug* pThis, amf_bool enable);
-        amf_bool           (AMF_STD_CALL *AssertsEnabled)(AMFDebug* pThis);
-    } AMFDebugVtbl;
-
-    struct AMFDebug
-    {
-        const AMFDebugVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-}
-#endif
-
-#endif // AMF_Debug_h

plugins/obs-ffmpeg/external/AMF/include/core/Dump.h

@@ -1,112 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Dump_h
-#define AMF_Dump_h
-#pragma once
-
-#include "Platform.h"
-#include "Result.h"
-#include "Interface.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFDump : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x75366ad4, 0x504c, 0x430b, 0xbb, 0xe2, 0xad, 0x21, 0x82, 0x8, 0xf, 0x72);
-
-
-        virtual const wchar_t*  AMF_STD_CALL GetDumpBasePath() const = 0;             //  Get application dump base path
-        virtual AMF_RESULT      AMF_STD_CALL SetDumpBasePath(const wchar_t* path) = 0;    //  Set application dump base path
-
-        //  Enable/disable input and/or output stream dumps
-        virtual bool            AMF_STD_CALL IsInputDumpEnabled() const = 0;
-        virtual AMF_RESULT      AMF_STD_CALL EnableInputDump(bool enabled) = 0;     
-        virtual const wchar_t*  AMF_STD_CALL GetInputDumpFullName() const = 0;  //  Get full name of dump file
-
-        //  Enable/disable input and/or output stream dumps
-        virtual bool            AMF_STD_CALL IsOutputDumpEnabled() const = 0;
-        virtual AMF_RESULT      AMF_STD_CALL EnableOutputDump(bool enabled) = 0;     
-        virtual const wchar_t*  AMF_STD_CALL GetOutputDumpFullName() const = 0;  //  Get full name of dump file
-
-        //  When enabled, each new application session will create a subfolder with a time stamp in the base path tree (disabled by default)
-        virtual bool            AMF_STD_CALL IsPerSessionDumpEnabled() const = 0;
-        virtual void            AMF_STD_CALL EnablePerSessionDump(bool enabled) = 0;      
-    };
-    typedef AMFInterfacePtr_T<AMFDump> AMFDumpPtr;
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFDump, 0x75366ad4, 0x504c, 0x430b, 0xbb, 0xe2, 0xad, 0x21, 0x82, 0x8, 0xf, 0x72);
-    typedef struct AMFDump AMFDump;
-
-    typedef struct AMFDumpVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFDump* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFDump* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFDump* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-        
-        // AMFDump interface
-        const wchar_t*  (AMF_STD_CALL *GetDumpBasePath)(AMFDump* pThis) const;             //  Get application dump base path
-        AMF_RESULT      (AMF_STD_CALL *SetDumpBasePath)(AMFDump* pThis, const wchar_t* path);    //  Set application dump base path
-        
-        //  Enable/disable input and/or output stream dumps
-        bool            (AMF_STD_CALL *IsInputDumpEnabled)(AMFDump* pThis) const;
-        AMF_RESULT      (AMF_STD_CALL *EnableInputDump)(AMFDump* pThis, bool enabled);     
-        const wchar_t*  (AMF_STD_CALL *GetInputDumpFullName)(AMFDump* pThis) const;  //  Get full name of dump file
-
-        //  Enable/disable input and/or output stream dumps
-        bool            (AMF_STD_CALL *IsOutputDumpEnabled)(AMFDump* pThis) const;
-        AMF_RESULT      (AMF_STD_CALL *EnableOutputDump)(AMFDump* pThis, bool enabled);     
-        const wchar_t*  (AMF_STD_CALL *GetOutputDumpFullName)(AMFDump* pThis) const;  //  Get full name of dump file
-
-        //  When enabled, each new application session will create a subfolder with a time stamp in the base path tree (disabled by default)
-        bool            (AMF_STD_CALL *IsPerSessionDumpEnabled)(AMFDump* pThis) const;
-        void            (AMF_STD_CALL *EnablePerSessionDump)(AMFDump* pThis, bool enabled);      
-
-    } AMFDumpVtbl;
-
-    struct AMFDump
-    {
-        const AMFDumpVtbl *pVtbl;
-    };
-
-
-#endif // #if defined(__cplusplus)
-#if defined(__cplusplus)
-} // namespace
-#endif
-
-#endif //AMF_Dump_h

plugins/obs-ffmpeg/external/AMF/include/core/Factory.h

@@ -1,133 +0,0 @@
-//
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-//
-// MIT license
-//
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Factory_h
-#define AMF_Factory_h
-#pragma once
-
-#include "Platform.h"
-#include "Version.h"
-#include "Result.h"
-#include "Context.h"
-#include "Debug.h"
-#include "Trace.h"
-#include "Compute.h"
-
-#include "../components/Component.h"
-
-#if defined(__cplusplus)
-
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // AMFFactory interface - singleton
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFFactory
-    {
-    public:
-        virtual AMF_RESULT          AMF_STD_CALL CreateContext(AMFContext** ppContext) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CreateComponent(AMFContext* pContext, const wchar_t* id, AMFComponent** ppComponent) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetCacheFolder(const wchar_t* path) = 0;
-        virtual const wchar_t*      AMF_STD_CALL GetCacheFolder() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetDebug(AMFDebug** ppDebug) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetTrace(AMFTrace** ppTrace) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetPrograms(AMFPrograms** ppPrograms) = 0;
-   };
-#else
-    typedef struct AMFFactory AMFFactory;
-
-    typedef struct AMFFactoryVtbl
-    {
-        AMF_RESULT          (AMF_STD_CALL *CreateContext)(AMFFactory* pThis, AMFContext** ppContext);
-        AMF_RESULT          (AMF_STD_CALL *CreateComponent)(AMFFactory* pThis, AMFContext* pContext, const wchar_t* id, AMFComponent** ppComponent);
-        AMF_RESULT          (AMF_STD_CALL *SetCacheFolder)(AMFFactory* pThis, const wchar_t* path);
-        const wchar_t*      (AMF_STD_CALL *GetCacheFolder)(AMFFactory* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetDebug)(AMFFactory* pThis, AMFDebug** ppDebug);
-        AMF_RESULT          (AMF_STD_CALL *GetTrace)(AMFFactory* pThis, AMFTrace** ppTrace);
-        AMF_RESULT          (AMF_STD_CALL *GetPrograms)(AMFFactory* pThis, AMFPrograms** ppPrograms);
-    } AMFFactoryVtbl;
-
-    struct AMFFactory
-    {
-        const AMFFactoryVtbl *pVtbl;
-    };
-
-#endif
-#if defined(__cplusplus)
-}
-#endif
-
-//----------------------------------------------------------------------------------------------
-// DLL entry points
-//----------------------------------------------------------------------------------------------
-
-#define AMF_INIT_FUNCTION_NAME             "AMFInit"
-#define AMF_QUERY_VERSION_FUNCTION_NAME    "AMFQueryVersion"
-
-#if defined(__cplusplus)
-extern "C"
-{
-    typedef AMF_RESULT             (AMF_CDECL_CALL *AMFInit_Fn)(amf_uint64 version, amf::AMFFactory **ppFactory);
-    typedef AMF_RESULT             (AMF_CDECL_CALL *AMFQueryVersion_Fn)(amf_uint64 *pVersion);
-}
-#else
-    typedef AMF_RESULT             (AMF_CDECL_CALL *AMFInit_Fn)(amf_uint64 version, AMFFactory **ppFactory);
-    typedef AMF_RESULT             (AMF_CDECL_CALL *AMFQueryVersion_Fn)(amf_uint64 *pVersion);
-#endif
-
-#if defined(_WIN32)
-    #if defined(_M_AMD64)
-        #define AMF_DLL_NAME    L"amfrt64.dll"
-        #define AMF_DLL_NAMEA   "amfrt64.dll"
-#else
-        #define AMF_DLL_NAME    L"amfrt32.dll"
-        #define AMF_DLL_NAMEA   "amfrt32.dll"
-    #endif
-#elif defined(__ANDROID__) && !defined(AMF_ANDROID_ENCODER)
-    #define AMF_DLL_NAME    L"libamf.so"
-    #define AMF_DLL_NAMEA    "libamf.so"
-#elif defined(__APPLE__)
-    #define AMF_DLL_NAME    L"libamfrt.framework/libamfrt"
-    #define AMF_DLL_NAMEA   "libamfrt.framework/libamfrt"
-#elif defined(__linux__)
-    #if defined(__x86_64__) || defined(__aarch64__)
-        #define AMF_DLL_NAME    L"libamfrt64.so.1"
-        #define AMF_DLL_NAMEA   "libamfrt64.so.1"
-    #else
-        #define AMF_DLL_NAME    L"libamfrt32.so.1"
-        #define AMF_DLL_NAMEA   "libamfrt32.so.1"
-    #endif
-#endif
-//----------------------------------------------------------------------------------------------
-#endif   // AMF_Factory_h

plugins/obs-ffmpeg/external/AMF/include/core/Interface.h

@@ -1,258 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Interface_h
-#define AMF_Interface_h
-#pragma once
-
-#include "Result.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-#if defined(__cplusplus)
-    #define AMF_DECLARE_IID(_data1, _data2, _data3, _data41, _data42, _data43, _data44, _data45, _data46, _data47, _data48) \
-        static AMF_INLINE const amf::AMFGuid IID() \
-        { \
-            amf::AMFGuid uid = {_data1, _data2, _data3, _data41, _data42, _data43, _data44, _data45, _data46, _data47, _data48}; \
-            return uid; \
-        }
-#else
-#define AMF_DECLARE_IID(name, _data1, _data2, _data3, _data41, _data42, _data43, _data44, _data45, _data46, _data47, _data48) \
-        AMF_INLINE static const AMFGuid IID_##name(void) \
-        { \
-            AMFGuid uid = {_data1, _data2, _data3, _data41, _data42, _data43, _data44, _data45, _data46, _data47, _data48}; \
-            return uid; \
-        }
-#endif
-
-    //------------------------------------------------------------------------
-    // AMFInterface interface  - base class for all AMF interfaces
-    //------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0x9d872f34, 0x90dc, 0x4b93, 0xb6, 0xb2, 0x6c, 0xa3, 0x7c, 0x85, 0x25, 0xdb)
-
-        virtual amf_long            AMF_STD_CALL Acquire() = 0;
-        virtual amf_long            AMF_STD_CALL Release() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL QueryInterface(const AMFGuid& interfaceID, void** ppInterface) = 0;
-    };
-#else
-    AMF_DECLARE_IID(AMFInterface, 0x9d872f34, 0x90dc, 0x4b93, 0xb6, 0xb2, 0x6c, 0xa3, 0x7c, 0x85, 0x25, 0xdb)
-    typedef struct AMFInterface AMFInterface;
-
-    typedef struct AMFInterfaceVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFInterface* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFInterface* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFInterface* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-    } AMFInterfaceVtbl;
-
-    struct AMFInterface
-    {
-        const AMFInterfaceVtbl *pVtbl;
-    };
-#endif
-    //------------------------------------------------------------------------
-    // template for AMF smart pointer
-    //------------------------------------------------------------------------
-#if defined(__cplusplus)
-    template<class _Interf>
-    class AMFInterfacePtr_T
-    {
-    private:
-        _Interf* m_pInterf;
-
-        void InternalAcquire()
-        {
-            if(m_pInterf != NULL)
-            {
-                m_pInterf->Acquire();
-            }
-        }
-        void InternalRelease()
-        {
-            if(m_pInterf != NULL)
-            {
-                m_pInterf->Release();
-            }
-        }
-    public:
-        AMFInterfacePtr_T() : m_pInterf(NULL)
-        {}
-
-        AMFInterfacePtr_T(const AMFInterfacePtr_T<_Interf>& p) : m_pInterf(p.m_pInterf)
-        {
-            InternalAcquire();
-        }
-
-        AMFInterfacePtr_T(_Interf* pInterface) : m_pInterf(pInterface)
-        {
-            InternalAcquire();
-        }
-
-        template<class _OtherInterf>
-        explicit AMFInterfacePtr_T(const AMFInterfacePtr_T<_OtherInterf>& cp) : m_pInterf(NULL)
-        {
-            void* pInterf = NULL;
-            if((cp == NULL) || (cp->QueryInterface(_Interf::IID(), &pInterf) != AMF_OK))
-            {
-                pInterf = NULL;
-            }
-            m_pInterf = static_cast<_Interf*>(pInterf);
-        }
-
-        template<class _OtherInterf>
-        explicit AMFInterfacePtr_T(_OtherInterf* cp) : m_pInterf(NULL)
-        {
-            void* pInterf = NULL;
-            if((cp == NULL) || (cp->QueryInterface(_Interf::IID(), &pInterf) != AMF_OK))
-            {
-                pInterf = NULL;
-            }
-            m_pInterf = static_cast<_Interf*>(pInterf);
-        }
-
-        ~AMFInterfacePtr_T()
-        {
-            InternalRelease();
-        }
-
-        AMFInterfacePtr_T& operator=(_Interf* pInterface)
-        {
-            if(m_pInterf != pInterface)
-            {
-                _Interf* pOldInterface = m_pInterf;
-                m_pInterf = pInterface;
-                InternalAcquire();
-                if(pOldInterface != NULL)
-                {
-                    pOldInterface->Release();
-                }
-            }
-            return *this;
-        }
-
-        AMFInterfacePtr_T& operator=(const AMFInterfacePtr_T<_Interf>& cp)
-        {
-            return operator=(cp.m_pInterf);
-        }
-
-        void Attach(_Interf* pInterface)
-        {
-            InternalRelease();
-            m_pInterf = pInterface;
-        }
-
-        _Interf* Detach()
-        {
-            _Interf* const pOld = m_pInterf;
-            m_pInterf = NULL;
-            return pOld;
-        }
-        void Release()
-        {
-            InternalRelease();
-            m_pInterf = NULL;
-        }
-
-        operator _Interf*() const
-        {
-            return m_pInterf;
-        }
-
-        _Interf& operator*() const
-        {
-            return *m_pInterf;
-        }
-
-        // Returns the address of the interface pointer contained in this
-        // class. This is required for initializing from C-style factory function to
-        // avoid getting an incorrect ref count at the beginning.
-
-        _Interf** operator&()
-        {
-            InternalRelease();
-            m_pInterf = 0;
-            return &m_pInterf;
-        }
-
-        _Interf* operator->() const
-        {
-            return m_pInterf;
-        }
-
-        bool operator==(const AMFInterfacePtr_T<_Interf>& p)
-        {
-            return (m_pInterf == p.m_pInterf);
-        }
-
-        bool operator==(_Interf* p)
-        {
-            return (m_pInterf == p);
-        }
-
-        bool operator!=(const AMFInterfacePtr_T<_Interf>& p)
-        {
-            return !(operator==(p));
-        }
-        bool operator!=(_Interf* p)
-        {
-            return !(operator==(p));
-        }
-
-        _Interf* GetPtr()
-        {
-            return m_pInterf;
-        }
-
-        const _Interf* GetPtr() const
-        {
-            return m_pInterf;
-        }
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFInterface> AMFInterfacePtr;
-    //----------------------------------------------------------------------------------------------
-#endif
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif //#ifndef AMF_Interface_h

plugins/obs-ffmpeg/external/AMF/include/core/Plane.h

@@ -1,112 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Plane_h
-#define AMF_Plane_h
-#pragma once
-
-#include "Interface.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //---------------------------------------------------------------------------------------------
-    typedef enum AMF_PLANE_TYPE
-    {
-        AMF_PLANE_UNKNOWN       = 0,
-        AMF_PLANE_PACKED        = 1,             // for all packed formats: BGRA, YUY2, etc
-        AMF_PLANE_Y             = 2,
-        AMF_PLANE_UV            = 3,
-        AMF_PLANE_U             = 4,
-        AMF_PLANE_V             = 5,
-    } AMF_PLANE_TYPE;
-    //---------------------------------------------------------------------------------------------
-    // AMFPlane interface
-    //---------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFPlane : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0xbede1aa6, 0xd8fa, 0x4625, 0x94, 0x65, 0x6c, 0x82, 0xc4, 0x37, 0x71, 0x2e)
-
-        virtual AMF_PLANE_TYPE      AMF_STD_CALL GetType() = 0;
-        virtual void*               AMF_STD_CALL GetNative() = 0;
-        virtual amf_int32           AMF_STD_CALL GetPixelSizeInBytes() = 0;
-        virtual amf_int32           AMF_STD_CALL GetOffsetX() = 0;
-        virtual amf_int32           AMF_STD_CALL GetOffsetY() = 0;
-        virtual amf_int32           AMF_STD_CALL GetWidth() = 0;
-        virtual amf_int32           AMF_STD_CALL GetHeight() = 0;
-        virtual amf_int32           AMF_STD_CALL GetHPitch() = 0;
-        virtual amf_int32           AMF_STD_CALL GetVPitch() = 0;
-        virtual bool                AMF_STD_CALL IsTiled() = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFPlane> AMFPlanePtr;
-    //----------------------------------------------------------------------------------------------
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFPlane, 0xbede1aa6, 0xd8fa, 0x4625, 0x94, 0x65, 0x6c, 0x82, 0xc4, 0x37, 0x71, 0x2e)
-    typedef struct AMFPlane AMFPlane;
-    typedef struct AMFPlaneVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFPlane* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFPlane* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFPlane* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPlane interface
-        AMF_PLANE_TYPE      (AMF_STD_CALL *GetType)(AMFPlane* pThis);
-        void*               (AMF_STD_CALL *GetNative)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetPixelSizeInBytes)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetOffsetX)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetOffsetY)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetWidth)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetHeight)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetHPitch)(AMFPlane* pThis);
-        amf_int32           (AMF_STD_CALL *GetVPitch)(AMFPlane* pThis);
-        amf_bool            (AMF_STD_CALL *IsTiled)(AMFPlane* pThis);
-
-    } AMFPlaneVtbl;
-
-    struct AMFPlane
-    {
-        const AMFPlaneVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-#if defined(__cplusplus)
-} // namespace amf
-#endif
-
-#endif //#ifndef AMF_Plane_h

plugins/obs-ffmpeg/external/AMF/include/core/Platform.h

@@ -1,546 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Platform_h
-#define AMF_Platform_h
-#pragma once
-
-//----------------------------------------------------------------------------------------------
-// export declaration
-//----------------------------------------------------------------------------------------------
-#if defined(_WIN32)
-    #if defined(AMF_CORE_STATIC)
-        #define AMF_CORE_LINK
-    #else
-        #if defined(AMF_CORE_EXPORTS)
-            #define AMF_CORE_LINK __declspec(dllexport)
-        #else
-            #define AMF_CORE_LINK __declspec(dllimport)
-        #endif
-    #endif
-#elif defined(__linux)        
-        #if defined(AMF_CORE_EXPORTS)
-            #define AMF_CORE_LINK __attribute__((visibility("default")))
-        #else
-            #define AMF_CORE_LINK
-        #endif
-#else 
-    #define AMF_CORE_LINK
-#endif // #ifdef _WIN32
-
-#define AMF_MACRO_STRING2(x) #x
-#define AMF_MACRO_STRING(x) AMF_MACRO_STRING2(x)
-
-#define AMF_TODO(_todo) (__FILE__ "(" AMF_MACRO_STRING(__LINE__) "): TODO: "_todo)
-
-
- #if defined(__GNUC__) || defined(__clang__)
-     #define AMF_ALIGN(n) __attribute__((aligned(n)))
- #elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
-     #define AMF_ALIGN(n) __declspec(align(n))
- #else
-    #define AMF_ALIGN(n)
-//     #error Need to define AMF_ALIGN
- #endif
-
-#ifndef _WIN32
-typedef signed int HRESULT;
-#define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0)
-#define FAILED(hr) (((HRESULT)(hr)) < 0)
-#endif
-
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-
-#if defined(_WIN32)
-
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-    #define AMF_STD_CALL            __stdcall
-    #define AMF_CDECL_CALL          __cdecl
-    #define AMF_FAST_CALL           __fastcall
-#if defined(__GNUC__) || defined(__clang__)
-    #define AMF_INLINE              inline
-    #define AMF_FORCEINLINE         inline
-#else
-    #define AMF_INLINE              __inline
-    #define AMF_FORCEINLINE         __forceinline
-#endif
-    #define AMF_NO_VTABLE           __declspec(novtable)
-
-    #define AMFPRId64   "I64d"
-    #define LPRId64    L"I64d"
-
-    #define AMFPRIud64   "Iu64d"
-    #define LPRIud64    L"Iu64d"
-
-    #define AMFPRIx64   "I64x"
-    #define LPRIx64    L"I64x"
-
-#else // !WIN32 - Linux and Mac
-
-    #define AMF_STD_CALL
-    #define AMF_CDECL_CALL
-    #define AMF_FAST_CALL
-#if defined(__GNUC__) || defined(__clang__)
-    #define AMF_INLINE              inline
-    #define AMF_FORCEINLINE         inline
-#else
-    #define AMF_INLINE              __inline__
-    #define AMF_FORCEINLINE         __inline__
-#endif
-    #define AMF_NO_VTABLE           
-
-    #if !defined(AMFPRId64)
-        #define AMFPRId64    "lld"
-        #define LPRId64     L"lld"
-
-        #define AMFPRIud64    "ulld"
-        #define LPRIud64     L"ulld"
-
-        #define AMFPRIx64    "llx"
-        #define LPRIx64     L"llx"
-    #endif
-
-#endif // WIN32
-
-
-#if defined(_WIN32)
-#define AMF_WEAK __declspec( selectany ) 
-#elif defined (__GNUC__) || defined (__GCC__) || defined(__clang__)//GCC or CLANG
-#define AMF_WEAK __attribute__((weak))
-#endif
-
-#define amf_countof(x) (sizeof(x) / sizeof(x[0]))
-
-//-------------------------------------------------------------------------------------------------
-// basic data types
-//-------------------------------------------------------------------------------------------------
-typedef     int64_t             amf_int64;
-typedef     int32_t             amf_int32;
-typedef     int16_t             amf_int16;
-typedef     int8_t              amf_int8;
-
-typedef     uint64_t            amf_uint64;
-typedef     uint32_t            amf_uint32;
-typedef     uint16_t            amf_uint16;
-typedef     uint8_t             amf_uint8;
-typedef     size_t              amf_size;
-
-typedef     void*               amf_handle;
-typedef     double              amf_double;
-typedef     float               amf_float;
-
-typedef     void                amf_void;
-
-#if defined(__cplusplus)
-typedef     bool                amf_bool;
-#else
-typedef     amf_uint8           amf_bool;
-#define     true                1 
-#define     false               0 
-#endif
-
-typedef     long                amf_long; 
-typedef     int                 amf_int; 
-typedef     unsigned long       amf_ulong; 
-typedef     unsigned int        amf_uint; 
-
-typedef     amf_int64           amf_pts;     // in 100 nanosecs
-
-typedef amf_uint32              amf_flags;
-
-#define AMF_SECOND          10000000L    // 1 second in 100 nanoseconds
-#define AMF_MILLISECOND		(AMF_SECOND / 1000)
-#define AMF_MICROSECOND     (AMF_MILLISECOND / 1000)
-
-#define AMF_MIN(a, b) ((a) < (b) ? (a) : (b))
-#define AMF_MAX(a, b) ((a) > (b) ? (a) : (b))
-#define AMF_CLAMP(x, a, b) (AMF_MIN(AMF_MAX(x, a), b))
-
-#define AMF_BITS_PER_BYTE 8
-
-#if defined(_WIN32)
-    #define PATH_SEPARATOR_WSTR         L"\\"
-    #define PATH_SEPARATOR_WCHAR        L'\\'
-#elif defined(__linux) || defined(__APPLE__) // Linux & Apple
-    #define PATH_SEPARATOR_WSTR          L"/"
-    #define PATH_SEPARATOR_WCHAR         L'/'
-#endif
-
-typedef struct AMFRect
-{
-    amf_int32 left;
-    amf_int32 top;
-    amf_int32 right;
-    amf_int32 bottom;
-#if defined(__cplusplus)
-    bool operator==(const AMFRect& other) const
-    {
-         return left == other.left && top == other.top && right == other.right && bottom == other.bottom; 
-    }
-    AMF_INLINE bool operator!=(const AMFRect& other) const { return !operator==(other); }
-    amf_int32 Width() const { return right - left; }
-    amf_int32 Height() const { return bottom - top; }
-#endif
-} AMFRect;
-
-static AMF_INLINE struct AMFRect AMFConstructRect(amf_int32 left, amf_int32 top, amf_int32 right, amf_int32 bottom)
-{
-    struct AMFRect object = {left, top, right, bottom};
-    return object;
-}
-
-typedef struct AMFSize
-{
-    amf_int32 width;
-    amf_int32 height;
-#if defined(__cplusplus)
-    bool operator==(const AMFSize& other) const
-    {
-         return width == other.width && height == other.height; 
-    }
-    AMF_INLINE bool operator!=(const AMFSize& other) const { return !operator==(other); }
-#endif
-} AMFSize;
-
-static AMF_INLINE struct AMFSize AMFConstructSize(amf_int32 width, amf_int32 height)
-{
-    struct AMFSize object = {width, height};
-    return object;
-}
-
-typedef struct AMFPoint
-{
-    amf_int32 x;
-    amf_int32 y;
-#if defined(__cplusplus)
-    bool operator==(const AMFPoint& other) const
-    {
-         return x == other.x && y == other.y; 
-    }
-    AMF_INLINE bool operator!=(const AMFPoint& other) const { return !operator==(other); }
-#endif
-} AMFPoint;
-
-static AMF_INLINE struct AMFPoint AMFConstructPoint(amf_int32 x, amf_int32 y)
-{
-    struct AMFPoint object = { x, y };
-    return object;
-}
-
-typedef struct AMFFloatPoint2D
-{
-    amf_float x;
-    amf_float y;
-#if defined(__cplusplus)
-    bool operator==(const AMFFloatPoint2D& other) const
-    {
-        return x == other.x && y == other.y;
-    }
-    AMF_INLINE bool operator!=(const AMFFloatPoint2D& other) const { return !operator==(other); }
-#endif
-} AMFFloatPoint2D;
-
-static AMF_INLINE struct AMFFloatPoint2D AMFConstructFloatPoint2D(amf_float x, amf_float y)
-{
-    struct AMFFloatPoint2D object = {x, y};
-    return object;
-}
-typedef struct AMFFloatSize
-{
-    amf_float width;
-    amf_float height;
-#if defined(__cplusplus)
-    bool operator==(const AMFFloatSize& other) const
-    {
-        return width == other.width && height == other.height;
-    }
-    AMF_INLINE bool operator!=(const AMFFloatSize& other) const { return !operator==(other); }
-#endif
-} AMFFloatSize;
-
-static AMF_INLINE struct AMFFloatSize AMFConstructFloatSize(amf_float w, amf_float h)
-{
-    struct AMFFloatSize object = { w, h };
-    return object;
-}
-
-
-typedef struct AMFFloatPoint3D
-{
-    amf_float x;
-    amf_float y;
-    amf_float z;
-#if defined(__cplusplus)
-    bool operator==(const AMFFloatPoint3D& other) const
-    {
-        return x == other.x && y == other.y && z == other.z;
-    }
-    AMF_INLINE bool operator!=(const AMFFloatPoint3D& other) const { return !operator==(other); }
-#endif
-} AMFFloatPoint3D;
-
-static AMF_INLINE struct AMFFloatPoint3D AMFConstructFloatPoint3D(amf_float x, amf_float y, amf_float z)
-{
-    struct AMFFloatPoint3D object = { x, y, z };
-    return object;
-}
-
-typedef struct AMFFloatVector4D
-{
-    amf_float x;
-    amf_float y;
-    amf_float z;
-    amf_float w;
-#if defined(__cplusplus)
-    bool operator==(const AMFFloatVector4D& other) const
-    {
-        return x == other.x && y == other.y && z == other.z && w == other.w;
-    }
-    AMF_INLINE bool operator!=(const AMFFloatVector4D& other) const { return !operator==(other); }
-#endif
-} AMFFloatVector4D;
-
-static AMF_INLINE struct AMFFloatVector4D AMFConstructFloatVector4D(amf_float x, amf_float y, amf_float z, amf_float w)
-{
-    struct AMFFloatVector4D object = { x, y, z, w };
-    return object;
-}
-
-
-typedef struct AMFRate
-{
-    amf_uint32 num;
-    amf_uint32 den;
-#if defined(__cplusplus)
-    bool operator==(const AMFRate& other) const
-    {
-         return num == other.num && den == other.den; 
-    }
-    AMF_INLINE bool operator!=(const AMFRate& other) const { return !operator==(other); }
-#endif
-} AMFRate;
-
-static AMF_INLINE struct AMFRate AMFConstructRate(amf_uint32 num, amf_uint32 den)
-{
-    struct AMFRate object = {num, den};
-    return object;
-}
-
-typedef struct AMFRatio
-{
-    amf_uint32 num;
-    amf_uint32 den;
-#if defined(__cplusplus)
-    bool operator==(const AMFRatio& other) const
-    {
-         return num == other.num && den == other.den; 
-    }
-    AMF_INLINE bool operator!=(const AMFRatio& other) const { return !operator==(other); }
-#endif
-} AMFRatio;
-
-static AMF_INLINE struct AMFRatio AMFConstructRatio(amf_uint32 num, amf_uint32 den)
-{
-    struct AMFRatio object = {num, den};
-    return object;
-}
-
-#pragma pack(push, 1)
-#if defined(_MSC_VER)
-    #pragma warning( push )
-    #pragma warning(disable : 4200)
-    #pragma warning(disable : 4201)
-#endif
-
-typedef struct AMFColor
-{
-    union
-    {
-        struct
-        {
-            amf_uint8 r;
-            amf_uint8 g;
-            amf_uint8 b;
-            amf_uint8 a;
-        };
-        amf_uint32 rgba;
-    };
-#if defined(__cplusplus)
-    bool operator==(const AMFColor& other) const
-    {
-         return r == other.r && g == other.g && b == other.b && a == other.a; 
-    }
-    AMF_INLINE bool operator!=(const AMFColor& other) const { return !operator==(other); }
-#endif
-} AMFColor;
-#if defined(_MSC_VER)
-    #pragma warning( pop )
-#endif
-#pragma pack(pop)
-
-
-static AMF_INLINE struct AMFColor AMFConstructColor(amf_uint8 r, amf_uint8 g, amf_uint8 b, amf_uint8 a)
-{
-    struct AMFColor object;
-    object.r = r;
-    object.g = g;
-    object.b = b;
-    object.a = a;
-    return object;
-}
-
-#if defined(_WIN32)
-    #include <combaseapi.h>
-
-    #if defined(__cplusplus)
-    extern "C"
-    {
-    #endif
-        // allocator
-        static AMF_INLINE void* AMF_CDECL_CALL amf_variant_alloc(amf_size count)
-        {
-            return CoTaskMemAlloc(count);
-        }
-        static AMF_INLINE void AMF_CDECL_CALL amf_variant_free(void* ptr)
-        {
-            CoTaskMemFree(ptr);
-        }
-    #if defined(__cplusplus)
-    }
-    #endif
-
-#else // defined(_WIN32)
-    #include <stdlib.h>
-    #if defined(__cplusplus)
-    extern "C"
-    {
-    #endif
-        // allocator
-        static AMF_INLINE void* AMF_CDECL_CALL amf_variant_alloc(amf_size count)
-        {
-            return malloc(count);
-        }
-        static AMF_INLINE void AMF_CDECL_CALL amf_variant_free(void* ptr)
-        {
-            free(ptr);
-        }
-    #if defined(__cplusplus)
-    }
-    #endif
-#endif // defined(_WIN32)
-
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    typedef struct AMFGuid
-    {
-        amf_uint32 data1;
-        amf_uint16 data2;
-        amf_uint16 data3;
-        amf_uint8 data41;
-        amf_uint8 data42;
-        amf_uint8 data43;
-        amf_uint8 data44;
-        amf_uint8 data45;
-        amf_uint8 data46;
-        amf_uint8 data47;
-        amf_uint8 data48;
-#if defined(__cplusplus)
-        AMFGuid(amf_uint32 _data1, amf_uint16 _data2, amf_uint16 _data3,
-                amf_uint8 _data41, amf_uint8 _data42, amf_uint8 _data43, amf_uint8 _data44,
-                amf_uint8 _data45, amf_uint8 _data46, amf_uint8 _data47, amf_uint8 _data48)
-            : data1 (_data1),
-            data2 (_data2),
-            data3 (_data3),
-            data41(_data41),
-            data42(_data42),
-            data43(_data43),
-            data44(_data44),
-            data45(_data45),
-            data46(_data46),
-            data47(_data47),
-            data48(_data48)
-        {}
-
-        bool operator==(const AMFGuid& other) const
-        {
-            return
-                data1 == other.data1 &&
-                data2 == other.data2 &&
-                data3 == other.data3 &&
-                data41 == other.data41 &&
-                data42 == other.data42 &&
-                data43 == other.data43 &&
-                data44 == other.data44 &&
-                data45 == other.data45 &&
-                data46 == other.data46 &&
-                data47 == other.data47 &&
-                data48 == other.data48;
-        }
-        AMF_INLINE bool operator!=(const AMFGuid& other) const { return !operator==(other); }
-#endif
-    } AMFGuid;
-
-#if defined(__cplusplus)
-    static AMF_INLINE bool AMFCompareGUIDs(const AMFGuid& guid1, const AMFGuid& guid2)
-    {
-        return guid1 == guid2;
-    }
-#else
-    static AMF_INLINE amf_bool AMFCompareGUIDs(const struct AMFGuid guid1, const struct AMFGuid guid2)
-    {
-        return memcmp(&guid1, &guid2, sizeof(guid1)) == 0;
-    }
-#endif
-#if defined(__cplusplus)
-}
-#endif
-
-#if defined(__APPLE__)
-//#include <MacTypes.h>
-
-#define media_status_t int
-#define ANativeWindow void
-#define JNIEnv void
-#define jobject int
-#define JavaVM void
-
-#endif
-
-#endif //#ifndef AMF_Platform_h

plugins/obs-ffmpeg/external/AMF/include/core/PropertyStorage.h

@@ -1,275 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_PropertyStorage_h
-#define AMF_PropertyStorage_h
-#pragma once
-
-#include "Variant.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // AMFPropertyStorageObserver interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-
-    class AMF_NO_VTABLE AMFPropertyStorageObserver
-    {
-    public:
-        virtual void                AMF_STD_CALL OnPropertyChanged(const wchar_t* name) = 0;
-    };
-#else //#if defined(__cplusplus)
-    typedef struct AMFPropertyStorageObserver AMFPropertyStorageObserver;
-    typedef struct AMFPropertyStorageObserverVtbl
-    {
-        void                (AMF_STD_CALL *OnPropertyChanged)(AMFPropertyStorageObserver *pThis, const wchar_t* name);
-    } AMFPropertyStorageObserverVtbl;
-
-    struct AMFPropertyStorageObserver
-    {
-        const AMFPropertyStorageObserverVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-#if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AMFPropertyStorage interface
-    //----------------------------------------------------------------------------------------------
-    class AMF_NO_VTABLE AMFPropertyStorage : public AMFInterface
-    {
-    public:
-        AMF_DECLARE_IID(0xc7cec05b, 0xcfb9, 0x48af, 0xac, 0xe3, 0xf6, 0x8d, 0xf8, 0x39, 0x5f, 0xe3)
-
-        virtual AMF_RESULT          AMF_STD_CALL SetProperty(const wchar_t* name, AMFVariantStruct value) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetProperty(const wchar_t* name, AMFVariantStruct* pValue) const = 0;
-
-        virtual amf_bool            AMF_STD_CALL HasProperty(const wchar_t* name) const = 0;
-        virtual amf_size            AMF_STD_CALL GetPropertyCount() const = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetPropertyAt(amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue) const = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL Clear() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL AddTo(AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep) const= 0;
-        virtual AMF_RESULT          AMF_STD_CALL CopyTo(AMFPropertyStorage* pDest, amf_bool deep) const = 0;
-
-        virtual void                AMF_STD_CALL AddObserver(AMFPropertyStorageObserver* pObserver) = 0;
-        virtual void                AMF_STD_CALL RemoveObserver(AMFPropertyStorageObserver* pObserver) = 0;
-
-        template<typename _T>
-        AMF_RESULT                  AMF_STD_CALL SetProperty(const wchar_t* name, const _T& value);
-        template<typename _T>
-        AMF_RESULT                  AMF_STD_CALL GetProperty(const wchar_t* name, _T* pValue) const;
-        template<typename _T>
-        AMF_RESULT                  AMF_STD_CALL GetPropertyString(const wchar_t* name, _T* pValue) const;
-        template<typename _T>
-        AMF_RESULT                  AMF_STD_CALL GetPropertyWString(const wchar_t* name, _T* pValue) const;
-
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFPropertyStorage> AMFPropertyStoragePtr;
-    //----------------------------------------------------------------------------------------------
-
-#else // #if defined(__cplusplus)
-    typedef struct AMFPropertyStorage AMFPropertyStorage;
-        AMF_DECLARE_IID(AMFPropertyStorage, 0xc7cec05b, 0xcfb9, 0x48af, 0xac, 0xe3, 0xf6, 0x8d, 0xf8, 0x39, 0x5f, 0xe3)
-
-    typedef struct AMFPropertyStorageVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFPropertyStorage* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFPropertyStorage* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFPropertyStorage* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFPropertyStorage* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFPropertyStorage* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFPropertyStorage* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFPropertyStorage* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFPropertyStorage* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFPropertyStorage* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFPropertyStorage* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFPropertyStorage* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFPropertyStorage* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFPropertyStorage* pThis, AMFPropertyStorageObserver* pObserver);
-
-    } AMFPropertyStorageVtbl;
-
-    struct AMFPropertyStorage
-    {
-        const AMFPropertyStorageVtbl *pVtbl;
-    };
-
-    #define AMF_ASSIGN_PROPERTY_DATA(res, varType, pThis, name, val ) \
-    { \
-        AMFVariantStruct var = {0}; \
-        AMFVariantAssign##varType(&var, val); \
-        res = pThis->pVtbl->SetProperty(pThis, name, var ); \
-    }
-
-    #define AMF_QUERY_INTERFACE(res, from, InterfaceTypeTo, to) \
-    { \
-        AMFGuid guid_##InterfaceTypeTo = IID_##InterfaceTypeTo(); \
-        res = from->pVtbl->QueryInterface(from, &guid_##InterfaceTypeTo, (void**)&to); \
-    }
-
-    #define AMF_ASSIGN_PROPERTY_INTERFACE(res, pThis, name, val) \
-    { \
-        AMFInterface *amf_interface; \
-        AMFVariantStruct var; \
-        res = AMFVariantInit(&var); \
-        if (res == AMF_OK) \
-        { \
-            AMF_QUERY_INTERFACE(res, val, AMFInterface, amf_interface)\
-            if (res == AMF_OK) \
-            { \
-                res = AMFVariantAssignInterface(&var, amf_interface); \
-                amf_interface->pVtbl->Release(amf_interface); \
-                if (res == AMF_OK) \
-                { \
-                    res = pThis->pVtbl->SetProperty(pThis, name, var); \
-                } \
-            } \
-            AMFVariantClear(&var); \
-        } \
-    }
-
-    #define AMF_GET_PROPERTY_INTERFACE(res, pThis, name, TargetType, val) \
-    { \
-        AMFVariantStruct var; \
-        res = AMFVariantInit(&var); \
-        if (res != AMF_OK) \
-        { \
-            res = pThis->pVtbl->GetProperty(pThis, name, &var); \
-            if (res == AMF_OK) \
-            { \
-                if (var.type == AMF_VARIANT_INTERFACE && AMFVariantInterface(&var)) \
-                { \
-                    AMF_QUERY_INTERFACE(res, AMFVariantInterface(&var), TargetType, val); \
-                } \
-                else \
-                { \
-                    res = AMF_INVALID_DATA_TYPE; \
-                } \
-            } \
-        } \
-        AMFVariantClear(&var); \
-    }
-
-    #define AMF_ASSIGN_PROPERTY_TYPE(res, varType, dataType , pThis, name, val )  AMF_ASSIGN_PROPERTY_DATA(res, varType, pThis, name, (dataType)val)
-
-    #define AMF_ASSIGN_PROPERTY_INT64(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_TYPE(res, Int64, amf_int64, pThis, name, val)
-    #define AMF_ASSIGN_PROPERTY_DOUBLE(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_TYPE(res, Double, amf_double, pThis, name, val)
-    #define AMF_ASSIGN_PROPERTY_BOOL(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_TYPE(res, Bool, amf_bool, pThis, name, val)
-    #define AMF_ASSIGN_PROPERTY_RECT(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_DATA(res, Rect, pThis, name, &val)
-    #define AMF_ASSIGN_PROPERTY_SIZE(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_DATA(res, Size, pThis, name, &val)
-    #define AMF_ASSIGN_PROPERTY_POINT(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_DATA(res, Point, pThis, name, &val)
-    #define AMF_ASSIGN_PROPERTY_RATE(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_DATA(res, Rate, pThis, name, &val)
-    #define AMF_ASSIGN_PROPERTY_RATIO(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_DATA(res, Ratio, pThis, name, &val)
-    #define AMF_ASSIGN_PROPERTY_COLOR(res, pThis, name, val ) AMF_ASSIGN_PROPERTY_DATA(res, Color, pThis, name, &val)
-
-#endif // #if defined(__cplusplus)
-
-
-#if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // template methods implementations
-    //----------------------------------------------------------------------------------------------
-    template<typename _T> inline
-    AMF_RESULT AMF_STD_CALL AMFPropertyStorage::SetProperty(const wchar_t* name, const _T& value)
-    {
-        AMF_RESULT err = SetProperty(name, static_cast<const AMFVariantStruct&>(AMFVariant(value)));
-        return err;
-    }
-    //----------------------------------------------------------------------------------------------
-    template<typename _T> inline
-    AMF_RESULT AMF_STD_CALL AMFPropertyStorage::GetProperty(const wchar_t* name, _T* pValue) const
-    {
-        AMFVariant var;
-        AMF_RESULT err = GetProperty(name, static_cast<AMFVariantStruct*>(&var));
-        if(err == AMF_OK)
-        {
-            *pValue = static_cast<_T>(var);
-        }
-        return err;
-    }
-    //----------------------------------------------------------------------------------------------
-    template<typename _T> inline
-    AMF_RESULT AMF_STD_CALL AMFPropertyStorage::GetPropertyString(const wchar_t* name, _T* pValue) const
-    {
-        AMFVariant var;
-        AMF_RESULT err = GetProperty(name, static_cast<AMFVariantStruct*>(&var));
-        if(err == AMF_OK)
-        {
-            *pValue = var.ToString().c_str();
-        }
-        return err;
-    }
-    //----------------------------------------------------------------------------------------------
-    template<typename _T> inline
-    AMF_RESULT AMF_STD_CALL AMFPropertyStorage::GetPropertyWString(const wchar_t* name, _T* pValue) const
-    {
-        AMFVariant var;
-        AMF_RESULT err = GetProperty(name, static_cast<AMFVariantStruct*>(&var));
-        if(err == AMF_OK)
-        {
-            *pValue = var.ToWString().c_str();
-        }
-        return err;
-    }
-    //----------------------------------------------------------------------------------------------
-    template<> inline
-    AMF_RESULT AMF_STD_CALL AMFPropertyStorage::GetProperty(const wchar_t* name,
-            AMFInterface** ppValue) const
-    {
-        AMFVariant var;
-        AMF_RESULT err = GetProperty(name, static_cast<AMFVariantStruct*>(&var));
-        if(err == AMF_OK)
-        {
-            *ppValue = static_cast<AMFInterface*>(var);
-        }
-        if(*ppValue)
-        {
-            (*ppValue)->Acquire();
-        }
-        return err;
-    }
-#endif // #if defined(__cplusplus)
-
-#if defined(__cplusplus)
-} //namespace amf
-#endif
-
-#endif // #ifndef AMF_PropertyStorage_h

plugins/obs-ffmpeg/external/AMF/include/core/PropertyStorageEx.h

@@ -1,207 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_PropertyStorageEx_h
-#define AMF_PropertyStorageEx_h
-#pragma once
-
-#include "PropertyStorage.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_PROPERTY_CONTENT_ENUM
-    {
-        AMF_PROPERTY_CONTENT_DEFAULT = 0,
-        AMF_PROPERTY_CONTENT_XML,               // m_eType is AMF_VARIANT_STRING
-
-        AMF_PROPERTY_CONTENT_FILE_OPEN_PATH,    // m_eType AMF_VARIANT_WSTRING
-        AMF_PROPERTY_CONTENT_FILE_SAVE_PATH,    // m_eType AMF_VARIANT_WSTRING
-
-        AMF_PROPERTY_CONTENT_INTEGER_ARRAY,     // m_eType AMF_VARIANT_INTERFACE
-        AMF_PROPERTY_CONTENT_FLOAT_ARRAY        // m_eType AMF_VARIANT_INTERFACE
-    } AMF_PROPERTY_CONTENT_ENUM;
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_PROPERTY_ACCESS_TYPE
-    {
-        AMF_PROPERTY_ACCESS_PRIVATE             = 0,
-        AMF_PROPERTY_ACCESS_READ                = 0x1,
-        AMF_PROPERTY_ACCESS_WRITE               = 0x2,
-        AMF_PROPERTY_ACCESS_READ_WRITE          = (AMF_PROPERTY_ACCESS_READ | AMF_PROPERTY_ACCESS_WRITE),
-        AMF_PROPERTY_ACCESS_WRITE_RUNTIME       = 0x4,
-        AMF_PROPERTY_ACCESS_FULL                = 0xFF,
-		AMF_PROPERTY_ACCESS_NON_PERSISTANT		= 0x4000,
-		AMF_PROPERTY_ACCESS_NON_PERSISTANT_READ = (AMF_PROPERTY_ACCESS_NON_PERSISTANT | AMF_PROPERTY_ACCESS_READ),
-		AMF_PROPERTY_ACCESS_NON_PERSISTANT_READ_WRITE = (AMF_PROPERTY_ACCESS_NON_PERSISTANT | AMF_PROPERTY_ACCESS_READ_WRITE),
-		AMF_PROPERTY_ACCESS_NON_PERSISTANT_FULL = (AMF_PROPERTY_ACCESS_NON_PERSISTANT | AMF_PROPERTY_ACCESS_FULL),
-		AMF_PROPERTY_ACCESS_INVALID				= 0x8000
-    } AMF_PROPERTY_ACCESS_TYPE;
-
-    //----------------------------------------------------------------------------------------------
-    typedef struct AMFEnumDescriptionEntry
-    {
-        amf_int             value;
-        const wchar_t*      name;
-    } AMFEnumDescriptionEntry;
-    //----------------------------------------------------------------------------------------------
-    typedef amf_uint32 AMF_PROPERTY_CONTENT_TYPE;
-
-    typedef struct AMFPropertyInfo
-    {
-        const wchar_t*                  name;
-        const wchar_t*                  desc;
-        AMF_VARIANT_TYPE                type;
-        AMF_PROPERTY_CONTENT_TYPE       contentType;
-
-        AMFVariantStruct                defaultValue;
-        AMFVariantStruct                minValue;
-        AMFVariantStruct                maxValue;
-        AMF_PROPERTY_ACCESS_TYPE        accessType;
-        const AMFEnumDescriptionEntry*  pEnumDescription;
-
-#if defined(__cplusplus)
-        AMFPropertyInfo() :
-            name(NULL),
-            desc(NULL),
-            type(),
-            contentType(),
-            defaultValue(),
-            minValue(),
-            maxValue(),
-            accessType(AMF_PROPERTY_ACCESS_FULL),
-            pEnumDescription(NULL)
-        {}
-        AMFPropertyInfo(const AMFPropertyInfo& propery) : name(propery.name),
-            desc(propery.desc),
-            type(propery.type),
-            contentType(propery.contentType),
-            defaultValue(propery.defaultValue),
-            minValue(propery.minValue),
-            maxValue(propery.maxValue),
-            accessType(propery.accessType),
-            pEnumDescription(propery.pEnumDescription)
-        {}
-        virtual ~AMFPropertyInfo(){}
-
-        amf_bool AMF_STD_CALL AllowedRead() const
-        {
-            return (accessType & AMF_PROPERTY_ACCESS_READ) != 0;
-        }
-        amf_bool AMF_STD_CALL AllowedWrite() const
-        {
-            return (accessType & AMF_PROPERTY_ACCESS_WRITE) != 0;
-        }
-        amf_bool AMF_STD_CALL AllowedChangeInRuntime() const
-        {
-            return (accessType & AMF_PROPERTY_ACCESS_WRITE_RUNTIME) != 0;
-        }
-
-        AMFPropertyInfo& operator=(const AMFPropertyInfo& propery)
-        {
-            name = propery.name;
-            desc = propery.desc;
-            type = propery.type;
-            contentType = propery.contentType;
-            defaultValue = propery.defaultValue;
-            minValue = propery.minValue;
-            maxValue = propery.maxValue;
-            accessType = propery.accessType;
-            pEnumDescription = propery.pEnumDescription;
-
-            return *this;
-        }
-#endif // #if defined(__cplusplus)
-    } AMFPropertyInfo;
-    //----------------------------------------------------------------------------------------------
-    // AMFPropertyStorageEx interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFPropertyStorageEx : public AMFPropertyStorage
-    {
-    public:
-        AMF_DECLARE_IID(0x16b8958d, 0xe943, 0x4a33, 0xa3, 0x5a, 0x88, 0x5a, 0xd8, 0x28, 0xf2, 0x67)
-
-        virtual amf_size            AMF_STD_CALL GetPropertiesInfoCount() const = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetPropertyInfo(amf_size index, const AMFPropertyInfo** ppInfo) const = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetPropertyInfo(const wchar_t* name, const AMFPropertyInfo** ppInfo) const = 0;
-        virtual AMF_RESULT          AMF_STD_CALL ValidateProperty(const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated) const = 0;
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFPropertyStorageEx> AMFPropertyStorageExPtr;
-#else // #if defined(__cplusplus)
-    AMF_DECLARE_IID(AMFPropertyStorageEx, 0x16b8958d, 0xe943, 0x4a33, 0xa3, 0x5a, 0x88, 0x5a, 0xd8, 0x28, 0xf2, 0x67)
-    typedef struct AMFPropertyStorageEx AMFPropertyStorageEx;
-
-    typedef struct AMFPropertyStorageExVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFPropertyStorageEx* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFPropertyStorageEx* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFPropertyStorageEx* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFPropertyStorageEx* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFPropertyStorageEx* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFPropertyStorageEx* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFPropertyStorageEx* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFPropertyStorageEx* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFPropertyStorageEx* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFPropertyStorageEx* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFPropertyStorageEx* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFPropertyStorageEx* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFPropertyStorageEx* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFPropertyStorageEx interface
-
-        amf_size            (AMF_STD_CALL *GetPropertiesInfoCount)(AMFPropertyStorageEx* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfoAt)(AMFPropertyStorageEx* pThis, amf_size index, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyInfo)(AMFPropertyStorageEx* pThis, const wchar_t* name, const AMFPropertyInfo** ppInfo);
-        AMF_RESULT          (AMF_STD_CALL *ValidateProperty)(AMFPropertyStorageEx* pThis, const wchar_t* name, AMFVariantStruct value, AMFVariantStruct* pOutValidated);
-
-    } AMFPropertyStorageExVtbl;
-
-    struct AMFPropertyStorageEx
-    {
-        const AMFPropertyStorageExVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-} //namespace amf
-#endif
-
-
-#endif //#ifndef AMF_PropertyStorageEx_h

plugins/obs-ffmpeg/external/AMF/include/core/Result.h

@@ -1,127 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Result_h
-#define AMF_Result_h
-#pragma once
-
-#include "Platform.h"
-
-//----------------------------------------------------------------------------------------------
-// result codes
-//----------------------------------------------------------------------------------------------
-
-typedef enum AMF_RESULT
-{
-    AMF_OK                                   = 0,
-    AMF_FAIL                                    ,
-
-// common errors
-    AMF_UNEXPECTED                              ,
-
-    AMF_ACCESS_DENIED                           ,
-    AMF_INVALID_ARG                             ,
-    AMF_OUT_OF_RANGE                            ,
-
-    AMF_OUT_OF_MEMORY                           ,
-    AMF_INVALID_POINTER                         ,
-
-    AMF_NO_INTERFACE                            ,
-    AMF_NOT_IMPLEMENTED                         ,
-    AMF_NOT_SUPPORTED                           ,
-    AMF_NOT_FOUND                               ,
-
-    AMF_ALREADY_INITIALIZED                     ,
-    AMF_NOT_INITIALIZED                         ,
-
-    AMF_INVALID_FORMAT                          ,// invalid data format
-
-    AMF_WRONG_STATE                             ,
-    AMF_FILE_NOT_OPEN                           ,// cannot open file
-
-// device common codes
-    AMF_NO_DEVICE                               ,
-
-// device directx
-    AMF_DIRECTX_FAILED                          ,
-// device opencl 
-    AMF_OPENCL_FAILED                           ,
-// device opengl 
-    AMF_GLX_FAILED                              ,//failed to use GLX
-// device XV 
-    AMF_XV_FAILED                               , //failed to use Xv extension
-// device alsa
-    AMF_ALSA_FAILED                             ,//failed to use ALSA
-
-// component common codes
-
-    //result codes
-    AMF_EOF                                     ,
-    AMF_REPEAT                                  ,
-    AMF_INPUT_FULL                              ,//returned by AMFComponent::SubmitInput if input queue is full
-    AMF_RESOLUTION_CHANGED                      ,//resolution changed client needs to Drain/Terminate/Init
-    AMF_RESOLUTION_UPDATED                      ,//resolution changed in adaptive mode. New ROI will be set on output on newly decoded frames
-
-    //error codes
-    AMF_INVALID_DATA_TYPE                       ,//invalid data type
-    AMF_INVALID_RESOLUTION                      ,//invalid resolution (width or height)
-    AMF_CODEC_NOT_SUPPORTED                     ,//codec not supported
-    AMF_SURFACE_FORMAT_NOT_SUPPORTED            ,//surface format not supported
-    AMF_SURFACE_MUST_BE_SHARED                  ,//surface should be shared (DX11: (MiscFlags & D3D11_RESOURCE_MISC_SHARED) == 0, DX9: No shared handle found)
-
-// component video decoder
-    AMF_DECODER_NOT_PRESENT                     ,//failed to create the decoder
-    AMF_DECODER_SURFACE_ALLOCATION_FAILED       ,//failed to create the surface for decoding
-    AMF_DECODER_NO_FREE_SURFACES                ,
-
-// component video encoder
-    AMF_ENCODER_NOT_PRESENT                     ,//failed to create the encoder
-
-// component video processor
-
-// component video conveter
-
-// component dem
-    AMF_DEM_ERROR                               ,
-    AMF_DEM_PROPERTY_READONLY                   ,
-    AMF_DEM_REMOTE_DISPLAY_CREATE_FAILED        ,
-    AMF_DEM_START_ENCODING_FAILED               ,
-    AMF_DEM_QUERY_OUTPUT_FAILED                 ,
-
-// component TAN
-    AMF_TAN_CLIPPING_WAS_REQUIRED               , // Resulting data was truncated to meet output type's value limits.
-    AMF_TAN_UNSUPPORTED_VERSION                 , // Not supported version requested, solely for TANCreateContext().
-
-    AMF_NEED_MORE_INPUT                         ,//returned by AMFComponent::SubmitInput did not produce a buffer because more input submissions are required.
-} AMF_RESULT;
-
-#endif //#ifndef AMF_Result_h

plugins/obs-ffmpeg/external/AMF/include/core/Surface.h

@@ -1,281 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Surface_h
-#define AMF_Surface_h
-#pragma once
-
-#include "Data.h"
-#include "Plane.h"
-
-#if defined(_MSC_VER)
-    #pragma warning( push )
-    #pragma warning(disable : 4263)
-    #pragma warning(disable : 4264)
-#endif
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_SURFACE_FORMAT
-    {
-        AMF_SURFACE_UNKNOWN     = 0,
-        AMF_SURFACE_NV12,               ///< 1  - planar 4:2:0 Y width x height + packed UV width/2 x height/2 - 8 bit per component
-        AMF_SURFACE_YV12,               ///< 2  - planar 4:2:0 Y width x height + V width/2 x height/2 + U width/2 x height/2 - 8 bit per component
-        AMF_SURFACE_BGRA,               ///< 3  - packed 4:4:4 - 8 bit per component
-        AMF_SURFACE_ARGB,               ///< 4  - packed 4:4:4 - 8 bit per component
-        AMF_SURFACE_RGBA,               ///< 5  - packed 4:4:4 - 8 bit per component
-        AMF_SURFACE_GRAY8,              ///< 6  - single component - 8 bit
-        AMF_SURFACE_YUV420P,            ///< 7  - planar 4:2:0 Y width x height + U width/2 x height/2 + V width/2 x height/2 - 8 bit per component
-        AMF_SURFACE_U8V8,               ///< 8  - packed double component - 8 bit per component
-        AMF_SURFACE_YUY2,               ///< 9  - packed 4:2:2 Byte 0=8-bit Y'0; Byte 1=8-bit Cb; Byte 2=8-bit Y'1; Byte 3=8-bit Cr
-        AMF_SURFACE_P010,               ///< 10 - planar 4:2:0 Y width x height + packed UV width/2 x height/2 - 10 bit per component (16 allocated, upper 10 bits are used)
-        AMF_SURFACE_RGBA_F16,           ///< 11 - packed 4:4:4 - 16 bit per component float
-        AMF_SURFACE_UYVY,               ///< 12 - packed 4:2:2 the similar to YUY2 but Y and UV swapped: Byte 0=8-bit Cb; Byte 1=8-bit Y'0; Byte 2=8-bit Cr Byte 3=8-bit Y'1; (used the same DX/CL/Vulkan storage as YUY2)
-        AMF_SURFACE_R10G10B10A2,        ///< 13 - packed 4:4:4 to 4 bytes, 10 bit per RGB component, 2 bits per A 
-        AMF_SURFACE_Y210,               ///< 14 - packed 4:2:2 - Word 0=10-bit Y'0; Word 1=10-bit Cb; Word 2=10-bit Y'1; Word 3=10-bit Cr
-        AMF_SURFACE_AYUV,               ///< 15 - packed 4:4:4 - 8 bit per component YUVA
-        AMF_SURFACE_Y410,               ///< 16 - packed 4:4:4 - 10 bit per YUV component, 2 bits per A, AVYU 
-        AMF_SURFACE_Y416,               ///< 16 - packed 4:4:4 - 16 bit per component 4 bytes, AVYU
-        AMF_SURFACE_GRAY32,             ///< 17 - single component - 32 bit
-        AMF_SURFACE_P012,               ///< 18 - planar 4:2:0 Y width x height + packed UV width/2 x height/2 - 12 bit per component (16 allocated, upper 12 bits are used)
-        AMF_SURFACE_P016,               ///< 19 - planar 4:2:0 Y width x height + packed UV width/2 x height/2 - 16 bit per component (16 allocated, all bits are used)
-
-        AMF_SURFACE_FIRST = AMF_SURFACE_NV12,
-        AMF_SURFACE_LAST = AMF_SURFACE_P016
-    } AMF_SURFACE_FORMAT;
-    //----------------------------------------------------------------------------------------------
-    // AMF_SURFACE_USAGE translates to D3D11_BIND_FLAG or VkImageUsageFlags
-    // bit mask
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_SURFACE_USAGE_BITS
-    {                                                       // D3D11                        D3D12                                       Vulkan 
-        AMF_SURFACE_USAGE_DEFAULT           = 0x80000000,   // will apply default           D3D12_RESOURCE_FLAG_NONE                    VK_IMAGE_USAGE_TRANSFER_SRC_BIT| VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
-        AMF_SURFACE_USAGE_NONE              = 0x00000000,   // 0,                           D3D12_RESOURCE_FLAG_NONE,                   0
-        AMF_SURFACE_USAGE_SHADER_RESOURCE   = 0x00000001,   // D3D11_BIND_SHADER_RESOURCE,	D3D12_RESOURCE_FLAG_NONE					VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
-        AMF_SURFACE_USAGE_RENDER_TARGET     = 0x00000002,   // D3D11_BIND_RENDER_TARGET,    D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET,    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
-        AMF_SURFACE_USAGE_UNORDERED_ACCESS  = 0x00000004,   // D3D11_BIND_UNORDERED_ACCESS, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
-        AMF_SURFACE_USAGE_TRANSFER_SRC      = 0x00000008,   //								D3D12_RESOURCE_FLAG_NONE    	            VK_IMAGE_USAGE_TRANSFER_SRC_BIT
-        AMF_SURFACE_USAGE_TRANSFER_DST      = 0x00000010,   //								D3D12_RESOURCE_FLAG_NONE		            VK_IMAGE_USAGE_TRANSFER_DST_BIT
-        AMF_SURFACE_USAGE_LINEAR            = 0x00000020    
-    } AMF_SURFACE_USAGE_BITS;
-    typedef amf_flags AMF_SURFACE_USAGE;
-    //----------------------------------------------------------------------------------------------
-
-#if defined(_WIN32)
-    AMF_WEAK GUID  AMFFormatGUID = { 0x8cd592d0, 0x8063, 0x4af8, {0xa7, 0xd0, 0x32, 0x5b, 0xc5, 0xf7, 0x48, 0xab}}; // UINT(AMF_SURFACE_FORMAT), default - AMF_SURFACE_UNKNOWN; to be set on ID3D11Texture2D objects when used natively (i.e. force UYVY on DXGI_FORMAT_YUY2 texture)
-#endif
-
-    //----------------------------------------------------------------------------------------------
-    // frame type
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_FRAME_TYPE
-    {
-        // flags
-        AMF_FRAME_STEREO_FLAG                           = 0x10000000,
-        AMF_FRAME_LEFT_FLAG                             = AMF_FRAME_STEREO_FLAG | 0x20000000,
-        AMF_FRAME_RIGHT_FLAG                            = AMF_FRAME_STEREO_FLAG | 0x40000000,
-        AMF_FRAME_BOTH_FLAG                             = AMF_FRAME_LEFT_FLAG | AMF_FRAME_RIGHT_FLAG,
-        AMF_FRAME_INTERLEAVED_FLAG                      = 0x01000000,
-        AMF_FRAME_FIELD_FLAG                            = 0x02000000,
-        AMF_FRAME_EVEN_FLAG                             = 0x04000000,
-        AMF_FRAME_ODD_FLAG                              = 0x08000000,
-
-        // values
-        AMF_FRAME_UNKNOWN                               =-1,
-        AMF_FRAME_PROGRESSIVE                           = 0,
-
-        AMF_FRAME_INTERLEAVED_EVEN_FIRST                = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_EVEN_FLAG,
-        AMF_FRAME_INTERLEAVED_ODD_FIRST                 = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_ODD_FLAG,
-        AMF_FRAME_FIELD_SINGLE_EVEN                     = AMF_FRAME_FIELD_FLAG | AMF_FRAME_EVEN_FLAG,
-        AMF_FRAME_FIELD_SINGLE_ODD                      = AMF_FRAME_FIELD_FLAG | AMF_FRAME_ODD_FLAG,
-
-        AMF_FRAME_STEREO_LEFT                           = AMF_FRAME_LEFT_FLAG,
-        AMF_FRAME_STEREO_RIGHT                          = AMF_FRAME_RIGHT_FLAG,
-        AMF_FRAME_STEREO_BOTH                           = AMF_FRAME_BOTH_FLAG,
-
-        AMF_FRAME_INTERLEAVED_EVEN_FIRST_STEREO_LEFT    = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_EVEN_FLAG | AMF_FRAME_LEFT_FLAG,
-        AMF_FRAME_INTERLEAVED_EVEN_FIRST_STEREO_RIGHT   = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_EVEN_FLAG | AMF_FRAME_RIGHT_FLAG,
-        AMF_FRAME_INTERLEAVED_EVEN_FIRST_STEREO_BOTH    = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_EVEN_FLAG | AMF_FRAME_BOTH_FLAG,
-
-        AMF_FRAME_INTERLEAVED_ODD_FIRST_STEREO_LEFT     = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_ODD_FLAG | AMF_FRAME_LEFT_FLAG,
-        AMF_FRAME_INTERLEAVED_ODD_FIRST_STEREO_RIGHT    = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_ODD_FLAG | AMF_FRAME_RIGHT_FLAG,
-        AMF_FRAME_INTERLEAVED_ODD_FIRST_STEREO_BOTH     = AMF_FRAME_INTERLEAVED_FLAG | AMF_FRAME_ODD_FLAG | AMF_FRAME_BOTH_FLAG,
-    } AMF_FRAME_TYPE;
-
-    typedef enum AMF_ROTATION_ENUM
-    {
-        AMF_ROTATION_NONE   = 0,
-        AMF_ROTATION_90     = 1,
-        AMF_ROTATION_180    = 2,
-        AMF_ROTATION_270    = 3,
-    } AMF_ROTATION_ENUM;
-
-    #define AMF_SURFACE_ROTATION         L"Rotation"    // amf_int64(AMF_ROTATION_ENUM); default = AMF_ROTATION_NONE, can be set on surfaces
-
-    //----------------------------------------------------------------------------------------------
-    // AMFSurfaceObserver interface - callback; is called before internal release resources.
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMFSurface;
-    class AMF_NO_VTABLE AMFSurfaceObserver
-    {
-    public:
-        virtual void AMF_STD_CALL OnSurfaceDataRelease(AMFSurface* pSurface) = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFSurface AMFSurface;
-    typedef struct AMFSurfaceObserver AMFSurfaceObserver;
-
-    typedef struct AMFSurfaceObserverVtbl
-    {
-        void                (AMF_STD_CALL *OnSurfaceDataRelease)(AMFSurfaceObserver* pThis, AMFSurface* pSurface);
-    } AMFSurfaceObserverVtbl;
-
-    struct AMFSurfaceObserver
-    {
-        const AMFSurfaceObserverVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFSurface interface
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFSurface : public AMFData
-    {
-    public:
-        AMF_DECLARE_IID(0x3075dbe3, 0x8718, 0x4cfa, 0x86, 0xfb, 0x21, 0x14, 0xc0, 0xa5, 0xa4, 0x51)
-
-        virtual AMF_SURFACE_FORMAT  AMF_STD_CALL GetFormat() = 0;
-
-        // do not store planes outside. should be used together with Surface
-        virtual amf_size            AMF_STD_CALL GetPlanesCount() = 0;
-        virtual AMFPlane*           AMF_STD_CALL GetPlaneAt(amf_size index) = 0;
-        virtual AMFPlane*           AMF_STD_CALL GetPlane(AMF_PLANE_TYPE type) = 0;
-
-        virtual AMF_FRAME_TYPE      AMF_STD_CALL GetFrameType() = 0;
-        virtual void                AMF_STD_CALL SetFrameType(AMF_FRAME_TYPE type) = 0;
-
-        virtual AMF_RESULT          AMF_STD_CALL SetCrop(amf_int32 x,amf_int32 y, amf_int32 width, amf_int32 height) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL CopySurfaceRegion(AMFSurface* pDest, amf_int32 dstX, amf_int32 dstY, amf_int32 srcX, amf_int32 srcY, amf_int32 width, amf_int32 height) = 0;
-
-        // Observer management
-#ifdef __clang__
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Woverloaded-virtual"
-#endif
-        virtual void                AMF_STD_CALL AddObserver(AMFSurfaceObserver* pObserver) = 0;
-        virtual void                AMF_STD_CALL RemoveObserver(AMFSurfaceObserver* pObserver) = 0;
-#ifdef __clang__
-    #pragma clang diagnostic pop
-#endif
-
-    };
-    //----------------------------------------------------------------------------------------------
-    // smart pointer
-    //----------------------------------------------------------------------------------------------
-    typedef AMFInterfacePtr_T<AMFSurface> AMFSurfacePtr;
-    //----------------------------------------------------------------------------------------------
-#else // #if defined(__cplusplus)
-        AMF_DECLARE_IID(AMFSurface, 0x3075dbe3, 0x8718, 0x4cfa, 0x86, 0xfb, 0x21, 0x14, 0xc0, 0xa5, 0xa4, 0x51)
-    typedef struct AMFSurfaceVtbl
-    {
-        // AMFInterface interface
-        amf_long            (AMF_STD_CALL *Acquire)(AMFSurface* pThis);
-        amf_long            (AMF_STD_CALL *Release)(AMFSurface* pThis);
-        enum AMF_RESULT     (AMF_STD_CALL *QueryInterface)(AMFSurface* pThis, const struct AMFGuid *interfaceID, void** ppInterface);
-
-        // AMFPropertyStorage interface
-        AMF_RESULT          (AMF_STD_CALL *SetProperty)(AMFSurface* pThis, const wchar_t* name, AMFVariantStruct value);
-        AMF_RESULT          (AMF_STD_CALL *GetProperty)(AMFSurface* pThis, const wchar_t* name, AMFVariantStruct* pValue);
-        amf_bool            (AMF_STD_CALL *HasProperty)(AMFSurface* pThis, const wchar_t* name);
-        amf_size            (AMF_STD_CALL *GetPropertyCount)(AMFSurface* pThis);
-        AMF_RESULT          (AMF_STD_CALL *GetPropertyAt)(AMFSurface* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue);
-        AMF_RESULT          (AMF_STD_CALL *Clear)(AMFSurface* pThis);
-        AMF_RESULT          (AMF_STD_CALL *AddTo)(AMFSurface* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep);
-        AMF_RESULT          (AMF_STD_CALL *CopyTo)(AMFSurface* pThis, AMFPropertyStorage* pDest, amf_bool deep);
-        void                (AMF_STD_CALL *AddObserver)(AMFSurface* pThis, AMFPropertyStorageObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver)(AMFSurface* pThis, AMFPropertyStorageObserver* pObserver);
-
-        // AMFData interface
-
-        AMF_MEMORY_TYPE     (AMF_STD_CALL *GetMemoryType)(AMFSurface* pThis);
-
-        AMF_RESULT          (AMF_STD_CALL *Duplicate)(AMFSurface* pThis, AMF_MEMORY_TYPE type, AMFData** ppData);
-        AMF_RESULT          (AMF_STD_CALL *Convert)(AMFSurface* pThis, AMF_MEMORY_TYPE type); // optimal interop if possilble. Copy through host memory if needed
-        AMF_RESULT          (AMF_STD_CALL *Interop)(AMFSurface* pThis, AMF_MEMORY_TYPE type); // only optimal interop if possilble. No copy through host memory for GPU objects
-
-        AMF_DATA_TYPE       (AMF_STD_CALL *GetDataType)(AMFSurface* pThis);
-
-        amf_bool            (AMF_STD_CALL *IsReusable)(AMFSurface* pThis);
-
-        void                (AMF_STD_CALL *SetPts)(AMFSurface* pThis, amf_pts pts);
-        amf_pts             (AMF_STD_CALL *GetPts)(AMFSurface* pThis);
-        void                (AMF_STD_CALL *SetDuration)(AMFSurface* pThis, amf_pts duration);
-        amf_pts             (AMF_STD_CALL *GetDuration)(AMFSurface* pThis);
-
-        // AMFSurface interface
-
-        AMF_SURFACE_FORMAT  (AMF_STD_CALL *GetFormat)(AMFSurface* pThis);
-
-        // do not store planes outside. should be used together with Surface
-        amf_size            (AMF_STD_CALL *GetPlanesCount)(AMFSurface* pThis);
-        AMFPlane*           (AMF_STD_CALL *GetPlaneAt)(AMFSurface* pThis, amf_size index);
-        AMFPlane*           (AMF_STD_CALL *GetPlane)(AMFSurface* pThis, AMF_PLANE_TYPE type);
-
-        AMF_FRAME_TYPE      (AMF_STD_CALL *GetFrameType)(AMFSurface* pThis);
-        void                (AMF_STD_CALL *SetFrameType)(AMFSurface* pThis, AMF_FRAME_TYPE type);
-
-        AMF_RESULT          (AMF_STD_CALL *SetCrop)(AMFSurface* pThis, amf_int32 x,amf_int32 y, amf_int32 width, amf_int32 height);
-        AMF_RESULT          (AMF_STD_CALL *CopySurfaceRegion)(AMFSurface* pThis, AMFSurface* pDest, amf_int32 dstX, amf_int32 dstY, amf_int32 srcX, amf_int32 srcY, amf_int32 width, amf_int32 height);
-
-
-        // Observer management
-        void                (AMF_STD_CALL *AddObserver_Surface)(AMFSurface* pThis, AMFSurfaceObserver* pObserver);
-        void                (AMF_STD_CALL *RemoveObserver_Surface)(AMFSurface* pThis, AMFSurfaceObserver* pObserver);
-
-    } AMFSurfaceVtbl;
-
-    struct AMFSurface
-    {
-        const AMFSurfaceVtbl *pVtbl;
-    };
-#endif // #if defined(__cplusplus)
-#if defined(__cplusplus)
-}
-#endif
-#if defined(_MSC_VER)
-    #pragma warning( pop )
-#endif
-#endif //#ifndef AMF_Surface_h

plugins/obs-ffmpeg/external/AMF/include/core/Trace.h

@@ -1,183 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Trace_h
-#define AMF_Trace_h
-#pragma once
-
-#include "Platform.h"
-#include "Result.h"
-#include "Surface.h"
-#include "AudioBuffer.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // trace levels
-    //----------------------------------------------------------------------------------------------
-    #define AMF_TRACE_ERROR     0
-    #define AMF_TRACE_WARNING   1
-    #define AMF_TRACE_INFO      2 // default in sdk
-    #define AMF_TRACE_DEBUG     3
-    #define AMF_TRACE_TRACE     4
-
-    #define AMF_TRACE_TEST      5
-    #define AMF_TRACE_NOLOG     100
-
-    //----------------------------------------------------------------------------------------------
-    // available trace writers
-    //----------------------------------------------------------------------------------------------
-    #define AMF_TRACE_WRITER_CONSOLE            L"Console"
-    #define AMF_TRACE_WRITER_DEBUG_OUTPUT       L"DebugOutput"
-    #define AMF_TRACE_WRITER_FILE               L"File"
-
-    //----------------------------------------------------------------------------------------------
-    // AMFTraceWriter interface - callback
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFTraceWriter
-    {
-    public:
-        virtual void AMF_CDECL_CALL Write(const wchar_t* scope, const wchar_t* message) = 0;
-        virtual void AMF_CDECL_CALL Flush() = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFTraceWriter AMFTraceWriter;
-
-    typedef struct AMFTraceWriterVtbl
-    {
-        // AMFTraceWriter interface
-        void (AMF_CDECL_CALL *Write)(AMFTraceWriter* pThis, const wchar_t* scope, const wchar_t* message);
-        void (AMF_CDECL_CALL *Flush)(AMFTraceWriter* pThis);
-    } AMFTraceWriterVtbl;
-
-    struct AMFTraceWriter
-    {
-        const AMFTraceWriterVtbl *pVtbl;
-    };
-
-#endif // #if defined(__cplusplus)
-
-    //----------------------------------------------------------------------------------------------
-    // AMFTrace interface - singleton
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    class AMF_NO_VTABLE AMFTrace
-    {
-    public:
-        virtual  void               AMF_STD_CALL TraceW(const wchar_t* src_path, amf_int32 line, amf_int32 level, const wchar_t* scope,amf_int32 countArgs, const wchar_t* format, ...) = 0;
-        virtual  void               AMF_STD_CALL Trace(const wchar_t* src_path, amf_int32 line, amf_int32 level, const wchar_t* scope, const wchar_t* message, va_list* pArglist) = 0;
-
-        virtual amf_int32           AMF_STD_CALL SetGlobalLevel(amf_int32 level) = 0;
-        virtual amf_int32           AMF_STD_CALL GetGlobalLevel() = 0;
-
-        virtual amf_bool            AMF_STD_CALL EnableWriter(const wchar_t* writerID, bool enable) = 0;
-        virtual amf_bool            AMF_STD_CALL WriterEnabled(const wchar_t* writerID) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL TraceEnableAsync(amf_bool enable) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL TraceFlush() = 0;
-        virtual AMF_RESULT          AMF_STD_CALL SetPath(const wchar_t* path) = 0;
-        virtual AMF_RESULT          AMF_STD_CALL GetPath(wchar_t* path, amf_size* pSize) = 0;
-        virtual amf_int32           AMF_STD_CALL SetWriterLevel(const wchar_t* writerID, amf_int32 level) = 0;
-        virtual amf_int32           AMF_STD_CALL GetWriterLevel(const wchar_t* writerID) = 0;
-        virtual amf_int32           AMF_STD_CALL SetWriterLevelForScope(const wchar_t* writerID, const wchar_t* scope, amf_int32 level) = 0;
-        virtual amf_int32           AMF_STD_CALL GetWriterLevelForScope(const wchar_t* writerID, const wchar_t* scope) = 0;
-
-        virtual amf_int32           AMF_STD_CALL GetIndentation() = 0;
-        virtual void                AMF_STD_CALL Indent(amf_int32 addIndent) = 0;
-
-        virtual void                AMF_STD_CALL RegisterWriter(const wchar_t* writerID, AMFTraceWriter* pWriter, amf_bool enable) = 0;
-        virtual void                AMF_STD_CALL UnregisterWriter(const wchar_t* writerID) = 0;
-
-        virtual const wchar_t*      AMF_STD_CALL GetResultText(AMF_RESULT res) = 0;
-        virtual const wchar_t*      AMF_STD_CALL SurfaceGetFormatName(const AMF_SURFACE_FORMAT eSurfaceFormat) = 0;
-        virtual AMF_SURFACE_FORMAT  AMF_STD_CALL SurfaceGetFormatByName(const wchar_t* name) = 0;
-
-        virtual const wchar_t*      AMF_STD_CALL GetMemoryTypeName(const AMF_MEMORY_TYPE memoryType) = 0;
-        virtual AMF_MEMORY_TYPE     AMF_STD_CALL GetMemoryTypeByName(const wchar_t* name) = 0;
-
-        virtual const wchar_t*      AMF_STD_CALL GetSampleFormatName(const AMF_AUDIO_FORMAT eFormat) = 0;
-        virtual AMF_AUDIO_FORMAT    AMF_STD_CALL GetSampleFormatByName(const wchar_t* name) = 0;
-    };
-#else // #if defined(__cplusplus)
-    typedef struct AMFTrace AMFTrace;
-
-    typedef struct AMFTraceVtbl
-    {
-        // AMFTrace interface
-         void               (AMF_STD_CALL *TraceW)(AMFTrace* pThis, const wchar_t* src_path, amf_int32 line, amf_int32 level, const wchar_t* scope,amf_int32 countArgs, const wchar_t* format, ...);
-         void               (AMF_STD_CALL *Trace)(AMFTrace* pThis, const wchar_t* src_path, amf_int32 line, amf_int32 level, const wchar_t* scope, const wchar_t* message, va_list* pArglist);
-
-        amf_int32           (AMF_STD_CALL *SetGlobalLevel)(AMFTrace* pThis, amf_int32 level);
-        amf_int32           (AMF_STD_CALL *GetGlobalLevel)(AMFTrace* pThis);
-
-        amf_bool            (AMF_STD_CALL *EnableWriter)(AMFTrace* pThis, const wchar_t* writerID, amf_bool enable);
-        amf_bool            (AMF_STD_CALL *WriterEnabled)(AMFTrace* pThis, const wchar_t* writerID);
-        AMF_RESULT          (AMF_STD_CALL *TraceEnableAsync)(AMFTrace* pThis, amf_bool enable);
-        AMF_RESULT          (AMF_STD_CALL *TraceFlush)(AMFTrace* pThis);
-        AMF_RESULT          (AMF_STD_CALL *SetPath)(AMFTrace* pThis, const wchar_t* path);
-        AMF_RESULT          (AMF_STD_CALL *GetPath)(AMFTrace* pThis, wchar_t* path, amf_size* pSize);
-        amf_int32           (AMF_STD_CALL *SetWriterLevel)(AMFTrace* pThis, const wchar_t* writerID, amf_int32 level);
-        amf_int32           (AMF_STD_CALL *GetWriterLevel)(AMFTrace* pThis, const wchar_t* writerID);
-        amf_int32           (AMF_STD_CALL *SetWriterLevelForScope)(AMFTrace* pThis, const wchar_t* writerID, const wchar_t* scope, amf_int32 level);
-        amf_int32           (AMF_STD_CALL *GetWriterLevelForScope)(AMFTrace* pThis, const wchar_t* writerID, const wchar_t* scope);
-
-        amf_int32           (AMF_STD_CALL *GetIndentation)(AMFTrace* pThis);
-        void                (AMF_STD_CALL *Indent)(AMFTrace* pThis, amf_int32 addIndent);
-
-        void                (AMF_STD_CALL *RegisterWriter)(AMFTrace* pThis, const wchar_t* writerID, AMFTraceWriter* pWriter, amf_bool enable);
-        void                (AMF_STD_CALL *UnregisterWriter)(AMFTrace* pThis, const wchar_t* writerID);
-
-        const wchar_t*      (AMF_STD_CALL *GetResultText)(AMFTrace* pThis, AMF_RESULT res);
-        const wchar_t*      (AMF_STD_CALL *SurfaceGetFormatName)(AMFTrace* pThis, const AMF_SURFACE_FORMAT eSurfaceFormat);
-        AMF_SURFACE_FORMAT  (AMF_STD_CALL *SurfaceGetFormatByName)(AMFTrace* pThis, const wchar_t* name);
-
-        const wchar_t*      (AMF_STD_CALL *GetMemoryTypeName)(AMFTrace* pThis, const AMF_MEMORY_TYPE memoryType);
-        AMF_MEMORY_TYPE     (AMF_STD_CALL *GetMemoryTypeByName)(AMFTrace* pThis, const wchar_t* name);
-
-        const wchar_t*      (AMF_STD_CALL *GetSampleFormatName)(AMFTrace* pThis, const AMF_AUDIO_FORMAT eFormat);
-        AMF_AUDIO_FORMAT    (AMF_STD_CALL *GetSampleFormatByName)(AMFTrace* pThis, const wchar_t* name);
-    } AMFTraceVtbl;
-
-    struct AMFTrace
-    {
-        const AMFTraceVtbl *pVtbl;
-    };
-
-#endif
-#if defined(__cplusplus)
-}
-#endif
-
-
-#endif // AMF_Trace_h

plugins/obs-ffmpeg/external/AMF/include/core/Variant.h

@@ -1,2082 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef AMF_Variant_h
-#define AMF_Variant_h
-#pragma once
-#if defined(_MSC_VER)
-    #pragma warning(disable: 4996)
-#endif
-
-#include "Interface.h"
-#include <locale.h>
-#include <wchar.h>
-#include <string.h>
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    //----------------------------------------------------------------------------------------------
-    // variant types
-    //----------------------------------------------------------------------------------------------
-    typedef enum AMF_VARIANT_TYPE
-    {
-        AMF_VARIANT_EMPTY           = 0,
-
-        AMF_VARIANT_BOOL            = 1,
-        AMF_VARIANT_INT64           = 2,
-        AMF_VARIANT_DOUBLE          = 3,
-
-        AMF_VARIANT_RECT            = 4,
-        AMF_VARIANT_SIZE            = 5,
-        AMF_VARIANT_POINT           = 6,
-        AMF_VARIANT_RATE            = 7,
-        AMF_VARIANT_RATIO           = 8,
-        AMF_VARIANT_COLOR           = 9,
-
-        AMF_VARIANT_STRING          = 10,  // value is char*
-        AMF_VARIANT_WSTRING         = 11,  // value is wchar_t*
-        AMF_VARIANT_INTERFACE       = 12,  // value is AMFInterface*
-        AMF_VARIANT_FLOAT           = 13,
-
-        AMF_VARIANT_FLOAT_SIZE      = 14,
-        AMF_VARIANT_FLOAT_POINT2D   = 15,
-        AMF_VARIANT_FLOAT_POINT3D   = 16,
-        AMF_VARIANT_FLOAT_VECTOR4D  = 17
-    } AMF_VARIANT_TYPE;
-    //----------------------------------------------------------------------------------------------
-    // variant struct
-   //----------------------------------------------------------------------------------------------
-    typedef struct AMFVariantStruct
-    {
-        AMF_VARIANT_TYPE            type;
-        union
-        {
-            amf_bool                boolValue;
-            amf_int64               int64Value;
-            amf_double              doubleValue;
-            char*                   stringValue;
-            wchar_t*                wstringValue;
-            AMFInterface*           pInterface;
-            struct AMFRect          rectValue;
-            struct AMFSize          sizeValue;
-            struct AMFPoint         pointValue;
-            struct AMFRate          rateValue;
-            struct AMFRatio         ratioValue;
-            struct AMFColor         colorValue;
-            amf_float               floatValue;
-            struct AMFFloatSize     floatSizeValue;
-            struct AMFFloatPoint2D  floatPoint2DValue;
-            struct AMFFloatPoint3D  floatPoint3DValue;
-            struct AMFFloatVector4D floatVector4DValue;
-        };
-    } AMFVariantStruct;
-    //----------------------------------------------------------------------------------------------
-    // variant accessors
-    //----------------------------------------------------------------------------------------------
-
-    static AMF_INLINE AMF_VARIANT_TYPE     AMF_STD_CALL AMFVariantGetType(const AMFVariantStruct* _variant) { return (_variant)->type; }
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_VARIANT_TYPE&    AMF_STD_CALL AMFVariantGetType(AMFVariantStruct* _variant) { return (_variant)->type; }
-#endif
-    static AMF_INLINE amf_bool             AMF_STD_CALL AMFVariantGetBool(const AMFVariantStruct* _variant) { return (_variant)->boolValue; }
-    static AMF_INLINE amf_int64            AMF_STD_CALL AMFVariantGetInt64(const AMFVariantStruct* _variant) { return (_variant)->int64Value; }
-    static AMF_INLINE amf_double           AMF_STD_CALL AMFVariantGetDouble(const AMFVariantStruct* _variant) { return (_variant)->doubleValue; }
-    static AMF_INLINE amf_float            AMF_STD_CALL AMFVariantGetFloat(const AMFVariantStruct* _variant) { return (_variant)->floatValue; }
-    static AMF_INLINE const char*          AMF_STD_CALL AMFVariantGetString(const AMFVariantStruct* _variant) { return (_variant)->stringValue; }
-    static AMF_INLINE const wchar_t*       AMF_STD_CALL AMFVariantGetWString(const AMFVariantStruct* _variant) { return (_variant)->wstringValue; }
-#if defined(__cplusplus)
-    static AMF_INLINE const AMFInterface*  AMF_STD_CALL AMFVariantGetInterface(const AMFVariantStruct* _variant) { return (_variant)->pInterface; }
-#endif
-    static AMF_INLINE AMFInterface*        AMF_STD_CALL AMFVariantGetInterface(AMFVariantStruct* _variant) { return (_variant)->pInterface; }
-
-#if defined(__cplusplus)
-    static AMF_INLINE const AMFRect &      AMF_STD_CALL AMFVariantGetRect (const AMFVariantStruct* _variant) { return (_variant)->rectValue; }
-    static AMF_INLINE const AMFSize &      AMF_STD_CALL AMFVariantGetSize (const AMFVariantStruct* _variant) { return (_variant)->sizeValue; }
-    static AMF_INLINE const AMFPoint&      AMF_STD_CALL AMFVariantGetPoint(const AMFVariantStruct* _variant) { return (_variant)->pointValue; }
-    static AMF_INLINE const AMFFloatSize& AMF_STD_CALL AMFVariantGetFloatSize(const AMFVariantStruct* _variant) { return (_variant)->floatSizeValue; }
-    static AMF_INLINE const AMFFloatPoint2D& AMF_STD_CALL AMFVariantGetFloatPoint2D(const AMFVariantStruct* _variant) { return (_variant)->floatPoint2DValue; }
-    static AMF_INLINE const AMFFloatPoint3D& AMF_STD_CALL AMFVariantGetFloatPoint3D(const AMFVariantStruct* _variant) { return (_variant)->floatPoint3DValue; }
-    static AMF_INLINE const AMFFloatVector4D& AMF_STD_CALL AMFVariantGetFloatVector4D(const AMFVariantStruct* _variant) { return (_variant)->floatVector4DValue; }
-    static AMF_INLINE const AMFRate &      AMF_STD_CALL AMFVariantGetRate (const AMFVariantStruct* _variant) { return (_variant)->rateValue; }
-    static AMF_INLINE const AMFRatio&      AMF_STD_CALL AMFVariantGetRatio(const AMFVariantStruct* _variant) { return (_variant)->ratioValue; }
-    static AMF_INLINE const AMFColor&      AMF_STD_CALL AMFVariantGetColor(const AMFVariantStruct* _variant) { return (_variant)->colorValue; }
-#else // #if defined(__cplusplus)
-    static AMF_INLINE const AMFRect        AMF_STD_CALL AMFVariantGetRect (const AMFVariantStruct* _variant) { return (_variant)->rectValue; }
-    static AMF_INLINE const AMFSize        AMF_STD_CALL AMFVariantGetSize (const AMFVariantStruct* _variant) { return (_variant)->sizeValue; }
-    static AMF_INLINE const AMFPoint       AMF_STD_CALL AMFVariantGetPoint(const AMFVariantStruct* _variant) { return (_variant)->pointValue; }
-    static AMF_INLINE const AMFFloatSize  AMF_STD_CALL AMFVariantGetFloatSize(const AMFVariantStruct* _variant) { return (_variant)->floatSizeValue; }
-    static AMF_INLINE const AMFFloatPoint2D  AMF_STD_CALL AMFVariantGetFloatPoint2D(const AMFVariantStruct* _variant) { return (_variant)->floatPoint2DValue; }
-    static AMF_INLINE const AMFFloatPoint3D  AMF_STD_CALL AMFVariantGetFloatPoint3D(const AMFVariantStruct* _variant) { return (_variant)->floatPoint3DValue; }
-    static AMF_INLINE const AMFFloatVector4D  AMF_STD_CALL AMFVariantGetFloatVector4D(const AMFVariantStruct* _variant) { return (_variant)->floatVector4DValue; }
-    static AMF_INLINE const AMFRate        AMF_STD_CALL AMFVariantGetRate (const AMFVariantStruct* _variant) { return (_variant)->rateValue; }
-    static AMF_INLINE const AMFRatio       AMF_STD_CALL AMFVariantGetRatio(const AMFVariantStruct* _variant) { return (_variant)->ratioValue; }
-    static AMF_INLINE const AMFColor       AMF_STD_CALL AMFVariantGetColor(const AMFVariantStruct* _variant) { return (_variant)->colorValue; }
-#endif // #if defined(__cplusplus)
-
-
-    #define AMFVariantEmpty(_variant)     0
-    #define AMFVariantBool(_variant)      (_variant)->boolValue
-    #define AMFVariantInt64(_variant)     (_variant)->int64Value
-    #define AMFVariantDouble(_variant)    (_variant)->doubleValue
-    #define AMFVariantFloat(_variant)    (_variant)->floatValue
-
-    #define AMFVariantRect(_variant)      (_variant)->rectValue
-    #define AMFVariantSize(_variant)      (_variant)->sizeValue
-    #define AMFVariantPoint(_variant)     (_variant)->pointValue
-    #define AMFVariantFloatSize(_variant)     (_variant)->floatSizeValue
-    #define AMFVariantFloatPoint2D(_variant)     (_variant)->floatPoint2DValue
-    #define AMFVariantFloatPoint3D(_variant)     (_variant)->floatPoint3DValue
-    #define AMFVariantFloatVector4D(_variant)     (_variant)->floatVector4DValue
-    #define AMFVariantRate(_variant)      (_variant)->rateValue
-    #define AMFVariantRatio(_variant)     (_variant)->ratioValue
-    #define AMFVariantColor(_variant)     (_variant)->colorValue
-
-    #define AMFVariantString(_variant)    (_variant)->stringValue
-    #define AMFVariantWString(_variant)   (_variant)->wstringValue
-    #define AMFVariantInterface(_variant) (_variant)->pInterface
-    //----------------------------------------------------------------------------------------------
-    // variant hleper functions
-    //----------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantInit(AMFVariantStruct* pVariant);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantClear(AMFVariantStruct* pVariant);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantCompare(const AMFVariantStruct* pFirst, const AMFVariantStruct* pSecond, amf_bool* equal);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantCopy(AMFVariantStruct* pDest, const AMFVariantStruct* pSrc);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignBool(AMFVariantStruct* pDest, amf_bool value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignInt64(AMFVariantStruct* pDest, amf_int64 value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignDouble(AMFVariantStruct* pDest, amf_double value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloat(AMFVariantStruct* pDest, amf_float value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignString(AMFVariantStruct* pDest, const char* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignWString(AMFVariantStruct* pDest, const wchar_t* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignInterface(AMFVariantStruct* pDest, AMFInterface* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignRect(AMFVariantStruct* pDest, const AMFRect* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignSize(AMFVariantStruct* pDest, const AMFSize* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignPoint(AMFVariantStruct* pDest, const AMFPoint* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatSize(AMFVariantStruct* pDest, const AMFFloatSize* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatPoint2D(AMFVariantStruct* pDest, const AMFFloatPoint2D* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatPoint3D(AMFVariantStruct* pDest, const AMFFloatPoint3D* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatVector4D(AMFVariantStruct* pDest, const AMFFloatVector4D* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignRate(AMFVariantStruct* pDest, const AMFRate* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignRatio(AMFVariantStruct* pDest, const AMFRatio* value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignColor(AMFVariantStruct* pDest, const AMFColor* value);
-
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignRect(AMFVariantStruct* pDest, const AMFRect& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignSize(AMFVariantStruct* pDest, const AMFSize& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignPoint(AMFVariantStruct* pDest, const AMFPoint& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatSize(AMFVariantStruct* pDest, const AMFFloatSize& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatPoint2D(AMFVariantStruct* pDest, const AMFFloatPoint2D& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatPoint3D(AMFVariantStruct* pDest, const AMFFloatPoint3D& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignFloatVector4D(AMFVariantStruct* pDest, const AMFFloatVector4D& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignRate(AMFVariantStruct* pDest, const AMFRate& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignRatio(AMFVariantStruct* pDest, const AMFRatio& value);
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantAssignColor(AMFVariantStruct* pDest, const AMFColor& value);
-
-    static AMF_INLINE AMF_RESULT       AMF_CDECL_CALL AMFVariantChangeType(AMFVariantStruct* pDest, const AMFVariantStruct* pSrc, AMF_VARIANT_TYPE newType);
-#endif
-    static AMF_INLINE char*            AMF_CDECL_CALL AMFVariantDuplicateString(const char* from);
-    static AMF_INLINE void             AMF_CDECL_CALL AMFVariantFreeString(char* from);
-    static AMF_INLINE wchar_t*         AMF_CDECL_CALL AMFVariantDuplicateWString(const wchar_t* from);
-    static AMF_INLINE void             AMF_CDECL_CALL AMFVariantFreeWString(wchar_t* from);
-
-#if defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AMF_INLINE Variant helper class
-    //----------------------------------------------------------------------------------------------
-    class AMFVariant : public AMFVariantStruct
-    {
-    public:
-        class String;
-        class WString;
-
-    public:
-        AMFVariant() {  AMFVariantInit(this); }
-        explicit AMFVariant(const AMFVariantStruct& other) { AMFVariantInit(this); AMFVariantCopy(this, const_cast<AMFVariantStruct*>(&other)); }
-
-        explicit AMFVariant(const AMFVariantStruct* pOther);
-        template<typename T>
-        explicit AMFVariant(const AMFInterfacePtr_T<T>& pValue);
-
-        AMFVariant(const AMFVariant& other) { AMFVariantInit(this); AMFVariantCopy(this, const_cast<AMFVariantStruct*>(static_cast<const AMFVariantStruct*>(&other))); }
-
-        explicit AMF_INLINE AMFVariant(amf_bool value)          { AMFVariantInit(this); AMFVariantAssignBool(this, value); }
-        explicit AMF_INLINE AMFVariant(amf_int64 value)         { AMFVariantInit(this); AMFVariantAssignInt64(this, value); }
-        explicit AMF_INLINE AMFVariant(amf_uint64 value)        { AMFVariantInit(this); AMFVariantAssignInt64(this, (amf_int64)value); }
-        explicit AMF_INLINE AMFVariant(amf_int32 value)         { AMFVariantInit(this); AMFVariantAssignInt64(this, value); }
-        explicit AMF_INLINE AMFVariant(amf_uint32 value)        { AMFVariantInit(this); AMFVariantAssignInt64(this, value); }
-        explicit AMF_INLINE AMFVariant(amf_double value)        { AMFVariantInit(this); AMFVariantAssignDouble(this, value); }
-        explicit AMF_INLINE AMFVariant(amf_float value)         { AMFVariantInit(this); AMFVariantAssignFloat(this, value); }
-        explicit AMF_INLINE AMFVariant(const AMFRect & value)   { AMFVariantInit(this); AMFVariantAssignRect(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFSize & value)   { AMFVariantInit(this); AMFVariantAssignSize(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFPoint& value)   { AMFVariantInit(this); AMFVariantAssignPoint(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFFloatSize& value) { AMFVariantInit(this); AMFVariantAssignFloatSize(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFFloatPoint2D& value) { AMFVariantInit(this); AMFVariantAssignFloatPoint2D(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFFloatPoint3D& value) { AMFVariantInit(this); AMFVariantAssignFloatPoint3D(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFFloatVector4D& value) { AMFVariantInit(this); AMFVariantAssignFloatVector4D(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFRate & value)   { AMFVariantInit(this); AMFVariantAssignRate(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFRatio& value)   { AMFVariantInit(this); AMFVariantAssignRatio(this, &value); }
-        explicit AMF_INLINE AMFVariant(const AMFColor& value)   { AMFVariantInit(this); AMFVariantAssignColor(this, &value); }
-        explicit AMF_INLINE AMFVariant(const char* value)       { AMFVariantInit(this); AMFVariantAssignString(this, value); }
-        explicit AMF_INLINE AMFVariant(const wchar_t* value)    { AMFVariantInit(this); AMFVariantAssignWString(this, value); }
-        explicit AMF_INLINE AMFVariant(AMFInterface* pValue)    { AMFVariantInit(this); AMFVariantAssignInterface(this, pValue); }
-
-        ~AMFVariant() { AMFVariantClear(this); }
-
-        AMFVariant& operator=(const AMFVariantStruct& other);
-        AMFVariant& operator=(const AMFVariantStruct* pOther);
-        AMFVariant& operator=(const AMFVariant& other);
-
-        AMFVariant& operator=(amf_bool          value)      { AMFVariantAssignBool(this, value); return *this;}
-        AMFVariant& operator=(amf_int64         value)      { AMFVariantAssignInt64(this, value); return *this;}
-        AMFVariant& operator=(amf_uint64        value)      { AMFVariantAssignInt64(this, (amf_int64)value);  return *this;}
-        AMFVariant& operator=(amf_int32         value)      { AMFVariantAssignInt64(this, value);  return *this;}
-        AMFVariant& operator=(amf_uint32        value)      { AMFVariantAssignInt64(this, value);  return *this;}
-        AMFVariant& operator=(amf_double        value)      { AMFVariantAssignDouble(this, value);  return *this;}
-        AMFVariant& operator=(amf_float        value)       { AMFVariantAssignFloat(this, value);  return *this; }
-        AMFVariant& operator=(const AMFRect &   value)      { AMFVariantAssignRect(this, &value);  return *this;}
-        AMFVariant& operator=(const AMFSize &   value)      { AMFVariantAssignSize(this, &value);  return *this;}
-        AMFVariant& operator=(const AMFPoint&   value)      { AMFVariantAssignPoint(this, &value);  return *this;}
-        AMFVariant& operator=(const AMFFloatSize&   value) { AMFVariantAssignFloatSize(this, &value);  return *this; }
-        AMFVariant& operator=(const AMFFloatPoint2D&   value) { AMFVariantAssignFloatPoint2D(this, &value);  return *this; }
-        AMFVariant& operator=(const AMFFloatPoint3D&   value) { AMFVariantAssignFloatPoint3D(this, &value);  return *this; }
-        AMFVariant& operator=(const AMFFloatVector4D&   value) { AMFVariantAssignFloatVector4D(this, &value);  return *this; }
-        AMFVariant& operator=(const AMFRate &   value)      { AMFVariantAssignRate(this, &value);  return *this;}
-        AMFVariant& operator=(const AMFRatio&   value)      { AMFVariantAssignRatio(this, &value);  return *this;}
-        AMFVariant& operator=(const AMFColor&   value)      { AMFVariantAssignColor(this, &value);  return *this;}
-        AMFVariant& operator=(const char*       value)      { AMFVariantAssignString(this, value);  return *this;}
-        AMFVariant& operator=(const wchar_t*    value)      { AMFVariantAssignWString(this, value);  return *this;}
-        AMFVariant& operator=(AMFInterface*     value)      { AMFVariantAssignInterface(this, value);  return *this;}
-
-        template<typename T> AMFVariant& operator=(const AMFInterfacePtr_T<T>& value);
-
-        operator amf_bool() const           { return ToBool();       }
-        operator amf_int64() const          { return ToInt64();      }
-        operator amf_uint64() const         { return ToUInt64();     }
-        operator amf_int32() const          { return ToInt32();      }
-        operator amf_uint32() const         { return ToUInt32();     }
-        operator amf_double() const         { return ToDouble();     }
-        operator amf_float() const          { return ToFloat();      }
-        operator AMFRect () const           { return ToRect ();      }
-        operator AMFSize () const           { return ToSize ();      }
-        operator AMFPoint() const           { return ToPoint();      }
-        operator AMFFloatSize() const       { return ToFloatSize(); }
-        operator AMFFloatPoint2D() const    { return ToFloatPoint2D(); }
-        operator AMFFloatPoint3D() const    { return ToFloatPoint3D(); }
-        operator AMFFloatVector4D() const   { return ToFloatVector4D(); }
-        operator AMFRate () const           { return ToRate ();      }
-        operator AMFRatio() const           { return ToRatio();      }
-        operator AMFColor() const           { return ToColor();      }
-        operator AMFInterface*() const      { return ToInterface();  }
-
-        AMF_INLINE amf_bool         ToBool() const      { return Empty() ? false        : GetValue<amf_bool,   AMF_VARIANT_BOOL>(AMFVariantGetBool); }
-        AMF_INLINE amf_int64        ToInt64() const     { return Empty() ? 0            : GetValue<amf_int64,  AMF_VARIANT_INT64>(AMFVariantGetInt64); }
-        AMF_INLINE amf_uint64       ToUInt64() const    { return Empty() ? 0            : GetValue<amf_uint64, AMF_VARIANT_INT64>(AMFVariantGetInt64); }
-        AMF_INLINE amf_int32        ToInt32() const     { return Empty() ? 0            : GetValue<amf_int32,  AMF_VARIANT_INT64>(AMFVariantGetInt64); }
-        AMF_INLINE amf_uint32       ToUInt32() const    { return Empty() ? 0            : GetValue<amf_uint32, AMF_VARIANT_INT64>(AMFVariantGetInt64); }
-        AMF_INLINE amf_double       ToDouble() const    { return Empty() ? 0            : GetValue<amf_double, AMF_VARIANT_DOUBLE>(AMFVariantGetDouble); }
-        AMF_INLINE amf_float        ToFloat() const     { return Empty() ? 0            : GetValue<amf_float,  AMF_VARIANT_FLOAT>(AMFVariantGetFloat); }
-        AMF_INLINE AMFRect          ToRect () const     { return Empty() ? AMFRect()    : GetValue<AMFRect,  AMF_VARIANT_RECT>(AMFVariantGetRect); }
-        AMF_INLINE AMFSize          ToSize () const     { return Empty() ? AMFSize()    : GetValue<AMFSize,  AMF_VARIANT_SIZE>(AMFVariantGetSize); }
-        AMF_INLINE AMFPoint         ToPoint() const     { return Empty() ? AMFPoint()   : GetValue<AMFPoint, AMF_VARIANT_POINT>(AMFVariantGetPoint); }
-        AMF_INLINE AMFFloatSize     ToFloatSize() const { return Empty() ? AMFFloatSize() : GetValue<AMFFloatSize, AMF_VARIANT_FLOAT_SIZE>(AMFVariantGetFloatSize); }
-        AMF_INLINE AMFFloatPoint2D  ToFloatPoint2D() const { return Empty() ? AMFFloatPoint2D() : GetValue<AMFFloatPoint2D, AMF_VARIANT_FLOAT_POINT2D>(AMFVariantGetFloatPoint2D); }
-        AMF_INLINE AMFFloatPoint3D  ToFloatPoint3D() const { return Empty() ? AMFFloatPoint3D() : GetValue<AMFFloatPoint3D, AMF_VARIANT_FLOAT_POINT3D>(AMFVariantGetFloatPoint3D); }
-        AMF_INLINE AMFFloatVector4D ToFloatVector4D() const { return Empty() ? AMFFloatVector4D() : GetValue<AMFFloatVector4D, AMF_VARIANT_FLOAT_VECTOR4D>(AMFVariantGetFloatVector4D); }
-        AMF_INLINE AMFRate          ToRate () const     { return Empty() ? AMFRate()    : GetValue<AMFRate,  AMF_VARIANT_RATE>(AMFVariantGetRate); }
-        AMF_INLINE AMFRatio         ToRatio() const     { return Empty() ? AMFRatio()   : GetValue<AMFRatio, AMF_VARIANT_RATIO>(AMFVariantGetRatio); }
-        AMF_INLINE AMFColor         ToColor() const     { return Empty() ? AMFColor()   : GetValue<AMFColor, AMF_VARIANT_COLOR>(AMFVariantGetColor); }
-        AMF_INLINE AMFInterface*    ToInterface() const { return AMFVariantGetType(this) == AMF_VARIANT_INTERFACE ? this->pInterface : NULL; }
-        AMF_INLINE String           ToString() const;
-        AMF_INLINE WString          ToWString() const;
-
-        bool operator==(const AMFVariantStruct& other) const;
-        bool operator==(const AMFVariantStruct* pOther) const;
-
-        bool operator!=(const AMFVariantStruct& other) const;
-        bool operator!=(const AMFVariantStruct* pOther) const;
-
-        void Clear() { AMFVariantClear(this); }
-
-        void Attach(AMFVariantStruct& variant);
-        AMFVariantStruct Detach();
-
-        AMFVariantStruct& GetVariant();
-
-        void ChangeType(AMF_VARIANT_TYPE type, const AMFVariant* pSrc = NULL);
-
-        bool Empty() const;
-    private:
-        template<class ReturnType, AMF_VARIANT_TYPE variantType, typename Getter>
-        ReturnType GetValue(Getter getter) const;
-    };
-    //----------------------------------------------------------------------------------------------
-    // helper String class
-    //----------------------------------------------------------------------------------------------
-    class AMFVariant::String
-    {
-        friend class AMFVariant;
-    private:
-        void Free()
-        {
-            if (m_Str != NULL)
-            {
-                AMFVariantFreeString(m_Str);
-                m_Str = NULL;
-            }
-        }
-    public:
-        String() :m_Str(NULL){}
-        String(const char* str) : m_Str(NULL)
-        {
-            m_Str = AMFVariantDuplicateString(str);
-        }
-        String(const String& p_other) : m_Str(NULL)
-        {
-            operator=(p_other);
-        }
-
-#if (__cplusplus == 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X) || (_MSC_VER >= 1600)
-#pragma warning (push)
-#pragma warning (disable : 26439) //This kind of function may not throw. Declare it 'noexcept'.
-        String(String&& p_other) : m_Str(NULL)
-        {
-            operator=(p_other);
-        }
-#endif
-        ~String()
-        {
-            Free();
-        }
-
-        char& operator[](size_t index)
-        {
-            if (index >= size())
-            {
-                resize(index);
-            }
-            return m_Str[index];
-        }
-
-        String& operator=(const String& p_other)
-        {
-            Free();
-            m_Str = AMFVariantDuplicateString(p_other.m_Str);
-            return *this;
-        }
-#if (__cplusplus == 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X) || (_MSC_VER >= 1600)
-        String& operator=(String&& p_other)
-        {
-            Free();
-            m_Str = p_other.m_Str;
-            p_other.m_Str = NULL;    //    Transfer the ownership
-            return *this;
-        }
-#endif
-        bool operator==(const String& p_other) const
-        {
-            if (m_Str == NULL && p_other.m_Str == NULL)
-            {
-                return true;
-            }
-            else if ((m_Str == NULL && p_other.m_Str != NULL) || (m_Str != NULL && p_other.m_Str == NULL))
-            {
-                return false;
-            }
-            return strcmp(c_str(), p_other.c_str()) == 0;
-        }
-        const char* c_str() const { return m_Str; }
-        size_t size() const
-        {
-            if(m_Str == NULL)
-            {
-                return 0;
-            }
-            return (size_t)strlen(m_Str);
-        }
-
-        AMF_INLINE size_t length() const { return size(); }
-        
-        void resize(size_t sizeAlloc)
-        {
-            if(sizeAlloc == 0)
-            {
-                Free();
-                return;
-            }
-            char* str = (char*)amf_variant_alloc(sizeof(char)*(sizeAlloc + 1));
-            if(m_Str != NULL)
-            {
-                size_t copySize = sizeAlloc;
-                if(copySize > size())
-                {
-                    copySize = size();
-                }
-                memcpy(str, m_Str, copySize * sizeof(char));
-                Free();
-                str[sizeAlloc] = 0;
-            }
-            m_Str = str;
-        }
-    private:
-        char*    m_Str;
-    };
-    //----------------------------------------------------------------------------------------------
-    // helper WString class
-    //----------------------------------------------------------------------------------------------
-    class AMFVariant::WString
-    {
-        friend class AMFVariant;
-    private:
-        void Free()
-        {
-            if (m_Str != NULL)
-            {
-                AMFVariantFreeWString(m_Str);
-                m_Str = NULL;
-            }
-        }
-    public:
-        WString() :m_Str(NULL){}
-        WString(const wchar_t* str) : m_Str(NULL)
-        {
-            m_Str = AMFVariantDuplicateWString(str);
-        }
-        WString(const WString& p_other) : m_Str(NULL)
-        {
-            operator=(p_other);
-        }
-#if (__cplusplus == 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X) || (_MSC_VER >= 1600)
-        WString(WString&& p_other) : m_Str(NULL)
-        {
-            operator=(p_other);
-        }
-#endif
-        ~WString()
-        {
-            Free();
-        }
-
-        WString& operator=(const WString& p_other)
-        {
-            Free();
-            m_Str = AMFVariantDuplicateWString(p_other.m_Str);
-            return *this;
-        }
-#if (__cplusplus == 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X) || (_MSC_VER >= 1600)
-        WString& operator=(WString&& p_other)
-        {
-            Free();
-            m_Str = p_other.m_Str;
-            p_other.m_Str = NULL;    //    Transfer the ownership
-            return *this;
-        }
-#pragma warning (pop)
-#endif
-        wchar_t& operator[](size_t index)
-        {
-            if (index >= size())
-            {
-                resize(index);
-            }
-            return m_Str[index];
-        }
-
-        bool operator==(const WString& p_other) const
-        {
-            if (m_Str == NULL && p_other.m_Str == NULL)
-            {
-                return true;
-            }
-            else if ((m_Str == NULL && p_other.m_Str != NULL) || (m_Str != NULL && p_other.m_Str == NULL))
-            {
-                return false;
-            }
-            return wcscmp(c_str(), p_other.c_str()) == 0;
-        }
-
-        const wchar_t* c_str() const { return m_Str; }
-        size_t size()  const
-        {
-            if(m_Str == NULL)
-            {
-                return 0;
-            }
-            return (size_t)wcslen(m_Str);
-        }
-
-        AMF_INLINE size_t length() const { return size(); }
-        
-        void resize(size_t sizeAlloc)
-        {
-            if(sizeAlloc == 0)
-            {
-                Free();
-                return;
-            }
-            wchar_t* str = (wchar_t*)amf_variant_alloc(sizeof(wchar_t)*(sizeAlloc + 1));
-            if(m_Str != NULL)
-            {
-                size_t copySize = sizeAlloc;
-                if(copySize > size())
-                {
-                    copySize = size();
-                }
-                memcpy(str, m_Str, copySize * sizeof(wchar_t));
-                Free();
-                str[sizeAlloc] = 0;
-            }
-            m_Str = str;
-        }
-    private:
-        wchar_t*    m_Str;
-    };
-    //-------------------------------------------------------------------------------------------------
-    AMFVariant::String       AMFVariant::ToString() const
-    {
-        String temp = GetValue<String, AMF_VARIANT_STRING>(AMFVariantGetString); 
-        return String(temp.c_str());
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMFVariant::WString      AMFVariant::ToWString() const
-    {
-        WString temp = GetValue<WString, AMF_VARIANT_WSTRING>(AMFVariantGetWString);
-        return WString(temp.c_str());
-    }
-#endif // defined(__cplusplus)
-    //----------------------------------------------------------------------------------------------
-    // AMF_INLINE implementation of helper functions 
-    //----------------------------------------------------------------------------------------------
-    #define AMF_VARIANT_RETURN_IF_INVALID_POINTER(p) \
-       { \
-            if(p == NULL) \
-                    { \
-                 return AMF_INVALID_POINTER; \
-            } \
-       }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantInit(AMFVariantStruct* pVariant)
-    {
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pVariant);
-        pVariant->type = AMF_VARIANT_EMPTY;
-        return AMF_OK;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantClear(AMFVariantStruct* pVariant)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pVariant);
-
-        switch(AMFVariantGetType(pVariant))
-        {
-        case AMF_VARIANT_STRING:
-            amf_variant_free(AMFVariantString(pVariant));
-            pVariant->type = AMF_VARIANT_EMPTY;
-            break;
-
-        case AMF_VARIANT_WSTRING:
-            amf_variant_free(AMFVariantWString(pVariant));
-            pVariant->type = AMF_VARIANT_EMPTY;
-            break;
-
-        case AMF_VARIANT_INTERFACE:
-            if(AMFVariantInterface(pVariant) != NULL)
-            {
-#if defined(__cplusplus)
-                AMFVariantInterface(pVariant)->Release();
-#else
-                AMFVariantInterface(pVariant)->pVtbl->Release(AMFVariantInterface(pVariant));
-#endif
-                AMFVariantInterface(pVariant) = NULL;
-            }
-            pVariant->type = AMF_VARIANT_EMPTY;
-            break;
-
-        default:
-            pVariant->type = AMF_VARIANT_EMPTY;
-            break;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantCompare(const AMFVariantStruct* pFirst, const AMFVariantStruct* pSecond, amf_bool* bEqual)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pFirst);
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pSecond);
-    
-        if(pFirst == pSecond)
-        {
-            *bEqual = true;
-        }
-        else if(AMFVariantGetType(pFirst) != AMFVariantGetType(pSecond))
-        {
-            *bEqual = false;
-        }
-        else
-        {
-            switch(AMFVariantGetType(pFirst))
-            {
-            case AMF_VARIANT_EMPTY:
-                *bEqual = true;
-                break;
-            case AMF_VARIANT_BOOL:
-                *bEqual = AMFVariantGetBool(pFirst) == AMFVariantBool(pSecond);
-                break;
-            case AMF_VARIANT_INT64:
-                *bEqual = AMFVariantGetInt64(pFirst) == AMFVariantInt64(pSecond);
-                break;
-            case AMF_VARIANT_DOUBLE:
-                *bEqual = AMFVariantGetDouble(pFirst) == AMFVariantDouble(pSecond);
-                break;
-            case AMF_VARIANT_FLOAT:
-                *bEqual = AMFVariantGetFloat(pFirst) == AMFVariantFloat(pSecond);
-                break;
-            case AMF_VARIANT_RECT:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetRect(pFirst) == AMFVariantGetRect(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->rectValue, &pSecond->rectValue, sizeof(AMFRect)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_SIZE:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetSize(pFirst) == AMFVariantGetSize(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->sizeValue, &pSecond->sizeValue, sizeof(AMFSize)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_POINT:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetPoint(pFirst) == AMFVariantGetPoint(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->pointValue, &pSecond->pointValue, sizeof(AMFPoint)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_FLOAT_SIZE:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetFloatSize(pFirst) == AMFVariantGetFloatSize(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->floatSizeValue, &pSecond->floatSizeValue, sizeof(AMFFloatPoint2D)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_FLOAT_POINT2D:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetFloatPoint2D(pFirst) == AMFVariantGetFloatPoint2D(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->floatPoint2DValue, &pSecond->floatPoint2DValue, sizeof(AMFFloatPoint2D)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_FLOAT_POINT3D:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetFloatPoint3D(pFirst) == AMFVariantGetFloatPoint3D(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->floatPoint3DValue, &pSecond->floatPoint3DValue, sizeof(AMFFloatPoint3D)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_FLOAT_VECTOR4D:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetFloatVector4D(pFirst) == AMFVariantGetFloatVector4D(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->floatVector4DValue, &pSecond->floatVector4DValue, sizeof(AMFFloatPoint3D)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_RATE:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetRate(pFirst) == AMFVariantGetRate(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->rateValue, &pSecond->rateValue, sizeof(AMFRate)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_RATIO:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetRatio(pFirst) == AMFVariantGetRatio(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->ratioValue, &pSecond->ratioValue, sizeof(AMFRatio)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_COLOR:
-#if defined(__cplusplus)
-                *bEqual = AMFVariantGetColor(pFirst) == AMFVariantGetColor(pSecond);
-#else
-                *bEqual = memcmp(&pFirst->colorValue, &pSecond->colorValue, sizeof(AMFColor)) == 0;
-#endif
-                break;
-            case AMF_VARIANT_STRING:
-                *bEqual = strcmp(AMFVariantString(pFirst), AMFVariantString(pSecond)) == 0;
-                break;
-            case AMF_VARIANT_WSTRING:
-                *bEqual = wcscmp(AMFVariantWString(pFirst), AMFVariantWString(pSecond)) == 0;
-                break;
-            case AMF_VARIANT_INTERFACE:
-                *bEqual = AMFVariantInterface(pFirst) == AMFVariantInterface(pSecond);
-                break;
-            default:
-                errRet = AMF_INVALID_ARG;
-                break;
-            }
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantCopy(AMFVariantStruct* pDest, const AMFVariantStruct* pSrc)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pSrc);
-        if(pDest != pSrc)
-        {
-            switch(AMFVariantGetType(pSrc))
-            {
-            case AMF_VARIANT_EMPTY:
-                errRet = AMFVariantInit(pDest);
-                break;
-            case AMF_VARIANT_BOOL:
-                errRet = AMFVariantAssignBool(pDest, AMFVariantBool(pSrc));
-                break;
-            case AMF_VARIANT_INT64:
-                errRet = AMFVariantAssignInt64(pDest, AMFVariantInt64(pSrc));
-                break;
-            case AMF_VARIANT_DOUBLE:
-                errRet = AMFVariantAssignDouble(pDest, AMFVariantDouble(pSrc));
-                break;
-            case AMF_VARIANT_FLOAT:
-                errRet = AMFVariantAssignFloat(pDest, AMFVariantFloat(pSrc));
-                break;
-            case AMF_VARIANT_RECT:
-                errRet = AMFVariantAssignRect(pDest, &pSrc->rectValue);
-                break;
-            case AMF_VARIANT_SIZE:
-                errRet = AMFVariantAssignSize(pDest, &pSrc->sizeValue);
-                break;
-            case AMF_VARIANT_POINT:
-                errRet = AMFVariantAssignPoint(pDest, &pSrc->pointValue);
-                break;
-            case AMF_VARIANT_FLOAT_SIZE:
-                errRet = AMFVariantAssignFloatSize(pDest, &pSrc->floatSizeValue);
-                break;
-            case AMF_VARIANT_FLOAT_POINT2D:
-                errRet = AMFVariantAssignFloatPoint2D(pDest, &pSrc->floatPoint2DValue);
-                break;
-            case AMF_VARIANT_FLOAT_POINT3D:
-                errRet = AMFVariantAssignFloatPoint3D(pDest, &pSrc->floatPoint3DValue);
-                break;
-            case AMF_VARIANT_FLOAT_VECTOR4D:
-                errRet = AMFVariantAssignFloatVector4D(pDest, &pSrc->floatVector4DValue);
-                break;
-            case AMF_VARIANT_RATE:
-                errRet = AMFVariantAssignRate(pDest, &pSrc->rateValue);
-                break;
-            case AMF_VARIANT_RATIO:
-                errRet = AMFVariantAssignRatio(pDest, &pSrc->ratioValue);
-                break;
-            case AMF_VARIANT_COLOR:
-                errRet = AMFVariantAssignColor(pDest, &pSrc->colorValue);
-                break;
-            case AMF_VARIANT_STRING:
-                errRet = AMFVariantAssignString(pDest, AMFVariantString(pSrc));
-                break;
-            case AMF_VARIANT_WSTRING:
-                errRet = AMFVariantAssignWString(pDest, AMFVariantWString(pSrc));
-                break;
-            case AMF_VARIANT_INTERFACE:
-                errRet = AMFVariantAssignInterface(pDest, AMFVariantInterface(pSrc));
-                break;
-            default:
-                errRet = AMF_INVALID_ARG;
-                break;
-            }
-        }
-        return errRet;
-    }
-    #define AMFVariantTypeEmpty         AMF_VARIANT_EMPTY
-
-    #define AMFVariantTypeBool          AMF_VARIANT_BOOL
-    #define AMFVariantTypeInt64         AMF_VARIANT_INT64
-    #define AMFVariantTypeDouble        AMF_VARIANT_DOUBLE
-    #define AMFVariantTypeFloat         AMF_VARIANT_FLOAT
-
-    #define AMFVariantTypeRect          AMF_VARIANT_RECT
-    #define AMFVariantTypeSize          AMF_VARIANT_SIZE
-    #define AMFVariantTypePoint         AMF_VARIANT_POINT
-    #define AMFVariantTypeFloatPoint2D  AMF_VARIANT_FLOAT_POINT2D
-    #define AMFVariantTypeFloatPoint3D  AMF_VARIANT_FLOAT_POINT3D
-    #define AMFVariantTypeFloatVector4D AMF_VARIANT_FLOAT_VECTOR4D
-    
-    #define AMFVariantTypeRate          AMF_VARIANT_RATE
-    #define AMFVariantTypeRatio         AMF_VARIANT_RATIO
-    #define AMFVariantTypeColor         AMF_VARIANT_COLOR
-
-    #define AMFVariantTypeString        AMF_VARIANT_STRING
-    #define AMFVariantTypeWString       AMF_VARIANT_WSTRING
-    #define AMFVariantTypeInterface     AMF_VARIANT_INTERFACE
-
-#if defined(__cplusplus)
-    
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignString(AMFVariantStruct* pDest, const AMFVariant::String& value)
-    {
-        return AMFVariantAssignString(pDest, value.c_str());
-    }
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignWString(AMFVariantStruct* pDest, const AMFVariant::WString& value)
-    {
-        return AMFVariantAssignWString(pDest, value.c_str());
-    }
-        
-    static AMF_INLINE amf_bool AMFConvertEmptyToBool(void*, AMF_RESULT& res) { res = AMF_OK; return false; }
-    static AMF_INLINE amf_int64 AMFConvertEmptyToInt64(void*, AMF_RESULT& res) {res = AMF_OK; return 0; }
-    static AMF_INLINE amf_double AMFConvertEmptyToDouble(void*, AMF_RESULT& res) {res = AMF_OK; return 0; }
-    static AMF_INLINE amf_float AMFConvertEmptyToFloat(void*, AMF_RESULT& res) { res = AMF_OK; return 0; }
-
-    
-    static AMF_INLINE AMFVariant::String AMFConvertEmptyToString(void*, AMF_RESULT& res) {res = AMF_OK; return ""; }
-    static AMF_INLINE AMFVariant::WString AMFConvertEmptyToWString(void*, AMF_RESULT& res) {res = AMF_OK; return L""; }
-    static AMF_INLINE amf_int64 AMFConvertBoolToInt64(bool value, AMF_RESULT& res){res = AMF_OK; return value ? 1 : 0;}
-    static AMF_INLINE amf_double AMFConvertBoolToDouble(bool value, AMF_RESULT& res){res = AMF_OK; return value ? 1.0 : 0.0;}
-    static AMF_INLINE amf_float AMFConvertBoolToFloat(bool value, AMF_RESULT& res) { res = AMF_OK; return value ? 1.0f : 0.0f; }
-    static AMF_INLINE AMFVariant::String AMFConvertBoolToString(bool value, AMF_RESULT& res){res = AMF_OK; return value ? "true" : "false";}
-    static AMF_INLINE AMFVariant::WString AMFConvertBoolToWString(bool value, AMF_RESULT& res){res = AMF_OK; return value ? L"true" : L"false";}
-    static AMF_INLINE bool AMFConvertInt64ToBool(amf_int64 value, AMF_RESULT& res){res = AMF_OK;return value != 0;}
-    static AMF_INLINE amf_double AMFConvertInt64ToDouble(amf_int64 value, AMF_RESULT& res){res = AMF_OK;return (amf_double)value;}
-    static AMF_INLINE amf_float AMFConvertInt64ToFloat(amf_int64 value, AMF_RESULT& res) { res = AMF_OK; return (amf_float)value; }
-    static AMF_INLINE AMFVariant::String AMFConvertInt64ToString(amf_int64 value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%" AMFPRId64, (long long)value);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::WString AMFConvertInt64ToWString(amf_int64 value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        wchar_t buff[0xFF];
-        swprintf(buff, 0xFF, L"%" LPRId64, (long long)value);
-        return buff;
-    }
-
-    static AMF_INLINE bool AMFConvertDoubleToBool(amf_double value, AMF_RESULT& res){res = AMF_OK;return value != 0;}
-    static AMF_INLINE bool AMFConvertFloatToBool(amf_float value, AMF_RESULT& res) { res = AMF_OK; return value != 0; }
-    static AMF_INLINE amf_int64 AMFConvertDoubleToInt64(amf_double value, AMF_RESULT& res){res = AMF_OK;return amf_int64(value);}
-    static AMF_INLINE amf_int64 AMFConvertFloatToInt64(amf_float value, AMF_RESULT& res) { res = AMF_OK; return amf_int64(value); }
-    static AMF_INLINE AMFVariant::String AMFConvertDoubleToString(amf_double value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%lf", value);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMFConvertFloatToString(amf_float value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%f", value);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::WString AMFConvertDoubleToWString(amf_double value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        wchar_t buff[0xFF];
-        swprintf(buff, 0xFF, L"%lf", value);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::WString AMFConvertFloatToWString(amf_float value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        wchar_t buff[0xFF];
-        swprintf(buff, 0xFF, L"%f", value);
-        return buff;
-    }
-
-    static AMF_INLINE bool AMFConvertStringToBool(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFVariant::String tmp = value;
-        if(( tmp == "true") || ( tmp == "True") || ( tmp == "TRUE") || ( tmp == "1") )
-        {
-            return true;
-        }
-        else
-        {
-            if(( tmp == "false") || ( tmp == "False") || ( tmp == "FALSE") || ( tmp == "0") )
-            {
-                return false;
-            }
-        }
-        res = AMF_INVALID_ARG;
-        return false;
-    }
-
-    static AMF_INLINE amf_int64 AMFConvertStringToInt64(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        long long tmp = 0;
-        int readElements = 0;
-
-        if(value.size() > 2 && ( value.c_str()[0] == '0') && ( value.c_str()[1] == 'x') )
-        {
-            readElements = sscanf(value.c_str(), "0x%" AMFPRIx64, &tmp);
-        }
-        else if(value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%" AMFPRId64, &tmp);
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return 0;
-    }
-
-    static AMF_INLINE amf_double AMFConvertStringToDouble(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        amf_double tmp = 0;
-        int readElements = 0;
-        if(value.size() > 0)
-        { 
-            readElements = sscanf(value.c_str(), "%lf", &tmp);
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return 0;
-    }
-    static AMF_INLINE amf_float AMFConvertStringToFloat(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        amf_float tmp = 0;
-        int readElements = 0;
-        if (value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%f", &tmp);
-        }
-        if (readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return 0;
-    }
-
-    static AMF_INLINE AMFVariant::WString AMFConvertStringToWString(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-//        return amf_from_utf8_to_unicode(value);
-        AMFVariant::WString result;
-        if(0 == value.size())
-        {
-            return result;
-        }
-        const char* pUtf8Buff = value.c_str();
-
-#if defined(_WIN32)
-        _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
-        int UnicodeBuffSize = ::MultiByteToWideChar(CP_UTF8, 0, pUtf8Buff, -1, NULL, 0);
-        if(0 == UnicodeBuffSize)
-        {
-            return result;
-        }
-        UnicodeBuffSize += 8; // get some extra space
-        result.resize(UnicodeBuffSize);
-        UnicodeBuffSize = ::MultiByteToWideChar(CP_UTF8, 0, pUtf8Buff, -1, (LPWSTR)result.c_str(), UnicodeBuffSize);
-        UnicodeBuffSize--;
-
-#elif defined(__ANDROID__)
-        // on android mbstowcs cannot be used to define length
-        char* old_locale = setlocale(LC_CTYPE, "en_US.UTF8");
-
-        mbstate_t mbs;
-        mbrlen(NULL, 0, &mbs);
-        int len = value.size();
-        const char* pt = pUtf8Buff;
-        int UnicodeBuffSize = 0;
-        while(len > 0)
-        {
-            size_t length = mbrlen (pt, len, &mbs); //MM TODO Android always return 1
-            if((length == 0) || (length > len))
-            {
-                break;
-            }
-            UnicodeBuffSize++;
-            len -= length;
-            pt += length;
-        }
-        UnicodeBuffSize += 8; // get some extra space
-        result.resize(UnicodeBuffSize);
-
-        mbrlen (NULL, 0, &mbs);
-        len = value.size();
-        pt = pUtf8Buff;
-        UnicodeBuffSize = 0;
-        while(len > 0)                            
-        {
-            size_t length = mbrlen (pt, len, &mbs);
-            if((length == 0) || (length > len))
-            {
-                break;
-            }
-            mbrtowc(&((wchar_t*)(result.c_str()))[UnicodeBuffSize], pt, length, &mbs);     //MM TODO Android always return 1 char
-            UnicodeBuffSize++;
-            len -= length;
-            pt += length;
-        }
-        setlocale(LC_CTYPE, old_locale);
-
- #else
-        char* old_locale = setlocale(LC_CTYPE, "en_US.UTF8");
-        size_t UnicodeBuffSize = mbstowcs(NULL, pUtf8Buff, 0);
-        if(0 == UnicodeBuffSize)
-        {
-            return result;
-        }
-        UnicodeBuffSize += 8; // get some extra space
-        result.resize(UnicodeBuffSize);
-        UnicodeBuffSize = mbstowcs((wchar_t*)result.c_str(), pUtf8Buff, UnicodeBuffSize + 1);
-        setlocale(LC_CTYPE, old_locale);
-#endif
-        result.resize(UnicodeBuffSize);
-        return result;
-    }
-    static AMF_INLINE AMFVariant::String AMFConvertWStringToString(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-//      return amf_from_unicode_to_utf8(value);
-        AMFVariant::String result;
-        if(0 == value.size())
-        {
-            return result;
-        }
-
-        const wchar_t* pwBuff = value.c_str();
-
-#if defined(_WIN32)
-        _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
-        int Utf8BuffSize = ::WideCharToMultiByte(CP_UTF8, 0, pwBuff, -1, NULL, 0, NULL, NULL);
-        if(0 == Utf8BuffSize)
-        {
-            return result;
-        }
-        Utf8BuffSize += 8; // get some extra space
-        result.resize(Utf8BuffSize);
-        Utf8BuffSize = ::WideCharToMultiByte(CP_UTF8, 0, pwBuff, -1, (LPSTR)result.c_str(), Utf8BuffSize, NULL, NULL);
-        Utf8BuffSize--;
-#elif defined(__ANDROID__)
-        char* old_locale = setlocale(LC_CTYPE, "en_US.UTF8");
-        int Utf8BuffSize = value.length();
-        if(0 == Utf8BuffSize)
-        {
-            return result;
-        }
-        Utf8BuffSize += 8; // get some extra space
-        result.resize(Utf8BuffSize);
-
-        mbstate_t mbs;
-        mbrlen(NULL, 0, &mbs);
-
-        Utf8BuffSize = 0;
-        for( int i = 0; i < value.length(); i++)
-        {
-            //MM TODO Android - not implemented
-            //int written = wcrtomb(&result[Utf8BuffSize], pwBuff[i], &mbs);
-            ((char*)(result.c_str()))[Utf8BuffSize] = (char)(pwBuff[i]);
-            int written = 1;
-            // temp replacement
-            Utf8BuffSize += written;
-        }
-        setlocale(LC_CTYPE, old_locale);
-
-#else
-        char* old_locale = setlocale(LC_CTYPE, "en_US.UTF8");
-        size_t Utf8BuffSize = wcstombs(NULL, pwBuff, 0);
-        if(0 == Utf8BuffSize)
-        {
-            return result;
-        }
-        Utf8BuffSize += 8; // get some extra space
-        result.resize(Utf8BuffSize);
-        Utf8BuffSize = wcstombs((char*)result.c_str(), pwBuff, Utf8BuffSize + 1);
-
-        setlocale(LC_CTYPE, old_locale);
-#endif
-        result.resize(Utf8BuffSize);
-        return result;
-    }
-
-
-    static AMF_INLINE bool AMFConvertWStringToBool(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToBool(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE amf_int64 AMFConvertWStringToInt64(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToInt64(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE amf_double AMFConvertWStringToDouble(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToDouble(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE amf_float AMFConvertWStringToFloat(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToFloat(AMFConvertWStringToString(value, res), res);
-    }
-
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertRectToString(const AMFRect& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%d,%d,%d,%d", value.left, value.top, value.right, value.bottom);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertSizeToString(const AMFSize& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%d,%d", value.width, value.height);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertPointToString(const AMFPoint& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%d,%d", value.x, value.y);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatSizeToString(const AMFFloatSize& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%f,%f", value.width, value.height);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatPoint2DToString(const AMFFloatPoint2D& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%f,%f", value.x, value.y);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatPoint3DToString(const AMFFloatPoint3D& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%f,%f,%f", value.x, value.y, value.z);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatVector4DToString(const AMFFloatVector4D& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%f,%f,%f,%f", value.x, value.y, value.z, value.w);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertRateToString(const AMFRate& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%u,%u", value.num, value.den);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertRatioToString(const AMFRatio& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%u,%u", value.num, value.den);
-        return buff;
-    }
-    static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertColorToString(const AMFColor& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        char buff[0xFF];
-        sprintf(buff, "%u,%u,%u,%u", value.r, value.g, value.b, value.a);
-        return buff;
-    }
-
-    static AMF_INLINE AMFRect  AMF_STD_CALL AMFConvertStringToRect(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFRect tmp = {};
-        int readElements = 0;
-        if(value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%d,%d,%d,%d", &tmp.left, &tmp.top, &tmp.right, &tmp.bottom);
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-
-    static AMF_INLINE AMFSize  AMF_STD_CALL AMFConvertStringToSize(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFSize tmp = {};
-        int readElements = 0;
-        if(value.size() > 0)
-        {
-          if(strchr(value.c_str(), ',') != nullptr)
-          {
-            readElements = sscanf(value.c_str(), "%d,%d", &tmp.width, &tmp.height);
-          } 
-          else if (strchr(value.c_str(), 'x') != nullptr) 
-          {
-            readElements = sscanf(value.c_str(), "%dx%d", &tmp.width, &tmp.height);
-          }
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFPoint AMF_STD_CALL AMFConvertStringToPoint(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFPoint tmp = {};
-        int readElements = 0;
-        if(value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%d,%d", &tmp.x, &tmp.y);
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFFloatSize AMF_STD_CALL AMFConvertStringToFloatSize(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFFloatSize tmp = {};
-        int readElements = 0;
-        if (value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%f,%f", &tmp.width, &tmp.height);
-        }
-        if (readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFFloatPoint2D AMF_STD_CALL AMFConvertStringToFloatPoint2D(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFFloatPoint2D tmp = {};
-        int readElements = 0;
-        if (value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%f,%f", &tmp.x, &tmp.y);
-        }
-        if (readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFFloatPoint3D AMF_STD_CALL AMFConvertStringToFloatPoint3D(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFFloatPoint3D tmp = {};
-        int readElements = 0;
-        if (value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%f,%f,%f", &tmp.x, &tmp.y, &tmp.z);
-        }
-        if (readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFFloatVector4D AMF_STD_CALL AMFConvertStringToFloatVector4D(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFFloatVector4D tmp = {};
-        int readElements = 0;
-        if (value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%f,%f,%f,%f", &tmp.x, &tmp.y, &tmp.z, &tmp.w);
-        }
-        if (readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFRate  AMF_STD_CALL AMFConvertStringToRate(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFRate tmp = {};
-        int readElements = 0;
-        if(value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%u,%u", &tmp.num, &tmp.den);
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFRatio AMF_STD_CALL AMFConvertStringToRatio(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        AMFRatio tmp = {};
-        int readElements = 0;
-        if(value.size() > 0)
-        {
-            readElements = sscanf(value.c_str(), "%u,%u", &tmp.num, &tmp.den);
-        }
-        if(readElements)
-        {
-            return tmp;
-        }
-        res = AMF_INVALID_ARG;
-        return tmp;
-    }
-    static AMF_INLINE AMFColor AMF_STD_CALL AMFConvertStringToColor(const AMFVariant::String& value, AMF_RESULT& res)
-    {
-        res = AMF_OK;
-        int readElements = 0;
-        amf_uint32 r = 0;
-        amf_uint32 g = 0;
-        amf_uint32 b = 0;
-        amf_uint32 a = 0;
-        if(value.size() > 0)
-        { 
-            readElements = sscanf(value.c_str(), "%u,%u,%u,%u", &r, &g, &b, &a);
-        }
-        if(readElements)
-        {
-            return AMFConstructColor((amf_uint8)r, (amf_uint8)g, (amf_uint8)b, (amf_uint8)a);
-        }
-        res = AMF_INVALID_ARG;
-        return AMFConstructColor(0, 0, 0, 255);
-    }
-///////////////////////
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertRectToWString(const AMFRect& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertRectToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertSizeToWString(const AMFSize& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertSizeToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertPointToWString(const AMFPoint& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertPointToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertFloatSizeToWString(const AMFFloatSize& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertFloatSizeToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertFloatPoint2DToWString(const AMFFloatPoint2D& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertFloatPoint2DToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertFloatPoint3DToWString(const AMFFloatPoint3D& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertFloatPoint3DToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertFloatVector4DToWString(const AMFFloatVector4D& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertFloatVector4DToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertRateToWString(const AMFRate& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertRateToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertRatioToWString(const AMFRatio& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertRatioToString(value, res), res);
-    }
-    static AMF_INLINE AMFVariant::WString AMF_STD_CALL AMFConvertColorToWString(const AMFColor& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToWString(AMFConvertColorToString(value, res), res);
-    }
-
-    static AMF_INLINE AMFRect  AMF_STD_CALL AMFConvertWStringToRect(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToRect(AMFConvertWStringToString(value, res), res);
-    }
-
-    static AMF_INLINE AMFSize  AMF_STD_CALL AMFConvertWStringToSize(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToSize(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFPoint AMF_STD_CALL AMFConvertWStringToPoint(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToPoint(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFFloatSize AMF_STD_CALL AMFConvertWStringToFloatSize(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToFloatSize(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFFloatPoint2D AMF_STD_CALL AMFConvertWStringToFloatPoint2D(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToFloatPoint2D(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFFloatPoint3D AMF_STD_CALL AMFConvertWStringToFloatPoint3D(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToFloatPoint3D(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFFloatVector4D AMF_STD_CALL AMFConvertWStringToFloatVector4D(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToFloatVector4D(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFRate  AMF_STD_CALL AMFConvertWStringToRate(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToRate(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFRatio AMF_STD_CALL AMFConvertWStringToRatio(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToRatio(AMFConvertWStringToString(value, res), res);
-    }
-    static AMF_INLINE AMFColor AMF_STD_CALL AMFConvertWStringToColor(const AMFVariant::WString& value, AMF_RESULT& res)
-    {
-        return AMFConvertStringToColor(AMFConvertWStringToString(value, res), res);
-    }
-
-    //-------------------------------------------------------------------------------------------------
-    #define AMFConvertTool(srcType, dstType)\
-        if(AMFVariantGetType(pSrc) == AMFVariantType##srcType && newType == AMFVariantType##dstType)\
-        {\
-            AMF_RESULT res = AMF_OK;\
-            AMFVariantAssign##dstType(pDest, AMFConvert##srcType##To##dstType(AMFVariant##srcType(pSrc), res));\
-            return res;\
-        }\
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantChangeType(AMFVariantStruct* pDest, const AMFVariantStruct* pSrc, AMF_VARIANT_TYPE newType)
-    {
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        if(pSrc == 0)
-        {
-            pSrc = pDest;
-        }
-
-        if(AMFVariantGetType(pSrc) == newType)
-        {
-            if(pDest == pSrc)
-            {
-                return AMF_OK;
-            }
-            return AMFVariantCopy(pDest, pSrc);
-        }
-        AMFVariantClear(pDest);
-
-        AMFConvertTool(Empty, Bool);
-        AMFConvertTool(Empty, Int64);
-        AMFConvertTool(Empty, Double);
-        AMFConvertTool(Empty, Float);
-        AMFConvertTool(Empty, String);
-        AMFConvertTool(Empty, WString);
-
-        AMFConvertTool(Bool, Int64);
-        AMFConvertTool(Bool, Double);
-        AMFConvertTool(Bool, Float);
-        AMFConvertTool(Bool, String);
-        AMFConvertTool(Bool, WString);
-
-        AMFConvertTool(Int64, Bool);
-        AMFConvertTool(Int64, Double);
-        AMFConvertTool(Int64, Float);
-        AMFConvertTool(Int64, String);
-        AMFConvertTool(Int64, WString);
-
-        AMFConvertTool(Double, Bool);
-        AMFConvertTool(Double, Int64);
-        AMFConvertTool(Double, String);
-        AMFConvertTool(Double, String);
-
-        AMFConvertTool(Float, Bool);
-        AMFConvertTool(Float, Int64);
-        AMFConvertTool(Float, String);
-        AMFConvertTool(Float, String);
-
-        AMFConvertTool(String, Bool);
-        AMFConvertTool(String, Int64);
-        AMFConvertTool(String, Double);
-        AMFConvertTool(String, Float);
-        AMFConvertTool(String, WString);
-
-        AMFConvertTool(WString, Bool);
-        AMFConvertTool(WString, Int64);
-        AMFConvertTool(WString, Double);
-        AMFConvertTool(WString, Float);
-        AMFConvertTool(WString, String);
-
-        AMFConvertTool(String, Rect);
-        AMFConvertTool(String, Size);
-        AMFConvertTool(String, Point);
-        AMFConvertTool(String, Rate);
-        AMFConvertTool(String, Ratio);
-        AMFConvertTool(String, Color);
-
-        AMFConvertTool(Rect , String);
-        AMFConvertTool(Size , String);
-        AMFConvertTool(Point, String);
-        AMFConvertTool(Rate , String);
-        AMFConvertTool(Ratio, String);
-        AMFConvertTool(Color, String);
-
-        AMFConvertTool(WString, Rect);
-        AMFConvertTool(WString, Size);
-        AMFConvertTool(WString, Point);
-        AMFConvertTool(WString, Rate);
-        AMFConvertTool(WString, Ratio);
-        AMFConvertTool(WString, Color);
-
-        AMFConvertTool(Rect , WString);
-        AMFConvertTool(Size , WString);
-        AMFConvertTool(Point, WString);
-        AMFConvertTool(Rate , WString);
-        AMFConvertTool(Ratio, WString);
-        AMFConvertTool(Color, WString);
-
-        return AMF_INVALID_ARG;
-    }
-#endif // #if defined(__cplusplus)
-
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignBool(AMFVariantStruct* pDest, amf_bool value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_BOOL;
-            AMFVariantBool(pDest) = value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignInt64(AMFVariantStruct* pDest, amf_int64 value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_INT64;
-            AMFVariantInt64(pDest) = value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignDouble(AMFVariantStruct* pDest, amf_double value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_DOUBLE;
-            AMFVariantDouble(pDest) = value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloat(AMFVariantStruct* pDest, amf_float value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if (errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_FLOAT;
-            AMFVariantFloat(pDest) = value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignString(AMFVariantStruct* pDest, const char* pValue)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pValue);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            const size_t size = (strlen(pValue) + 1);
-            pDest->type = AMF_VARIANT_STRING;
-            AMFVariantString(pDest) = (char*)amf_variant_alloc(size * sizeof(char));
-            if(AMFVariantString(pDest))
-            {
-                memcpy(AMFVariantString(pDest), pValue, size * sizeof(char));
-            }
-            else
-            {
-                errRet = AMF_OUT_OF_MEMORY;
-            }
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignWString(AMFVariantStruct* pDest, const wchar_t* pValue)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pValue);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            const size_t size = (wcslen(pValue) + 1);
-            pDest->type = AMF_VARIANT_WSTRING;
-            AMFVariantWString(pDest) = (wchar_t*)amf_variant_alloc(size * sizeof(wchar_t));
-            if(AMFVariantWString(pDest))
-            {
-                memcpy(AMFVariantWString(pDest), pValue, size * sizeof(wchar_t));
-            }
-            else
-            {
-                errRet = AMF_OUT_OF_MEMORY;
-            }
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignInterface(AMFVariantStruct* pDest, AMFInterface* pValue)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-        //AMF_VARIANT_RETURN_IF_INVALID_POINTER(pValue);//can be NULL
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_INTERFACE;
-            AMFVariantInterface(pDest) = pValue;
-            if(AMFVariantInterface(pDest))
-            {
-#if defined(__cplusplus)
-                AMFVariantInterface(pDest)->Acquire();
-#else
-                AMFVariantInterface(pDest)->pVtbl->Acquire(AMFVariantInterface(pDest));
-#endif
-            }
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignRect(AMFVariantStruct* pDest, const AMFRect& value)
-    {
-        return AMFVariantAssignRect(pDest, &value);
-    }
-#endif
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignRect (AMFVariantStruct* pDest, const AMFRect* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_RECT;
-            AMFVariantRect(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignSize (AMFVariantStruct* pDest, const AMFSize& value)
-    {
-        return AMFVariantAssignSize (pDest, &value);
-    }
-#endif
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignSize (AMFVariantStruct* pDest, const AMFSize* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_SIZE;
-            AMFVariantSize(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignPoint(AMFVariantStruct* pDest, const AMFPoint& value)
-    {
-        return AMFVariantAssignPoint(pDest, &value);
-    }
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatSize(AMFVariantStruct* pDest, const AMFFloatSize& value)
-    {
-        return AMFVariantAssignFloatSize(pDest, &value);
-    }
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatPoint2D(AMFVariantStruct* pDest, const AMFFloatPoint2D& value)
-    {
-        return AMFVariantAssignFloatPoint2D(pDest, &value);
-    }
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatPoint3D(AMFVariantStruct* pDest, const AMFFloatPoint3D& value)
-    {
-        return AMFVariantAssignFloatPoint3D(pDest, &value);
-    }
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatVector4D(AMFVariantStruct* pDest, const AMFFloatVector4D& value)
-    {
-        return AMFVariantAssignFloatVector4D(pDest, &value);
-    }
-#endif
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignPoint(AMFVariantStruct* pDest, const AMFPoint* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_POINT;
-            AMFVariantPoint(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatSize(AMFVariantStruct* pDest, const AMFFloatSize* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if (errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_FLOAT_SIZE;
-            AMFVariantFloatSize(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatPoint2D(AMFVariantStruct* pDest, const AMFFloatPoint2D* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if (errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_FLOAT_POINT2D;
-            AMFVariantFloatPoint2D(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatPoint3D(AMFVariantStruct* pDest, const AMFFloatPoint3D* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if (errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_FLOAT_POINT3D;
-            AMFVariantFloatPoint3D(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignFloatVector4D(AMFVariantStruct* pDest, const AMFFloatVector4D* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if (errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_FLOAT_VECTOR4D;
-            AMFVariantFloatVector4D(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignRate (AMFVariantStruct* pDest, const AMFRate& value)
-    {
-        return AMFVariantAssignRate (pDest, &value);
-    }
-#endif
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignRate (AMFVariantStruct* pDest, const AMFRate* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_RATE;
-            AMFVariantRate(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignRatio(AMFVariantStruct* pDest, const AMFRatio& value)
-    {
-        return AMFVariantAssignRatio(pDest, &value);
-    }
-#endif
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignRatio(AMFVariantStruct* pDest, const AMFRatio* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_RATIO;
-            AMFVariantRatio(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignColor(AMFVariantStruct* pDest, const AMFColor& value)
-    {
-        return AMFVariantAssignColor(pDest, &value);
-    }
-#endif
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE AMF_RESULT AMF_CDECL_CALL AMFVariantAssignColor(AMFVariantStruct* pDest, const AMFColor* value)
-    {
-        AMF_RESULT errRet = AMF_OK;
-        AMF_VARIANT_RETURN_IF_INVALID_POINTER(pDest);
-
-        errRet = AMFVariantInit(pDest);
-        if(errRet == AMF_OK)
-        {
-            pDest->type = AMF_VARIANT_COLOR;
-            AMFVariantColor(pDest) = *value;
-        }
-        return errRet;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE char* AMF_CDECL_CALL AMFVariantDuplicateString(const char* from)
-    {
-        char* ret = 0;
-        if(from)
-        {
-            ret = (char*)amf_variant_alloc(sizeof(char)*(strlen(from) + 1));
-            if(ret)
-            {
-                strcpy(ret, from);
-            }
-        }
-        return ret;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE void AMF_CDECL_CALL AMFVariantFreeString(char* from)
-    {
-        amf_variant_free(from);
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE wchar_t* AMF_CDECL_CALL AMFVariantDuplicateWString(const wchar_t* from)
-    {
-        wchar_t* ret = 0;
-        if(from)
-        {
-            ret = (wchar_t*)amf_variant_alloc(sizeof(wchar_t)*(wcslen(from) + 1));
-            if(ret)
-            {
-                wcscpy(ret, from);
-            }
-        }
-        return ret;
-    }
-    //-------------------------------------------------------------------------------------------------
-    static AMF_INLINE void AMF_CDECL_CALL AMFVariantFreeWString(wchar_t* from)
-    {
-        amf_variant_free(from);
-    }
-    //----------------------------------------------------------------------------------------------
-    // AMF_INLINE implementation of AMFVariant class
-    //----------------------------------------------------------------------------------------------
-#if defined(__cplusplus)
-    AMF_INLINE AMFVariant::AMFVariant(const AMFVariantStruct* pOther)
-    {
-        AMFVariantInit(this);
-        if(pOther != NULL)
-        {
-            AMFVariantCopy(this, const_cast<AMFVariantStruct*>(pOther));
-        }
-    }
-    //-------------------------------------------------------------------------------------------------
-    template<typename T>
-    AMFVariant::AMFVariant(const AMFInterfacePtr_T<T>& pValue)
-    {
-        AMFVariantInit(this);
-        AMFVariantAssignInterface(this, pValue);
-    }
-    //-------------------------------------------------------------------------------------------------
-    template<class ReturnType, AMF_VARIANT_TYPE variantType, typename Getter>
-    ReturnType AMFVariant::GetValue(Getter getter) const
-    {
-        ReturnType str = ReturnType();
-        if(AMFVariantGetType(this) == variantType)
-        {
-            str = static_cast<ReturnType>(getter(this));
-        }
-        else
-        {
-            AMFVariant varDest;
-            varDest.ChangeType(variantType, this);
-            if(varDest.type != AMF_VARIANT_EMPTY)
-            {
-                str = static_cast<ReturnType>(getter(&varDest));
-            }
-        }
-        return str;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE AMFVariant& AMFVariant::operator=(const AMFVariantStruct& other)
-    {
-        AMFVariantClear(this);
-        AMFVariantCopy(this, const_cast<AMFVariantStruct*>(&other));
-        return *this;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE AMFVariant& AMFVariant::operator=(const AMFVariantStruct* pOther)
-    {
-        if(pOther != NULL)
-        {
-            AMFVariantClear(this);
-            AMFVariantCopy(this, const_cast<AMFVariantStruct*>(pOther));
-        }
-        return *this;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE AMFVariant& AMFVariant::operator=(const AMFVariant& other)
-    {
-        AMFVariantClear(this);
-        AMFVariantCopy(this,
-                const_cast<AMFVariantStruct*>(static_cast<const AMFVariantStruct*>(&other)));
-        return *this;
-    }
-    //-------------------------------------------------------------------------------------------------
-    template<typename T>
-    AMFVariant& AMFVariant::operator=(const AMFInterfacePtr_T<T>& value)
-    {
-        AMFVariantClear(this);
-        AMFVariantAssignInterface(this, value);
-        return *this;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE bool AMFVariant::operator==(const AMFVariantStruct& other) const
-    {
-        return *this == &other;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE bool AMFVariant::operator==(const AMFVariantStruct* pOther) const
-    {
-        //TODO: double check
-        amf_bool ret = false;
-        if(pOther == NULL)
-        {
-            ret = false;
-        }
-        else
-        {
-            AMFVariantCompare(this, pOther, &ret);
-        }
-        return ret;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE bool AMFVariant::operator!=(const AMFVariantStruct& other) const
-    {
-        return !(*this == &other);
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE bool AMFVariant::operator!=(const AMFVariantStruct* pOther) const
-    {
-        return !(*this == pOther);
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE void AMFVariant::Attach(AMFVariantStruct& variant)
-    {
-        Clear();
-        memcpy(this, &variant, sizeof(variant));
-        AMFVariantGetType(&variant) = AMF_VARIANT_EMPTY;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE AMFVariantStruct AMFVariant::Detach()
-    {
-        AMFVariantStruct varResult = *this;
-        AMFVariantGetType(this) = AMF_VARIANT_EMPTY;
-        return varResult;
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE AMFVariantStruct& AMFVariant::GetVariant()
-    {
-        return *static_cast<AMFVariantStruct*>(this);
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE void AMFVariant::ChangeType(AMF_VARIANT_TYPE newType, const AMFVariant* pSrc)
-    {
-        AMFVariantChangeType(this, pSrc, newType);
-    }
-    //-------------------------------------------------------------------------------------------------
-    AMF_INLINE bool AMFVariant::Empty() const
-    {
-        return type == AMF_VARIANT_EMPTY;
-    }
-    //-------------------------------------------------------------------------------------------------
-#endif // #if defined(__cplusplus)
-
-#if defined(__cplusplus)
-} //namespace amf
-#endif
-
-#endif //#ifndef AMF_Variant_h

plugins/obs-ffmpeg/external/AMF/include/core/Version.h

@@ -1,59 +0,0 @@
-// 
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-// 
-// MIT license 
-// 
-// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-/**
-***************************************************************************************************
-* @file  Version.h
-* @brief Version declaration
-***************************************************************************************************
-*/
-#ifndef AMF_Version_h
-#define AMF_Version_h
-#pragma once
-
-#include "Platform.h"
-
-#define AMF_MAKE_FULL_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_RELEASE, VERSION_BUILD_NUM)    ( ((amf_uint64)(VERSION_MAJOR) << 48ull) | ((amf_uint64)(VERSION_MINOR) << 32ull) | ((amf_uint64)(VERSION_RELEASE) << 16ull)  | (amf_uint64)(VERSION_BUILD_NUM))
-
-#define AMF_GET_MAJOR_VERSION(x)      ((x >> 48ull) & 0xFFFF)
-#define AMF_GET_MINOR_VERSION(x)      ((x >> 32ull) & 0xFFFF)
-#define AMF_GET_SUBMINOR_VERSION(x)   ((x >> 16ull) & 0xFFFF)
-#define AMF_GET_BUILD_VERSION(x)      ((x >>  0ull) & 0xFFFF)
-
-#define AMF_VERSION_MAJOR       1
-#define AMF_VERSION_MINOR       4
-#define AMF_VERSION_RELEASE     29
-#define AMF_VERSION_BUILD_NUM   0
-
-#define AMF_FULL_VERSION AMF_MAKE_FULL_VERSION(AMF_VERSION_MAJOR, AMF_VERSION_MINOR, AMF_VERSION_RELEASE, AMF_VERSION_BUILD_NUM)
-
-#endif //#ifndef AMF_Version_h

plugins/obs-ffmpeg/external/AMF/include/core/VulkanAMF.h

@@ -1,111 +0,0 @@
-//
-// Notice Regarding Standards.  AMD does not provide a license or sublicense to
-// any Intellectual Property Rights relating to any standards, including but not
-// limited to any audio and/or video codec technologies such as MPEG-2, MPEG-4;
-// AVC/H.264; HEVC/H.265; AAC decode/FFMPEG; AAC encode/FFMPEG; VC-1; and MP3
-// (collectively, the "Media Technologies"). For clarity, you will pay any
-// royalties due for such third party technologies, which may include the Media
-// Technologies that are owed as a result of AMD providing the Software to you.
-//
-// MIT license
-//
-// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#ifndef __VulkanAMF_h__
-#define __VulkanAMF_h__
-#pragma once
-#include "Platform.h"
-
-#include "vulkan/vulkan.h"
-
-#if defined(__cplusplus)
-namespace amf
-{
-#endif
-    typedef struct AMFVulkanDevice
-    {
-        amf_size            cbSizeof;           // sizeof(AMFVulkanDevice)
-        void*               pNext;              // reserved for extensions
-        VkInstance          hInstance;
-        VkPhysicalDevice    hPhysicalDevice;
-        VkDevice            hDevice;
-    } AMFVulkanDevice;
-
-    typedef struct AMFVulkanSync
-    {
-        amf_size            cbSizeof;           // sizeof(AMFVulkanSync)
-        void*               pNext;              // reserved for extensions
-        VkSemaphore         hSemaphore;         // VkSemaphore; can be nullptr
-        bool                bSubmitted;         // if true - wait for hSemaphore. re-submit hSemaphore if not synced by other ways and set to true
-        VkFence             hFence;             // To sync on CPU; can be nullptr. Submitted in vkQueueSubmit. If waited for hFence, null it, do not delete or reset.
-    } AMFVulkanSync;
-
-    typedef struct AMFVulkanBuffer
-    {
-        amf_size            cbSizeof;           // sizeof(AMFVulkanBuffer)
-        void*               pNext;              // reserved for extensions
-        VkBuffer            hBuffer;
-        VkDeviceMemory      hMemory;
-        amf_int64           iSize;
-        amf_int64           iAllocatedSize;     // for reuse
-        amf_uint32          eAccessFlags;       // VkAccessFlagBits
-        amf_uint32          eUsage;             // AMF_BUFFER_USAGE
-        amf_uint32          eAccess;            // AMF_MEMORY_CPU_ACCESS
-        AMFVulkanSync       Sync;
-    } AMFVulkanBuffer;
-
-    typedef struct AMFVulkanSurface
-    {
-        amf_size            cbSizeof;           // sizeof(AMFVulkanSurface)
-        void*               pNext;              // reserved for extensions
-        // surface properties
-        VkImage             hImage;             // vulkan native image for which the surface is created
-        VkDeviceMemory      hMemory;            // memory for hImage, can be nullptr
-        amf_int64           iSize;              // memory size
-        amf_uint32          eFormat;            // VkFormat
-        amf_int32           iWidth;             // image width
-        amf_int32           iHeight;            // image height
-        amf_uint32          eCurrentLayout;     // VkImageLayout
-        amf_uint32          eUsage;             // AMF_SURFACE_USAGE
-        amf_uint32          eAccess;            // AMF_MEMORY_CPU_ACCESS
-        AMFVulkanSync       Sync;               // To sync on GPU
-    } AMFVulkanSurface;
-
-    typedef struct AMFVulkanView
-    {
-        amf_size            cbSizeof;           // sizeof(AMFVulkanView)
-        void*               pNext;              // reserved for extensions
-        // surface properties
-        AMFVulkanSurface    *pSurface;
-        VkImageView         hView;
-        amf_int32           iPlaneWidth;
-        amf_int32           iPlaneHeight;
-        amf_int32           iPlaneWidthPitch;
-        amf_int32           iPlaneHeightPitch;
-    } AMFVulkanView;
-
-#define AMF_CONTEXT_VULKAN_COMPUTE_QUEUE  L"VulkanComputeQueue" // amf_int64; default=0; Compute queue index in range [0, (VkQueueFamilyProperties.queueCount-1)] of the compute queue family.
-
-#if defined(__cplusplus)
-} // namespace amf
-#endif
-#endif // __VulkanAMF_h__

plugins/obs-ffmpeg/obs-amf-test/CMakeLists.txt

@@ -1,8 +1,10 @@
 project(obs-amf-test)
 
-include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/libobs)
-
 add_executable(obs-amf-test)
+
+target_include_directories(obs-amf-test PRIVATE ${CMAKE_SOURCE_DIR}/libobs
+                                                ${CMAKE_PREFIX_PATH}/include)
+
 target_sources(obs-amf-test PRIVATE obs-amf-test.cpp)
 target_link_libraries(obs-amf-test d3d11 dxgi dxguid)
 

plugins/obs-ffmpeg/obs-amf-test/obs-amf-test.cpp

@@ -1,8 +1,8 @@
-#include "../external/AMF/include/core/Factory.h"
-#include "../external/AMF/include/core/Trace.h"
-#include "../external/AMF/include/components/VideoEncoderVCE.h"
-#include "../external/AMF/include/components/VideoEncoderHEVC.h"
-#include "../external/AMF/include/components/VideoEncoderAV1.h"
+#include <AMF/core/Factory.h>
+#include <AMF/core/Trace.h>
+#include <AMF/components/VideoEncoderVCE.h>
+#include <AMF/components/VideoEncoderHEVC.h>
+#include <AMF/components/VideoEncoderAV1.h>
 
 #include <util/windows/ComPtr.hpp>
 

plugins/obs-ffmpeg/texture-amf.cpp

@@ -14,11 +14,11 @@
 #include <deque>
 #include <map>
 
-#include "external/AMF/include/components/VideoEncoderHEVC.h"
-#include "external/AMF/include/components/VideoEncoderVCE.h"
-#include "external/AMF/include/components/VideoEncoderAV1.h"
-#include "external/AMF/include/core/Factory.h"
-#include "external/AMF/include/core/Trace.h"
+#include <AMF/components/VideoEncoderHEVC.h>
+#include <AMF/components/VideoEncoderVCE.h>
+#include <AMF/components/VideoEncoderAV1.h>
+#include <AMF/core/Factory.h>
+#include <AMF/core/Trace.h>
 
 #include <dxgi.h>
 #include <d3d11.h>