Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package AMF for openSUSE:Factory checked in at 2026-05-10 16:47:19 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/AMF (Old) and /work/SRC/openSUSE:Factory/.AMF.new.1966 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "AMF" Sun May 10 16:47:19 2026 rev:7 rq:1352188 version:1.5.2 Changes: -------- --- /work/SRC/openSUSE:Factory/AMF/AMF.changes 2026-02-16 13:16:17.523413850 +0100 +++ /work/SRC/openSUSE:Factory/.AMF.new.1966/AMF.changes 2026-05-10 16:47:57.871895829 +0200 @@ -1,0 +2,7 @@ +Sat May 09 10:48:17 UTC 2026 - ecsos <[email protected]> + +- Update to version 1.5.2: + * AMF v1.5.2 release + * Add `static` to fix errors when an inline function is used in multiple files (#582) + +------------------------------------------------------------------- Old: ---- AMF-1.5.0.obscpio New: ---- AMF-1.5.2.obscpio ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ AMF.spec ++++++ --- /var/tmp/diff_new_pack.IgFHUS/_old 2026-05-10 16:47:58.411917929 +0200 +++ /var/tmp/diff_new_pack.IgFHUS/_new 2026-05-10 16:47:58.415918092 +0200 @@ -1,7 +1,7 @@ # # spec file for package AMF # -# Copyright (c) 2024 SUSE LLC +# Copyright (c) 2026 SUSE LLC and contributors # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,7 +17,7 @@ Name: AMF -Version: 1.5.0 +Version: 1.5.2 Release: 0 Summary: Advanced Media Framework (AMF) SDK License: MIT ++++++ AMF-1.5.0.obscpio -> AMF-1.5.2.obscpio ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/doc/AMF_Video_Converter_API.md new/AMF-1.5.2/amf/doc/AMF_Video_Converter_API.md --- old/AMF-1.5.0/amf/doc/AMF_Video_Converter_API.md 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/doc/AMF_Video_Converter_API.md 2026-05-06 17:01:13.000000000 +0200 @@ -20,13 +20,13 @@ ### Copyright Notice -© 2014-2022 Advanced Micro Devices, Inc. All rights reserved +© 2014-2025 Advanced Micro Devices, Inc. All rights reserved 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) 2022 Advanced Micro Devices, Inc. All rights reserved. +Copyright (c) 2022-2025 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: @@ -58,7 +58,7 @@ ## 2 AMF Video Converter Component -The Video Converter accepts input frames stored in `AMFSurface` objects wrapping DirectX 9 surfaces, DirectX 11 textures, OpenGL or OpenCL surfaces. The output is placed in `AMFSurface` objects wrapping DirectX 9 surfaces, DirectX 11 textures, OpenGL or OpenCL surfaces, depending on the component configuration. +The Video Converter accepts input frames stored in `AMFSurface` objects wrapping DirectX 9 surfaces, DirectX 11 textures, DirectX 12 textures, Vulkan surfaces, OpenGL or OpenCL surfaces. The output is placed in `AMFSurface` objects wrapping DirectX 9 surfaces, DirectX 11 textures, DirectX 12 textures, Vulkan surfaces, OpenGL or OpenCL surfaces, depending on the component configuration. Include `public/include/components/VideoConverter.h` @@ -71,6 +71,8 @@ 2. DirectX 9 3. OpenGL 4. OpenCL + 5. DirectX 12 + 6. Vulkan 2. Configure the Converter component by setting the necessary properties using the `AMFPropertyStorage::SetProperty` method on the converter object. 3. Call the `AMFComponent::Init` method of the converter object. @@ -90,6 +92,8 @@ | SCALE | amf_int64 | | FORCE_OUTPUT_SURFACE_SIZE | amf_bool | | COLOR_PROFILE | amf_int64 | +| COMPUTE_DEVICE | amf_int64 | +| INPUT_TONEMAPPING | amf_int64 | <p align="center"> Table 1. AMF Video Converter parameters which configure input and output @@ -101,13 +105,21 @@ `AMF_VIDEO_CONVERTER_OUTPUT_FORMAT` **Values:** -`AMF_SURFACE_UNKNOWN`, `AMF_SURFACE_NV12`, `AMF_SURFACE_BGRA`, `AMF_SURFACE_YUV420P` (progressive only) +**8-bit formats:** `AMF_SURFACE_NV12`, `AMF_SURFACE_BGRA`, `AMF_SURFACE_ARGB`, `AMF_SURFACE_RGBA`, `AMF_SURFACE_YUV420P` (progressive only), `AMF_SURFACE_YV12`, `AMF_SURFACE_YUY2`, `AMF_SURFACE_UYVY`, `AMF_SURFACE_AYUV` + +**10-bit formats:** `AMF_SURFACE_P010`, `AMF_SURFACE_Y210`, `AMF_SURFACE_Y410`, `AMF_SURFACE_R10G10B10A2` + +**12-bit formats:** `AMF_SURFACE_P012` + +**16-bit formats:** `AMF_SURFACE_P016`, `AMF_SURFACE_Y416`, `AMF_SURFACE_RGBA_F16` + +**Other:** `AMF_SURFACE_UNKNOWN` **Default Value:** `AMF_SURFACE_UNKNOWN` **Description:** -Specifies the output color format/space. +Specifies the output color format/space. Support is hardware dependent. --- @@ -115,7 +127,7 @@ `AMF_VIDEO_CONVERTER_MEMORY_TYPE` **Values:** -`AMF_MEMORY_DX11`, `AMF_MEMORY_DX9`, `AMF_MEMORY_UNKNOWN` (retain the same memory type as input (no interop)) +`AMF_MEMORY_DX11`, `AMF_MEMORY_DX9`, `AMF_MEMORY_DX12`, `AMF_MEMORY_VULKAN`, `AMF_MEMORY_UNKNOWN` (retain the same memory type as input (no interop)) **Default Value:** `AMF_MEMORY_UNKNOWN` @@ -244,6 +256,41 @@ --- +**Name:** +`AMF_VIDEO_CONVERTER_COMPUTE_DEVICE` + +**Values:** +`AMF_MEMORY_TYPE` (device type) + +**Default Value:** +`AMF_MEMORY_UNKNOWN` (auto) + +**Description:** +Specifies the compute device type to use for video conversion. + +--- + +**Name:** +`AMF_VIDEO_CONVERTER_INPUT_TONEMAPPING` + +**Values:** +`AMF_VIDEO_CONVERTER_TONEMAPPING_ENUM`: + - `AMF_VIDEO_CONVERTER_TONEMAPPING_UNDEFINED` – Undefined/unspecified tone mapping + - `AMF_VIDEO_CONVERTER_TONEMAPPING_COPY` – Copy without tone mapping + - `AMF_VIDEO_CONVERTER_TONEMAPPING_AMD` – AMD proprietary tone mapping algorithm + - `AMF_VIDEO_CONVERTER_TONEMAPPING_LINEAR` – Linear tone mapping + - `AMF_VIDEO_CONVERTER_TONEMAPPING_GAMMA` – Gamma-based tone mapping + - `AMF_VIDEO_CONVERTER_TONEMAPPING_REINHARD` – Reinhard tone mapping + - `AMF_VIDEO_CONVERTER_TONEMAPPING_2390` – ITU-R BT.2390 tone mapping + +**Default Value:** +`AMF_VIDEO_CONVERTER_TONEMAPPING_UNDEFINED` + +**Description:** +Specifies the tone mapping algorithm to apply to HDR input content when converting to SDR output formats. + +--- + The `COLOR_PROFILE` parameter can fully describe a surface in SDR use case. For HDR use case the `TRANSFER_CHARACTERISTIC`, `COLOR_PRIMARIES` and `NOMINAL_RANGE` parameters describe the surface. | Name (prefix "AMF_VIDEO_CONVERTER_") | Type | diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/doc/AMF_Video_Encode_API.md new/AMF-1.5.2/amf/doc/AMF_Video_Encode_API.md --- old/AMF-1.5.0/amf/doc/AMF_Video_Encode_API.md 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/doc/AMF_Video_Encode_API.md 2026-05-06 17:01:13.000000000 +0200 @@ -620,7 +620,7 @@ | LOWLATENCY_MODE | amf_bool | | FRAMESIZE | AMFSize | | ASPECT_RATIO | AMFRatio | -| MAX_REFRAMES | amf_int64 | +| MAX_NUM_REFRAMES | amf_int64 | | MAX_CONSECUTIVE_BPICTURES | amf_int64 | | ADAPTIVE_MINIGOP | amf_bool | | PRE_ANALYSIS_ENABLE | amf_bool | @@ -802,7 +802,12 @@ `0` **Description:** -Maximum number of consecutive B Pictures. It is suggested to set this value to `3` if `AMF_VIDEO_ENCODER_B_PIC_PATTERN` is not `0` as well as to enable Adaptive MiniGOP and PA. +Maximum number of consecutive B Pictures. +It is recommended to set this value to `3` if `AMF_VIDEO_ENCODER_B_PIC_PATTERN` is not `0`, or both Adaptive MiniGOP and PA are enabled. +If users specify either `AMF_VIDEO_ENCODER_B_PIC_PATTERN` or `AMF_VIDEO_ENCODER_ADAPTIVE_MINIGOP` but do not explicitly set `AMF_VIDEO_ENCODER_MAX_CONSECUTIVE_BPICTURES`, this property will default to: +- the value of `AMF_VIDEO_ENCODER_B_PIC_PATTERN` (if `AMF_VIDEO_ENCODER_B_PIC_PATTERN` is set), or +- `3` (if `AMF_VIDEO_ENCODER_ADAPTIVE_MINIGOP` is set). +- prioritizes `AMF_VIDEO_ENCODER_ADAPTIVE_MINIGOP` over `AMF_VIDEO_ENCODER_B_PIC_PATTERN` --- @@ -816,7 +821,7 @@ `false` **Description:** -Disable/Enable Adaptive MiniGOP, can enable with PA enabled. +Disable/Enable Adaptive MiniGOP. Requires PA to be enabled with a minimum LOOKAHEAD_BUFFER_DEPTH size of 1. --- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/doc/AMF_Video_Encode_AV1_API.md new/AMF-1.5.2/amf/doc/AMF_Video_Encode_AV1_API.md --- old/AMF-1.5.0/amf/doc/AMF_Video_Encode_AV1_API.md 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/doc/AMF_Video_Encode_AV1_API.md 2026-05-06 17:01:13.000000000 +0200 @@ -740,6 +740,11 @@ **Description:** Maximum number of consecutive B Pictures. +It is recommended to set this value to `3` if `AMF_VIDEO_ENCODER_AV1_B_PIC_PATTERN` is not `0`, or both Adaptive MiniGOP and PA are enabled. +If users specify either `AMF_VIDEO_ENCODER_AV1_B_PIC_PATTERN` or `AMF_VIDEO_ENCODER_AV1_ADAPTIVE_MINIGOP` but do not explicitly set `AMF_VIDEO_ENCODER_AV1_MAX_CONSECUTIVE_BPICTURES`, this property will default to: +- the value of `AMF_VIDEO_ENCODER_AV1_B_PIC_PATTERN` (if `AMF_VIDEO_ENCODER_AV1_B_PIC_PATTERN` is set), or +- `3` (if `AMF_VIDEO_ENCODER_AV1_ADAPTIVE_MINIGOP` is set). +- prioritizes `AMF_VIDEO_ENCODER_AV1_ADAPTIVE_MINIGOP` over `AMF_VIDEO_ENCODER_AV1_B_PIC_PATTERN` --- @@ -753,7 +758,7 @@ `false` **Description:** -Disable/Enable Adaptive MiniGOP, can enable with PA enabled. +Disable/Enable Adaptive MiniGOP. Requires PA to be enabled with a minimum LOOKAHEAD_BUFFER_DEPTH size of 1. --- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/doc/AMF_Video_PreAnalysis_API.md new/AMF-1.5.2/amf/doc/AMF_Video_PreAnalysis_API.md --- old/AMF-1.5.0/amf/doc/AMF_Video_PreAnalysis_API.md 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/doc/AMF_Video_PreAnalysis_API.md 2026-05-06 17:01:13.000000000 +0200 @@ -132,6 +132,8 @@ Table 1. AMF PA properties in encoder mode </p> +**Note:** Property constraints (min/max values, allowed enum values, etc.) can be queried through the `AMFPropertyStorageEx` interface using `AMFPropertyInfo`. See the [AMF API Reference](AMF_API_Reference.md#22143-amfpropertystorageex) for details. + --- **Name:** @@ -200,7 +202,7 @@ `false` **Description:** -Enables static scene detection. A frame in a static scene will be encoded as a skip frame if the reference frame quality is acceptable. Refer to AMF_PA_MAX_QP_BEFORE_FORCE_SKIP for details. +Enables static scene detection. A frame in a static scene will be encoded as a skip frame if the reference frame quality is acceptable. Refer to AMF_PA_MAX_QP_BEFORE_FORCE_SKIP for details. Requires a minimum `LOOKAHEAD_BUFFER_DEPTH` size of 1. --- @@ -292,18 +294,18 @@ `LOOKAHEAD_BUFFER_DEPTH` **Values:** -`0 - MAX_LOOKAHEAD_DEPTH` +`0 - 41` **Default Value associated with usages:** - - Transcoding: `0` - - Ultra low latency: `0` - - Low latency: `0` - - Webcam: `0` + - Transcoding: `11` + - Ultra low latency: `1` + - Low latency: `1` + - Webcam: `1` - HQ: `11` - - HQLL: `0` + - HQLL: `1` **Description:** -Sets the PA lookahead buffer size. The longer the buffer depth, the better the quality and the longer the latency. Suggested lookahead buffer sizes are 11(short), 21(medium) or 41(long). +Sets the PA lookahead buffer size. The longer the buffer depth, the better the quality and the longer the latency. Suggested lookahead buffer sizes are 1(very short), 11(short), 21(medium) or 41(long). Some PA features require a minimum size of 1 to operate correctly. --- @@ -336,7 +338,7 @@ - HQLL: `AMF_PA_TAQ_MODE_NONE` **Description:** -Sets the temporal adaptive quantization mode. MODE_1 is suitable for non-gaming applications whereas MODE_2 is suitable for gaming applications. MODE_2 is supported on encoder memory type DX11. +Sets the temporal adaptive quantization mode. MODE_1 is suitable for non-gaming applications whereas MODE_2 is suitable for gaming applications. MODE_2 is supported on encoder memory type DX11. Requires a minimum `LOOKAHEAD_BUFFER_DEPTH` size of 1. --- @@ -460,7 +462,7 @@ `false` **Description:** -Enables static scene detection. A frame in a static scene will be encoded as a skip frame if the reference frame quality is acceptable. Refer to AMF_PA_MAX_QP_BEFORE_FORCE_SKIP for details. +Enables static scene detection. A frame in a static scene will be encoded as a skip frame if the reference frame quality is acceptable. Refer to AMF_PA_MAX_QP_BEFORE_FORCE_SKIP for details. Requires a minimum `LOOKAHEAD_BUFFER_DEPTH` size of 1. --- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/doc/README.md new/AMF-1.5.2/amf/doc/README.md --- old/AMF-1.5.0/amf/doc/README.md 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/doc/README.md 2026-05-06 17:01:13.000000000 +0200 @@ -3,19 +3,25 @@ AMF is a light-weight, portable multimedia framework that abstracts away most of the platform and API-specific details and allows for easy implementation of multimedia applications using a variety of technologies, such as DirectX 11, OpenGL, and OpenCL and facilitates an efficient interop between them. <div> - <a href="https://github.com/GPUOpen-LibrariesAndSDKs/AMF/releases/latest/";><img src="http://gpuopen-librariesandsdks.github.io/media/latest-release-button.svg"; alt="Latest release" title="Latest release"></a> + <a href="https://www.amd.com/en/support/download/";><img src="https://img.shields.io/badge/Windows%20Driver-Download-0078D6?style=for-the-badge&logo=windows"; alt="Windows Driver" title="Windows Driver"></a> + <a href="https://repo.radeon.com/amf/";><img src="https://img.shields.io/badge/Linux%20Driver-Download-FCC624?style=for-the-badge&logo=linux&logoColor=black"; alt="Linux Driver" title="Linux Driver"></a> </div> +## Table of Contents +- [Prerequisites](#prerequisites) +- [Version History](#version-history) +- [Getting Started](#getting-started) +- [Third-Party Software](#third-party-software) +- [Attribution](#attribution) + ### Prerequisites * Windows - * Windows® 7 (SP1 with the Platform Update) (AMF v1.4.18.0 and older) - * Windows® 8.1 (AMF v1.4.0.0 and older) * Windows® 10, or Windows® 11 * Windows Subsystem for Linux (DX12 Decoder and Converter Only) - * Visual Studio® 2019 + * Visual Studio® 2022 * Linux - * RHEL 9.6 / 10 - * Ubuntu 24.04.2 / 22.04.5 + * RHEL 9.8 / 10.2 + * Ubuntu 24.04.4 / 26.04.0 * SLED/SLES 15.7 / 16 * Driver and AMF component installation instructions are available on the [Wiki page](https://github.com/GPUOpen-LibrariesAndSDKs/AMF/wiki). @@ -32,8 +38,14 @@ | Ubuntu 20.04.0 | 20.20 | | \**All supported distros* | 20.40 | + +### Version History * AMF SDK is backward compatible with all previous driver versions. -* Version 1.5.0: AMD Radeon Software Adrenalin Edition 25.10.2 (25.20.21.01) or newer. Added 4:4:4/4:2:2 chroma subsampling support for VideoConverter color space conversion and scaling. Samples updated to VS 2022. +* Version 1.5.2: AMD Radeon Software Adrenalin Edition 26.5.1 (26.10.07.01) or newer. Updated FFmpeg to 8.0.1. + + **Note:** The AMF Linux release will be available shortly after the Radeon Software Adrenalin Edition driver release. + +* Version 1.5.0: AMD Radeon Software Adrenalin Edition 25.10.1 (25.20.21.01) or newer. Added 4:4:4/4:2:2 chroma subsampling support for VideoConverter color space conversion and scaling. Samples updated to VS 2022. * Version 1.4.36: AMD Radeon Software Adrenalin Edition 25.1.1 (24.30.31.03) or newer. Added B-frame support and picture management options for AV1 encoder. New high quality presets for HEVC and AVC encoders. New SimpleFRC sample app. * Version 1.4.35: AMD Radeon Software Adrenalin Edition 24.9.1 (24.20.11.01) or newer. Added multi-HW instance encoder mode. Updated FFmpeg to 7.0. Added split frame encoding. * Version 1.4.34: AMD Radeon Software Adrenalin Edition 24.6.1 (24.10.21.01) or newer. Added Linux support for DVR sample. New HEVC header insertion mode. Stable support for RADV drivers for AMF on Linux in VideoConverter/HQScaler/VideoEncoder and experimental for decoder. Added DX11 support for FRC component. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/components/FRC.h new/AMF-1.5.2/amf/public/include/components/FRC.h --- old/AMF-1.5.0/amf/public/include/components/FRC.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/components/FRC.h 2026-05-06 17:01:13.000000000 +0200 @@ -44,6 +44,7 @@ FRC_ENGINE_DX12 = 1, FRC_ENGINE_OPENCL = 2, FRC_ENGINE_DX11 = 3, + FRC_ENGINE_VULKAN = 4, }; // Select present mode for FRC diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/components/HQScaler.h new/AMF-1.5.2/amf/public/include/components/HQScaler.h --- old/AMF-1.5.0/amf/public/include/components/HQScaler.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/components/HQScaler.h 2026-05-06 17:01:13.000000000 +0200 @@ -58,7 +58,7 @@ #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_KEEP_ASPECT_RATIO L"KeepAspectRatio" // bool (default=true) 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. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/components/PreAnalysis.h new/AMF-1.5.2/amf/public/include/components/PreAnalysis.h --- old/AMF-1.5.0/amf/public/include/components/PreAnalysis.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/components/PreAnalysis.h 2026-05-06 17:01:13.000000000 +0200 @@ -98,17 +98,17 @@ #define AMF_PA_QUERY_TIMEOUT L"PAQueryTimeout" // amf_int64; default = 0 (no wait); timeout for QueryOutput call in ms. -#define AMF_PA_SCENE_CHANGE_DETECTION_ENABLE L"PASceneChangeDetectionEnable" // bool (default : True) - Enable Scene Change Detection GPU algorithm -#define AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY L"PASceneChangeDetectionSensitivity" // AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_ENUM (default : Medium) - Scene Change Detection Sensitivity -#define AMF_PA_STATIC_SCENE_DETECTION_ENABLE L"PAStaticSceneDetectionEnable" // bool (default : False) - Enable Skip Detection GPU algorithm -#define AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY L"PAStaticSceneDetectionSensitivity" // AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_ENUM (default : High) - Allowable absolute difference between pixels (sample counts) -#define AMF_PA_FRAME_SAD_ENABLE L"PAFrameSadEnable" // bool (default : True) - Enable Frame SAD algorithm -#define AMF_PA_ACTIVITY_TYPE L"PAActivityType" // AMF_PA_ACTIVITY_TYPE_ENUM (default : Calculate on Y) - Block activity calculation mode -#define AMF_PA_LTR_ENABLE L"PALongTermReferenceEnable" // bool (default : False) - Enable Automatic Long Term Reference frame management -#define AMF_PA_LOOKAHEAD_BUFFER_DEPTH L"PALookAheadBufferDepth" // amf_uint64 (default : 0) Values: [0, MAX_LOOKAHEAD_DEPTH] - PA lookahead buffer size -#define AMF_PA_PAQ_MODE L"PAPerceptualAQMode" // AMF_PA_PAQ_MODE_ENUM (default : AMF_PA_PAQ_MODE_NONE) - Perceptual AQ mode -#define AMF_PA_TAQ_MODE L"PATemporalAQMode" // AMF_PA_TAQ_MODE_ENUM (default: AMF_PA_TAQ_MODE_NONE) - Temporal AQ mode -#define AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE L"PAHighMotionQualityBoostMode" // AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE_ENUM (default: None) - High motion quality boost mode +#define AMF_PA_SCENE_CHANGE_DETECTION_ENABLE L"PASceneChangeDetectionEnable" // bool (default : True) - Enable Scene Change Detection GPU algorithm +#define AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY L"PASceneChangeDetectionSensitivity" // AMF_PA_SCENE_CHANGE_DETECTION_SENSITIVITY_ENUM (default : Medium) - Scene Change Detection Sensitivity +#define AMF_PA_STATIC_SCENE_DETECTION_ENABLE L"PAStaticSceneDetectionEnable" // bool (default : False) - Enable Skip Detection GPU algorithm +#define AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY L"PAStaticSceneDetectionSensitivity" // AMF_PA_STATIC_SCENE_DETECTION_SENSITIVITY_ENUM (default : High) - Allowable absolute difference between pixels (sample counts) +#define AMF_PA_FRAME_SAD_ENABLE L"PAFrameSadEnable" // bool (default : True) - Enable Frame SAD algorithm +#define AMF_PA_ACTIVITY_TYPE L"PAActivityType" // AMF_PA_ACTIVITY_TYPE_ENUM (default : Calculate on Y) - Block activity calculation mode +#define AMF_PA_LTR_ENABLE L"PALongTermReferenceEnable" // bool (default : False) - Enable Automatic Long Term Reference frame management +#define AMF_PA_LOOKAHEAD_BUFFER_DEPTH L"PALookAheadBufferDepth" // amf_uint64 (default : depends on USAGE) Values: [0, MAX_LOOKAHEAD_DEPTH] - PA lookahead buffer size +#define AMF_PA_PAQ_MODE L"PAPerceptualAQMode" // AMF_PA_PAQ_MODE_ENUM (default : AMF_PA_PAQ_MODE_NONE) - Perceptual AQ mode +#define AMF_PA_TAQ_MODE L"PATemporalAQMode" // AMF_PA_TAQ_MODE_ENUM (default: AMF_PA_TAQ_MODE_NONE) - Temporal AQ mode +#define AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE L"PAHighMotionQualityBoostMode" // AMF_PA_HIGH_MOTION_QUALITY_BOOST_MODE_ENUM (default: None) - High motion quality boost mode /////////////////////////////////////////// // the following properties are available @@ -117,20 +117,20 @@ // 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_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 +#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 in standalone mode -#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 when PA is standalone -#define AMF_PA_STATIC_SCENE_DETECT L"PAStaticSceneDetect" // bool - True/False - available if AMF_PA_STATIC_SCENE_DETECTION_ENABLE was set to True when PA is standalone +#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 when PA is standalone +#define AMF_PA_STATIC_SCENE_DETECT L"PAStaticSceneDetect" // bool - True/False - available if AMF_PA_STATIC_SCENE_DETECTION_ENABLE was set to True when PA is standalone #endif //#ifndef AMFPreAnalysis_h diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/components/VideoConverter.h new/AMF-1.5.2/amf/public/include/components/VideoConverter.h --- old/AMF-1.5.0/amf/public/include/components/VideoConverter.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/components/VideoConverter.h 2026-05-06 17:01:13.000000000 +0200 @@ -62,7 +62,7 @@ -#define AMF_VIDEO_CONVERTER_OUTPUT_FORMAT L"OutputFormat" // Values : AMF_SURFACE_NV12 or AMF_SURFACE_BGRA or AMF_SURFACE_YUV420P +#define AMF_VIDEO_CONVERTER_OUTPUT_FORMAT L"OutputFormat" // Values : AMF_SURFACE_ formats (NV12, BGRA, ARGB, RGBA, YUV420P, YV12, YUY2, UYVY, AYUV, P010, Y210, Y410, R10G10B10A2, P012, P016, Y416, RGBA_F16) #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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/core/AudioBuffer.h new/AMF-1.5.2/amf/public/include/core/AudioBuffer.h --- old/AMF-1.5.0/amf/public/include/core/AudioBuffer.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/core/AudioBuffer.h 2026-05-06 17:01:13.000000000 +0200 @@ -85,7 +85,7 @@ } AMF_AUDIO_CHANNEL_LAYOUT; // get the most common layout for a given number of speakers - inline int GetDefaultChannelLayout(int channels) + static inline int GetDefaultChannelLayout(int channels) { switch (channels) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/core/Buffer.h new/AMF-1.5.2/amf/public/include/core/Buffer.h --- old/AMF-1.5.0/amf/public/include/core/Buffer.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/core/Buffer.h 2026-05-06 17:01:13.000000000 +0200 @@ -78,6 +78,7 @@ }; #else // #if defined(__cplusplus) typedef struct AMFBuffer AMFBuffer; + typedef struct AMFBuffer1 AMFBuffer1; typedef struct AMFBufferObserver AMFBufferObserver; typedef struct AMFBufferObserverVtbl @@ -131,8 +132,30 @@ typedef AMFInterfacePtr_T<AMFBuffer> AMFBufferPtr; //---------------------------------------------------------------------------------------------- + + //---------------------------------------------------------------------------------------------- + // AMFBuffer1 interface + //---------------------------------------------------------------------------------------------- + class AMF_NO_VTABLE AMFBuffer1 : public AMFBuffer + { + public: + AMF_DECLARE_IID(0x8051a17d, 0x462d, 0x4f09, 0xb8, 0x42, 0x3c, 0x72, 0xf7, 0xa8, 0x5b, 0x24) + + virtual amf_uint64 AMF_STD_CALL GetOffset() = 0; + virtual AMF_RESULT AMF_STD_CALL SetOffset(amf_uint64 offset) = 0; + + virtual AMF_RESULT AMF_STD_CALL Map(AMF_MEMORY_CPU_ACCESS flags, void** ppData) = 0; // only READ and WRITE flags are valid + virtual AMF_RESULT AMF_STD_CALL Unmap() = 0; + }; + //---------------------------------------------------------------------------------------------- + // smart pointer + //---------------------------------------------------------------------------------------------- + typedef AMFInterfacePtr_T<AMFBuffer1> AMFBuffer1Ptr; + //---------------------------------------------------------------------------------------------- + + #else // #if defined(__cplusplus) - AMF_DECLARE_IID(AMFBuffer, 0xb04b7248, 0xb6f0, 0x4321, 0xb6, 0x91, 0xba, 0xa4, 0x74, 0xf, 0x9f, 0xcb) + AMF_DECLARE_IID(AMFBuffer, 0xb04b7248, 0xb6f0, 0x4321, 0xb6, 0x91, 0xba, 0xa4, 0x74, 0xf, 0x9f, 0xcb) typedef struct AMFBufferVtbl { @@ -187,6 +210,70 @@ const AMFBufferVtbl *pVtbl; }; + + AMF_DECLARE_IID(AMFBuffer1, 0x8051a17d, 0x462d, 0x4f09, 0xb8, 0x42, 0x3c, 0x72, 0xf7, 0xa8, 0x5b, 0x24) + + typedef struct AMFBuffer1Vtbl + { + // AMFInterface interface + amf_long (AMF_STD_CALL *Acquire)(AMFBuffer1* pThis); + amf_long (AMF_STD_CALL *Release)(AMFBuffer1* pThis); + enum AMF_RESULT (AMF_STD_CALL *QueryInterface)(AMFBuffer1* pThis, const struct AMFGuid *interfaceID, void** ppInterface); + + // AMFPropertyStorage interface + AMF_RESULT (AMF_STD_CALL *SetProperty)(AMFBuffer1* pThis, const wchar_t* name, AMFVariantStruct value); + AMF_RESULT (AMF_STD_CALL *GetProperty)(AMFBuffer1* pThis, const wchar_t* name, AMFVariantStruct* pValue); + amf_bool (AMF_STD_CALL *HasProperty)(AMFBuffer1* pThis, const wchar_t* name); + amf_size (AMF_STD_CALL *GetPropertyCount)(AMFBuffer1* pThis); + AMF_RESULT (AMF_STD_CALL *GetPropertyAt)(AMFBuffer1* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue); + AMF_RESULT (AMF_STD_CALL *Clear)(AMFBuffer1* pThis); + AMF_RESULT (AMF_STD_CALL *AddTo)(AMFBuffer1* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep); + AMF_RESULT (AMF_STD_CALL *CopyTo)(AMFBuffer1* pThis, AMFPropertyStorage* pDest, amf_bool deep); + void (AMF_STD_CALL *AddObserver)(AMFBuffer1* pThis, AMFPropertyStorageObserver* pObserver); + void (AMF_STD_CALL *RemoveObserver)(AMFBuffer1* pThis, AMFPropertyStorageObserver* pObserver); + + // AMFData interface + + AMF_MEMORY_TYPE (AMF_STD_CALL *GetMemoryType)(AMFBuffer1* pThis); + + AMF_RESULT (AMF_STD_CALL *Duplicate)(AMFBuffer1* pThis, AMF_MEMORY_TYPE type, AMFData** ppData); + AMF_RESULT (AMF_STD_CALL *Convert)(AMFBuffer1* pThis, AMF_MEMORY_TYPE type); // optimal interop if possilble. Copy through host memory if needed + AMF_RESULT (AMF_STD_CALL *Interop)(AMFBuffer1* 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)(AMFBuffer1* pThis); + + amf_bool (AMF_STD_CALL *IsReusable)(AMFBuffer1* pThis); + + void (AMF_STD_CALL *SetPts)(AMFBuffer1* pThis, amf_pts pts); + amf_pts (AMF_STD_CALL *GetPts)(AMFBuffer1* pThis); + void (AMF_STD_CALL *SetDuration)(AMFBuffer1* pThis, amf_pts duration); + amf_pts (AMF_STD_CALL *GetDuration)(AMFBuffer1* pThis); + + // AMFBuffer interface + + AMF_RESULT (AMF_STD_CALL *SetSize)(AMFBuffer1* pThis, amf_size newSize); + amf_size (AMF_STD_CALL *GetSize)(AMFBuffer1* pThis); + void* (AMF_STD_CALL *GetNative)(AMFBuffer1* pThis); + + // Observer management + void (AMF_STD_CALL *AddObserver_Buffer)(AMFBuffer1* pThis, AMFBufferObserver* pObserver); + void (AMF_STD_CALL *RemoveObserver_Buffer)(AMFBuffer1* pThis, AMFBufferObserver* pObserver); + + // AMFBuffer1 interface + + amf_uint64 (AMF_STD_CALL *GetOffset)(AMFBuffer1* pThis); + AMF_RESULT (AMF_STD_CALL *SetOffset)(AMFBuffer1* pThis, amf_uint64 offset); + + AMF_RESULT (AMF_STD_CALL *Map)(AMFBuffer1* pThis, AMF_MEMORY_CPU_ACCESS flags, void** ppData); // only READ and WRITE flags are valid + AMF_RESULT (AMF_STD_CALL *Unmap)(AMFBuffer1* pThis); + + } AMFBuffer1Vtbl; + + struct AMFBuffer1 + { + const AMFBuffer1Vtbl *pVtbl; + }; + #endif // #if defined(__cplusplus) #if defined(__cplusplus) } // namespace diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/core/Platform.h new/AMF-1.5.2/amf/public/include/core/Platform.h --- old/AMF-1.5.0/amf/public/include/core/Platform.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/core/Platform.h 2026-05-06 17:01:13.000000000 +0200 @@ -95,12 +95,6 @@ // #error Need to define AMF_ALIGN #endif -#ifndef _WIN32 -typedef signed int HRESULT; -#define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0) -#define FAILED(hr) (((HRESULT)(hr)) < 0) -#endif - #include <stdio.h> #include <stdint.h> #include <string.h> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/core/Surface.h new/AMF-1.5.2/amf/public/include/core/Surface.h --- old/AMF-1.5.0/amf/public/include/core/Surface.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/core/Surface.h 2026-05-06 17:01:13.000000000 +0200 @@ -164,6 +164,7 @@ }; #else // #if defined(__cplusplus) typedef struct AMFSurface AMFSurface; + typedef struct AMFSurface1 AMFSurface1; typedef struct AMFSurfaceObserver AMFSurfaceObserver; typedef struct AMFSurfaceObserverVtbl @@ -223,8 +224,29 @@ //---------------------------------------------------------------------------------------------- typedef AMFInterfacePtr_T<AMFSurface> AMFSurfacePtr; //---------------------------------------------------------------------------------------------- + + + //---------------------------------------------------------------------------------------------- + // AMFSurface1 interface + //---------------------------------------------------------------------------------------------- + class AMF_NO_VTABLE AMFSurface1 : public AMFSurface + { + public: + AMF_DECLARE_IID(0xd236db3e, 0x6945, 0x4158, 0xad, 0x29, 0x4a, 0x8a, 0x38, 0x6b, 0xfc, 0x61) + + virtual AMF_RESULT AMF_STD_CALL Map(AMF_MEMORY_CPU_ACCESS flags, amf_size planeCount, amf_size* pRowPitches, void** ppData) = 0; // only READ and WRITE flags are valid + virtual AMF_RESULT AMF_STD_CALL Unmap() = 0; + }; + //---------------------------------------------------------------------------------------------- + // smart pointer + //---------------------------------------------------------------------------------------------- + typedef AMFInterfacePtr_T<AMFSurface1> AMFSurface1Ptr; + //---------------------------------------------------------------------------------------------- + + #else // #if defined(__cplusplus) - AMF_DECLARE_IID(AMFSurface, 0x3075dbe3, 0x8718, 0x4cfa, 0x86, 0xfb, 0x21, 0x14, 0xc0, 0xa5, 0xa4, 0x51) + AMF_DECLARE_IID(AMFSurface, 0x3075dbe3, 0x8718, 0x4cfa, 0x86, 0xfb, 0x21, 0x14, 0xc0, 0xa5, 0xa4, 0x51) + typedef struct AMFSurfaceVtbl { // AMFInterface interface @@ -287,6 +309,76 @@ { const AMFSurfaceVtbl *pVtbl; }; + + + AMF_DECLARE_IID(AMFSurface1, 0xd236db3e, 0x6945, 0x4158, 0xad, 0x29, 0x4a, 0x8a, 0x38, 0x6b, 0xfc, 0x61) + + typedef struct AMFSurface1Vtbl + { + // AMFInterface interface + amf_long (AMF_STD_CALL *Acquire)(AMFSurface1* pThis); + amf_long (AMF_STD_CALL *Release)(AMFSurface1* pThis); + enum AMF_RESULT (AMF_STD_CALL *QueryInterface)(AMFSurface1* pThis, const struct AMFGuid *interfaceID, void** ppInterface); + + // AMFPropertyStorage interface + AMF_RESULT (AMF_STD_CALL *SetProperty)(AMFSurface1* pThis, const wchar_t* name, AMFVariantStruct value); + AMF_RESULT (AMF_STD_CALL *GetProperty)(AMFSurface1* pThis, const wchar_t* name, AMFVariantStruct* pValue); + amf_bool (AMF_STD_CALL *HasProperty)(AMFSurface1* pThis, const wchar_t* name); + amf_size (AMF_STD_CALL *GetPropertyCount)(AMFSurface1* pThis); + AMF_RESULT (AMF_STD_CALL *GetPropertyAt)(AMFSurface1* pThis, amf_size index, wchar_t* name, amf_size nameSize, AMFVariantStruct* pValue); + AMF_RESULT (AMF_STD_CALL *Clear)(AMFSurface1* pThis); + AMF_RESULT (AMF_STD_CALL *AddTo)(AMFSurface1* pThis, AMFPropertyStorage* pDest, amf_bool overwrite, amf_bool deep); + AMF_RESULT (AMF_STD_CALL *CopyTo)(AMFSurface1* pThis, AMFPropertyStorage* pDest, amf_bool deep); + void (AMF_STD_CALL *AddObserver)(AMFSurface1* pThis, AMFPropertyStorageObserver* pObserver); + void (AMF_STD_CALL *RemoveObserver)(AMFSurface1* pThis, AMFPropertyStorageObserver* pObserver); + + // AMFData interface + + AMF_MEMORY_TYPE (AMF_STD_CALL *GetMemoryType)(AMFSurface1* pThis); + + AMF_RESULT (AMF_STD_CALL *Duplicate)(AMFSurface1* pThis, AMF_MEMORY_TYPE type, AMFData** ppData); + AMF_RESULT (AMF_STD_CALL *Convert)(AMFSurface1* pThis, AMF_MEMORY_TYPE type); // optimal interop if possilble. Copy through host memory if needed + AMF_RESULT (AMF_STD_CALL *Interop)(AMFSurface1* 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)(AMFSurface1* pThis); + + amf_bool (AMF_STD_CALL *IsReusable)(AMFSurface1* pThis); + + void (AMF_STD_CALL *SetPts)(AMFSurface1* pThis, amf_pts pts); + amf_pts (AMF_STD_CALL *GetPts)(AMFSurface1* pThis); + void (AMF_STD_CALL *SetDuration)(AMFSurface1* pThis, amf_pts duration); + amf_pts (AMF_STD_CALL *GetDuration)(AMFSurface1* pThis); + + // AMFSurface interface + + AMF_SURFACE_FORMAT (AMF_STD_CALL *GetFormat)(AMFSurface1* pThis); + + // do not store planes outside. should be used together with Surface + amf_size (AMF_STD_CALL *GetPlanesCount)(AMFSurface1* pThis); + AMFPlane* (AMF_STD_CALL *GetPlaneAt)(AMFSurface1* pThis, amf_size index); + AMFPlane* (AMF_STD_CALL *GetPlane)(AMFSurface1* pThis, AMF_PLANE_TYPE type); + + AMF_FRAME_TYPE (AMF_STD_CALL *GetFrameType)(AMFSurface1* pThis); + void (AMF_STD_CALL *SetFrameType)(AMFSurface1* pThis, AMF_FRAME_TYPE type); + + AMF_RESULT (AMF_STD_CALL *SetCrop)(AMFSurface1* pThis, amf_int32 x,amf_int32 y, amf_int32 width, amf_int32 height); + AMF_RESULT (AMF_STD_CALL *CopySurfaceRegion)(AMFSurface1* pThis, AMFSurface1* 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)(AMFSurface1* pThis, AMFSurfaceObserver* pObserver); + void (AMF_STD_CALL *RemoveObserver_Surface)(AMFSurface1* pThis, AMFSurfaceObserver* pObserver); + + // AMFSurface1 interface + + AMF_RESULT (AMF_STD_CALL *Map)(AMFSurface1* pThis, AMF_MEMORY_CPU_ACCESS flags, amf_size planeCount, amf_size* pRowPitches, void** ppData); // only READ and WRITE flags are valid + AMF_RESULT (AMF_STD_CALL *Unmap)(AMFSurface1* pThis); + } AMFSurface1Vtbl; + + struct AMFSurface1 + { + const AMFSurface1Vtbl *pVtbl; + }; #endif // #if defined(__cplusplus) #if defined(__cplusplus) } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/core/Variant.h new/AMF-1.5.2/amf/public/include/core/Variant.h --- old/AMF-1.5.0/amf/public/include/core/Variant.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/core/Variant.h 2026-05-06 17:01:13.000000000 +0200 @@ -892,14 +892,14 @@ { res = AMF_OK; char buff[0xFF]; - sprintf(buff, "%lf", value); + snprintf(buff, sizeof(buff), "%.16f", value); return buff; } static AMF_INLINE AMFVariant::String AMFConvertFloatToString(amf_float value, AMF_RESULT& res) { res = AMF_OK; char buff[0xFF]; - sprintf(buff, "%f", value); + snprintf(buff, sizeof(buff), "%.6f", value); return buff; } static AMF_INLINE AMFVariant::WString AMFConvertDoubleToWString(amf_double value, AMF_RESULT& res) @@ -1178,28 +1178,28 @@ { res = AMF_OK; char buff[0xFF]; - sprintf(buff, "%f,%f", value.width, value.height); + snprintf(buff, sizeof(buff), "%.16f,%.16f", value.width, value.height); return buff; } static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatPoint2DToString(const AMFFloatPoint2D& value, AMF_RESULT& res) { res = AMF_OK; char buff[0xFF]; - sprintf(buff, "%f,%f", value.x, value.y); + snprintf(buff, sizeof(buff), "%.6f,%.6f", value.x, value.y); return buff; } static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatPoint3DToString(const AMFFloatPoint3D& value, AMF_RESULT& res) { res = AMF_OK; char buff[0xFF]; - sprintf(buff, "%f,%f,%f", value.x, value.y, value.z); + snprintf(buff, sizeof(buff), "%.6f,%.6f,%.6f", value.x, value.y, value.z); return buff; } static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertFloatVector4DToString(const AMFFloatVector4D& value, AMF_RESULT& res) { res = AMF_OK; char buff[0xFF]; - sprintf(buff, "%f,%f,%f,%f", value.x, value.y, value.z, value.w); + snprintf(buff, sizeof(buff), "%.6f,%.6f,%.6f,%.6f", value.x, value.y, value.z, value.w); return buff; } static AMF_INLINE AMFVariant::String AMF_STD_CALL AMFConvertRateToString(const AMFRate& value, AMF_RESULT& res) @@ -2089,6 +2089,21 @@ return type == AMF_VARIANT_EMPTY; } //------------------------------------------------------------------------------------------------- + // These global operators are needed to suppress a C++20 warning about an ambiguous call to operator== even though it has a unique viable function + // MSVC and GCC are able to figure it out, but Clang is being overzealous + AMF_INLINE bool operator==(const AMFVariantStruct& left, const AMFVariantStruct& right) + { + bool ret; + AMFVariantCompare(&left, &right, &ret); + return ret; + } + AMF_INLINE bool operator!=(const AMFVariantStruct& left, const AMFVariantStruct& right) + { + bool ret; + AMFVariantCompare(&left, &right, &ret); + return !ret; + } + #endif // #if defined(__cplusplus) #if defined(__cplusplus) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/AMF-1.5.0/amf/public/include/core/Version.h new/AMF-1.5.2/amf/public/include/core/Version.h --- old/AMF-1.5.0/amf/public/include/core/Version.h 2025-10-29 14:30:32.000000000 +0100 +++ new/AMF-1.5.2/amf/public/include/core/Version.h 2026-05-06 17:01:13.000000000 +0200 @@ -51,7 +51,7 @@ #define AMF_VERSION_MAJOR 1 #define AMF_VERSION_MINOR 5 -#define AMF_VERSION_RELEASE 0 +#define AMF_VERSION_RELEASE 2 #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) ++++++ AMF.obsinfo ++++++ --- /var/tmp/diff_new_pack.IgFHUS/_old 2026-05-10 16:47:58.663928242 +0200 +++ /var/tmp/diff_new_pack.IgFHUS/_new 2026-05-10 16:47:58.667928405 +0200 @@ -1,5 +1,5 @@ name: AMF -version: 1.5.0 -mtime: 1761744632 -commit: afed28d37aca1938da2eedc50599bb3535a987ec +version: 1.5.2 +mtime: 1778079673 +commit: eadd00804d5f7e5cd8c85d540073198312870776 ++++++ _service ++++++ --- /var/tmp/diff_new_pack.IgFHUS/_old 2026-05-10 16:47:58.707930042 +0200 +++ /var/tmp/diff_new_pack.IgFHUS/_new 2026-05-10 16:47:58.711930207 +0200 @@ -3,7 +3,7 @@ <param name="url">https://github.com/GPUOpen-LibrariesAndSDKs/AMF.git</param> <param name="scm">git</param> <param name="versionformat">@PARENT_TAG@</param> - <param name="revision">v1.5.0</param> + <param name="revision">v1.5.2</param> <param name="changesgenerate">enable</param> <param name="versionrewrite-pattern">v(.*)</param> <param name="include">LICENSE.txt</param> ++++++ _servicedata ++++++ --- /var/tmp/diff_new_pack.IgFHUS/_old 2026-05-10 16:47:58.735931189 +0200 +++ /var/tmp/diff_new_pack.IgFHUS/_new 2026-05-10 16:47:58.739931352 +0200 @@ -3,6 +3,6 @@ <param name="url">https://github.com/GPUOpen-LibrariesAndSDKs/AMF</param> <param name="changesrevision">a118570647cfa579af8875c3955a314c3ddd7058</param></service><service name="tar_scm"> <param name="url">https://github.com/GPUOpen-LibrariesAndSDKs/AMF.git</param> - <param name="changesrevision">afed28d37aca1938da2eedc50599bb3535a987ec</param></service></servicedata> + <param name="changesrevision">eadd00804d5f7e5cd8c85d540073198312870776</param></service></servicedata> (No newline at EOF)
![http://gpuopen-librariesandsdks.github.io/media/latest-release-button.svg"](http://gpuopen-librariesandsdks.github.io/media/latest-release-button.svg"){kind=link}