661 lines
33 KiB
C
661 lines
33 KiB
C
|
/* Copyright (c) 2011 Xiph.Org Foundation
|
||
|
|
Written by Jean-Marc Valin */
|
||
|
|
/*
|
||
|
|
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_multistream.h
|
||
|
|
* @brief Opus reference implementation multistream API
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef OPUS_MULTISTREAM_H
|
||
|
|
#define OPUS_MULTISTREAM_H
|
||
|
|
|
||
|
|
#include "opus.h"
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
extern "C" {
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/** @cond OPUS_INTERNAL_DOC */
|
||
|
|
|
||
|
|
/** Macros to trigger compilation errors when the wrong types are provided to a
|
||
|
|
* CTL. */
|
||
|
|
/**@{*/
|
||
|
|
#define __opus_check_encstate_ptr(ptr) ((ptr) + ((ptr) - (OpusEncoder**)(ptr)))
|
||
|
|
#define __opus_check_decstate_ptr(ptr) ((ptr) + ((ptr) - (OpusDecoder**)(ptr)))
|
||
|
|
/**@}*/
|
||
|
|
|
||
|
|
/** These are the actual encoder and decoder CTL ID numbers.
|
||
|
|
* They should not be used directly by applications.
|
||
|
|
* In general, SETs should be even and GETs should be odd.*/
|
||
|
|
/**@{*/
|
||
|
|
#define OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST 5120
|
||
|
|
#define OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST 5122
|
||
|
|
/**@}*/
|
||
|
|
|
||
|
|
/** @endcond */
|
||
|
|
|
||
|
|
/** @defgroup opus_multistream_ctls Multistream specific encoder and decoder CTLs
|
||
|
|
*
|
||
|
|
* These are convenience macros that are specific to the
|
||
|
|
* opus_multistream_encoder_ctl() and opus_multistream_decoder_ctl()
|
||
|
|
* interface.
|
||
|
|
* The CTLs from @ref opus_genericctls, @ref opus_encoderctls, and
|
||
|
|
* @ref opus_decoderctls may be applied to a multistream encoder or decoder as
|
||
|
|
* well.
|
||
|
|
* In addition, you may retrieve the encoder or decoder state for an specific
|
||
|
|
* stream via #OPUS_MULTISTREAM_GET_ENCODER_STATE or
|
||
|
|
* #OPUS_MULTISTREAM_GET_DECODER_STATE and apply CTLs to it individually.
|
||
|
|
*/
|
||
|
|
/**@{*/
|
||
|
|
|
||
|
|
/** Gets the encoder state for an individual stream of a multistream encoder.
|
||
|
|
* @param[in] x <tt>opus_int32</tt>: The index of the stream whose encoder you
|
||
|
|
* wish to retrieve.
|
||
|
|
* This must be non-negative and less than
|
||
|
|
* the <code>streams</code> parameter used
|
||
|
|
* to initialize the encoder.
|
||
|
|
* @param[out] y <tt>OpusEncoder**</tt>: Returns a pointer to the given
|
||
|
|
* encoder state.
|
||
|
|
* @retval OPUS_BAD_ARG The index of the requested stream was out of range.
|
||
|
|
* @hideinitializer
|
||
|
|
*/
|
||
|
|
#define OPUS_MULTISTREAM_GET_ENCODER_STATE(x,y) OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST, __opus_check_int(x), __opus_check_encstate_ptr(y)
|
||
|
|
|
||
|
|
/** Gets the decoder state for an individual stream of a multistream decoder.
|
||
|
|
* @param[in] x <tt>opus_int32</tt>: The index of the stream whose decoder you
|
||
|
|
* wish to retrieve.
|
||
|
|
* This must be non-negative and less than
|
||
|
|
* the <code>streams</code> parameter used
|
||
|
|
* to initialize the decoder.
|
||
|
|
* @param[out] y <tt>OpusDecoder**</tt>: Returns a pointer to the given
|
||
|
|
* decoder state.
|
||
|
|
* @retval OPUS_BAD_ARG The index of the requested stream was out of range.
|
||
|
|
* @hideinitializer
|
||
|
|
*/
|
||
|
|
#define OPUS_MULTISTREAM_GET_DECODER_STATE(x,y) OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST, __opus_check_int(x), __opus_check_decstate_ptr(y)
|
||
|
|
|
||
|
|
/**@}*/
|
||
|
|
|
||
|
|
/** @defgroup opus_multistream Opus Multistream API
|
||
|
|
* @{
|
||
|
|
*
|
||
|
|
* The multistream API allows individual Opus streams to be combined into a
|
||
|
|
* single packet, enabling support for up to 255 channels. Unlike an
|
||
|
|
* elementary Opus stream, the encoder and decoder must negotiate the channel
|
||
|
|
* configuration before the decoder can successfully interpret the data in the
|
||
|
|
* packets produced by the encoder. Some basic information, such as packet
|
||
|
|
* duration, can be computed without any special negotiation.
|
||
|
|
*
|
||
|
|
* The format for multistream Opus packets is defined in the
|
||
|
|
* <a href="http://tools.ietf.org/html/draft-terriberry-oggopus">Ogg
|
||
|
|
* encapsulation specification</a> and is based on the self-delimited Opus
|
||
|
|
* framing described in Appendix B of <a href="http://tools.ietf.org/html/rfc6716">RFC 6716</a>.
|
||
|
|
* Normal Opus packets are just a degenerate case of multistream Opus packets,
|
||
|
|
* and can be encoded or decoded with the multistream API by setting
|
||
|
|
* <code>streams</code> to <code>1</code> when initializing the encoder or
|
||
|
|
* decoder.
|
||
|
|
*
|
||
|
|
* Multistream Opus streams can contain up to 255 elementary Opus streams.
|
||
|
|
* These may be either "uncoupled" or "coupled", indicating that the decoder
|
||
|
|
* is configured to decode them to either 1 or 2 channels, respectively.
|
||
|
|
* The streams are ordered so that all coupled streams appear at the
|
||
|
|
* beginning.
|
||
|
|
*
|
||
|
|
* A <code>mapping</code> table defines which decoded channel <code>i</code>
|
||
|
|
* should be used for each input/output (I/O) channel <code>j</code>. This table is
|
||
|
|
* typically provided as an unsigned char array.
|
||
|
|
* Let <code>i = mapping[j]</code> be the index for I/O channel <code>j</code>.
|
||
|
|
* If <code>i < 2*coupled_streams</code>, then I/O channel <code>j</code> is
|
||
|
|
* encoded as the left channel of stream <code>(i/2)</code> if <code>i</code>
|
||
|
|
* is even, or as the right channel of stream <code>(i/2)</code> if
|
||
|
|
* <code>i</code> is odd. Otherwise, I/O channel <code>j</code> is encoded as
|
||
|
|
* mono in stream <code>(i - coupled_streams)</code>, unless it has the special
|
||
|
|
* value 255, in which case it is omitted from the encoding entirely (the
|
||
|
|
* decoder will reproduce it as silence). Each value <code>i</code> must either
|
||
|
|
* be the special value 255 or be less than <code>streams + coupled_streams</code>.
|
||
|
|
*
|
||
|
|
* The output channels specified by the encoder
|
||
|
|
* should use the
|
||
|
|
* <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
|
||
|
|
* channel ordering</a>. A decoder may wish to apply an additional permutation
|
||
|
|
* to the mapping the encoder used to achieve a different output channel
|
||
|
|
* order (e.g. for outputing in WAV order).
|
||
|
|
*
|
||
|
|
* Each multistream packet contains an Opus packet for each stream, and all of
|
||
|
|
* the Opus packets in a single multistream packet must have the same
|
||
|
|
* duration. Therefore the duration of a multistream packet can be extracted
|
||
|
|
* from the TOC sequence of the first stream, which is located at the
|
||
|
|
* beginning of the packet, just like an elementary Opus stream:
|
||
|
|
*
|
||
|
|
* @code
|
||
|
|
* int nb_samples;
|
||
|
|
* int nb_frames;
|
||
|
|
* nb_frames = opus_packet_get_nb_frames(data, len);
|
||
|
|
* if (nb_frames < 1)
|
||
|
|
* return nb_frames;
|
||
|
|
* nb_samples = opus_packet_get_samples_per_frame(data, 48000) * nb_frames;
|
||
|
|
* @endcode
|
||
|
|
*
|
||
|
|
* The general encoding and decoding process proceeds exactly the same as in
|
||
|
|
* the normal @ref opus_encoder and @ref opus_decoder APIs.
|
||
|
|
* See their documentation for an overview of how to use the corresponding
|
||
|
|
* multistream functions.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/** Opus multistream encoder state.
|
||
|
|
* This contains the complete state of a multistream Opus encoder.
|
||
|
|
* It is position independent and can be freely copied.
|
||
|
|
* @see opus_multistream_encoder_create
|
||
|
|
* @see opus_multistream_encoder_init
|
||
|
|
*/
|
||
|
|
typedef struct OpusMSEncoder OpusMSEncoder;
|
||
|
|
|
||
|
|
/** Opus multistream decoder state.
|
||
|
|
* This contains the complete state of a multistream Opus decoder.
|
||
|
|
* It is position independent and can be freely copied.
|
||
|
|
* @see opus_multistream_decoder_create
|
||
|
|
* @see opus_multistream_decoder_init
|
||
|
|
*/
|
||
|
|
typedef struct OpusMSDecoder OpusMSDecoder;
|
||
|
|
|
||
|
|
/**\name Multistream encoder functions */
|
||
|
|
/**@{*/
|
||
|
|
|
||
|
|
/** Gets the size of an OpusMSEncoder structure.
|
||
|
|
* @param streams <tt>int</tt>: The total number of streams to encode from the
|
||
|
|
* input.
|
||
|
|
* This must be no more than 255.
|
||
|
|
* @param coupled_streams <tt>int</tt>: Number of coupled (2 channel) streams
|
||
|
|
* to encode.
|
||
|
|
* This must be no larger than the total
|
||
|
|
* number of streams.
|
||
|
|
* Additionally, The total number of
|
||
|
|
* encoded channels (<code>streams +
|
||
|
|
* coupled_streams</code>) must be no
|
||
|
|
* more than 255.
|
||
|
|
* @returns The size in bytes on success, or a negative error code
|
||
|
|
* (see @ref opus_errorcodes) on error.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_encoder_get_size(
|
||
|
|
int streams,
|
||
|
|
int coupled_streams
|
||
|
|
);
|
||
|
|
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_surround_encoder_get_size(
|
||
|
|
int channels,
|
||
|
|
int mapping_family
|
||
|
|
);
|
||
|
|
|
||
|
|
|
||
|
|
/** Allocates and initializes a multistream encoder state.
|
||
|
|
* Call opus_multistream_encoder_destroy() to release
|
||
|
|
* this object when finished.
|
||
|
|
* @param Fs <tt>opus_int32</tt>: Sampling rate of the input signal (in Hz).
|
||
|
|
* This must be one of 8000, 12000, 16000,
|
||
|
|
* 24000, or 48000.
|
||
|
|
* @param channels <tt>int</tt>: Number of channels in the input signal.
|
||
|
|
* This must be at most 255.
|
||
|
|
* It may be greater than the number of
|
||
|
|
* coded channels (<code>streams +
|
||
|
|
* coupled_streams</code>).
|
||
|
|
* @param streams <tt>int</tt>: The total number of streams to encode from the
|
||
|
|
* input.
|
||
|
|
* This must be no more than the number of channels.
|
||
|
|
* @param coupled_streams <tt>int</tt>: Number of coupled (2 channel) streams
|
||
|
|
* to encode.
|
||
|
|
* This must be no larger than the total
|
||
|
|
* number of streams.
|
||
|
|
* Additionally, The total number of
|
||
|
|
* encoded channels (<code>streams +
|
||
|
|
* coupled_streams</code>) must be no
|
||
|
|
* more than the number of input channels.
|
||
|
|
* @param[in] mapping <code>const unsigned char[channels]</code>: Mapping from
|
||
|
|
* encoded channels to input channels, as described in
|
||
|
|
* @ref opus_multistream. As an extra constraint, the
|
||
|
|
* multistream encoder does not allow encoding coupled
|
||
|
|
* streams for which one channel is unused since this
|
||
|
|
* is never a good idea.
|
||
|
|
* @param application <tt>int</tt>: The target encoder application.
|
||
|
|
* This must be one of the following:
|
||
|
|
* <dl>
|
||
|
|
* <dt>#OPUS_APPLICATION_VOIP</dt>
|
||
|
|
* <dd>Process signal for improved speech intelligibility.</dd>
|
||
|
|
* <dt>#OPUS_APPLICATION_AUDIO</dt>
|
||
|
|
* <dd>Favor faithfulness to the original input.</dd>
|
||
|
|
* <dt>#OPUS_APPLICATION_RESTRICTED_LOWDELAY</dt>
|
||
|
|
* <dd>Configure the minimum possible coding delay by disabling certain modes
|
||
|
|
* of operation.</dd>
|
||
|
|
* </dl>
|
||
|
|
* @param[out] error <tt>int *</tt>: Returns #OPUS_OK on success, or an error
|
||
|
|
* code (see @ref opus_errorcodes) on
|
||
|
|
* failure.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSEncoder *opus_multistream_encoder_create(
|
||
|
|
opus_int32 Fs,
|
||
|
|
int channels,
|
||
|
|
int streams,
|
||
|
|
int coupled_streams,
|
||
|
|
const unsigned char *mapping,
|
||
|
|
int application,
|
||
|
|
int *error
|
||
|
|
) OPUS_ARG_NONNULL(5);
|
||
|
|
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSEncoder *opus_multistream_surround_encoder_create(
|
||
|
|
opus_int32 Fs,
|
||
|
|
int channels,
|
||
|
|
int mapping_family,
|
||
|
|
int *streams,
|
||
|
|
int *coupled_streams,
|
||
|
|
unsigned char *mapping,
|
||
|
|
int application,
|
||
|
|
int *error
|
||
|
|
) OPUS_ARG_NONNULL(5);
|
||
|
|
|
||
|
|
/** Initialize a previously allocated multistream encoder state.
|
||
|
|
* The memory pointed to by \a st must be at least the size returned by
|
||
|
|
* opus_multistream_encoder_get_size().
|
||
|
|
* This is intended for applications which use their own allocator instead of
|
||
|
|
* malloc.
|
||
|
|
* To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
|
||
|
|
* @see opus_multistream_encoder_create
|
||
|
|
* @see opus_multistream_encoder_get_size
|
||
|
|
* @param st <tt>OpusMSEncoder*</tt>: Multistream encoder state to initialize.
|
||
|
|
* @param Fs <tt>opus_int32</tt>: Sampling rate of the input signal (in Hz).
|
||
|
|
* This must be one of 8000, 12000, 16000,
|
||
|
|
* 24000, or 48000.
|
||
|
|
* @param channels <tt>int</tt>: Number of channels in the input signal.
|
||
|
|
* This must be at most 255.
|
||
|
|
* It may be greater than the number of
|
||
|
|
* coded channels (<code>streams +
|
||
|
|
* coupled_streams</code>).
|
||
|
|
* @param streams <tt>int</tt>: The total number of streams to encode from the
|
||
|
|
* input.
|
||
|
|
* This must be no more than the number of channels.
|
||
|
|
* @param coupled_streams <tt>int</tt>: Number of coupled (2 channel) streams
|
||
|
|
* to encode.
|
||
|
|
* This must be no larger than the total
|
||
|
|
* number of streams.
|
||
|
|
* Additionally, The total number of
|
||
|
|
* encoded channels (<code>streams +
|
||
|
|
* coupled_streams</code>) must be no
|
||
|
|
* more than the number of input channels.
|
||
|
|
* @param[in] mapping <code>const unsigned char[channels]</code>: Mapping from
|
||
|
|
* encoded channels to input channels, as described in
|
||
|
|
* @ref opus_multistream. As an extra constraint, the
|
||
|
|
* multistream encoder does not allow encoding coupled
|
||
|
|
* streams for which one channel is unused since this
|
||
|
|
* is never a good idea.
|
||
|
|
* @param application <tt>int</tt>: The target encoder application.
|
||
|
|
* This must be one of the following:
|
||
|
|
* <dl>
|
||
|
|
* <dt>#OPUS_APPLICATION_VOIP</dt>
|
||
|
|
* <dd>Process signal for improved speech intelligibility.</dd>
|
||
|
|
* <dt>#OPUS_APPLICATION_AUDIO</dt>
|
||
|
|
* <dd>Favor faithfulness to the original input.</dd>
|
||
|
|
* <dt>#OPUS_APPLICATION_RESTRICTED_LOWDELAY</dt>
|
||
|
|
* <dd>Configure the minimum possible coding delay by disabling certain modes
|
||
|
|
* of operation.</dd>
|
||
|
|
* </dl>
|
||
|
|
* @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes)
|
||
|
|
* on failure.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT int opus_multistream_encoder_init(
|
||
|
|
OpusMSEncoder *st,
|
||
|
|
opus_int32 Fs,
|
||
|
|
int channels,
|
||
|
|
int streams,
|
||
|
|
int coupled_streams,
|
||
|
|
const unsigned char *mapping,
|
||
|
|
int application
|
||
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6);
|
||
|
|
|
||
|
|
OPUS_EXPORT int opus_multistream_surround_encoder_init(
|
||
|
|
OpusMSEncoder *st,
|
||
|
|
opus_int32 Fs,
|
||
|
|
int channels,
|
||
|
|
int mapping_family,
|
||
|
|
int *streams,
|
||
|
|
int *coupled_streams,
|
||
|
|
unsigned char *mapping,
|
||
|
|
int application
|
||
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6);
|
||
|
|
|
||
|
|
/** Encodes a multistream Opus frame.
|
||
|
|
* @param st <tt>OpusMSEncoder*</tt>: Multistream encoder state.
|
||
|
|
* @param[in] pcm <tt>const opus_int16*</tt>: The input signal as interleaved
|
||
|
|
* samples.
|
||
|
|
* This must contain
|
||
|
|
* <code>frame_size*channels</code>
|
||
|
|
* samples.
|
||
|
|
* @param 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 int opus_multistream_encode(
|
||
|
|
OpusMSEncoder *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 a multistream Opus frame from floating point input.
|
||
|
|
* @param st <tt>OpusMSEncoder*</tt>: Multistream encoder state.
|
||
|
|
* @param[in] pcm <tt>const float*</tt>: The input signal as interleaved
|
||
|
|
* samples 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.
|
||
|
|
* This must contain
|
||
|
|
* <code>frame_size*channels</code>
|
||
|
|
* samples.
|
||
|
|
* @param 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 int opus_multistream_encode_float(
|
||
|
|
OpusMSEncoder *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>OpusMSEncoder</code> allocated by
|
||
|
|
* opus_multistream_encoder_create().
|
||
|
|
* @param st <tt>OpusMSEncoder*</tt>: Multistream encoder state to be freed.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT void opus_multistream_encoder_destroy(OpusMSEncoder *st);
|
||
|
|
|
||
|
|
/** Perform a CTL function on a multistream Opus encoder.
|
||
|
|
*
|
||
|
|
* Generally the request and subsequent arguments are generated by a
|
||
|
|
* convenience macro.
|
||
|
|
* @param st <tt>OpusMSEncoder*</tt>: Multistream encoder state.
|
||
|
|
* @param request This and all remaining parameters should be replaced by one
|
||
|
|
* of the convenience macros in @ref opus_genericctls,
|
||
|
|
* @ref opus_encoderctls, or @ref opus_multistream_ctls.
|
||
|
|
* @see opus_genericctls
|
||
|
|
* @see opus_encoderctls
|
||
|
|
* @see opus_multistream_ctls
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...) OPUS_ARG_NONNULL(1);
|
||
|
|
|
||
|
|
/**@}*/
|
||
|
|
|
||
|
|
/**\name Multistream decoder functions */
|
||
|
|
/**@{*/
|
||
|
|
|
||
|
|
/** Gets the size of an <code>OpusMSDecoder</code> structure.
|
||
|
|
* @param streams <tt>int</tt>: The total number of streams coded in the
|
||
|
|
* input.
|
||
|
|
* This must be no more than 255.
|
||
|
|
* @param coupled_streams <tt>int</tt>: Number streams to decode as coupled
|
||
|
|
* (2 channel) streams.
|
||
|
|
* This must be no larger than the total
|
||
|
|
* number of streams.
|
||
|
|
* Additionally, The total number of
|
||
|
|
* coded channels (<code>streams +
|
||
|
|
* coupled_streams</code>) must be no
|
||
|
|
* more than 255.
|
||
|
|
* @returns The size in bytes on success, or a negative error code
|
||
|
|
* (see @ref opus_errorcodes) on error.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_decoder_get_size(
|
||
|
|
int streams,
|
||
|
|
int coupled_streams
|
||
|
|
);
|
||
|
|
|
||
|
|
/** Allocates and initializes a multistream decoder state.
|
||
|
|
* Call opus_multistream_decoder_destroy() to release
|
||
|
|
* this object when finished.
|
||
|
|
* @param Fs <tt>opus_int32</tt>: Sampling rate to decode at (in Hz).
|
||
|
|
* This must be one of 8000, 12000, 16000,
|
||
|
|
* 24000, or 48000.
|
||
|
|
* @param channels <tt>int</tt>: Number of channels to output.
|
||
|
|
* This must be at most 255.
|
||
|
|
* It may be different from the number of coded
|
||
|
|
* channels (<code>streams +
|
||
|
|
* coupled_streams</code>).
|
||
|
|
* @param streams <tt>int</tt>: The total number of streams coded in the
|
||
|
|
* input.
|
||
|
|
* This must be no more than 255.
|
||
|
|
* @param coupled_streams <tt>int</tt>: Number of streams to decode as coupled
|
||
|
|
* (2 channel) streams.
|
||
|
|
* This must be no larger than the total
|
||
|
|
* number of streams.
|
||
|
|
* Additionally, The total number of
|
||
|
|
* coded channels (<code>streams +
|
||
|
|
* coupled_streams</code>) must be no
|
||
|
|
* more than 255.
|
||
|
|
* @param[in] mapping <code>const unsigned char[channels]</code>: Mapping from
|
||
|
|
* coded channels to output channels, as described in
|
||
|
|
* @ref opus_multistream.
|
||
|
|
* @param[out] error <tt>int *</tt>: Returns #OPUS_OK on success, or an error
|
||
|
|
* code (see @ref opus_errorcodes) on
|
||
|
|
* failure.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusMSDecoder *opus_multistream_decoder_create(
|
||
|
|
opus_int32 Fs,
|
||
|
|
int channels,
|
||
|
|
int streams,
|
||
|
|
int coupled_streams,
|
||
|
|
const unsigned char *mapping,
|
||
|
|
int *error
|
||
|
|
) OPUS_ARG_NONNULL(5);
|
||
|
|
|
||
|
|
/** Intialize a previously allocated decoder state object.
|
||
|
|
* The memory pointed to by \a st must be at least the size returned by
|
||
|
|
* opus_multistream_encoder_get_size().
|
||
|
|
* This is intended for applications which use their own allocator instead of
|
||
|
|
* malloc.
|
||
|
|
* To reset a previously initialized state, use the #OPUS_RESET_STATE CTL.
|
||
|
|
* @see opus_multistream_decoder_create
|
||
|
|
* @see opus_multistream_deocder_get_size
|
||
|
|
* @param st <tt>OpusMSEncoder*</tt>: Multistream encoder state to initialize.
|
||
|
|
* @param Fs <tt>opus_int32</tt>: Sampling rate to decode at (in Hz).
|
||
|
|
* This must be one of 8000, 12000, 16000,
|
||
|
|
* 24000, or 48000.
|
||
|
|
* @param channels <tt>int</tt>: Number of channels to output.
|
||
|
|
* This must be at most 255.
|
||
|
|
* It may be different from the number of coded
|
||
|
|
* channels (<code>streams +
|
||
|
|
* coupled_streams</code>).
|
||
|
|
* @param streams <tt>int</tt>: The total number of streams coded in the
|
||
|
|
* input.
|
||
|
|
* This must be no more than 255.
|
||
|
|
* @param coupled_streams <tt>int</tt>: Number of streams to decode as coupled
|
||
|
|
* (2 channel) streams.
|
||
|
|
* This must be no larger than the total
|
||
|
|
* number of streams.
|
||
|
|
* Additionally, The total number of
|
||
|
|
* coded channels (<code>streams +
|
||
|
|
* coupled_streams</code>) must be no
|
||
|
|
* more than 255.
|
||
|
|
* @param[in] mapping <code>const unsigned char[channels]</code>: Mapping from
|
||
|
|
* coded channels to output channels, as described in
|
||
|
|
* @ref opus_multistream.
|
||
|
|
* @returns #OPUS_OK on success, or an error code (see @ref opus_errorcodes)
|
||
|
|
* on failure.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT int opus_multistream_decoder_init(
|
||
|
|
OpusMSDecoder *st,
|
||
|
|
opus_int32 Fs,
|
||
|
|
int channels,
|
||
|
|
int streams,
|
||
|
|
int coupled_streams,
|
||
|
|
const unsigned char *mapping
|
||
|
|
) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(6);
|
||
|
|
|
||
|
|
/** Decode a multistream Opus packet.
|
||
|
|
* @param st <tt>OpusMSDecoder*</tt>: Multistream decoder state.
|
||
|
|
* @param[in] data <tt>const unsigned char*</tt>: Input payload.
|
||
|
|
* Use a <code>NULL</code>
|
||
|
|
* pointer to indicate packet
|
||
|
|
* loss.
|
||
|
|
* @param len <tt>opus_int32</tt>: Number of bytes in payload.
|
||
|
|
* @param[out] pcm <tt>opus_int16*</tt>: Output signal, with interleaved
|
||
|
|
* samples.
|
||
|
|
* This must contain room for
|
||
|
|
* <code>frame_size*channels</code>
|
||
|
|
* samples.
|
||
|
|
* @param frame_size <tt>int</tt>: The number of samples per channel of
|
||
|
|
* available space in \a 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
|
||
|
|
* <b>must</b> be a multiple of 2.5 ms.
|
||
|
|
* @param 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 samples decoded on success or a negative error code
|
||
|
|
* (see @ref opus_errorcodes) on failure.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_decode(
|
||
|
|
OpusMSDecoder *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 a multistream Opus packet with floating point output.
|
||
|
|
* @param st <tt>OpusMSDecoder*</tt>: Multistream decoder state.
|
||
|
|
* @param[in] data <tt>const unsigned char*</tt>: Input payload.
|
||
|
|
* Use a <code>NULL</code>
|
||
|
|
* pointer to indicate packet
|
||
|
|
* loss.
|
||
|
|
* @param len <tt>opus_int32</tt>: Number of bytes in payload.
|
||
|
|
* @param[out] pcm <tt>opus_int16*</tt>: Output signal, with interleaved
|
||
|
|
* samples.
|
||
|
|
* This must contain room for
|
||
|
|
* <code>frame_size*channels</code>
|
||
|
|
* samples.
|
||
|
|
* @param frame_size <tt>int</tt>: The number of samples per channel of
|
||
|
|
* available space in \a 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
|
||
|
|
* <b>must</b> be a multiple of 2.5 ms.
|
||
|
|
* @param 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 samples decoded on success or a negative error code
|
||
|
|
* (see @ref opus_errorcodes) on failure.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_multistream_decode_float(
|
||
|
|
OpusMSDecoder *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 a multistream Opus decoder.
|
||
|
|
*
|
||
|
|
* Generally the request and subsequent arguments are generated by a
|
||
|
|
* convenience macro.
|
||
|
|
* @param st <tt>OpusMSDecoder*</tt>: Multistream decoder state.
|
||
|
|
* @param request This and all remaining parameters should be replaced by one
|
||
|
|
* of the convenience macros in @ref opus_genericctls,
|
||
|
|
* @ref opus_decoderctls, or @ref opus_multistream_ctls.
|
||
|
|
* @see opus_genericctls
|
||
|
|
* @see opus_decoderctls
|
||
|
|
* @see opus_multistream_ctls
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT int opus_multistream_decoder_ctl(OpusMSDecoder *st, int request, ...) OPUS_ARG_NONNULL(1);
|
||
|
|
|
||
|
|
/** Frees an <code>OpusMSDecoder</code> allocated by
|
||
|
|
* opus_multistream_decoder_create().
|
||
|
|
* @param st <tt>OpusMSDecoder</tt>: Multistream decoder state to be freed.
|
||
|
|
*/
|
||
|
|
OPUS_EXPORT void opus_multistream_decoder_destroy(OpusMSDecoder *st);
|
||
|
|
|
||
|
|
/**@}*/
|
||
|
|
|
||
|
|
/**@}*/
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif /* OPUS_MULTISTREAM_H */
|