Add opus custom support

.gitignore

@@ -1,2 +1,4 @@
 .build
 .DS_Store
+DerivedData
+.swiftpm

Package.swift

@@ -14,6 +14,10 @@ let package = Package(
 			name: "Copus",
 			targets: ["Copus"]
 		),
+		.library(
+			name: "Copuswrapper",
+			targets: ["Copuswrapper"]
+		),
 		.library(
 			name: "Opus",
 			targets: ["Opus", "Copus"]
@@ -88,6 +92,7 @@ let package = Package(
 				.headerSearchPath("silk/float"),
 
 				.define("OPUS_BUILD"),
+				.define("CUSTOM_MODES"),
 				.define("VAR_ARRAYS", to: "1"),
 				.define("FLOATING_POINT"), // Enable Opus floating-point mode
 
@@ -105,9 +110,17 @@ let package = Package(
 				.define("HAVE_UNISTD_H", to: "1"),
 			]
 		),
+		.target(
+			name: "Copuswrapper",
+			dependencies: ["Copus"],
+			publicHeadersPath: "include",
+			cSettings: [
+				.headerSearchPath("."),
+			]
+		),
 		.target(
 			name: "Opus",
-			dependencies: ["Copus"]
+			dependencies: ["Copus", "Copuswrapper"]
 		),
 		.testTarget(
 			name: "OpusTests",

Sources/Copuswrapper/include/variadic-wrapper.h

@@ -0,0 +1,11 @@
+#ifndef __OPUS_VARIADIC_WRAPPER_H__
+#define __OPUS_VARIADIC_WRAPPER_H__
+
+//#include ""
+#include <opus_defines.h>
+#include <opus_custom.h>
+
+int opus_custom_encoder_ctl_wrapper(OpusCustomEncoder *OPUS_RESTRICT st, int request, opus_int32 val);
+int opus_custom_decoder_ctl_wrapper(OpusCustomDecoder *OPUS_RESTRICT st, int request, opus_int32 val);
+
+#endif

Sources/Copuswrapper/variadic-wrapper.c

@@ -0,0 +1,11 @@
+#include "variadic-wrapper.h"
+
+int opus_custom_encoder_ctl_wrapper(OpusCustomEncoder *OPUS_RESTRICT st, int request, opus_int32 val)
+{
+	return opus_custom_encoder_ctl(st, request, val);
+}
+
+int opus_custom_decoder_ctl_wrapper(OpusCustomDecoder *OPUS_RESTRICT st, int request, opus_int32 val)
+{
+	return opus_custom_decoder_ctl(st, request, val);
+}

Sources/Opus/Opus.Custom.swift

@@ -0,0 +1,95 @@
+import AVFoundation
+import Copus
+import Copuswrapper
+import Foundation
+
+public extension Opus {
+	///
+	/// Implements a custom opus encoder / decoder.
+	/// Custom implementations can have non-standard frame sizes
+	///
+	final class Custom {
+		private let opusCustomMode: OpaquePointer
+		let encoder: Opus.Encoder
+		let decoder: Opus.Decoder
+		private let format: AVAudioFormat
+		public let frameSize: Int32
+
+		public init(format: AVAudioFormat,
+		            application _: Application = .audio,
+		            frameSize: UInt32 = 128) throws
+		{
+			if !format.isValidOpusPCMFormat {
+				throw Opus.Error.badArgument
+			}
+			self.format = format
+			self.frameSize = Int32(frameSize)
+
+			var error: Opus.Error = .ok
+
+			// Create custom parameters
+			guard let customMode = opus_custom_mode_create(
+				Int32(format.sampleRate),
+				Int32(frameSize),
+				&error.rawValue
+			) else { throw error }
+			opusCustomMode = customMode
+
+			// Create custom encoder
+			encoder = try Opus.Encoder(customOpus: opusCustomMode,
+			                           format: format,
+			                           frameSize: frameSize)
+			// Create custom decoder
+			decoder = try Opus.Decoder(customOpus: opusCustomMode,
+			                           format: format,
+			                           frameSize: frameSize)
+		}
+
+		deinit {
+			opus_custom_mode_destroy(opusCustomMode)
+		}
+
+		///
+		/// Wrapper onto the opus_custom_encoder_ctl function
+		/// https://www.opus-codec.org/docs/opus_api-1.3.1/group__opus__encoderctls.html
+		/// - Parameter request The Opus CTL to change
+		/// - Parameter value The value to set it to
+		///
+		/// - Returns Opus.Error code
+		public func encoderCtl(request: Int32, value: Int32) -> Opus.Error {
+			Opus.Error(
+				rawValue: opus_custom_encoder_ctl_wrapper(encoder.encoder, request, value)
+			)
+		}
+
+		///
+		/// Encode a PCM buffer to data using the custom mode configuration and max size
+		/// - parameter avData Audio data to compress
+		/// - parameter compressedSize Opus packet size to compress to
+		/// - Returns Data containing the Opus packet
+		public func encode(_ avData: AVAudioPCMBuffer,
+		                   compressedSize: Int) throws -> Data
+		{
+			try encoder.encode(avData, compressedSize: compressedSize)
+		}
+
+		///
+		/// Decode an opus packet
+		/// If the data is empty, it is treated as a dropped packet
+		/// - Parameter data Compressed data
+		/// - Parameter compressedPacketSize Number of bytes of data
+		/// - Parameter sampleMultiplier Frame size multiplier if greater than one
+		/// - Returns Uncompressed audio buffer
+		public func decode(_ data: Data,
+		                   compressedPacketSize: Int32,
+		                   sampleMultiplier: Int32 = 1) throws -> AVAudioPCMBuffer
+		{
+			guard data.isEmpty || data.count == compressedPacketSize else {
+				throw Opus.Error.bufferTooSmall
+			}
+			return try decoder.decode(data,
+			                          compressedPacketSize: compressedPacketSize,
+			                          sampleMultiplier: sampleMultiplier)
+		}
+	}
+}

Sources/Opus/Opus.Decoder.swift

@@ -5,9 +5,10 @@ public extension Opus {
 	class Decoder {
 		let format: AVAudioFormat
 		let decoder: OpaquePointer
+		let customFrameSize: Int32?
 
-		// TODO: throw an error if format is unsupported
 		public init(format: AVAudioFormat, application _: Application = .audio) throws {
+			customFrameSize = nil
 			if !format.isValidOpusPCMFormat {
 				throw Opus.Error.badArgument
 			}
@@ -22,6 +23,27 @@ public extension Opus {
 			}
 		}
 
+		public init(customOpus: OpaquePointer,
+		            format: AVAudioFormat,
+		            frameSize: UInt32) throws
+		{
+			customFrameSize = Int32(frameSize)
+			if !format.isValidOpusPCMFormat {
+				throw Opus.Error.badArgument
+			}
+
+			self.format = format
+
+			// Initialize Opus decoder
+			var error: Opus.Error = .ok
+			decoder = opus_custom_decoder_create(customOpus,
+			                                     Int32(format.channelCount),
+			                                     &error.rawValue)
+			if error != .ok {
+				throw error
+			}
+		}
+
 		deinit {
 			opus_decoder_destroy(decoder)
 		}
@@ -38,28 +60,42 @@ public extension Opus {
 // MARK: Public decode methods
 
 public extension Opus.Decoder {
-	func decode(_ input: Data) throws -> AVAudioPCMBuffer {
+	func decode(_ input: Data,
+	            compressedPacketSize: Int32? = nil,
+	            sampleMultiplier: Int32 = 1) throws -> AVAudioPCMBuffer
+	{
 		try input.withUnsafeBytes {
+			var output: AVAudioPCMBuffer
 			let input = $0.bindMemory(to: UInt8.self)
-			let sampleCount = opus_decoder_get_nb_samples(decoder, input.baseAddress!, Int32($0.count))
-			if sampleCount < 0 {
-				throw Opus.Error(sampleCount)
+			if compressedPacketSize != nil, let frameSize = customFrameSize {
+				output = AVAudioPCMBuffer(
+					pcmFormat: format,
+					frameCapacity: AVAudioFrameCount(frameSize * sampleMultiplier)
+				)!
+			} else {
+				let sampleCount = opus_decoder_get_nb_samples(decoder, input.baseAddress!, Int32($0.count))
+				if sampleCount < 0 {
+					throw Opus.Error(sampleCount)
+				}
+				output = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(sampleCount))!
 			}
-			let output = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(sampleCount))!
-			try decode(input, to: output)
+
+			try decode(input, to: output, packetSize: compressedPacketSize)
 			return output
 		}
 	}
 
-	func decode(_ input: UnsafeBufferPointer<UInt8>, to output: AVAudioPCMBuffer) throws {
+	func decode(_ input: UnsafeBufferPointer<UInt8>, to output: AVAudioPCMBuffer,
+	            packetSize: Int32? = nil) throws
+	{
 		let decodedCount: Int
 		switch output.format.commonFormat {
 		case .pcmFormatInt16:
 			let output = UnsafeMutableBufferPointer(start: output.int16ChannelData![0], count: Int(output.frameCapacity))
-			decodedCount = try decode(input, to: output)
+			decodedCount = try decode(input, to: output, packetSize: packetSize)
 		case .pcmFormatFloat32:
 			let output = UnsafeMutableBufferPointer(start: output.floatChannelData![0], count: Int(output.frameCapacity))
-			decodedCount = try decode(input, to: output)
+			decodedCount = try decode(input, to: output, packetSize: packetSize)
 		default:
 			throw Opus.Error.badArgument
 		}
@@ -73,30 +109,58 @@ public extension Opus.Decoder {
 // MARK: Private decode methods
 
 extension Opus.Decoder {
-	private func decode(_ input: UnsafeBufferPointer<UInt8>, to output: UnsafeMutableBufferPointer<Int16>) throws -> Int {
-		let decodedCount = opus_decode(
-			decoder,
-			input.baseAddress!,
-			Int32(input.count),
-			output.baseAddress!,
-			Int32(output.count),
-			0
-		)
+	private func decode(_ input: UnsafeBufferPointer<UInt8>,
+	                    to output: UnsafeMutableBufferPointer<Int16>,
+	                    packetSize: Int32?) throws -> Int
+	{
+		var decodedCount: Int32 = 0
+		if let size = packetSize {
+			decodedCount = opus_custom_decode(
+				decoder,
+				input.isEmpty ? nil : input.baseAddress,
+				size,
+				output.baseAddress!,
+				Int32(output.count)
+			)
+		} else {
+			decodedCount = opus_decode(
+				decoder,
+				input.isEmpty ? nil : input.baseAddress,
+				Int32(input.count),
+				output.baseAddress!,
+				Int32(output.count),
+				0
+			)
+		}
 		if decodedCount < 0 {
 			throw Opus.Error(decodedCount)
 		}
 		return Int(decodedCount)
 	}
 
-	private func decode(_ input: UnsafeBufferPointer<UInt8>, to output: UnsafeMutableBufferPointer<Float32>) throws -> Int {
-		let decodedCount = opus_decode_float(
-			decoder,
-			input.baseAddress!,
-			Int32(input.count),
-			output.baseAddress!,
-			Int32(output.count),
-			0
-		)
+	private func decode(_ input: UnsafeBufferPointer<UInt8>,
+	                    to output: UnsafeMutableBufferPointer<Float32>,
+	                    packetSize: Int32?) throws -> Int
+	{
+		var decodedCount: Int32 = 0
+		if let size = packetSize {
+			decodedCount = opus_custom_decode_float(
+				decoder,
+				input.isEmpty ? nil : input.baseAddress,
+				size,
+				output.baseAddress!,
+				Int32(output.count)
+			)
+		} else {
+			decodedCount = opus_decode_float(
+				decoder,
+				input.isEmpty ? nil : input.baseAddress,
+				Int32(input.count),
+				output.baseAddress!,
+				Int32(output.count),
+				0
+			)
+		}
 		if decodedCount < 0 {
 			throw Opus.Error(decodedCount)
 		}