Merge pull request #32 from AvionBlock/dev

v1.6.0 release.

Author: SineVector241

.github/workflows/OpusCompile.yml

@@ -374,6 +374,16 @@ public enum EncoderCTL
         /// Provide external DNN weights from binary object (only when explicitly built without the weights).
         /// </summary>
         OPUS_SET_DNN_BLOB = 4052,
+        
+        /// <summary>
+        /// If set to 1, enables quality extension (QEXT), otherwise disables it (default). Warning: This will hurt audio quality unless operating at a very high bitrate.
+        /// </summary>
+        OPUS_SET_QEXT = 4056,
+        
+        /// <summary>
+        /// Gets the encoder's configured quality extension (QEXT).
+        /// </summary>
+        OPUS_GET_QEXT = 4057
     }
 
     /// <summary>
@@ -400,6 +410,26 @@ public enum DecoderCTL
         /// Gets the pitch of the last decoded frame, if available.
         /// </summary>
         OPUS_GET_PITCH = 4033,
+        
+        /// <summary>
+        /// Enables blind bandwidth extension for wideband signals if decoding sampling rate is 48 kHz.
+        /// </summary>
+        OPUS_SET_OSCE_BWE = 4054,
+        
+        /// <summary>
+        /// Gets blind bandwidth extension flag for wideband signals if decoding sampling rate is 48 kHz.
+        /// </summary>
+        OPUS_GET_OSCE_BWE = 4055,
+        
+        /// <summary>
+        /// If set to 1, the decoder will ignore all extensions found in the padding area (does not affect DRED, which is decoded separately).
+        /// </summary>
+        OPUS_SET_IGNORE_EXTENSIONS = 4058,
+        
+        /// <summary>
+        /// Gets whether the decoder is ignoring extensions.
+        /// </summary>
+        OPUS_GET_IGNORE_EXTENSIONS = 4059,
     }
 
     /// <summary>

OpusSharp.Core/Enums.cs

@@ -61,6 +61,58 @@ public static int GetPitch(this OpusDecoder decoder)
             decoder.Ctl(DecoderCTL.OPUS_GET_PITCH, ref pitch);
             return pitch;
         }
+        
+        /// <summary>
+        /// Enables or disables the decoder's OSCE BWE module.
+        /// </summary>
+        /// <param name="decoder">The decoder state.</param>
+        /// <param name="enabled">Whether to enable or disable the OSCE BWE module.</param>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public static void SetOsceBwe(this OpusDecoder decoder, bool enabled)
+        {
+            decoder.Ctl(DecoderCTL.OPUS_SET_OSCE_BWE, enabled ? 1 : 0);
+        }
+
+        /// <summary>
+        /// Determines whether the decoder's OSCE BWE module is enabled or not.
+        /// </summary>
+        /// <param name="decoder">The decoder state.</param>
+        /// <returns>Whether the OSCE BWE module is enabled or not.</returns>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public static bool GetOsceBwe(this OpusDecoder decoder)
+        {
+            var value = 0;
+            decoder.Ctl(DecoderCTL.OPUS_GET_OSCE_BWE, ref value);
+            return value == 1;
+        }
+        
+        /// <summary>
+        /// Sets whether the decoder should ignore extensions in the padding area.
+        /// </summary>
+        /// <param name="decoder">The decoder state.</param>
+        /// <param name="disabled">Whether to disable all found extensions in the padding area.</param>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public static void SetIgnoreExtensions(this OpusDecoder decoder, bool disabled)
+        {
+            decoder.Ctl(DecoderCTL.OPUS_SET_IGNORE_EXTENSIONS, disabled ? 1 : 0);
+        }
+
+        /// <summary>
+        /// Determines whether the decoder is ignoring extensions found in the padding area.
+        /// </summary>
+        /// <param name="decoder">The decoder state.</param>
+        /// <returns>Whether the decoder is ignoring extensions.</returns>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public static bool GetIgnoreExtensions(this OpusDecoder decoder)
+        {
+            var value = 0;
+            decoder.Ctl(DecoderCTL.OPUS_GET_IGNORE_EXTENSIONS, ref value);
+            return value == 1;
+        }
 
         /// <summary>
         /// Resets the codec state to be equivalent to a freshly initialized state.

OpusSharp.Core/Extensions/OpusDecoderExtensions.cs

@@ -414,6 +414,32 @@ public static int GetInDtx(this OpusEncoder encoder)
             return value;
         }
 
+        /// <summary>
+        /// Configures the encoder's QEXT extension.
+        /// </summary>
+        /// <param name="encoder">The encoder state.</param>
+        /// <param name="enabled">Whether to enable the QEXT extension or not.</param>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public static void SetQext(this OpusEncoder encoder, bool enabled)
+        {
+            encoder.Ctl(EncoderCTL.OPUS_SET_QEXT, enabled ? 1 : 0);
+        }
+        
+        /// <summary>
+        /// Determine if the QEXT extension is enabled in the encoder.
+        /// </summary>
+        /// <param name="encoder">The encoder state.</param>
+        /// <returns>Whether the QEXT extension is enabled or not.</returns>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public static bool GetQext(this OpusEncoder encoder)
+        {
+            var value = 0;
+            encoder.Ctl(EncoderCTL.OPUS_GET_QEXT, ref value);
+            return value == 1;
+        }
+        
         /// <summary>
         /// Resets the codec state to be equivalent to a freshly initialized state.
         /// </summary>

OpusSharp.Core/Extensions/OpusEncoderExtensions.cs

@@ -56,6 +56,18 @@ public static class NativeOpus
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         public static extern unsafe int opus_encode(OpusEncoderSafeHandle st, short* pcm, int frame_size, byte* data, int max_data_bytes);
 
+        /// <summary>
+        /// Encodes an Opus frame.
+        /// </summary>
+        /// <param name="st">Encoder state.</param>
+        /// <param name="pcm">Input signal (interleaved if 2 channels) representing (or slightly exceeding) 24-bit values. length is frame_size*channels*sizeof(int)</param>
+        /// <param name="frame_size">Number of samples per channel in the input signal. This must be an Opus frame size for the encoder's sampling rate. For example, at 48 kHz the permitted values are 120, 240, 480, 960, 1920, and 2880. Passing in a duration of less than 10 ms (480 samples at 48 kHz) will prevent the encoder from using the LPC or hybrid modes.</param>
+        /// <param name="data">Output payload. This must contain storage for at least max_data_bytes.</param>
+        /// <param name="max_data_bytes">Size of the allocated memory for the output payload. This may be used to impose an upper limit on the instant bitrate, but should not be used as the only bitrate control. Use <see cref="EncoderCTL.OPUS_SET_BITRATE"/> to control the bitrate.</param>
+        /// <returns>The length of the encoded packet (in bytes) on success or a negative error code (see <see cref="OpusErrorCodes"/>) on failure.</returns>
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern unsafe int opus_encode24(OpusEncoderSafeHandle st, int* pcm, int frame_size, byte* data, int max_data_bytes);
+        
         /// <summary>
         /// Encodes an Opus frame from floating point input.
         /// </summary>
@@ -179,6 +191,19 @@ public static class NativeOpus
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         public static extern unsafe int opus_decode(OpusDecoderSafeHandle st, byte* data, int len, short* pcm, int frame_size, int decode_fec);
 
+        /// <summary>
+        /// Decode an Opus packet.
+        /// </summary>
+        /// <param name="st">Decoder state.</param>
+        /// <param name="data">Input payload. Use a NULL pointer to indicate packet loss.</param>
+        /// <param name="len">Number of bytes in payload.</param>
+        /// <param name="pcm">Output signal (interleaved if 2 channels). length is frame_size*channels*sizeof(int).</param>
+        /// <param name="frame_size">Number of samples per channel of available space in pcm. If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1), then frame_size needs to be exactly the duration of audio that is missing, otherwise the decoder will not be in the optimal state to decode the next incoming packet. For the PLC and FEC cases, frame_size must be a multiple of 2.5 ms.</param>
+        /// <param name="decode_fec">Flag (0 or 1) to request that any in-band forward error correction data be decoded. If no such data is available, the frame is decoded as if it were lost.</param>
+        /// <returns>Number of decoded samples or <see cref="OpusErrorCodes"/>.</returns>
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern unsafe int opus_decode24(OpusDecoderSafeHandle st, byte* data, int len, int* pcm, int frame_size, int decode_fec);
+
         /// <summary>
         /// Decode an Opus packet with floating point output.
         /// </summary>
@@ -338,6 +363,18 @@ public static class NativeOpus
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         public static extern unsafe int opus_decoder_dred_decode(OpusDecoderSafeHandle st, OpusDREDSafeHandle dred, int dred_offset, short* pcm, int frame_size);
 
+        /// <summary>
+        /// Decode audio from an <see cref="OpusDREDSafeHandle"/> packet with floating point output.
+        /// </summary>
+        /// <param name="st">Decoder state.</param>
+        /// <param name="dred">DRED state.</param>
+        /// <param name="dred_offset">position of the redundancy to decode (in samples before the beginning of the real audio data in the packet).</param>
+        /// <param name="pcm">Output signal (interleaved if 2 channels). length is frame_size*channels*sizeof(int)</param>
+        /// <param name="frame_size">Number of samples per channel to decode in pcm. frame_size must be a multiple of 2.5 ms.</param>
+        /// <returns>Number of decoded samples or <see cref="OpusErrorCodes"/>.</returns>
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern unsafe int opus_decoder_dred_decode24(OpusDecoderSafeHandle st, OpusDREDSafeHandle dred, int dred_offset, int* pcm, int frame_size);
+
         /// <summary>
         /// Decode audio from an <see cref="OpusDREDSafeHandle"/> packet with floating point output.
         /// </summary>
@@ -636,6 +673,18 @@ public static class NativeOpus
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         public static extern unsafe int opus_multistream_encode(OpusMSEncoderSafeHandle st, short* pcm, int frame_size, byte* data, int max_data_bytes);
 
+        /// <summary>
+        /// Encodes a multistream Opus frame.
+        /// </summary>
+        /// <param name="st">Multistream encoder state.</param>
+        /// <param name="pcm">The input signal as interleaved samples. This must contain frame_size*channels samples.</param>
+        /// <param name="frame_size">Number of samples per channel in the input signal. This must be an Opus frame size for the encoder's sampling rate. For example, at 48 kHz the permitted values are 120, 240, 480, 960, 1920, and 2880. Passing in a duration of less than 10 ms (480 samples at 48 kHz) will prevent the encoder from using the LPC or hybrid modes.</param>
+        /// <param name="data">Output payload. This must contain storage for at least max_data_bytes.</param>
+        /// <param name="max_data_bytes">Size of the allocated memory for the output payload. This may be used to impose an upper limit on the instant bitrate, but should not be used as the only bitrate control. Use <see cref="EncoderCTL.OPUS_SET_BITRATE"/> to control the bitrate.</param>
+        /// <returns>The length of the encoded packet (in bytes) on success or a negative error code (see <see cref="OpusErrorCodes"/>) on failure.</returns>
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern unsafe int opus_multistream_encode24(OpusMSEncoderSafeHandle st, int* pcm, int frame_size, byte* data, int max_data_bytes);
+        
         /// <summary>
         /// Encodes a multistream Opus frame from floating point input.
         /// </summary>
@@ -766,6 +815,19 @@ public static class NativeOpus
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
         public static extern unsafe int opus_multistream_decode(OpusMSDecoderSafeHandle st, byte* data, int len, short* pcm, int frame_size, int decode_fec);
 
+        /// <summary>
+        /// Decode a multistream Opus packet.
+        /// </summary>
+        /// <param name="st">Multistream decoder state.</param>
+        /// <param name="data">Input payload. Use a NULL pointer to indicate packet loss.</param>
+        /// <param name="len">Number of bytes in payload.</param>
+        /// <param name="pcm">Output signal, with interleaved samples. This must contain room for frame_size*channels samples.</param>
+        /// <param name="frame_size">The number of samples per channel of available space in pcm. If this is less than the maximum packet duration (120 ms; 5760 for 48kHz), this function will not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=1), then frame_size needs to be exactly the duration of audio that is missing, otherwise the decoder will not be in the optimal state to decode the next incoming packet. For the PLC and FEC cases, frame_size must be a multiple of 2.5 ms.</param>
+        /// <param name="decode_fec">Flag (0 or 1) to request that any in-band forward error correction data be decoded. If no such data is available, the frame is decoded as if it were lost.</param>
+        /// <returns>Number of samples decoded on success or a negative error code (see <see cref="OpusErrorCodes"/>) on failure.</returns>
+        [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern unsafe int opus_multistream_decode24(OpusMSDecoderSafeHandle st, int* data, int len, short* pcm, int frame_size, int decode_fec);
+
         /// <summary>
         /// Decode a multistream Opus packet with floating point output.
         /// </summary>

OpusSharp.Core/NativeOpus.cs

@@ -99,6 +99,34 @@ public unsafe int Decode(Span<byte> input, int length, Span<short> output, int f
                 return result;
             }
         }
+        
+        /// <summary>
+        /// Decodes an opus encoded frame.
+        /// </summary>
+        /// <param name="input">Input payload. Use null to indicate packet loss</param>
+        /// <param name="length">Number of bytes in payload.</param>
+        /// <param name="output">Output signal (interleaved if 2 channels). length is frame_size*channels.</param>
+        /// <param name="frame_size">Number of samples per channel of available space in pcm. If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=true), then frame_size needs to be exactly the duration of audio that is missing, otherwise the decoder will not be in the optimal state to decode the next incoming packet. For the PLC and FEC cases, frame_size must be a multiple of 2.5 ms.</param>
+        /// <param name="decode_fec">Request that any in-band forward error correction data be decoded. If no such data is available, the frame is decoded as if it were lost.</param>
+        /// <returns>Number of decoded samples or <see cref="OpusErrorCodes"/>.</returns>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public unsafe int Decode(Span<byte> input, int length, Span<int> output, int frame_size, bool decode_fec)
+        {
+            ThrowIfDisposed();
+
+            fixed (byte* inputPtr = input)
+            fixed (int* outputPtr = output)
+            {
+                var result = _useStatic
+                    ? StaticNativeOpus.opus_decode24(_handler, inputPtr, length, outputPtr, frame_size,
+                        decode_fec ? 1 : 0)
+                    : NativeOpus.opus_decode24(_handler, inputPtr, length, outputPtr, frame_size,
+                        decode_fec ? 1 : 0);
+                CheckError(result);
+                return result;
+            }
+        }
 
         /// <summary>
         /// Decodes an opus encoded frame.
@@ -156,6 +184,20 @@ public int Decode(byte[]? input, int length, byte[] output, int frame_size, bool
         public int Decode(byte[]? input, int length, short[] output, int frame_size, bool decode_fec) =>
             Decode(input.AsSpan(), length, output.AsSpan(), frame_size, decode_fec);
 
+        /// <summary>
+        /// Decodes an opus encoded frame.
+        /// </summary>
+        /// <param name="input">Input payload. Use null to indicate packet loss</param>
+        /// <param name="length">Number of bytes in payload.</param>
+        /// <param name="output">Output signal (interleaved if 2 channels). length is (frame_size*channels)/2. Note: I don't know if this is correct.</param>
+        /// <param name="frame_size">Number of samples per channel of available space in pcm. If this is less than the maximum packet duration (120ms; 5760 for 48kHz), this function will not be capable of decoding some packets. In the case of PLC (data==NULL) or FEC (decode_fec=true), then frame_size needs to be exactly the duration of audio that is missing, otherwise the decoder will not be in the optimal state to decode the next incoming packet. For the PLC and FEC cases, frame_size must be a multiple of 2.5 ms.</param>
+        /// <param name="decode_fec">Request that any in-band forward error correction data be decoded. If no such data is available, the frame is decoded as if it were lost.</param>
+        /// <returns>Number of decoded samples or <see cref="OpusErrorCodes"/>.</returns>
+        /// <exception cref="OpusException" />
+        /// <exception cref="ObjectDisposedException" />
+        public int Decode(byte[]? input, int length, int[] output, int frame_size, bool decode_fec) =>
+            Decode(input.AsSpan(), length, output.AsSpan(), frame_size, decode_fec);
+        
         /// <summary>
         /// Decodes an opus encoded frame.
         /// </summary>