| /* 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_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 assuptions 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)</li> |
| * </ul> |
| * |
| * opus_encode() and opus_encode_frame() 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 1 byte, 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; |
| |
| 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) |
| * @param [in] channels <tt>int</tt>: Number of channels (1/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 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 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) |
| * @param [in] channels <tt>int</tt>: Number of channels (1/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. |
| * The passed frame_size must an opus frame size for the encoder's sampling rate. |
| * For example, at 48kHz the permitted values are 120, 240, 480, 960, 1920, and 2880. |
| * Passing in a duration of less than 10ms (480 samples at 48kHz) will |
| * prevent the encoder from using the LPC or hybrid modes. |
| * @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 frame of input signal |
| * @param [out] data <tt>char*</tt>: Output payload (at least max_data_bytes long) |
| * @param [in] max_data_bytes <tt>opus_int32</tt>: Allocated memory for payload; don't use for controlling bitrate |
| * @returns length of the data payload (in bytes) or @ref opus_errorcodes |
| */ |
| 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. |
| * The passed frame_size must an opus frame size for the encoder's sampling rate. |
| * For example, at 48kHz the permitted values are 120, 240, 480, 960, 1920, and 2880. |
| * Passing in a duration of less than 10ms (480 samples at 48kHz) will |
| * prevent the encoder from using the LPC or hybrid modes. |
| * @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 frame of input signal |
| * @param [out] data <tt>char*</tt>: Output payload (at least max_data_bytes long) |
| * @param [in] max_data_bytes <tt>opus_int32</tt>: Allocated memory for payload; don't use for controlling bitrate |
| * @returns length of the data payload (in bytes) or @ref opus_errorcodes |
| */ |
| 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 OpusEncoder 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. |
| * @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 or 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 assuptions 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 occured. 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 OpusDecoder structure. |
| * @param [in] channels <tt>int</tt>: Number of channels |
| * @returns size |
| */ |
| 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) |
| * @param [in] channels <tt>int</tt>: Number of channels (1/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 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) |
| * @param [in] channels <tt>int</tt>: Number of channels (1/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 frame |
| * @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 *pcm, |
| * if less than the maximum frame size (120ms) some frames can not be decoded |
| * @param [in] decode_fec <tt>int</tt>: Flag (0/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 frame 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 *pcm, |
| * if less than the maximum frame size (120ms) some frames can not be decoded |
| * @param [in] decode_fec <tt>int</tt>: Flag (0/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. |
| * @see opus_genericctls |
| */ |
| OPUS_EXPORT int opus_decoder_ctl(OpusDecoder *st, int request, ...) OPUS_ARG_NONNULL(1); |
| |
| /** Frees an OpusDecoder 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>short[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], |
| short size[48], |
| int *payload_offset |
| ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4); |
| |
| /** 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 |
| * @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz |
| * @returns Number of samples per frame |
| * @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_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_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] 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_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); |
| /**@}*/ |
| |
| /** @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. |
| * |
| */ |
| |
| typedef struct OpusRepacketizer OpusRepacketizer; |
| |
| OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_size(void); |
| |
| OPUS_EXPORT OpusRepacketizer *opus_repacketizer_init(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1); |
| |
| OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusRepacketizer *opus_repacketizer_create(void); |
| |
| OPUS_EXPORT void opus_repacketizer_destroy(OpusRepacketizer *rp); |
| |
| OPUS_EXPORT int opus_repacketizer_cat(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2); |
| |
| 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); |
| |
| OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_nb_frames(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1); |
| |
| OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1); |
| |
| /**@}*/ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* OPUS_H */ |