981 lines
47 KiB
C
981 lines
47 KiB
C
/* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
|
|
Written by Jean-Marc Valin and Koen Vos */
|
|
/*
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
- Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
- Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
|
|
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/**
|
|
* @file opus.h
|
|
* @brief Opus reference implementation API
|
|
*/
|
|
|
|
#ifndef OPUS_H
|
|
#define OPUS_H
|
|
|
|
#include "opus_types.h"
|
|
#include "opus_defines.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @mainpage Opus
|
|
*
|
|
* The Opus codec is designed for interactive speech and audio transmission over the Internet.
|
|
* It is designed by the IETF Codec Working Group and incorporates technology from
|
|
* Skype's SILK codec and Xiph.Org's CELT codec.
|
|
*
|
|
* The Opus codec is designed to handle a wide range of interactive audio applications,
|
|
* including Voice over IP, videoconferencing, in-game chat, and even remote live music
|
|
* performances. It can scale from low bit-rate narrowband speech to very high quality
|
|
* stereo music. Its main features are:
|
|
|
|
* @li Sampling rates from 8 to 48 kHz
|
|
* @li Bit-rates from 6 kb/s to 510 kb/s
|
|
* @li Support for both constant bit-rate (CBR) and variable bit-rate (VBR)
|
|
* @li Audio bandwidth from narrowband to full-band
|
|
* @li Support for speech and music
|
|
* @li Support for mono and stereo
|
|
* @li Support for multichannel (up to 255 channels)
|
|
* @li Frame sizes from 2.5 ms to 60 ms
|
|
* @li Good loss robustness and packet loss concealment (PLC)
|
|
* @li Floating point and fixed-point implementation
|
|
*
|
|
* Documentation sections:
|
|
* @li @ref opus_encoder
|
|
* @li @ref opus_decoder
|
|
* @li @ref opus_repacketizer
|
|
* @li @ref opus_multistream
|
|
* @li @ref opus_libinfo
|
|
* @li @ref opus_custom
|
|
*/
|
|
|
|
/** @defgroup opus_encoder Opus Encoder
|
|
* @{
|
|
*
|
|
* @brief This page describes the process and functions used to encode Opus.
|
|
*
|
|
* Since Opus is a stateful codec, the encoding process starts with creating an encoder
|
|
* state. This can be done with:
|
|
*
|
|
* @code
|
|
* int error;
|
|
* OpusEncoder *enc;
|
|
* enc = opus_encoder_create(Fs, channels, application, &error);
|
|
* @endcode
|
|
*
|
|
* From this point, @c enc can be used for encoding an audio stream. An encoder state
|
|
* @b must @b not be used for more than one stream at the same time. Similarly, the encoder
|
|
* state @b must @b not be re-initialized for each frame.
|
|
*
|
|
* While opus_encoder_create() allocates memory for the state, it's also possible
|
|
* to initialize pre-allocated memory:
|
|
*
|
|
* @code
|
|
* int size;
|
|
* int error;
|
|
* OpusEncoder *enc;
|
|
* size = opus_encoder_get_size(channels);
|
|
* enc = malloc(size);
|
|
* error = opus_encoder_init(enc, Fs, channels, application);
|
|
* @endcode
|
|
*
|
|
* where opus_encoder_get_size() returns the required size for the encoder state. Note that
|
|
* future versions of this code may change the size, so no assumptions should be made about it.
|
|
*
|
|
* The encoder state is always continuous in memory and only a shallow copy is sufficient
|
|
* to copy it (e.g. memcpy())
|
|
*
|
|
* It is possible to change some of the encoder's settings using the opus_encoder_ctl()
|
|
* interface. All these settings already default to the recommended value, so they should
|
|
* only be changed when necessary. The most common settings one may want to change are:
|
|
*
|
|
* @code
|
|
* opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate));
|
|
* opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
|
|
* opus_encoder_ctl(enc, OPUS_SET_SIGNAL(signal_type));
|
|
* @endcode
|
|
*
|
|
* where
|
|
*
|
|
* @arg bitrate is in bits per second (b/s)
|
|
* @arg complexity is a value from 1 to 10, where 1 is the lowest complexity and 10 is the highest
|
|
* @arg signal_type is either OPUS_AUTO (default), OPUS_SIGNAL_VOICE, or OPUS_SIGNAL_MUSIC
|
|
*
|
|
* See @ref opus_encoderctls and @ref opus_genericctls for a complete list of parameters that can be set or queried. Most parameters can be set or changed at any time during a stream.
|
|
*
|
|
* To encode a frame, opus_encode() or opus_encode_float() must be called with exactly one frame (2.5, 5, 10, 20, 40 or 60 ms) of audio data:
|
|
* @code
|
|
* len = opus_encode(enc, audio_frame, frame_size, packet, max_packet);
|
|
* @endcode
|
|
*
|
|
* where
|
|
* <ul>
|
|
* <li>audio_frame is the audio data in opus_int16 (or float for opus_encode_float())</li>
|
|
* <li>frame_size is the duration of the frame in samples (per channel)</li>
|
|
* <li>packet is the byte array to which the compressed data is written</li>
|
|
* <li>max_packet is the maximum number of bytes that can be written in the packet (4000 bytes is recommended).
|
|
* Do not use max_packet to control VBR target bitrate, instead use the #OPUS_SET_BITRATE CTL.</li>
|
|
* </ul>
|
|
*
|
|
* opus_encode() and opus_encode_float() return the number of bytes actually written to the packet.
|
|
* The return value <b>can be negative</b>, which indicates that an error has occurred. If the return value
|
|
* is 2 bytes or less, then the packet does not need to be transmitted (DTX).
|
|
*
|
|
* Once the encoder state if no longer needed, it can be destroyed with
|
|
*
|
|
* @code
|
|
* opus_encoder_destroy(enc);
|
|
* @endcode
|
|
*
|
|
* If the encoder was created with opus_encoder_init() rather than opus_encoder_create(),
|
|
* then no action is required aside from potentially freeing the memory that was manually
|
|
* allocated for it (calling free(enc) for the example above)
|
|
*
|
|
*/
|
|
|
|
/** Opus encoder state.
|
|
* This contains the complete state of an Opus encoder.
|
|
* It is position independent and can be freely copied.
|
|
* @see opus_encoder_create,opus_encoder_init
|
|
*/
|
|
typedef struct OpusEncoder OpusEncoder;
|
|
|
|
/** Gets the size of an <code>OpusEncoder</code> structure.
|
|
* @param[in] channels <tt>int</tt>: Number of channels.
|
|
* This must be 1 or 2.
|
|
* @returns The size in bytes.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_encoder_get_size(int channels);
|
|
|
|
/**
|
|
*/
|
|
|
|
/** Allocates and initializes an encoder state.
|
|
* There are three coding modes:
|
|
*
|
|
* @ref OPUS_APPLICATION_VOIP gives best quality at a given bitrate for voice
|
|
* signals. It enhances the input signal by high-pass filtering and
|
|
* emphasizing formants and harmonics. Optionally it includes in-band
|
|
* forward error correction to protect against packet loss. Use this
|
|
* mode for typical VoIP applications. Because of the enhancement,
|
|
* even at high bitrates the output may sound different from the input.
|
|
*
|
|
* @ref OPUS_APPLICATION_AUDIO gives best quality at a given bitrate for most
|
|
* non-voice signals like music. Use this mode for music and mixed
|
|
* (music/voice) content, broadcast, and applications requiring less
|
|
* than 15 ms of coding delay.
|
|
*
|
|
* @ref OPUS_APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that
|
|
* disables the speech-optimized mode in exchange for slightly reduced delay.
|
|
* This mode can only be set on an newly initialized or freshly reset encoder
|
|
* because it changes the codec delay.
|
|
*
|
|
* This is useful when the caller knows that the speech-optimized modes will not be needed (use with caution).
|
|
* @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
|
|
* This must be one of 8000, 12000, 16000,
|
|
* 24000, or 48000.
|
|
* @param [in] channels <tt>int</tt>: Number of channels (1 or 2) in input signal
|
|
* @param [in] application <tt>int</tt>: Coding mode (@ref OPUS_APPLICATION_VOIP/@ref OPUS_APPLICATION_AUDIO/@ref OPUS_APPLICATION_RESTRICTED_LOWDELAY)
|
|
* @param [out] error <tt>int*</tt>: @ref opus_errorcodes
|
|
* @note Regardless of the sampling rate and number channels selected, the Opus encoder
|
|
* can switch to a lower audio bandwidth or number of channels if the bitrate
|
|
* selected is too low. This also means that it is safe to always use 48 kHz stereo input
|
|
* and let the encoder optimize the encoding.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusEncoder *opus_encoder_create(
|
|
opus_int32 Fs,
|
|
int channels,
|
|
int application,
|
|
int *error
|
|
);
|
|
|
|
/** Initializes a previously allocated encoder state
|
|
* The memory pointed to by st must be at least the size returned by opus_encoder_get_size().
|
|
* This is intended for applications which use their own allocator instead of malloc.
|
|
* @see opus_encoder_create(),opus_encoder_get_size()
|
|
* To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
|
|
* @param [in] st <tt>OpusEncoder*</tt>: Encoder state
|
|
* @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
|
|
* This must be one of 8000, 12000, 16000,
|
|
* 24000, or 48000.
|
|
* @param [in] channels <tt>int</tt>: Number of channels (1 or 2) in input signal
|
|
* @param [in] application <tt>int</tt>: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)
|
|
* @retval #OPUS_OK Success or @ref opus_errorcodes
|
|
*/
|
|
OPUS_EXPORT int opus_encoder_init(
|
|
OpusEncoder *st,
|
|
opus_int32 Fs,
|
|
int channels,
|
|
int application
|
|
) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Encodes an Opus frame.
|
|
* @param [in] st <tt>OpusEncoder*</tt>: Encoder state
|
|
* @param [in] pcm <tt>opus_int16*</tt>: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(opus_int16)
|
|
* @param [in] frame_size <tt>int</tt>: 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 [out] data <tt>unsigned char*</tt>: Output payload.
|
|
* This must contain storage for at
|
|
* least \a max_data_bytes.
|
|
* @param [in] max_data_bytes <tt>opus_int32</tt>: 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 #OPUS_SET_BITRATE to
|
|
* control the bitrate.
|
|
* @returns The length of the encoded packet (in bytes) on success or a
|
|
* negative error code (see @ref opus_errorcodes) on failure.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode(
|
|
OpusEncoder *st,
|
|
const opus_int16 *pcm,
|
|
int frame_size,
|
|
unsigned char *data,
|
|
opus_int32 max_data_bytes
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
|
|
|
|
/** Encodes an Opus frame from floating point input.
|
|
* @param [in] st <tt>OpusEncoder*</tt>: Encoder state
|
|
* @param [in] pcm <tt>float*</tt>: Input in float format (interleaved if 2 channels), with a normal range of +/-1.0.
|
|
* Samples with a range beyond +/-1.0 are supported but will
|
|
* be clipped by decoders using the integer API and should
|
|
* only be used if it is known that the far end supports
|
|
* extended dynamic range.
|
|
* length is frame_size*channels*sizeof(float)
|
|
* @param [in] frame_size <tt>int</tt>: 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 [out] data <tt>unsigned char*</tt>: Output payload.
|
|
* This must contain storage for at
|
|
* least \a max_data_bytes.
|
|
* @param [in] max_data_bytes <tt>opus_int32</tt>: 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 #OPUS_SET_BITRATE to
|
|
* control the bitrate.
|
|
* @returns The length of the encoded packet (in bytes) on success or a
|
|
* negative error code (see @ref opus_errorcodes) on failure.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode_float(
|
|
OpusEncoder *st,
|
|
const float *pcm,
|
|
int frame_size,
|
|
unsigned char *data,
|
|
opus_int32 max_data_bytes
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
|
|
|
|
/** Frees an <code>OpusEncoder</code> allocated by opus_encoder_create().
|
|
* @param[in] st <tt>OpusEncoder*</tt>: State to be freed.
|
|
*/
|
|
OPUS_EXPORT void opus_encoder_destroy(OpusEncoder *st);
|
|
|
|
/** Perform a CTL function on an Opus encoder.
|
|
*
|
|
* Generally the request and subsequent arguments are generated
|
|
* by a convenience macro.
|
|
* @param st <tt>OpusEncoder*</tt>: Encoder state.
|
|
* @param request This and all remaining parameters should be replaced by one
|
|
* of the convenience macros in @ref opus_genericctls or
|
|
* @ref opus_encoderctls.
|
|
* @see opus_genericctls
|
|
* @see opus_encoderctls
|
|
*/
|
|
OPUS_EXPORT int opus_encoder_ctl(OpusEncoder *st, int request, ...) OPUS_ARG_NONNULL(1);
|
|
/**@}*/
|
|
|
|
/** @defgroup opus_decoder Opus Decoder
|
|
* @{
|
|
*
|
|
* @brief This page describes the process and functions used to decode Opus.
|
|
*
|
|
* The decoding process also starts with creating a decoder
|
|
* state. This can be done with:
|
|
* @code
|
|
* int error;
|
|
* OpusDecoder *dec;
|
|
* dec = opus_decoder_create(Fs, channels, &error);
|
|
* @endcode
|
|
* where
|
|
* @li Fs is the sampling rate and must be 8000, 12000, 16000, 24000, or 48000
|
|
* @li channels is the number of channels (1 or 2)
|
|
* @li error will hold the error code in case of failure (or #OPUS_OK on success)
|
|
* @li the return value is a newly created decoder state to be used for decoding
|
|
*
|
|
* While opus_decoder_create() allocates memory for the state, it's also possible
|
|
* to initialize pre-allocated memory:
|
|
* @code
|
|
* int size;
|
|
* int error;
|
|
* OpusDecoder *dec;
|
|
* size = opus_decoder_get_size(channels);
|
|
* dec = malloc(size);
|
|
* error = opus_decoder_init(dec, Fs, channels);
|
|
* @endcode
|
|
* where opus_decoder_get_size() returns the required size for the decoder state. Note that
|
|
* future versions of this code may change the size, so no assumptions should be made about it.
|
|
*
|
|
* The decoder state is always continuous in memory and only a shallow copy is sufficient
|
|
* to copy it (e.g. memcpy())
|
|
*
|
|
* To decode a frame, opus_decode() or opus_decode_float() must be called with a packet of compressed audio data:
|
|
* @code
|
|
* frame_size = opus_decode(dec, packet, len, decoded, max_size, 0);
|
|
* @endcode
|
|
* where
|
|
*
|
|
* @li packet is the byte array containing the compressed data
|
|
* @li len is the exact number of bytes contained in the packet
|
|
* @li decoded is the decoded audio data in opus_int16 (or float for opus_decode_float())
|
|
* @li max_size is the max duration of the frame in samples (per channel) that can fit into the decoded_frame array
|
|
*
|
|
* opus_decode() and opus_decode_float() return the number of samples (per channel) decoded from the packet.
|
|
* If that value is negative, then an error has occurred. This can occur if the packet is corrupted or if the audio
|
|
* buffer is too small to hold the decoded audio.
|
|
*
|
|
* Opus is a stateful codec with overlapping blocks and as a result Opus
|
|
* packets are not coded independently of each other. Packets must be
|
|
* passed into the decoder serially and in the correct order for a correct
|
|
* decode. Lost packets can be replaced with loss concealment by calling
|
|
* the decoder with a null pointer and zero length for the missing packet.
|
|
*
|
|
* A single codec state may only be accessed from a single thread at
|
|
* a time and any required locking must be performed by the caller. Separate
|
|
* streams must be decoded with separate decoder states and can be decoded
|
|
* in parallel unless the library was compiled with NONTHREADSAFE_PSEUDOSTACK
|
|
* defined.
|
|
*
|
|
*/
|
|
|
|
/** Opus decoder state.
|
|
* This contains the complete state of an Opus decoder.
|
|
* It is position independent and can be freely copied.
|
|
* @see opus_decoder_create,opus_decoder_init
|
|
*/
|
|
typedef struct OpusDecoder OpusDecoder;
|
|
|
|
/** Gets the size of an <code>OpusDecoder</code> structure.
|
|
* @param [in] channels <tt>int</tt>: Number of channels.
|
|
* This must be 1 or 2.
|
|
* @returns The size in bytes.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_size(int channels);
|
|
|
|
/** Allocates and initializes a decoder state.
|
|
* @param [in] Fs <tt>opus_int32</tt>: Sample rate to decode at (Hz).
|
|
* This must be one of 8000, 12000, 16000,
|
|
* 24000, or 48000.
|
|
* @param [in] channels <tt>int</tt>: Number of channels (1 or 2) to decode
|
|
* @param [out] error <tt>int*</tt>: #OPUS_OK Success or @ref opus_errorcodes
|
|
*
|
|
* Internally Opus stores data at 48000 Hz, so that should be the default
|
|
* value for Fs. However, the decoder can efficiently decode to buffers
|
|
* at 8, 12, 16, and 24 kHz so if for some reason the caller cannot use
|
|
* data at the full sample rate, or knows the compressed data doesn't
|
|
* use the full frequency range, it can request decoding at a reduced
|
|
* rate. Likewise, the decoder is capable of filling in either mono or
|
|
* interleaved stereo pcm buffers, at the caller's request.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusDecoder *opus_decoder_create(
|
|
opus_int32 Fs,
|
|
int channels,
|
|
int *error
|
|
);
|
|
|
|
/** Initializes a previously allocated decoder state.
|
|
* The state must be at least the size returned by opus_decoder_get_size().
|
|
* This is intended for applications which use their own allocator instead of malloc. @see opus_decoder_create,opus_decoder_get_size
|
|
* To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
|
|
* @param [in] st <tt>OpusDecoder*</tt>: Decoder state.
|
|
* @param [in] Fs <tt>opus_int32</tt>: Sampling rate to decode to (Hz).
|
|
* This must be one of 8000, 12000, 16000,
|
|
* 24000, or 48000.
|
|
* @param [in] channels <tt>int</tt>: Number of channels (1 or 2) to decode
|
|
* @retval #OPUS_OK Success or @ref opus_errorcodes
|
|
*/
|
|
OPUS_EXPORT int opus_decoder_init(
|
|
OpusDecoder *st,
|
|
opus_int32 Fs,
|
|
int channels
|
|
) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Decode an Opus packet.
|
|
* @param [in] st <tt>OpusDecoder*</tt>: Decoder state
|
|
* @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss
|
|
* @param [in] len <tt>opus_int32</tt>: Number of bytes in payload*
|
|
* @param [out] pcm <tt>opus_int16*</tt>: Output signal (interleaved if 2 channels). length
|
|
* is frame_size*channels*sizeof(opus_int16)
|
|
* @param [in] frame_size Number of samples per channel of available space in \a 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 <b>must</b> be a multiple of 2.5 ms.
|
|
* @param [in] decode_fec <tt>int</tt>: 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.
|
|
* @returns Number of decoded samples or @ref opus_errorcodes
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode(
|
|
OpusDecoder *st,
|
|
const unsigned char *data,
|
|
opus_int32 len,
|
|
opus_int16 *pcm,
|
|
int frame_size,
|
|
int decode_fec
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
|
|
|
|
/** Decode an Opus packet with floating point output.
|
|
* @param [in] st <tt>OpusDecoder*</tt>: Decoder state
|
|
* @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss
|
|
* @param [in] len <tt>opus_int32</tt>: Number of bytes in payload
|
|
* @param [out] pcm <tt>float*</tt>: Output signal (interleaved if 2 channels). length
|
|
* is frame_size*channels*sizeof(float)
|
|
* @param [in] frame_size Number of samples per channel of available space in \a 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 <b>must</b> be a multiple of 2.5 ms.
|
|
* @param [in] decode_fec <tt>int</tt>: 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.
|
|
* @returns Number of decoded samples or @ref opus_errorcodes
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode_float(
|
|
OpusDecoder *st,
|
|
const unsigned char *data,
|
|
opus_int32 len,
|
|
float *pcm,
|
|
int frame_size,
|
|
int decode_fec
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
|
|
|
|
/** Perform a CTL function on an Opus decoder.
|
|
*
|
|
* Generally the request and subsequent arguments are generated
|
|
* by a convenience macro.
|
|
* @param st <tt>OpusDecoder*</tt>: Decoder state.
|
|
* @param request This and all remaining parameters should be replaced by one
|
|
* of the convenience macros in @ref opus_genericctls or
|
|
* @ref opus_decoderctls.
|
|
* @see opus_genericctls
|
|
* @see opus_decoderctls
|
|
*/
|
|
OPUS_EXPORT int opus_decoder_ctl(OpusDecoder *st, int request, ...) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Frees an <code>OpusDecoder</code> allocated by opus_decoder_create().
|
|
* @param[in] st <tt>OpusDecoder*</tt>: State to be freed.
|
|
*/
|
|
OPUS_EXPORT void opus_decoder_destroy(OpusDecoder *st);
|
|
|
|
/** Parse an opus packet into one or more frames.
|
|
* Opus_decode will perform this operation internally so most applications do
|
|
* not need to use this function.
|
|
* This function does not copy the frames, the returned pointers are pointers into
|
|
* the input packet.
|
|
* @param [in] data <tt>char*</tt>: Opus packet to be parsed
|
|
* @param [in] len <tt>opus_int32</tt>: size of data
|
|
* @param [out] out_toc <tt>char*</tt>: TOC pointer
|
|
* @param [out] frames <tt>char*[48]</tt> encapsulated frames
|
|
* @param [out] size <tt>opus_int16[48]</tt> sizes of the encapsulated frames
|
|
* @param [out] payload_offset <tt>int*</tt>: returns the position of the payload within the packet (in bytes)
|
|
* @returns number of frames
|
|
*/
|
|
OPUS_EXPORT int opus_packet_parse(
|
|
const unsigned char *data,
|
|
opus_int32 len,
|
|
unsigned char *out_toc,
|
|
const unsigned char *frames[48],
|
|
opus_int16 size[48],
|
|
int *payload_offset
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(5);
|
|
|
|
/** Gets the bandwidth of an Opus packet.
|
|
* @param [in] data <tt>char*</tt>: Opus packet
|
|
* @retval OPUS_BANDWIDTH_NARROWBAND Narrowband (4kHz bandpass)
|
|
* @retval OPUS_BANDWIDTH_MEDIUMBAND Mediumband (6kHz bandpass)
|
|
* @retval OPUS_BANDWIDTH_WIDEBAND Wideband (8kHz bandpass)
|
|
* @retval OPUS_BANDWIDTH_SUPERWIDEBAND Superwideband (12kHz bandpass)
|
|
* @retval OPUS_BANDWIDTH_FULLBAND Fullband (20kHz bandpass)
|
|
* @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_bandwidth(const unsigned char *data) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Gets the number of samples per frame from an Opus packet.
|
|
* @param [in] data <tt>char*</tt>: Opus packet.
|
|
* This must contain at least one byte of
|
|
* data.
|
|
* @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz.
|
|
* This must be a multiple of 400, or
|
|
* inaccurate results will be returned.
|
|
* @returns Number of samples per frame.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Gets the number of channels from an Opus packet.
|
|
* @param [in] data <tt>char*</tt>: Opus packet
|
|
* @returns Number of channels
|
|
* @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_channels(const unsigned char *data) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Gets the number of frames in an Opus packet.
|
|
* @param [in] packet <tt>char*</tt>: Opus packet
|
|
* @param [in] len <tt>opus_int32</tt>: Length of packet
|
|
* @returns Number of frames
|
|
* @retval OPUS_BAD_ARG Insufficient data was passed to the function
|
|
* @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Gets the number of samples of an Opus packet.
|
|
* @param [in] packet <tt>char*</tt>: Opus packet
|
|
* @param [in] len <tt>opus_int32</tt>: Length of packet
|
|
* @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz.
|
|
* This must be a multiple of 400, or
|
|
* inaccurate results will be returned.
|
|
* @returns Number of samples
|
|
* @retval OPUS_BAD_ARG Insufficient data was passed to the function
|
|
* @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len, opus_int32 Fs) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Gets the number of samples of an Opus packet.
|
|
* @param [in] dec <tt>OpusDecoder*</tt>: Decoder state
|
|
* @param [in] packet <tt>char*</tt>: Opus packet
|
|
* @param [in] len <tt>opus_int32</tt>: Length of packet
|
|
* @returns Number of samples
|
|
* @retval OPUS_BAD_ARG Insufficient data was passed to the function
|
|
* @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
|
|
|
|
/** Applies soft-clipping to bring a float signal within the [-1,1] range. If
|
|
* the signal is already in that range, nothing is done. If there are values
|
|
* outside of [-1,1], then the signal is clipped as smoothly as possible to
|
|
* both fit in the range and avoid creating excessive distortion in the
|
|
* process.
|
|
* @param [in,out] pcm <tt>float*</tt>: Input PCM and modified PCM
|
|
* @param [in] frame_size <tt>int</tt> Number of samples per channel to process
|
|
* @param [in] channels <tt>int</tt>: Number of channels
|
|
* @param [in,out] softclip_mem <tt>float*</tt>: State memory for the soft clipping process (one float per channel, initialized to zero)
|
|
*/
|
|
OPUS_EXPORT void opus_pcm_soft_clip(float *pcm, int frame_size, int channels, float *softclip_mem);
|
|
|
|
|
|
/**@}*/
|
|
|
|
/** @defgroup opus_repacketizer Repacketizer
|
|
* @{
|
|
*
|
|
* The repacketizer can be used to merge multiple Opus packets into a single
|
|
* packet or alternatively to split Opus packets that have previously been
|
|
* merged. Splitting valid Opus packets is always guaranteed to succeed,
|
|
* whereas merging valid packets only succeeds if all frames have the same
|
|
* mode, bandwidth, and frame size, and when the total duration of the merged
|
|
* packet is no more than 120 ms. The 120 ms limit comes from the
|
|
* specification and limits decoder memory requirements at a point where
|
|
* framing overhead becomes negligible.
|
|
*
|
|
* The repacketizer currently only operates on elementary Opus
|
|
* streams. It will not manipualte multistream packets successfully, except in
|
|
* the degenerate case where they consist of data from a single stream.
|
|
*
|
|
* The repacketizing process starts with creating a repacketizer state, either
|
|
* by calling opus_repacketizer_create() or by allocating the memory yourself,
|
|
* e.g.,
|
|
* @code
|
|
* OpusRepacketizer *rp;
|
|
* rp = (OpusRepacketizer*)malloc(opus_repacketizer_get_size());
|
|
* if (rp != NULL)
|
|
* opus_repacketizer_init(rp);
|
|
* @endcode
|
|
*
|
|
* Then the application should submit packets with opus_repacketizer_cat(),
|
|
* extract new packets with opus_repacketizer_out() or
|
|
* opus_repacketizer_out_range(), and then reset the state for the next set of
|
|
* input packets via opus_repacketizer_init().
|
|
*
|
|
* For example, to split a sequence of packets into individual frames:
|
|
* @code
|
|
* unsigned char *data;
|
|
* int len;
|
|
* while (get_next_packet(&data, &len))
|
|
* {
|
|
* unsigned char out[1276];
|
|
* opus_int32 out_len;
|
|
* int nb_frames;
|
|
* int err;
|
|
* int i;
|
|
* err = opus_repacketizer_cat(rp, data, len);
|
|
* if (err != OPUS_OK)
|
|
* {
|
|
* release_packet(data);
|
|
* return err;
|
|
* }
|
|
* nb_frames = opus_repacketizer_get_nb_frames(rp);
|
|
* for (i = 0; i < nb_frames; i++)
|
|
* {
|
|
* out_len = opus_repacketizer_out_range(rp, i, i+1, out, sizeof(out));
|
|
* if (out_len < 0)
|
|
* {
|
|
* release_packet(data);
|
|
* return (int)out_len;
|
|
* }
|
|
* output_next_packet(out, out_len);
|
|
* }
|
|
* opus_repacketizer_init(rp);
|
|
* release_packet(data);
|
|
* }
|
|
* @endcode
|
|
*
|
|
* Alternatively, to combine a sequence of frames into packets that each
|
|
* contain up to <code>TARGET_DURATION_MS</code> milliseconds of data:
|
|
* @code
|
|
* // The maximum number of packets with duration TARGET_DURATION_MS occurs
|
|
* // when the frame size is 2.5 ms, for a total of (TARGET_DURATION_MS*2/5)
|
|
* // packets.
|
|
* unsigned char *data[(TARGET_DURATION_MS*2/5)+1];
|
|
* opus_int32 len[(TARGET_DURATION_MS*2/5)+1];
|
|
* int nb_packets;
|
|
* unsigned char out[1277*(TARGET_DURATION_MS*2/2)];
|
|
* opus_int32 out_len;
|
|
* int prev_toc;
|
|
* nb_packets = 0;
|
|
* while (get_next_packet(data+nb_packets, len+nb_packets))
|
|
* {
|
|
* int nb_frames;
|
|
* int err;
|
|
* nb_frames = opus_packet_get_nb_frames(data[nb_packets], len[nb_packets]);
|
|
* if (nb_frames < 1)
|
|
* {
|
|
* release_packets(data, nb_packets+1);
|
|
* return nb_frames;
|
|
* }
|
|
* nb_frames += opus_repacketizer_get_nb_frames(rp);
|
|
* // If adding the next packet would exceed our target, or it has an
|
|
* // incompatible TOC sequence, output the packets we already have before
|
|
* // submitting it.
|
|
* // N.B., The nb_packets > 0 check ensures we've submitted at least one
|
|
* // packet since the last call to opus_repacketizer_init(). Otherwise a
|
|
* // single packet longer than TARGET_DURATION_MS would cause us to try to
|
|
* // output an (invalid) empty packet. It also ensures that prev_toc has
|
|
* // been set to a valid value. Additionally, len[nb_packets] > 0 is
|
|
* // guaranteed by the call to opus_packet_get_nb_frames() above, so the
|
|
* // reference to data[nb_packets][0] should be valid.
|
|
* if (nb_packets > 0 && (
|
|
* ((prev_toc & 0xFC) != (data[nb_packets][0] & 0xFC)) ||
|
|
* opus_packet_get_samples_per_frame(data[nb_packets], 48000)*nb_frames >
|
|
* TARGET_DURATION_MS*48))
|
|
* {
|
|
* out_len = opus_repacketizer_out(rp, out, sizeof(out));
|
|
* if (out_len < 0)
|
|
* {
|
|
* release_packets(data, nb_packets+1);
|
|
* return (int)out_len;
|
|
* }
|
|
* output_next_packet(out, out_len);
|
|
* opus_repacketizer_init(rp);
|
|
* release_packets(data, nb_packets);
|
|
* data[0] = data[nb_packets];
|
|
* len[0] = len[nb_packets];
|
|
* nb_packets = 0;
|
|
* }
|
|
* err = opus_repacketizer_cat(rp, data[nb_packets], len[nb_packets]);
|
|
* if (err != OPUS_OK)
|
|
* {
|
|
* release_packets(data, nb_packets+1);
|
|
* return err;
|
|
* }
|
|
* prev_toc = data[nb_packets][0];
|
|
* nb_packets++;
|
|
* }
|
|
* // Output the final, partial packet.
|
|
* if (nb_packets > 0)
|
|
* {
|
|
* out_len = opus_repacketizer_out(rp, out, sizeof(out));
|
|
* release_packets(data, nb_packets);
|
|
* if (out_len < 0)
|
|
* return (int)out_len;
|
|
* output_next_packet(out, out_len);
|
|
* }
|
|
* @endcode
|
|
*
|
|
* An alternate way of merging packets is to simply call opus_repacketizer_cat()
|
|
* unconditionally until it fails. At that point, the merged packet can be
|
|
* obtained with opus_repacketizer_out() and the input packet for which
|
|
* opus_repacketizer_cat() needs to be re-added to a newly reinitialized
|
|
* repacketizer state.
|
|
*/
|
|
|
|
typedef struct OpusRepacketizer OpusRepacketizer;
|
|
|
|
/** Gets the size of an <code>OpusRepacketizer</code> structure.
|
|
* @returns The size in bytes.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_size(void);
|
|
|
|
/** (Re)initializes a previously allocated repacketizer state.
|
|
* The state must be at least the size returned by opus_repacketizer_get_size().
|
|
* This can be used for applications which use their own allocator instead of
|
|
* malloc().
|
|
* It must also be called to reset the queue of packets waiting to be
|
|
* repacketized, which is necessary if the maximum packet duration of 120 ms
|
|
* is reached or if you wish to submit packets with a different Opus
|
|
* configuration (coding mode, audio bandwidth, frame size, or channel count).
|
|
* Failure to do so will prevent a new packet from being added with
|
|
* opus_repacketizer_cat().
|
|
* @see opus_repacketizer_create
|
|
* @see opus_repacketizer_get_size
|
|
* @see opus_repacketizer_cat
|
|
* @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state to
|
|
* (re)initialize.
|
|
* @returns A pointer to the same repacketizer state that was passed in.
|
|
*/
|
|
OPUS_EXPORT OpusRepacketizer *opus_repacketizer_init(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Allocates memory and initializes the new repacketizer with
|
|
* opus_repacketizer_init().
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusRepacketizer *opus_repacketizer_create(void);
|
|
|
|
/** Frees an <code>OpusRepacketizer</code> allocated by
|
|
* opus_repacketizer_create().
|
|
* @param[in] rp <tt>OpusRepacketizer*</tt>: State to be freed.
|
|
*/
|
|
OPUS_EXPORT void opus_repacketizer_destroy(OpusRepacketizer *rp);
|
|
|
|
/** Add a packet to the current repacketizer state.
|
|
* This packet must match the configuration of any packets already submitted
|
|
* for repacketization since the last call to opus_repacketizer_init().
|
|
* This means that it must have the same coding mode, audio bandwidth, frame
|
|
* size, and channel count.
|
|
* This can be checked in advance by examining the top 6 bits of the first
|
|
* byte of the packet, and ensuring they match the top 6 bits of the first
|
|
* byte of any previously submitted packet.
|
|
* The total duration of audio in the repacketizer state also must not exceed
|
|
* 120 ms, the maximum duration of a single packet, after adding this packet.
|
|
*
|
|
* The contents of the current repacketizer state can be extracted into new
|
|
* packets using opus_repacketizer_out() or opus_repacketizer_out_range().
|
|
*
|
|
* In order to add a packet with a different configuration or to add more
|
|
* audio beyond 120 ms, you must clear the repacketizer state by calling
|
|
* opus_repacketizer_init().
|
|
* If a packet is too large to add to the current repacketizer state, no part
|
|
* of it is added, even if it contains multiple frames, some of which might
|
|
* fit.
|
|
* If you wish to be able to add parts of such packets, you should first use
|
|
* another repacketizer to split the packet into pieces and add them
|
|
* individually.
|
|
* @see opus_repacketizer_out_range
|
|
* @see opus_repacketizer_out
|
|
* @see opus_repacketizer_init
|
|
* @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state to which to
|
|
* add the packet.
|
|
* @param[in] data <tt>const unsigned char*</tt>: The packet data.
|
|
* The application must ensure
|
|
* this pointer remains valid
|
|
* until the next call to
|
|
* opus_repacketizer_init() or
|
|
* opus_repacketizer_destroy().
|
|
* @param len <tt>opus_int32</tt>: The number of bytes in the packet data.
|
|
* @returns An error code indicating whether or not the operation succeeded.
|
|
* @retval #OPUS_OK The packet's contents have been added to the repacketizer
|
|
* state.
|
|
* @retval #OPUS_INVALID_PACKET The packet did not have a valid TOC sequence,
|
|
* the packet's TOC sequence was not compatible
|
|
* with previously submitted packets (because
|
|
* the coding mode, audio bandwidth, frame size,
|
|
* or channel count did not match), or adding
|
|
* this packet would increase the total amount of
|
|
* audio stored in the repacketizer state to more
|
|
* than 120 ms.
|
|
*/
|
|
OPUS_EXPORT int opus_repacketizer_cat(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
|
|
|
|
|
|
/** Construct a new packet from data previously submitted to the repacketizer
|
|
* state via opus_repacketizer_cat().
|
|
* @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state from which to
|
|
* construct the new packet.
|
|
* @param begin <tt>int</tt>: The index of the first frame in the current
|
|
* repacketizer state to include in the output.
|
|
* @param end <tt>int</tt>: One past the index of the last frame in the
|
|
* current repacketizer state to include in the
|
|
* output.
|
|
* @param[out] data <tt>const unsigned char*</tt>: The buffer in which to
|
|
* store the output packet.
|
|
* @param maxlen <tt>opus_int32</tt>: The maximum number of bytes to store in
|
|
* the output buffer. In order to guarantee
|
|
* success, this should be at least
|
|
* <code>1276</code> for a single frame,
|
|
* or for multiple frames,
|
|
* <code>1277*(end-begin)</code>.
|
|
* However, <code>1*(end-begin)</code> plus
|
|
* the size of all packet data submitted to
|
|
* the repacketizer since the last call to
|
|
* opus_repacketizer_init() or
|
|
* opus_repacketizer_create() is also
|
|
* sufficient, and possibly much smaller.
|
|
* @returns The total size of the output packet on success, or an error code
|
|
* on failure.
|
|
* @retval #OPUS_BAD_ARG <code>[begin,end)</code> was an invalid range of
|
|
* frames (begin < 0, begin >= end, or end >
|
|
* opus_repacketizer_get_nb_frames()).
|
|
* @retval #OPUS_BUFFER_TOO_SMALL \a maxlen was insufficient to contain the
|
|
* complete output packet.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out_range(OpusRepacketizer *rp, int begin, int end, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
|
|
|
|
/** Return the total number of frames contained in packet data submitted to
|
|
* the repacketizer state so far via opus_repacketizer_cat() since the last
|
|
* call to opus_repacketizer_init() or opus_repacketizer_create().
|
|
* This defines the valid range of packets that can be extracted with
|
|
* opus_repacketizer_out_range() or opus_repacketizer_out().
|
|
* @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state containing the
|
|
* frames.
|
|
* @returns The total number of frames contained in the packet data submitted
|
|
* to the repacketizer state.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_nb_frames(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Construct a new packet from data previously submitted to the repacketizer
|
|
* state via opus_repacketizer_cat().
|
|
* This is a convenience routine that returns all the data submitted so far
|
|
* in a single packet.
|
|
* It is equivalent to calling
|
|
* @code
|
|
* opus_repacketizer_out_range(rp, 0, opus_repacketizer_get_nb_frames(rp),
|
|
* data, maxlen)
|
|
* @endcode
|
|
* @param rp <tt>OpusRepacketizer*</tt>: The repacketizer state from which to
|
|
* construct the new packet.
|
|
* @param[out] data <tt>const unsigned char*</tt>: The buffer in which to
|
|
* store the output packet.
|
|
* @param maxlen <tt>opus_int32</tt>: The maximum number of bytes to store in
|
|
* the output buffer. In order to guarantee
|
|
* success, this should be at least
|
|
* <code>1277*opus_repacketizer_get_nb_frames(rp)</code>.
|
|
* However,
|
|
* <code>1*opus_repacketizer_get_nb_frames(rp)</code>
|
|
* plus the size of all packet data
|
|
* submitted to the repacketizer since the
|
|
* last call to opus_repacketizer_init() or
|
|
* opus_repacketizer_create() is also
|
|
* sufficient, and possibly much smaller.
|
|
* @returns The total size of the output packet on success, or an error code
|
|
* on failure.
|
|
* @retval #OPUS_BUFFER_TOO_SMALL \a maxlen was insufficient to contain the
|
|
* complete output packet.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1);
|
|
|
|
/** Pads a given Opus packet to a larger size (possibly changing the TOC sequence).
|
|
* @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
|
|
* packet to pad.
|
|
* @param len <tt>opus_int32</tt>: The size of the packet.
|
|
* This must be at least 1.
|
|
* @param new_len <tt>opus_int32</tt>: The desired size of the packet after padding.
|
|
* This must be at least as large as len.
|
|
* @returns an error code
|
|
* @retval #OPUS_OK \a on success.
|
|
* @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len.
|
|
* @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
|
|
*/
|
|
OPUS_EXPORT int opus_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len);
|
|
|
|
/** Remove all padding from a given Opus packet and rewrite the TOC sequence to
|
|
* minimize space usage.
|
|
* @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
|
|
* packet to strip.
|
|
* @param len <tt>opus_int32</tt>: The size of the packet.
|
|
* This must be at least 1.
|
|
* @returns The new size of the output packet on success, or an error code
|
|
* on failure.
|
|
* @retval #OPUS_BAD_ARG \a len was less than 1.
|
|
* @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_packet_unpad(unsigned char *data, opus_int32 len);
|
|
|
|
/** Pads a given Opus multi-stream packet to a larger size (possibly changing the TOC sequence).
|
|
* @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
|
|
* packet to pad.
|
|
* @param len <tt>opus_int32</tt>: The size of the packet.
|
|
* This must be at least 1.
|
|
* @param new_len <tt>opus_int32</tt>: The desired size of the packet after padding.
|
|
* This must be at least 1.
|
|
* @param nb_streams <tt>opus_int32</tt>: The number of streams (not channels) in the packet.
|
|
* This must be at least as large as len.
|
|
* @returns an error code
|
|
* @retval #OPUS_OK \a on success.
|
|
* @retval #OPUS_BAD_ARG \a len was less than 1.
|
|
* @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
|
|
*/
|
|
OPUS_EXPORT int opus_multistream_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len, int nb_streams);
|
|
|
|
/** Remove all padding from a given Opus multi-stream packet and rewrite the TOC sequence to
|
|
* minimize space usage.
|
|
* @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
|
|
* packet to strip.
|
|
* @param len <tt>opus_int32</tt>: The size of the packet.
|
|
* This must be at least 1.
|
|
* @param nb_streams <tt>opus_int32</tt>: The number of streams (not channels) in the packet.
|
|
* This must be at least 1.
|
|
* @returns The new size of the output packet on success, or an error code
|
|
* on failure.
|
|
* @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len.
|
|
* @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
|
|
*/
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_packet_unpad(unsigned char *data, opus_int32 len, int nb_streams);
|
|
|
|
/**@}*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* OPUS_H */
|