mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
4 weeks ago
6 changed files with 618 additions and 0 deletions
@ -0,0 +1,201 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Numerics; |
||||
|
using BenchmarkDotNet.Attributes; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Components; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
using SixLabors.ImageSharp.PixelFormats; |
||||
|
using SixLabors.ImageSharp.Processing; |
||||
|
using SixLabors.ImageSharp.Tests; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Benchmarks.Codecs.Heif; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Measures encoding a photographic sequence with fractional motion at the interpolation-search effort boundaries.
|
||||
|
/// </summary>
|
||||
|
[MemoryDiagnoser] |
||||
|
public class Av1SequenceEncoderBenchmarks |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The number of displayed pictures in each independently encoded sequence.
|
||||
|
/// </summary>
|
||||
|
private const int FrameCount = 3; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The native AV1 quantizer index corresponding to libaom's public constant-quality level 30.
|
||||
|
/// </summary>
|
||||
|
private const int QIndex = 120; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The fixed native speed baseline, independent of ImageSharp's effort scale.
|
||||
|
/// </summary>
|
||||
|
private const int NativeCpuUsed = 6; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The native public quantizer corresponding to <see cref="QIndex"/>, also used for both rate-control bounds.
|
||||
|
/// </summary>
|
||||
|
private const int NativeQuality = 30; |
||||
|
|
||||
|
private Image<Rgb24> sequence; |
||||
|
private Configuration configuration; |
||||
|
private ObuColorConfig colorConfig; |
||||
|
private MemoryStream output; |
||||
|
private string outputDirectory; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets or sets the square frame dimension.
|
||||
|
/// </summary>
|
||||
|
[Params(256, 512)] |
||||
|
public int Dimension { get; set; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets or sets the effort controlling fixed, common switchable, or independently switchable filters.
|
||||
|
/// </summary>
|
||||
|
[Params(7, 8, 9)] |
||||
|
public int Effort { get; set; } |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Prepares identical photographic RGB frames and a planar source file for checking reconstructed output quality.
|
||||
|
/// </summary>
|
||||
|
[GlobalSetup] |
||||
|
public void Setup() |
||||
|
{ |
||||
|
this.configuration = Configuration.Default.Clone(); |
||||
|
this.configuration.MaxDegreeOfParallelism = 1; |
||||
|
this.colorConfig = new ObuColorConfig |
||||
|
{ |
||||
|
BitDepth = Av1BitDepth.EightBit, |
||||
|
IsColorDescriptionPresent = true, |
||||
|
ColorPrimaries = ObuColorPrimaries.Bt601, |
||||
|
TransferCharacteristics = ObuTransferCharacteristics.Bt601, |
||||
|
MatrixCoefficients = ObuMatrixCoefficients.Bt601, |
||||
|
ColorRange = true, |
||||
|
SubSamplingX = true, |
||||
|
SubSamplingY = true, |
||||
|
ChromaSamplePosition = ObuChromoSamplePosition.Unknown |
||||
|
}; |
||||
|
|
||||
|
this.output = new MemoryStream(); |
||||
|
this.outputDirectory = TestEnvironment.CreateOutputDirectory("Heif", "Av1", nameof(Av1SequenceEncoderBenchmarks)); |
||||
|
string inputPath = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Png.Bike); |
||||
|
using Image<Rgb24> photograph = Image.Load<Rgb24>(inputPath); |
||||
|
|
||||
|
// Leave a source margin for the half-pixel translations. Resampling is setup work, not encoder time;
|
||||
|
// every invocation consumes the same three images rather than repeatedly translating a previous result.
|
||||
|
photograph.Mutate(context => context.Resize(new ResizeOptions |
||||
|
{ |
||||
|
Size = new Size(this.Dimension + FrameCount, this.Dimension + FrameCount), |
||||
|
Mode = ResizeMode.Crop |
||||
|
})); |
||||
|
|
||||
|
Rectangle sourceBounds = new(0, 0, photograph.Width, photograph.Height); |
||||
|
Size targetSize = new(this.Dimension, this.Dimension); |
||||
|
this.sequence = photograph.Clone(context => context.Crop(new Rectangle(Point.Empty, targetSize))); |
||||
|
for (int frameIndex = 1; frameIndex < FrameCount; frameIndex++) |
||||
|
{ |
||||
|
Matrix3x2 translation = Matrix3x2.CreateTranslation(-0.5F * frameIndex, -0.5F * frameIndex); |
||||
|
using Image<Rgb24> translated = photograph.Clone(context => |
||||
|
context.Transform(sourceBounds, translation, targetSize, KnownResamplers.Bicubic)); |
||||
|
|
||||
|
this.sequence.Frames.AddFrame(translated.Frames.RootFrame); |
||||
|
} |
||||
|
|
||||
|
// Export the production-converted source planes only for checking reconstructed output quality.
|
||||
|
// Neither timed encoder reads this file: both convert the original RGB frames during each operation.
|
||||
|
using Av1EncoderFrameBuffer<byte> planar = new(this.configuration, this.Dimension, this.Dimension, 8, Av1ColorFormat.Yuv420, 0, 0); |
||||
|
using FileStream raw = File.Create(Path.Combine(this.outputDirectory, $"bike-{this.Dimension}-3frames.source.yuv")); |
||||
|
foreach (ImageFrame<Rgb24> frame in this.sequence.Frames) |
||||
|
{ |
||||
|
Av1FrameEncoder.PrepareSource(this.configuration, frame, planar.Frame, this.colorConfig); |
||||
|
for (int planeIndex = 0; planeIndex < this.colorConfig.PlaneCount; planeIndex++) |
||||
|
{ |
||||
|
Buffer2DRegion<byte> plane = planar.Frame.View.GetPlane((Av1Plane)planeIndex); |
||||
|
for (int y = 0; y < plane.Height; y++) |
||||
|
{ |
||||
|
raw.Write(plane.DangerousGetRowSpan(y)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Encodes one key picture and two dependent pictures, returning the complete OBU payload length.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The encoded sequence length.</returns>
|
||||
|
[Benchmark] |
||||
|
public long ImageSharp() |
||||
|
{ |
||||
|
this.output.SetLength(0); |
||||
|
using Av1FrameEncoder.SequenceEncoder encoder = Av1FrameEncoder.CreateColorSequenceEncoder( |
||||
|
this.configuration, this.Dimension, this.Dimension, this.colorConfig, QIndex, this.Effort); |
||||
|
|
||||
|
// One operation owns the real sequence lifetime: allocation, conversion, key/inter coding, and disposal.
|
||||
|
// The caller's destination is reused, excluding filesystem and MemoryStream growth from steady-state timing.
|
||||
|
encoder.EncodeKeyFrame(this.sequence.Frames.RootFrame, this.output); |
||||
|
for (int frameIndex = 1; frameIndex < FrameCount; frameIndex++) |
||||
|
{ |
||||
|
encoder.EncodeInterFrame(this.sequence.Frames[frameIndex], this.output); |
||||
|
} |
||||
|
|
||||
|
return this.output.Length; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Encodes the same RGB sequence with current-main libaom, including conversion, allocation, output, and disposal.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The encoded sequence length.</returns>
|
||||
|
[Benchmark(Baseline = true)] |
||||
|
public long Libaom() |
||||
|
{ |
||||
|
// cpu-used is a separate speed scale, not an ImageSharp effort mapping. Keep the reference at
|
||||
|
// good-quality speed six while comparing the three managed interpolation-search boundaries.
|
||||
|
this.output.SetLength(0); |
||||
|
using LibaomBenchmarkEncoder encoder = LibaomBenchmarkEncoder.Open(this.Dimension, this.Dimension, NativeQuality, NativeCpuUsed); |
||||
|
using Av1EncoderFrameBuffer<byte> planar = new(this.configuration, this.Dimension, this.Dimension, 8, Av1ColorFormat.Yuv420, 0, 0); |
||||
|
using Av1FrameEncoder.Av1EncoderConversionWorkspace conversion = new(this.configuration, this.Dimension, this.colorConfig, false, false); |
||||
|
Rectangle bounds = new(0, 0, this.Dimension, this.Dimension); |
||||
|
for (int frameIndex = 0; frameIndex < FrameCount; frameIndex++) |
||||
|
{ |
||||
|
// Conversion belongs inside both measured paths. Reuse the same row workspace and SIMD converter
|
||||
|
// as the managed sequence encoder, writing directly into the planes passed to native libaom.
|
||||
|
conversion.Convert<Rgb24, Av1EncoderFrame<byte>.PlanarView, byte, HeifByteSampleConverter>( |
||||
|
this.configuration, this.sequence.Frames[frameIndex], bounds, planar.Frame.View); |
||||
|
|
||||
|
encoder.Encode(planar.Frame, frameIndex, this.output); |
||||
|
} |
||||
|
|
||||
|
encoder.Finish(this.output); |
||||
|
return this.output.Length; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Retains the measured managed encoder output and releases the input images and destination stream.
|
||||
|
/// </summary>
|
||||
|
[GlobalCleanup(Target = nameof(ImageSharp))] |
||||
|
public void CleanupImageSharp() => this.Cleanup($"bike-{this.Dimension}-q{QIndex}-effort{this.Effort}.obu"); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Retains the measured reference encoder output and releases the input images and destination stream.
|
||||
|
/// </summary>
|
||||
|
[GlobalCleanup(Target = nameof(Libaom))] |
||||
|
public void CleanupLibaom() => this.Cleanup($"bike-{this.Dimension}-q{QIndex}-libaom-cpu{NativeCpuUsed}.obu"); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Writes the measured payload without another encoding pass and releases the shared benchmark resources.
|
||||
|
/// </summary>
|
||||
|
/// <param name="outputName">The codec-specific payload file name.</param>
|
||||
|
private void Cleanup(string outputName) |
||||
|
{ |
||||
|
// Output validation and quality measurement use the actual measured payload, with no encode or decode
|
||||
|
// hidden inside the timed operation and no file-sized ToArray copy.
|
||||
|
using FileStream encoded = File.Create(Path.Combine(this.outputDirectory, outputName)); |
||||
|
this.output.Position = 0; |
||||
|
this.output.CopyTo(encoded); |
||||
|
this.output.Dispose(); |
||||
|
this.sequence.Dispose(); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,135 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using System.Runtime.InteropServices; |
||||
|
using Microsoft.Win32.SafeHandles; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Pipeline; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Benchmarks.Codecs.Heif; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Owns a benchmark-only libaom encoder through a C adapter compiled against the reference's actual headers.
|
||||
|
/// </summary>
|
||||
|
internal sealed unsafe partial class LibaomBenchmarkEncoder : SafeHandleZeroOrMinusOneIsInvalid |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The benchmark adapter's platform-independent library name.
|
||||
|
/// </summary>
|
||||
|
private const string LibraryName = "imagesharp_aom_benchmark"; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes an empty handle for the native create call's generated marshaller.
|
||||
|
/// </summary>
|
||||
|
public LibaomBenchmarkEncoder() |
||||
|
: base(ownsHandle: true) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Opens one native sequence with a single coding thread, no lookahead, and the requested quality and speed.
|
||||
|
/// </summary>
|
||||
|
public static LibaomBenchmarkEncoder Open(int width, int height, int quality, int speed) |
||||
|
{ |
||||
|
CheckStatus(Create((uint)width, (uint)height, (uint)quality, speed, out LibaomBenchmarkEncoder encoder)); |
||||
|
return encoder; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Encodes the converted source planes and consumes every output packet before those bytes can be invalidated.
|
||||
|
/// </summary>
|
||||
|
public void Encode(Av1EncoderFrame<byte> frame, long frameIndex, Stream output) |
||||
|
{ |
||||
|
Buffer2DRegion<byte> y = frame.View.GetPlane(Av1Plane.Y); |
||||
|
Buffer2DRegion<byte> u = frame.View.GetPlane(Av1Plane.U); |
||||
|
Buffer2DRegion<byte> v = frame.View.GetPlane(Av1Plane.V); |
||||
|
fixed (byte* yPointer = y.DangerousGetRowSpan(0), uPointer = u.DangerousGetRowSpan(0), vPointer = v.DangerousGetRowSpan(0)) |
||||
|
{ |
||||
|
// The native call is synchronous. Its input descriptors borrow these pinned rows only until
|
||||
|
// EncodeFrame returns; the encoder owns any retained reference and lookahead storage itself.
|
||||
|
CheckStatus(EncodeFrame(this, yPointer, uPointer, vPointer, y.Stride, u.Stride, frameIndex)); |
||||
|
} |
||||
|
|
||||
|
this.WritePackets(output); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Finishes the sequence and writes any remaining coded packets.
|
||||
|
/// </summary>
|
||||
|
public void Finish(Stream output) |
||||
|
{ |
||||
|
do |
||||
|
{ |
||||
|
CheckStatus(Flush(this)); |
||||
|
} |
||||
|
while (this.WritePackets(output)); |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
protected override bool ReleaseHandle() => Destroy(this.handle) == 0; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Writes borrowed packet memory before the next call into the native codec invalidates it.
|
||||
|
/// </summary>
|
||||
|
private bool WritePackets(Stream output) |
||||
|
{ |
||||
|
bool wrotePacket = false; |
||||
|
while (NextPacket(this, out byte* data, out nuint length) != 0) |
||||
|
{ |
||||
|
// Packet lengths are bounded by the benchmark's image dimensions. Stream.Write consumes the
|
||||
|
// borrowed bytes synchronously, without retaining a native pointer or creating a managed array.
|
||||
|
output.Write(new ReadOnlySpan<byte>(data, (int)length)); |
||||
|
wrotePacket = true; |
||||
|
} |
||||
|
|
||||
|
return wrotePacket; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Converts a native codec error into a managed benchmark failure instead of accepting invalid timing data.
|
||||
|
/// </summary>
|
||||
|
private static void CheckStatus(int status) |
||||
|
{ |
||||
|
if (status != 0) |
||||
|
{ |
||||
|
throw new InvalidOperationException(Marshal.PtrToStringUTF8(ErrorString(status))); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Creates an owned opaque context; no libaom structure layout crosses the managed boundary.
|
||||
|
/// </summary>
|
||||
|
[LibraryImport(LibraryName, EntryPoint = "benchmark_create")] |
||||
|
private static partial int Create(uint width, uint height, uint quality, int speed, out LibaomBenchmarkEncoder encoder); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Borrows three pinned planes for one synchronous native encode call.
|
||||
|
/// </summary>
|
||||
|
[LibraryImport(LibraryName, EntryPoint = "benchmark_encode")] |
||||
|
private static partial int EncodeFrame(LibaomBenchmarkEncoder encoder, byte* y, byte* u, byte* v, int yStride, int uvStride, long frameIndex); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Signals the end of the native sequence.
|
||||
|
/// </summary>
|
||||
|
[LibraryImport(LibraryName, EntryPoint = "benchmark_flush")] |
||||
|
private static partial int Flush(LibaomBenchmarkEncoder encoder); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns borrowed native packet storage and its pointer-sized length.
|
||||
|
/// </summary>
|
||||
|
[LibraryImport(LibraryName, EntryPoint = "benchmark_next_packet")] |
||||
|
private static partial int NextPacket(LibaomBenchmarkEncoder encoder, out byte* data, out nuint length); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Destroys the context through the same native library that allocated it.
|
||||
|
/// </summary>
|
||||
|
[LibraryImport(LibraryName, EntryPoint = "benchmark_destroy")] |
||||
|
private static partial int Destroy(nint encoder); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a static UTF-8 error message owned by libaom.
|
||||
|
/// </summary>
|
||||
|
[LibraryImport(LibraryName, EntryPoint = "benchmark_error_string")] |
||||
|
private static partial nint ErrorString(int status); |
||||
|
} |
||||
@ -0,0 +1,12 @@ |
|||||
|
cmake_minimum_required(VERSION 3.20) |
||||
|
project(imagesharp_aom_benchmark LANGUAGES C CXX) |
||||
|
|
||||
|
# Link the explicitly supplied current-main Release reference build. This adapter is benchmark-only; |
||||
|
# it is never referenced by ImageSharp or copied by the production project. |
||||
|
set(AOM_SOURCE_DIRECTORY "" CACHE PATH "Verified official libaom source directory") |
||||
|
set(AOM_BUILD_DIRECTORY "" CACHE PATH "Matching optimized Release libaom build directory") |
||||
|
add_library(imagesharp_aom_benchmark SHARED aom_benchmark.c) |
||||
|
target_include_directories(imagesharp_aom_benchmark PRIVATE "${AOM_SOURCE_DIRECTORY}") |
||||
|
find_library(AOM_LIBRARY NAMES aom PATHS "${AOM_BUILD_DIRECTORY}" NO_DEFAULT_PATH REQUIRED) |
||||
|
target_link_libraries(imagesharp_aom_benchmark PRIVATE "${AOM_LIBRARY}") |
||||
|
set_target_properties(imagesharp_aom_benchmark PROPERTIES C_STANDARD 11 LINKER_LANGUAGE CXX) |
||||
@ -0,0 +1,131 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
#include <stdint.h> |
||||
|
#include <stdlib.h> |
||||
|
#include "aom/aom_encoder.h" |
||||
|
#include "aom/aomcx.h" |
||||
|
|
||||
|
#if defined(_WIN32) |
||||
|
#define BENCHMARK_API __declspec(dllexport) |
||||
|
#else |
||||
|
#define BENCHMARK_API __attribute__((visibility("default"))) |
||||
|
#endif |
||||
|
|
||||
|
// Keep libaom's version-dependent structures and variadic controls entirely on the C side.
|
||||
|
// The managed benchmark exchanges only opaque ownership, fixed-width integers, and borrowed buffers.
|
||||
|
typedef struct benchmark_encoder { |
||||
|
aom_codec_ctx_t codec; |
||||
|
aom_codec_iter_t iterator; |
||||
|
unsigned int width; |
||||
|
unsigned int height; |
||||
|
} benchmark_encoder; |
||||
|
|
||||
|
// Creates one single-threaded, unlagged, constant-quality sequence using the reference's normal tools.
|
||||
|
// A successful result belongs to the caller and must be released by benchmark_destroy.
|
||||
|
BENCHMARK_API int benchmark_create(unsigned int width, unsigned int height, |
||||
|
unsigned int quality, int speed, |
||||
|
benchmark_encoder **result) { |
||||
|
aom_codec_enc_cfg_t config; |
||||
|
aom_codec_iface_t *iface = aom_codec_av1_cx(); |
||||
|
aom_codec_err_t status = aom_codec_enc_config_default(iface, &config, AOM_USAGE_GOOD_QUALITY); |
||||
|
*result = NULL; |
||||
|
if (status != AOM_CODEC_OK) return status; |
||||
|
|
||||
|
benchmark_encoder *encoder = calloc(1, sizeof(*encoder)); |
||||
|
if (encoder == NULL) return AOM_CODEC_MEM_ERROR; |
||||
|
|
||||
|
config.g_w = width; |
||||
|
config.g_h = height; |
||||
|
config.g_threads = 1; |
||||
|
config.g_lag_in_frames = 0; |
||||
|
config.g_timebase.num = 1; |
||||
|
config.g_timebase.den = 30; |
||||
|
config.rc_end_usage = AOM_Q; |
||||
|
// Fix both bounds to the requested quantizer. CQ alone permits frame-quality boosts, whereas
|
||||
|
// the managed sequence uses this same base quantizer for every frame in the comparison.
|
||||
|
config.rc_min_quantizer = quality; |
||||
|
config.rc_max_quantizer = quality; |
||||
|
config.kf_mode = AOM_KF_DISABLED; |
||||
|
status = aom_codec_enc_init(&encoder->codec, iface, &config, 0); |
||||
|
if (status != AOM_CODEC_OK) { |
||||
|
free(encoder); |
||||
|
return status; |
||||
|
} |
||||
|
|
||||
|
// These calls remain type-checked against the current libaom headers, including each control's argument type.
|
||||
|
status = aom_codec_control(&encoder->codec, AOME_SET_CPUUSED, speed); |
||||
|
if (status == AOM_CODEC_OK) status = aom_codec_control(&encoder->codec, AOME_SET_CQ_LEVEL, quality); |
||||
|
if (status == AOM_CODEC_OK) status = aom_codec_control(&encoder->codec, AV1E_SET_ROW_MT, 0u); |
||||
|
if (status == AOM_CODEC_OK) status = aom_codec_control(&encoder->codec, AV1E_SET_COLOR_PRIMARIES, AOM_CICP_CP_BT_601); |
||||
|
if (status == AOM_CODEC_OK) status = aom_codec_control(&encoder->codec, AV1E_SET_TRANSFER_CHARACTERISTICS, AOM_CICP_TC_BT_601); |
||||
|
if (status == AOM_CODEC_OK) status = aom_codec_control(&encoder->codec, AV1E_SET_MATRIX_COEFFICIENTS, AOM_CICP_MC_BT_601); |
||||
|
if (status == AOM_CODEC_OK) status = aom_codec_control(&encoder->codec, AV1E_SET_COLOR_RANGE, AOM_CR_FULL_RANGE); |
||||
|
if (status != AOM_CODEC_OK) { |
||||
|
aom_codec_destroy(&encoder->codec); |
||||
|
free(encoder); |
||||
|
return status; |
||||
|
} |
||||
|
|
||||
|
encoder->width = width; |
||||
|
encoder->height = height; |
||||
|
*result = encoder; |
||||
|
return AOM_CODEC_OK; |
||||
|
} |
||||
|
|
||||
|
// Borrows the already converted planes for this synchronous encode call. The caller pins all three
|
||||
|
// pointers until it returns; libaom retains its own reference pictures, never these managed input pointers.
|
||||
|
BENCHMARK_API int benchmark_encode(benchmark_encoder *encoder, unsigned char *y, |
||||
|
unsigned char *u, unsigned char *v, |
||||
|
int y_stride, int uv_stride, int64_t frame_index) { |
||||
|
aom_image_t image; |
||||
|
if (aom_img_wrap(&image, AOM_IMG_FMT_I420, encoder->width, encoder->height, 1, y) == NULL) { |
||||
|
return AOM_CODEC_INVALID_PARAM; |
||||
|
} |
||||
|
|
||||
|
// ImageSharp's source planes include aligned borders. Describe those existing rows directly instead
|
||||
|
// of flattening them into another contiguous YUV allocation before calling the reference encoder.
|
||||
|
image.planes[AOM_PLANE_Y] = y; |
||||
|
image.planes[AOM_PLANE_U] = u; |
||||
|
image.planes[AOM_PLANE_V] = v; |
||||
|
image.stride[AOM_PLANE_Y] = y_stride; |
||||
|
image.stride[AOM_PLANE_U] = uv_stride; |
||||
|
image.stride[AOM_PLANE_V] = uv_stride; |
||||
|
encoder->iterator = NULL; |
||||
|
return aom_codec_encode(&encoder->codec, &image, frame_index, 1, 0); |
||||
|
} |
||||
|
|
||||
|
// Drains delayed output at the end of the sequence even though lookahead is disabled.
|
||||
|
BENCHMARK_API int benchmark_flush(benchmark_encoder *encoder) { |
||||
|
encoder->iterator = NULL; |
||||
|
return aom_codec_encode(&encoder->codec, NULL, -1, 1, 0); |
||||
|
} |
||||
|
|
||||
|
// The returned packet storage belongs to libaom and is valid only until the next codec call.
|
||||
|
// The managed side copies it directly into the same kind of destination stream as its own encoder.
|
||||
|
BENCHMARK_API int benchmark_next_packet(benchmark_encoder *encoder, const void **data, size_t *length) { |
||||
|
const aom_codec_cx_pkt_t *packet; |
||||
|
while ((packet = aom_codec_get_cx_data(&encoder->codec, &encoder->iterator)) != NULL) { |
||||
|
if (packet->kind == AOM_CODEC_CX_FRAME_PKT) { |
||||
|
*data = packet->data.frame.buf; |
||||
|
*length = packet->data.frame.sz; |
||||
|
return 1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
*data = NULL; |
||||
|
*length = 0; |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
// Releases exactly the native context allocated by benchmark_create.
|
||||
|
BENCHMARK_API int benchmark_destroy(benchmark_encoder *encoder) { |
||||
|
aom_codec_err_t status = aom_codec_destroy(&encoder->codec); |
||||
|
free(encoder); |
||||
|
return status; |
||||
|
} |
||||
|
|
||||
|
// Libaom owns this static UTF-8 error string; the caller must not free it.
|
||||
|
BENCHMARK_API const char *benchmark_error_string(int status) { |
||||
|
return aom_codec_err_to_string((aom_codec_err_t)status); |
||||
|
} |
||||
@ -0,0 +1,137 @@ |
|||||
|
# AV1 sequence encoder comparison |
||||
|
|
||||
|
`Av1SequenceEncoderBenchmarks` compares the managed AV1 sequence encoder with an optimized build of official libaom `main`. |
||||
|
The native adapter belongs only to this benchmark project. ImageSharp production code remains fully managed. |
||||
|
|
||||
|
## Measurement boundary |
||||
|
|
||||
|
Both methods start with the same three `Rgb24` photographic frames and finish with the complete raw AV1 OBU sequence in a reused `MemoryStream`. |
||||
|
The measured operation includes encoder/workspace construction, RGB-to-YUV conversion for every frame, encoding, output writes, flushing where required, and disposal. |
||||
|
Both use the existing ImageSharp SIMD color converter and write directly into the aligned source planes consumed by their encoder. |
||||
|
Libaom receives pinned plane pointers for each synchronous encode call; it does not read a preconverted input file. |
||||
|
|
||||
|
Image loading, resizing, half-pixel source translations, validation-file writes, decoding, and quality calculations are outside both measured methods. |
||||
|
MemoryStream capacity is retained between operations for both methods. These are RGB-to-OBU measurements, not public HEIF container-save measurements. |
||||
|
Do not compare them with `aomenc`'s internal encode-time report, which excludes the conversion boundary. |
||||
|
|
||||
|
The source is the existing `TestImages.Png.Bike` photograph. Frames one and two are independently translated by half a pixel and one pixel on both axes. |
||||
|
The parameter matrix contains 256x256 and 512x512 frames at ImageSharp efforts seven, eight, and nine. |
||||
|
Input is full-range BT.601, eight-bit 4:2:0; each sequence contains one key frame and two dependent frames. |
||||
|
Both codecs use one coding thread. Libaom uses good-quality mode, no lookahead, disabled automatic key frames, and `cpu-used=6`. |
||||
|
That speed is an independent reference setting, not a mapping from the ImageSharp effort scale. |
||||
|
|
||||
|
ImageSharp's base quantizer index is 120. Libaom's public quantizer 30 maps to that same index in the pinned reference. |
||||
|
The native minimum and maximum quantizers are both fixed to 30, in addition to the CQ setting, so frame-level CQ boosts cannot lower the base quantizer. |
||||
|
Other native coding tools remain enabled. Identical quantizers do not imply identical quality or bitrate; always retain size and decoded-quality results with timings. |
||||
|
|
||||
|
BenchmarkDotNet's allocation column measures managed allocations only. It does not measure libaom's native allocations, pooled native memory, or total peak memory. |
||||
|
Do not interpret its allocation ratio as a whole-encoder memory comparison. |
||||
|
|
||||
|
## Build the reference and benchmark adapter |
||||
|
|
||||
|
The verified source revision is `d565eec60f084421fa34fc0534b760c6452b6a6c`, libaom 3.15.0, exported at `D:\GitHub\ynse01\aom-d565eec6-source`. |
||||
|
The x64 Release build is `D:\GitHub\ynse01\aom-d565eec6-build-x64-release`. |
||||
|
It uses MSVC 19.51.36256.0 and NASM 3.02, runtime CPU detection, and SSE2, SSE4.1, AVX2, and AVX512 kernels. |
||||
|
The generic reference decoder build is suitable for conformance but must not be used as the timing reference. |
||||
|
|
||||
|
Run from the repository root in an x64 Visual Studio developer PowerShell with the existing CMake, Ninja, NASM, and Perl installations available: |
||||
|
|
||||
|
```powershell |
||||
|
$aomSourceDirectory = 'D:/GitHub/ynse01/aom-d565eec6-source' |
||||
|
$aomBuildDirectory = 'D:/GitHub/ynse01/aom-d565eec6-build-x64-release' |
||||
|
$adapterBuildDirectory = 'artifacts/av1-native-benchmark-release' |
||||
|
|
||||
|
cmake -S $aomSourceDirectory -B $aomBuildDirectory -G Ninja ` |
||||
|
-DCMAKE_BUILD_TYPE=Release -DAOM_TARGET_CPU=x86_64 -DENABLE_NASM=ON ` |
||||
|
-DENABLE_TESTS=OFF -DENABLE_EXAMPLES=ON -DENABLE_TOOLS=ON ` |
||||
|
-DCONFIG_WEBM_IO=OFF -DCONFIG_LIBYUV=OFF |
||||
|
if ($LASTEXITCODE -ne 0) { throw 'Reference configuration failed.' } |
||||
|
|
||||
|
cmake --build $aomBuildDirectory --target aomenc aomdec --parallel 4 |
||||
|
if ($LASTEXITCODE -ne 0) { throw 'Reference build failed.' } |
||||
|
|
||||
|
cmake -S tests/ImageSharp.Benchmarks/Codecs/Heif/Native -B $adapterBuildDirectory -G Ninja ` |
||||
|
-DCMAKE_BUILD_TYPE=Release "-DAOM_SOURCE_DIRECTORY=$aomSourceDirectory" "-DAOM_BUILD_DIRECTORY=$aomBuildDirectory" |
||||
|
if ($LASTEXITCODE -ne 0) { throw 'Adapter configuration failed.' } |
||||
|
|
||||
|
cmake --build $adapterBuildDirectory --parallel 1 |
||||
|
if ($LASTEXITCODE -ne 0) { throw 'Adapter build failed.' } |
||||
|
|
||||
|
dotnet build tests/ImageSharp.Benchmarks/ImageSharp.Benchmarks.csproj -c Release -f net11.0 ` |
||||
|
--no-restore --disable-build-servers -m:1 -p:UseSharedCompilation=false ` |
||||
|
-p:SIXLABORS_TESTING_PREVIEW=true -p:SIXLABORS_DISABLE_CONFIG_COPY=true |
||||
|
if ($LASTEXITCODE -ne 0) { throw 'Managed build failed.' } |
||||
|
|
||||
|
Copy-Item -LiteralPath "$adapterBuildDirectory/imagesharp_aom_benchmark.dll" ` |
||||
|
-Destination artifacts/bin/tests/ImageSharp.Benchmarks/Release/net11.0/imagesharp_aom_benchmark.dll |
||||
|
``` |
||||
|
|
||||
|
The adapter links the explicit reference build. It neither downloads tools nor adds a native production dependency. |
||||
|
Rebuild it whenever the source headers or reference library change; record the exact source revision and optimized build configuration with every report. |
||||
|
|
||||
|
## Validate, then measure |
||||
|
|
||||
|
Run one pair first, in the existing benchmark host with the in-process toolchain. Do not run builds or tests concurrently with timing. |
||||
|
|
||||
|
```powershell |
||||
|
$benchmarkAssembly = 'artifacts/bin/tests/ImageSharp.Benchmarks/Release/net11.0/ImageSharp.Benchmarks.dll' |
||||
|
$benchmarkFilter = '*Av1SequenceEncoderBenchmarks.*(Dimension: 256, Effort: 7)' |
||||
|
|
||||
|
dotnet $benchmarkAssembly --inProcess --job Dry --filter $benchmarkFilter ` |
||||
|
--stopOnFirstError --noOverwrite --artifacts artifacts/BenchmarkDotNet/av1-sequence-rgb-dry |
||||
|
``` |
||||
|
|
||||
|
The actual last measured payload for each method and the independently exported source planes are retained under |
||||
|
`tests/Images/ActualOutput/Heif/Av1/Av1SequenceEncoderBenchmarks`. |
||||
|
Both timed methods convert RGB on every invocation; the exported source file exists only for offline quality calculation. |
||||
|
Decode both payloads using the matching current-main `aomdec`, and require the expected complete three-frame YUV length: |
||||
|
|
||||
|
```powershell |
||||
|
$outputDirectory = 'tests/Images/ActualOutput/Heif/Av1/Av1SequenceEncoderBenchmarks' |
||||
|
foreach ($payloadName in 'bike-256-q120-effort7.obu', 'bike-256-q120-libaom-cpu6.obu') { |
||||
|
$payloadPath = Join-Path $outputDirectory $payloadName |
||||
|
& "$aomBuildDirectory/aomdec.exe" --codec=av1 --threads=1 --rawvideo -o "$payloadPath.yuv" $payloadPath |
||||
|
if ($LASTEXITCODE -ne 0) { throw "Reference decode failed: $payloadName" } |
||||
|
|
||||
|
if ((Get-Item -LiteralPath "$payloadPath.yuv").Length -ne (3 * 256 * 256 * 3 / 2)) { |
||||
|
throw "Incomplete decoded sequence: $payloadName" |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
dotnet $benchmarkAssembly --inProcess --job Short --filter $benchmarkFilter ` |
||||
|
--stopOnFirstError --noOverwrite --artifacts artifacts/BenchmarkDotNet/av1-sequence-rgb-short |
||||
|
``` |
||||
|
|
||||
|
Repeat output validation after the measured run. Compute per-plane PSNR against the exported source using |
||||
|
`10 * log10(255^2 * sampleCount / squaredErrorSum)`, accumulated over all three frames. |
||||
|
Aggregate YUV PSNR uses the total squared error and sample count, not the arithmetic mean of the three PSNR values. |
||||
|
Keep bitstream length, quality, absolute time, runtime, CPU information, reference settings, and any environment warnings together. |
||||
|
The short job is an initial diagnostic checkpoint, not a substitute for the complete size/quality/performance matrix or an equal-quality rate-distortion comparison. |
||||
|
|
||||
|
## Verified checkpoint: 2026-09-05 |
||||
|
|
||||
|
The final fixed-quantizer pair ran with BenchmarkDotNet 0.15.8, .NET 11.0.0-preview.7.26381.103, x64 RyuJIT, and AVX512 available. |
||||
|
The in-process Short job used three warmup iterations and three measured iterations. Each operation encoded all three 256x256 frames. |
||||
|
|
||||
|
| Encoder setting | Mean sequence time | OBU size | Y PSNR | U PSNR | V PSNR | Aggregate YUV PSNR | |
||||
|
| --- | ---: | ---: | ---: | ---: | ---: | ---: | |
||||
|
| ImageSharp effort 7, base index 120 | 2,053.31 ms | 11.54 KiB | 39.040 dB | 38.630 dB | 32.778 dB | 37.124 dB | |
||||
|
| Libaom cpu-used 6, fixed public quantizer 30 | 70.67 ms | 8.27 KiB | 39.275 dB | 39.637 dB | 37.351 dB | 38.942 dB | |
||||
|
|
||||
|
Both final measured payloads decode to exactly three complete native YUV frames using the optimized current-main reference decoder. |
||||
|
ImageSharp is about 29 times slower for this case while producing a larger, lower-PSNR sequence. The performance exit gate remains open. |
||||
|
The managed allocation counter reports 9.38 MiB per ImageSharp operation; its source still needs attribution, and it is not comparable with libaom's unmeasured native footprint. |
||||
|
|
||||
|
Evidence is retained in `artifacts/BenchmarkDotNet/av1-sequence-rgb-fixed-q-short-20260905/20260905-131149`. |
||||
|
The initial Dry run and earlier unrestricted-CQ Short run are preliminary checks, not the final comparison above. |
||||
|
BenchmarkDotNet could not change the power plan or query CPU model information in this environment; those warnings remain in the log. |
||||
|
This result is a local diagnostic, not a controlled-hardware or equal-quality performance claim. |
||||
|
|
||||
|
Final OBU SHA-256 values: |
||||
|
|
||||
|
- ImageSharp: `AB0327D33405FB7A6EC1895D465C9EE08E0B218DDA9D7E8EE7E0DCA6C5F8A73B` |
||||
|
- Libaom: `0C44A3475849762B5A09937397DEA4397264B83E79DAF930A06B70734977E4A9` |
||||
|
|
||||
|
The final Release benchmark build has zero errors and 39 existing benchmark warnings outside the new files. |
||||
|
Roslyn compiler and analyzer diagnostics contain no errors or warnings in the new benchmark files. |
||||
|
No production file changed in this benchmark checkpoint; the preceding 2,524-case encoder/entropy verification remains the latest production test run. |
||||
Loading…
Reference in new issue