jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

obs-ffmpeg: Add texture-based hardware AMD encoder 

Adds support for texture-based AMD encoding, with both H264, HEVC, and
HDR support. Falls back to FFmpeg when texture-based encoding cannot be
used for whatever reason.

(Jim note: This is based upon obsproject/obs-studio#4538 by AMD/Luxoft
with fewer files, FFmpeg fallback for software encoding, and HDR
support. I also went to lengths to ensure that FFmpeg command line
parameters also works with it)

Co-authored-by: Jim <obs.jim@gmail.com>
master
OvchinnikovDmitrii 2022-04-22 17:39:59 -07:00 committed by Jim
parent 4e206896b2
commit 4e140d2ffe
56 changed files with 11835 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
plugins/obs-ffmpeg/CMakeLists.txt
View File

@ -63,6 +63,8 @@ target_compile_options(
)
if(OS_WINDOWS)
add_subdirectory(obs-amf-test)
if(MSVC)
target_link_libraries(obs-ffmpeg PRIVATE OBS::w32-pthreads)
endif()
@ -71,8 +73,9 @@ if(OS_WINDOWS)
configure_file(${CMAKE_SOURCE_DIR}/cmake/bundle/windows/obs-module.rc.in
obs-ffmpeg.rc)
target_sources(obs-ffmpeg PRIVATE jim-nvenc.c jim-nvenc.h jim-nvenc-helpers.c
obs-ffmpeg.rc)
target_sources(
obs-ffmpeg PRIVATE texture-amf.cpp texture-amf-opts.hpp jim-nvenc.c
jim-nvenc.h jim-nvenc-helpers.c obs-ffmpeg.rc)
elseif(OS_POSIX AND NOT OS_MACOS)
find_package(Libpci REQUIRED)

10
plugins/obs-ffmpeg/data/locale/en-US.ini
View File

@ -12,6 +12,9 @@ KeyframeIntervalSec="Keyframe Interval (seconds, 0=auto)"
Lossless="Lossless"
Level="Level"
AMFOpts="AMF/FFmpeg Options"
AMFOpts.ToolTip="Use to specify custom AMF or FFmpeg options. For example, \"level=5.2 profile=main BPicturesPattern=3\""
BFrames="Max B-frames"
VAAPI.Codec="VAAPI Codec"
@ -33,6 +36,10 @@ NVENC.CQLevel="CQ Level"
NVENC.10bitUnsupported="Cannot perform 10-bit encode on this encoder."
NVENC.TooManyBFrames="Max B-frames setting (%d) is more than encoder supports (%d)."
AMF.Preset.speed="Speed"
AMF.Preset.balanced="Balanced"
AMF.Preset.quality="Quality"
FFmpegSource="Media Source"
LocalFile="Local File"
Looping="Loop"
@ -72,6 +79,9 @@ WarnWindowsDefender="If Windows 10 Ransomware Protection is enabled it can also
Encoder.Error="Failed to open %1: %2"
Encoder.Timeout="Encoder %1 is taking too long to encode (timeout: %2 seconds)"
AMF.Error="Failed to open AMF codec: %1"
AMF.GenericError="Check your video drivers are up to date. Try closing other recording software which might be using the AMD encoder such as the Radeon Software or Windows 10 Game DVR."
NVENC.Error="Failed to open NVENC codec: %1"
NVENC.GenericError="Check your video drivers are up to date. Try closing other recording software which might be using NVENC such as NVIDIA Shadowplay or Windows 10 Game DVR."
NVENC.BadGPUIndex="You have selected GPU %1 in your output encoder settings. Set this back to 0 and try again."

79
plugins/obs-ffmpeg/external/AMF/include/components/Ambisonic2SRenderer.h vendored Normal file
View File

@ -0,0 +1,79 @@
//
// 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

86
plugins/obs-ffmpeg/external/AMF/include/components/AudioCapture.h vendored Normal file
View File

@ -0,0 +1,86 @@
//
// 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

198
plugins/obs-ffmpeg/external/AMF/include/components/Capture.h vendored Normal file
View File

@ -0,0 +1,198 @@
//
// 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__

76
plugins/obs-ffmpeg/external/AMF/include/components/ChromaKey.h vendored Normal file
View File

@ -0,0 +1,76 @@
//
// 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__

138
plugins/obs-ffmpeg/external/AMF/include/components/ColorSpace.h vendored Normal file
View File

@ -0,0 +1,138 @@
//
// 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

443
plugins/obs-ffmpeg/external/AMF/include/components/Component.h vendored Normal file
View File

@ -0,0 +1,443 @@
//
// 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_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

172
plugins/obs-ffmpeg/external/AMF/include/components/ComponentCaps.h vendored Normal file
View File

@ -0,0 +1,172 @@
//
// 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

53
plugins/obs-ffmpeg/external/AMF/include/components/CursorCapture.h vendored Normal file
View File

@ -0,0 +1,53 @@
//
// 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:
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

81
plugins/obs-ffmpeg/external/AMF/include/components/DisplayCapture.h vendored Normal file
View File

@ -0,0 +1,81 @@
//
// 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

62
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGAudioConverter.h vendored Normal file
View File

@ -0,0 +1,62 @@
//
// 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

68
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGAudioDecoder.h vendored Normal file
View File

@ -0,0 +1,68 @@
//
// 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

66
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGAudioEncoder.h vendored Normal file
View File

@ -0,0 +1,66 @@
//
// 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

54
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGComponents.h vendored Normal file
View File

@ -0,0 +1,54 @@
//
// 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

66
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGFileDemuxer.h vendored Normal file
View File

@ -0,0 +1,66 @@
//
// 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

53
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGFileMuxer.h vendored Normal file
View File

@ -0,0 +1,53 @@
//
// 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)
#endif //#ifndef AMF_FileMuxerFFMPEG_h

53
plugins/obs-ffmpeg/external/AMF/include/components/FFMPEGVideoDecoder.h vendored Normal file
View File

@ -0,0 +1,53 @@
//
// 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

64
plugins/obs-ffmpeg/external/AMF/include/components/HQScaler.h vendored Normal file
View File

@ -0,0 +1,64 @@
//
// 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,
};
// 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.
#endif //#ifndef AMFHQScaler_h

79
plugins/obs-ffmpeg/external/AMF/include/components/MediaSource.h vendored Normal file
View File

@ -0,0 +1,79 @@
//
// 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

110
plugins/obs-ffmpeg/external/AMF/include/components/PreAnalysis.h vendored Normal file
View File

@ -0,0 +1,110 @@
//
// 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
};
// 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 : True) - 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 : True) - Enable Automatic Long Term Reference frame management
///////////////////////////////////////////
// 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

59
plugins/obs-ffmpeg/external/AMF/include/components/PreProcessing.h vendored Normal file
View File

@ -0,0 +1,59 @@
//
// 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

52
plugins/obs-ffmpeg/external/AMF/include/components/VideoCapture.h vendored Normal file
View File

@ -0,0 +1,52 @@
//
// 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

121
plugins/obs-ffmpeg/external/AMF/include/components/VideoConverter.h vendored Normal file
View File

@ -0,0 +1,121 @@
//
// 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

122
plugins/obs-ffmpeg/external/AMF/include/components/VideoDecoderUVD.h vendored Normal file
View File

@ -0,0 +1,122 @@
//
// 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"
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
#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__
#endif //#ifndef AMF_VideoDecoderUVD_h

296
plugins/obs-ffmpeg/external/AMF/include/components/VideoEncoderHEVC.h vendored Normal file
View File

@ -0,0 +1,296 @@
//
// 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
};
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.
// 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_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
// 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_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)
#endif //#ifndef AMF_VideoEncoderHEVC_h

326
plugins/obs-ffmpeg/external/AMF/include/components/VideoEncoderVCE.h vendored Normal file
View File

@ -0,0 +1,326 @@
//
// 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_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
};
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; default = 42; H264 profile 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
#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)
#endif //#ifndef AMF_VideoEncoderVCE_h

124
plugins/obs-ffmpeg/external/AMF/include/components/VideoStitch.h vendored Normal file
View File

@ -0,0 +1,124 @@
//
// 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

83
plugins/obs-ffmpeg/external/AMF/include/components/ZCamLiveStream.h vendored Normal file
View File

@ -0,0 +1,83 @@
//
// 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

234
plugins/obs-ffmpeg/external/AMF/include/core/AudioBuffer.h vendored Normal file
View File

@ -0,0 +1,234 @@
//
// 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

187
plugins/obs-ffmpeg/external/AMF/include/core/Buffer.h vendored Normal file
View File

@ -0,0 +1,187 @@
//
// 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

302
plugins/obs-ffmpeg/external/AMF/include/core/Compute.h vendored Normal file
View File

@ -0,0 +1,302 @@
//
// 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

147
plugins/obs-ffmpeg/external/AMF/include/core/ComputeFactory.h vendored Normal file
View File

@ -0,0 +1,147 @@
//
// 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

786
plugins/obs-ffmpeg/external/AMF/include/core/Context.h vendored Normal file
View File

@ -0,0 +1,786 @@
//
// 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

52
plugins/obs-ffmpeg/external/AMF/include/core/CurrentTime.h vendored Normal file
View File

@ -0,0 +1,52 @@
//
// 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

44
plugins/obs-ffmpeg/external/AMF/include/core/D3D12AMF.h vendored Normal file
View File

@ -0,0 +1,44 @@
//
// 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
#endif
#endif // __D3D12AMF_h__

177
plugins/obs-ffmpeg/external/AMF/include/core/Data.h vendored Normal file
View File

@ -0,0 +1,177 @@
//
// 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

78
plugins/obs-ffmpeg/external/AMF/include/core/Debug.h vendored Normal file
View File

@ -0,0 +1,78 @@
//
// 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

112
plugins/obs-ffmpeg/external/AMF/include/core/Dump.h vendored Normal file
View File

@ -0,0 +1,112 @@
//
// 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

133
plugins/obs-ffmpeg/external/AMF/include/core/Factory.h vendored Normal file
View File

@ -0,0 +1,133 @@
//
// 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__)
#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

258
plugins/obs-ffmpeg/external/AMF/include/core/Interface.h vendored Normal file
View File

@ -0,0 +1,258 @@
//
// 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

112
plugins/obs-ffmpeg/external/AMF/include/core/Plane.h vendored Normal file
View File

@ -0,0 +1,112 @@
//
// 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

547
plugins/obs-ffmpeg/external/AMF/include/core/Platform.h vendored Normal file
View File

@ -0,0 +1,547 @@
//
// 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
#if defined(__linux) || (__clang__)
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_MIN(a, b) ((a) < (b) ? (a) : (b))
#define AMF_MAX(a, b) ((a) > (b) ? (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 )
#endif
#if defined(WIN32)
#if defined(_MSC_VER)
#pragma warning(disable : 4200)
#pragma warning(disable : 4201)
#endif
#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

275
plugins/obs-ffmpeg/external/AMF/include/core/PropertyStorage.h vendored Normal file
View File

@ -0,0 +1,275 @@
//
// 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

207
plugins/obs-ffmpeg/external/AMF/include/core/PropertyStorageEx.h vendored Normal file
View File

@ -0,0 +1,207 @@
//
// 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

127
plugins/obs-ffmpeg/external/AMF/include/core/Result.h vendored Normal file
View File

@ -0,0 +1,127 @@
//
// 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

279
plugins/obs-ffmpeg/external/AMF/include/core/Surface.h vendored Normal file
View File

@ -0,0 +1,279 @@
//
// 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_FIRST = AMF_SURFACE_NV12,
AMF_SURFACE_LAST = AMF_SURFACE_GRAY32
} 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

183
plugins/obs-ffmpeg/external/AMF/include/core/Trace.h vendored Normal file
View File

@ -0,0 +1,183 @@
//
// 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

2075
plugins/obs-ffmpeg/external/AMF/include/core/Variant.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

59
plugins/obs-ffmpeg/external/AMF/include/core/Version.h vendored Normal file
View File

@ -0,0 +1,59 @@
//
// 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 24
#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

108
plugins/obs-ffmpeg/external/AMF/include/core/VulkanAMF.h vendored Normal file
View File

@ -0,0 +1,108 @@
//
// 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(AMFVulkanSemaphore)
void* pNext; // reserved for extensions
VkSemaphore hSemaphore;
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;
VkDeviceMemory hMemory;
amf_int64 iSize; // memory size
amf_uint32 eFormat; // VkFormat
amf_int32 iWidth;
amf_int32 iHeight;
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(AMFVulkanSurface)
void* pNext; // reserved for extensions
// surface properties
AMFVulkanSurface *pSurface;
VkImageView hView;
amf_int32 iPlaneWidth;
amf_int32 iPlaneHeight;
amf_int32 iPlaneWidthPitch;
amf_int32 iPlaneHeightPitch;
} AMFVulkanView;
#if defined(__cplusplus)
} // namespace amf
#endif
#endif // __VulkanAMF_h__

11
plugins/obs-ffmpeg/obs-amf-test/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
project(obs-amf-test)
include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/libobs)
add_executable(obs-amf-test)
target_sources(obs-amf-test PRIVATE obs-amf-test.cpp)
target_link_libraries(obs-amf-test d3d11 dxgi dxguid)
set_target_properties(obs-amf-test PROPERTIES FOLDER "plugins/obs-ffmpeg")
setup_binary_target(obs-amf-test)

131
plugins/obs-ffmpeg/obs-amf-test/obs-amf-test.cpp Normal file
View File

@ -0,0 +1,131 @@
#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 <util/windows/ComPtr.hpp>
#include <dxgi.h>
#include <d3d11.h>
#include <d3d11_1.h>
#include <string>
#include <map>
using namespace amf;
#ifdef _MSC_VER
extern "C" __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
#endif
#define AMD_VENDOR_ID 0x1002
struct adapter_caps {
bool is_amd = false;
bool supports_avc = false;
bool supports_hevc = false;
};
static AMFFactory *amf_factory = nullptr;
static std::map<uint32_t, adapter_caps> adapter_info;
static bool has_encoder(AMFContextPtr &amf_context, const wchar_t *encoder_name)
{
AMFComponentPtr encoder;
AMF_RESULT res = amf_factory->CreateComponent(amf_context, encoder_name,
&encoder);
return res == AMF_OK;
}
static bool get_adapter_caps(IDXGIFactory *factory, uint32_t adapter_idx)
{
AMF_RESULT res;
HRESULT hr;
ComPtr<IDXGIAdapter> adapter;
hr = factory->EnumAdapters(adapter_idx, &adapter);
if (FAILED(hr))
return false;
adapter_caps &caps = adapter_info[adapter_idx];
DXGI_ADAPTER_DESC desc;
adapter->GetDesc(&desc);
if (desc.VendorId != AMD_VENDOR_ID)
return true;
caps.is_amd = true;
ComPtr<IDXGIOutput> output;
hr = adapter->EnumOutputs(0, &output);
if (FAILED(hr))
return true;
ComPtr<ID3D11Device> device;
ComPtr<ID3D11DeviceContext> context;
hr = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, nullptr, 0,
nullptr, 0, D3D11_SDK_VERSION, &device, nullptr,
&context);
if (FAILED(hr))
return true;
AMFContextPtr amf_context;
res = amf_factory->CreateContext(&amf_context);
if (res != AMF_OK)
return true;
res = amf_context->InitDX11(device);
if (res != AMF_OK)
return true;
caps.supports_avc = has_encoder(amf_context, AMFVideoEncoderVCE_AVC);
caps.supports_hevc = has_encoder(amf_context, AMFVideoEncoder_HEVC);
return true;
}
int main(void)
try {
ComPtr<IDXGIFactory> factory;
AMF_RESULT res;
HRESULT hr;
/* --------------------------------------------------------- */
/* try initializing amf, I guess */
HMODULE amf_module = LoadLibraryW(AMF_DLL_NAME);
if (!amf_module)
throw "Failed to load AMF lib";
auto init =
(AMFInit_Fn)GetProcAddress(amf_module, AMF_INIT_FUNCTION_NAME);
if (!init)
throw "Failed to get init func";
res = init(AMF_FULL_VERSION, &amf_factory);
if (res != AMF_OK)
throw "AMFInit failed";
hr = CreateDXGIFactory1(__uuidof(IDXGIFactory), (void **)&factory);
if (FAILED(hr))
throw "CreateDXGIFactory1 failed";
uint32_t idx = 0;
while (get_adapter_caps(factory, idx++))
;
for (auto &[idx, caps] : adapter_info) {
printf("[%d]\n", idx);
printf("is_amd=%s\n", caps.is_amd ? "true" : "false");
printf("supports_avc=%s\n",
caps.supports_avc ? "true" : "false");
printf("supports_hevc=%s\n",
caps.supports_hevc ? "true" : "false");
}
return 0;
} catch (const char *text) {
printf("[error]\nstring=%s\n", text);
return 0;
}

8
plugins/obs-ffmpeg/obs-ffmpeg.c
View File

@ -294,6 +294,8 @@ static bool vaapi_supported(void)
#ifdef _WIN32
extern void jim_nvenc_load(bool h264, bool hevc);
extern void jim_nvenc_unload(void);
extern void amf_load(void);
extern void amf_unload(void);
#endif
#if ENABLE_FFMPEG_LOGGING
@ -353,6 +355,11 @@ bool obs_module_load(void)
obs_register_encoder(&hevc_nvenc_encoder_info);
#endif
}
#ifdef _WIN32
amf_load();
#endif
#if !defined(_WIN32) && defined(LIBAVUTIL_VAAPI_AVAILABLE)
if (vaapi_supported()) {
blog(LOG_INFO, "FFMPEG VAAPI supported");
@ -374,6 +381,7 @@ void obs_module_unload(void)
#endif
#ifdef _WIN32
amf_unload();
jim_nvenc_unload();
#endif
}

272
plugins/obs-ffmpeg/texture-amf-opts.hpp Normal file
View File

@ -0,0 +1,272 @@
static bool str_to_bool(const char *str)
{
if (!str)
return false;
if (*str == '1')
return true;
if (*str == '0')
return false;
if (astrcmpi(str, "true") == 0)
return true;
if (astrcmpi(str, "false") == 0)
return false;
return false;
}
static void amf_apply_opt(amf_base *enc, obs_option *opt)
{
bool avc = enc->codec == amf_codec_type::AVC;
bool hevc = enc->codec == amf_codec_type::HEVC;
if (strcmp(opt->name, "g") == 0 || strcmp(opt->name, "keyint") == 0) {
int val = atoi(opt->value);
if (enc->codec == amf_codec_type::AVC)
set_avc_opt(IDR_PERIOD, val);
else
set_hevc_opt(NUM_GOPS_PER_IDR, val);
} else if (strcmp(opt->name, "usage") == 0) {
if (strcmp(opt->value, "transcoding") == 0) {
set_enum_opt(USAGE, TRANSCONDING);
} else if (strcmp(opt->value, "ultralowlatency") == 0) {
set_enum_opt(USAGE, ULTRA_LOW_LATENCY);
} else if (strcmp(opt->value, "lowlatency") == 0) {
set_enum_opt(USAGE, LOW_LATENCY);
} else if (strcmp(opt->value, "webcam") == 0) {
set_enum_opt(USAGE, WEBCAM);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (strcmp(opt->name, "profile") == 0) {
if (strcmp(opt->value, "main") == 0) {
set_enum_opt(PROFILE, MAIN);
} else if (enc->codec != amf_codec_type::AVC) {
warn("Invalid value for %s: %s", opt->name, opt->value);
return;
}
if (strcmp(opt->value, "high") == 0) {
set_opt(PROFILE, AMF_VIDEO_ENCODER_PROFILE_HIGH);
} else if (strcmp(opt->value, "constrained_baseline") == 0) {
set_opt(PROFILE,
AMF_VIDEO_ENCODER_PROFILE_CONSTRAINED_BASELINE);
} else if (strcmp(opt->value, "constrained_high") == 0) {
set_opt(PROFILE,
AMF_VIDEO_ENCODER_PROFILE_CONSTRAINED_HIGH);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (strcmp(opt->name, "level") == 0) {
std::string val = opt->value;
size_t pos = val.find('.');
if (pos != std::string::npos)
val.erase(pos, 1);
int level = std::stoi(val);
set_opt(PROFILE_LEVEL, level);
} else if (strcmp(opt->name, "quality") == 0) {
if (strcmp(opt->value, "speed") == 0) {
set_enum_opt(QUALITY_PRESET, SPEED);
} else if (strcmp(opt->value, "balanced") == 0) {
set_enum_opt(QUALITY_PRESET, BALANCED);
} else if (strcmp(opt->value, "quality") == 0) {
set_enum_opt(QUALITY_PRESET, QUALITY);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (strcmp(opt->name, "rc") == 0) {
if (strcmp(opt->value, "cqp") == 0) {
set_enum_opt(RATE_CONTROL_METHOD, CONSTANT_QP);
} else if (strcmp(opt->value, "cbr") == 0) {
set_enum_opt(RATE_CONTROL_METHOD, CBR);
} else if (strcmp(opt->value, "vbr_peak") == 0) {
set_enum_opt(RATE_CONTROL_METHOD, PEAK_CONSTRAINED_VBR);
} else if (strcmp(opt->value, "vbr_latency") == 0) {
set_enum_opt(RATE_CONTROL_METHOD,
LATENCY_CONSTRAINED_VBR);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (strcmp(opt->name, "enforce_hrd") == 0) {
bool val = str_to_bool(opt->value);
set_opt(ENFORCE_HRD, val);
} else if (strcmp(opt->name, "filler_data") == 0) {
bool val = str_to_bool(opt->value);
set_opt(FILLER_DATA_ENABLE, val);
} else if (strcmp(opt->name, "vbaq") == 0) {
bool val = str_to_bool(opt->value);
set_opt(ENABLE_VBAQ, val);
} else if (strcmp(opt->name, "qp_i") == 0) {
int val = atoi(opt->value);
set_opt(QP_I, val);
} else if (strcmp(opt->name, "qp_p") == 0) {
int val = atoi(opt->value);
set_opt(QP_P, val);
} else if (strcmp(opt->name, "me_half_pel") == 0) {
bool val = str_to_bool(opt->value);
set_opt(MOTION_HALF_PIXEL, val);
} else if (strcmp(opt->name, "me_quarter_pel") == 0) {
bool val = str_to_bool(opt->value);
set_opt(MOTION_QUARTERPIXEL, val);
} else if (strcmp(opt->name, "aud") == 0) {
bool val = str_to_bool(opt->value);
set_opt(INSERT_AUD, val);
} else if (strcmp(opt->name, "max_au_size") == 0) {
int val = atoi(opt->value);
set_opt(MAX_AU_SIZE, val);
} else if (avc && strcmp(opt->name, "preanalysis") == 0) {
bool val = str_to_bool(opt->value);
set_avc_property(enc, PREENCODE_ENABLE, val);
} else if (avc && strcmp(opt->name, "qp_b") == 0) {
int val = atoi(opt->value);
set_avc_property(enc, QP_B, val);
} else if (avc && strcmp(opt->name, "frame_skipping") == 0) {
bool val = str_to_bool(opt->value);
set_avc_property(enc, RATE_CONTROL_SKIP_FRAME_ENABLE, val);
} else if (avc && strcmp(opt->name, "header_spacing") == 0) {
int val = atoi(opt->value);
set_avc_property(enc, HEADER_INSERTION_SPACING, val);
} else if (avc && strcmp(opt->name, "bf_delta_qp") == 0) {
int val = atoi(opt->value);
set_avc_property(enc, B_PIC_DELTA_QP, val);
} else if (avc && strcmp(opt->name, "bf_ref") == 0) {
bool val = str_to_bool(opt->value);
set_avc_property(enc, B_REFERENCE_ENABLE, val);
} else if (avc && strcmp(opt->name, "bf_ref_delta_qp") == 0) {
int val = atoi(opt->value);
set_avc_property(enc, REF_B_PIC_DELTA_QP, val);
} else if (avc && strcmp(opt->name, "intra_refresh_mb") == 0) {
int val = atoi(opt->value);
set_avc_property(enc, INTRA_REFRESH_NUM_MBS_PER_SLOT, val);
} else if (avc && strcmp(opt->name, "coder") == 0) {
if (strcmp(opt->value, "auto") == 0) {
set_avc_opt(CABAC_ENABLE, AMF_VIDEO_ENCODER_UNDEFINED);
} else if (strcmp(opt->value, "cavlc") == 0) {
set_avc_opt(CABAC_ENABLE, AMF_VIDEO_ENCODER_CALV);
} else if (strcmp(opt->value, "cabac") == 0) {
set_avc_opt(CABAC_ENABLE, AMF_VIDEO_ENCODER_CABAC);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (hevc && strcmp(opt->name, "profile_tier") == 0) {
if (strcmp(opt->value, "main") == 0) {
set_hevc_enum(TIER, MAIN);
} else if (strcmp(opt->value, "high") == 0) {
set_hevc_enum(TIER, HIGH);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (hevc && strcmp(opt->name, "header_insertion_mode") == 0) {
if (strcmp(opt->value, "none") == 0) {
set_hevc_enum(HEADER_INSERTION_MODE, NONE);
} else if (strcmp(opt->value, "gop") == 0) {
set_hevc_enum(HEADER_INSERTION_MODE, GOP_ALIGNED);
} else if (strcmp(opt->value, "idr") == 0) {
set_hevc_enum(HEADER_INSERTION_MODE, IDR_ALIGNED);
} else {
warn("Invalid value for %s: %s", opt->name, opt->value);
}
} else if (hevc && strcmp(opt->name, "skip_frame") == 0) {
bool val = str_to_bool(opt->value);
set_hevc_property(enc, RATE_CONTROL_SKIP_FRAME_ENABLE, val);
} else if (hevc && strcmp(opt->name, "gops_per_idr") == 0) {
int val = atoi(opt->value);
set_hevc_property(enc, NUM_GOPS_PER_IDR, val);
} else if (hevc && strcmp(opt->name, "min_qp_i") == 0) {
int val = atoi(opt->value);
set_hevc_property(enc, MIN_QP_I, val);
} else if (hevc && strcmp(opt->name, "max_qp_i") == 0) {
int val = atoi(opt->value);
set_hevc_property(enc, MAX_QP_I, val);
} else if (hevc && strcmp(opt->name, "min_qp_i") == 0) {
int val = atoi(opt->value);
set_hevc_property(enc, MIN_QP_P, val);
} else if (hevc && strcmp(opt->name, "max_qp_i") == 0) {
int val = atoi(opt->value);
set_hevc_property(enc, MAX_QP_P, val);
} else {
wchar_t wname[256];
int val;
bool is_bool = false;
if (astrcmpi(opt->value, "true") == 0) {
is_bool = true;
val = 1;
} else if (astrcmpi(opt->value, "false") == 0) {
is_bool = true;
val = 0;
} else {
val = atoi(opt->value);
}
os_utf8_to_wcs(opt->name, 0, wname, _countof(wname));
if (is_bool) {
bool bool_val = (bool)val;
set_amf_property(enc, wname, bool_val);
} else {
set_amf_property(enc, wname, val);
}
}
}

1732
plugins/obs-ffmpeg/texture-amf.cpp Normal file
View File

File diff suppressed because it is too large Load Diff