Correct documentation in opus_custom.h.
[opus.git] / include / opus.h
1 /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited
2    Written by Jean-Marc Valin and Koen Vos */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 /**
29  * @file opus.h
30  * @brief Opus reference implementation API
31  */
32
33 #ifndef OPUS_H
34 #define OPUS_H
35
36 #include "opus_types.h"
37 #include "opus_defines.h"
38
39 #ifdef __cplusplus
40 extern "C" {
41 #endif
42
43 /**
44  * @mainpage Opus
45  *
46  * The Opus codec is designed for interactive speech and audio transmission over the Internet.
47  * It is designed by the IETF Codec Working Group and incorporates technology from
48  * Skype's SILK codec and Xiph.Org's CELT codec.
49  *
50  * The Opus codec is designed to handle a wide range of interactive audio applications,
51  * including Voice over IP, videoconferencing, in-game chat, and even remote live music
52  * performances. It can scale from low bit-rate narrowband speech to very high quality
53  * stereo music. Its main features are:
54
55  * @li Sampling rates from 8 to 48 kHz
56  * @li Bit-rates from 6 kb/s 510 kb/s
57  * @li Support for both constant bit-rate (CBR) and variable bit-rate (VBR)
58  * @li Audio bandwidth from narrowband to full-band
59  * @li Support for speech and music
60  * @li Support for mono and stereo
61  * @li Frame sizes from 2.5 ms to 60 ms
62  * @li Good loss robustness and packet loss concealment (PLC)
63  * @li Floating point and fixed-point implementation
64  *
65  * Documentation sections:
66  * @li @ref opus_encoder
67  * @li @ref opus_decoder
68  * @li @ref opus_repacketizer
69  * @li @ref opus_libinfo
70  * @li @ref opus_custom
71  */
72
73 /** @defgroup opus_encoder Opus Encoder
74   * @{
75   *
76   * Since Opus is a stateful codec, the encoding process starts with creating an encoder
77   * state. This can be done with:
78   *
79   * @code
80   * int          error;
81   * OpusEncoder *enc;
82   * enc = opus_encoder_create(Fs, channels, application, &error);
83   * @endcode
84   *
85   * From this point, @c enc can be used for encoding an audio stream. An encoder state
86   * @b must @b not be used for more than one stream at the same time. Similarly, the encoder
87   * state @b must @b not be re-initialized for each frame.
88   *
89   * While opus_encoder_create() allocates memory for the state, it's also possible
90   * to initialize pre-allocated memory:
91   *
92   * @code
93   * int          size;
94   * int          error;
95   * OpusEncoder *enc;
96   * size = opus_encoder_get_size(channels);
97   * enc = malloc(size);
98   * error = opus_encoder_init(enc, Fs, channels, application);
99   * @endcode
100   *
101   * where opus_encoder_get_size() returns the required size for the encoder state. Note that
102   * future versions of this code may change the size, so no assuptions should be made about it.
103   *
104   * The encoder state is always continuous in memory and only a shallow copy is sufficient
105   * to copy it (e.g. memcpy())
106   *
107   * It is possible to change some of the encoder's settings using the opus_encoder_ctl()
108   * interface. All these settings already default to the recommended value, so they should
109   * only be changed when necessary. The most common settings one may want to change are:
110   *
111   * @code
112   * opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate));
113   * opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
114   * opus_encoder_ctl(enc, OPUS_SET_SIGNAL(signal_type));
115   * @endcode
116   *
117   * where
118   *
119   * @arg bitrate is in bits per second (b/s)
120   * @arg complexity is a value from 1 to 10, where 1 is the lowest complexity and 10 is the highest
121   * @arg signal_type is either OPUS_AUTO (default), OPUS_SIGNAL_VOICE, or OPUS_SIGNAL_MUSIC
122   *
123   * 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.
124   *
125   * 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:
126   * @code
127   * len = opus_encode(enc, audio_frame, frame_size, packet, max_packet);
128   * @endcode
129   *
130   * where
131   * <ul>
132   * <li>audio_frame is the audio data in opus_int16 (or float for opus_encode_float())</li>
133   * <li>frame_size is the duration of the frame in samples (per channel)</li>
134   * <li>packet is the byte array to which the compressed data is written</li>
135   * <li>max_packet is the maximum number of bytes that can be written in the packet (4000 bytes is recommended)</li>
136   * </ul>
137   *
138   * opus_encode() and opus_encode_frame() return the number of bytes actually written to the packet.
139   * The return value <b>can be negative</b>, which indicates that an error has occurred. If the return value
140   * is 1 byte, then the packet does not need to be transmitted (DTX).
141   *
142   * Once the encoder state if no longer needed, it can be destroyed with
143   *
144   * @code
145   * opus_encoder_destroy(enc);
146   * @endcode
147   *
148   * If the encoder was created with opus_encoder_init() rather than opus_encoder_create(),
149   * then no action is required aside from potentially freeing the memory that was manually
150   * allocated for it (calling free(enc) for the example above)
151   *
152   */
153
154 /** Opus encoder state.
155   * This contains the complete state of an Opus encoder.
156   * It is position independent and can be freely copied.
157   * @see opus_encoder_create,opus_encoder_init
158   */
159 typedef struct OpusEncoder OpusEncoder;
160
161 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_encoder_get_size(int channels);
162
163 /**
164  */
165
166 /** Allocates and initializes an encoder state.
167  * There are three coding modes:
168  *
169  * @ref OPUS_APPLICATION_VOIP gives best quality at a given bitrate for voice
170  *    signals. It enhances the  input signal by high-pass filtering and
171  *    emphasizing formants and harmonics. Optionally  it includes in-band
172  *    forward error correction to protect against packet loss. Use this
173  *    mode for typical VoIP applications. Because of the enhancement,
174  *    even at high bitrates the output may sound different from the input.
175  *
176  * @ref OPUS_APPLICATION_AUDIO gives best quality at a given bitrate for most
177  *    non-voice signals like music. Use this mode for music and mixed
178  *    (music/voice) content, broadcast, and applications requiring less
179  *    than 15 ms of coding delay.
180  *
181  * @ref OPUS_APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that
182  *    disables the speech-optimized mode in exchange for slightly reduced delay.
183  *    This mode can only be set on an newly initialized or freshly reset encoder
184  *    because it changes the codec delay.
185  *
186  * This is useful when the caller knows that the speech-optimized modes will not be needed (use with caution).
187  * @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
188  * @param [in] channels <tt>int</tt>: Number of channels (1/2) in input signal
189  * @param [in] application <tt>int</tt>: Coding mode (@ref OPUS_APPLICATION_VOIP/@ref OPUS_APPLICATION_AUDIO/@ref OPUS_APPLICATION_RESTRICTED_LOWDELAY)
190  * @param [out] error <tt>int*</tt>: @ref opus_errorcodes
191  * @note Regardless of the sampling rate and number channels selected, the Opus encoder
192  * can switch to a lower audio audio bandwidth or number of channels if the bitrate
193  * selected is too low. This also means that it is safe to always use 48 kHz stereo input
194  * and let the encoder optimize the encoding.
195  */
196 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusEncoder *opus_encoder_create(
197     opus_int32 Fs,
198     int channels,
199     int application,
200     int *error
201 );
202
203 /** Initializes a previously allocated encoder state
204   * The memory pointed to by st must be the size returned by opus_encoder_get_size.
205   * This is intended for applications which use their own allocator instead of malloc.
206   * @see opus_encoder_create(),opus_encoder_get_size()
207   * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
208   * @param [in] st <tt>OpusEncoder*</tt>: Encoder state
209   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
210   * @param [in] channels <tt>int</tt>: Number of channels (1/2) in input signal
211   * @param [in] application <tt>int</tt>: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)
212   * @retval OPUS_OK Success or @ref opus_errorcodes
213   */
214 OPUS_EXPORT int opus_encoder_init(
215     OpusEncoder *st,
216     opus_int32 Fs,
217     int channels,
218     int application
219 ) OPUS_ARG_NONNULL(1);
220
221 /** Encodes an Opus frame.
222   * The passed frame_size must an opus frame size for the encoder's sampling rate.
223   * For example, at 48kHz the permitted values are 120, 240, 480, or 960.
224   * Passing in a duration of less than 10ms (480 samples at 48kHz) will
225   * prevent the encoder from using the LPC or hybrid modes.
226   * @param [in] st <tt>OpusEncoder*</tt>: Encoder state
227   * @param [in] pcm <tt>opus_int16*</tt>: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(opus_int16)
228   * @param [in] frame_size <tt>int</tt>: Number of samples per frame of input signal
229   * @param [out] data <tt>char*</tt>: Output payload (at least max_data_bytes long)
230   * @param [in] max_data_bytes <tt>opus_int32</tt>: Allocated memory for payload; don't use for controlling bitrate
231   * @returns length of the data payload (in bytes) or @ref opus_errorcodes
232   */
233 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode(
234     OpusEncoder *st,
235     const opus_int16 *pcm,
236     int frame_size,
237     unsigned char *data,
238     opus_int32 max_data_bytes
239 ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
240
241 /** Encodes an Opus frame from floating point input.
242   * The passed frame_size must an opus frame size for the encoder's sampling rate.
243   * For example, at 48kHz the permitted values are 120, 240, 480, or 960.
244   * Passing in a duration of less than 10ms (480 samples at 48kHz) will
245   * prevent the encoder from using the LPC or hybrid modes.
246   * @param [in] st <tt>OpusEncoder*</tt>: Encoder state
247   * @param [in] pcm <tt>float*</tt>: Input in float format (interleaved if 2 channels), with a normal range of +/-1.0.
248   *          Samples with a range beyond +/-1.0 are supported but will
249   *          be clipped by decoders using the integer API and should
250   *          only be used if it is known that the far end supports
251   *          extended dynamic range.
252   *          length is frame_size*channels*sizeof(float)
253   * @param [in] frame_size <tt>int</tt>: Number of samples per frame of input signal
254   * @param [out] data <tt>char*</tt>: Output payload (at least max_data_bytes long)
255   * @param [in] max_data_bytes <tt>opus_int32</tt>: Allocated memory for payload; don't use for controlling bitrate
256   * @returns length of the data payload (in bytes) or @ref opus_errorcodes
257   */
258 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_encode_float(
259     OpusEncoder *st,
260     const float *pcm,
261     int frame_size,
262     unsigned char *data,
263     opus_int32 max_data_bytes
264 ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2) OPUS_ARG_NONNULL(4);
265
266 /** Frees an OpusEncoder allocated by opus_encoder_create.
267   * @param[in] st <tt>OpusEncoder*</tt>: State to be freed.
268   */
269 OPUS_EXPORT void opus_encoder_destroy(OpusEncoder *st);
270
271 /** Perform a CTL function on an Opus encoder.
272   *
273   * Generally the request and subsequent arguments are generated
274   * by a convenience macro.
275   * @see opus_encoderctls
276   */
277 OPUS_EXPORT int opus_encoder_ctl(OpusEncoder *st, int request, ...) OPUS_ARG_NONNULL(1);
278 /**@}*/
279
280 /** @defgroup opus_decoder Opus Decoder
281   * @{
282   *
283   *
284   * The decoding process also starts with creating a decoder
285   * state. This can be done with:
286   * @code
287   * int          error;
288   * OpusDecoder *dec;
289   * dec = opus_decoder_create(Fs, channels, &error);
290   * @endcode
291   * where
292   * @li Fs is the sampling rate and must be 8000, 12000, 16000, 24000, or 48000
293   * @li channels is the number of channels (1 or 2)
294   * @li error will hold the error code in case or failure (or OPUS_OK on success)
295   * @li the return value is a newly created decoder state to be used for decoding
296   *
297   * While opus_decoder_create() allocates memory for the state, it's also possible
298   * to initialize pre-allocated memory:
299   * @code
300   * int          size;
301   * int          error;
302   * OpusDecoder *dec;
303   * size = opus_decoder_get_size(channels);
304   * dec = malloc(size);
305   * error = opus_decoder_init(dec, Fs, channels);
306   * @endcode
307   * where opus_decoder_get_size() returns the required size for the decoder state. Note that
308   * future versions of this code may change the size, so no assuptions should be made about it.
309   *
310   * The decoder state is always continuous in memory and only a shallow copy is sufficient
311   * to copy it (e.g. memcpy())
312   *
313   * To decode a frame, opus_decode() or opus_decode_float() must be called with a packet of compressed audio data:
314   * @code
315   * frame_size = opus_decode(dec, packet, len, decoded, max_size, 0);
316   * @endcode
317   * where
318   *
319   * @li packet is the byte array containing the compressed data
320   * @li len is the exact number of bytes contained in the packet
321   * @li decoded is the decoded audio data in opus_int16 (or float for opus_decode_float())
322   * @li max_size is the max duration of the frame in samples (per channel) that can fit into the decoded_frame array
323   *
324   * opus_decode() and opus_decode_float() return the number of samples (per channel) decoded from the packet.
325   * If that value is negative, then an error has occured. This can occur if the packet is corrupted or if the audio
326   * buffer is too small to hold the decoded audio.
327
328 */
329
330 /** Opus decoder state.
331   * This contains the complete state of an Opus decoder.
332   * It is position independent and can be freely copied.
333   * @see opus_decoder_create,opus_decoder_init
334   */
335 typedef struct OpusDecoder OpusDecoder;
336
337 /** Gets the size of an OpusDecoder structure.
338   * @param [in] channels <tt>int</tt>: Number of channels
339   * @returns size
340   */
341 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_size(int channels);
342
343 /** Allocates and initializes a decoder state.
344   * @param [in] Fs <tt>opus_int32</tt>: Sample rate to decode at (Hz)
345   * @param [in] channels <tt>int</tt>: Number of channels (1/2) to decode
346   * @param [out] error <tt>int*</tt>: OPUS_OK Success or @ref opus_errorcodes
347   *
348   * Internally Opus stores data at 48000 Hz, so that should be the default
349   * value for Fs. However, the decoder can efficiently decode to buffers
350   * at 8, 12, 16, and 24 kHz so if for some reason the caller cannot use
351   * data at the full sample rate, or knows the compressed data doesn't
352   * use the full frequency range, it can request decoding at a reduced
353   * rate. Likewise, the decoder is capable of filling in either mono or
354   * interleaved stereo pcm buffers, at the caller's request.
355   */
356 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusDecoder *opus_decoder_create(
357     opus_int32 Fs,
358     int channels,
359     int *error
360 );
361
362 /** Initializes a previously allocated decoder state.
363   * The state must be the size returned by opus_decoder_get_size.
364   * This is intended for applications which use their own allocator instead of malloc. @see opus_decoder_create,opus_decoder_get_size
365   * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
366   * @param [in] st <tt>OpusDecoder*</tt>: Decoder state.
367   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate to decode to (Hz)
368   * @param [in] channels <tt>int</tt>: Number of channels (1/2) to decode
369   * @retval OPUS_OK Success or @ref opus_errorcodes
370   */
371 OPUS_EXPORT int opus_decoder_init(
372     OpusDecoder *st,
373     opus_int32 Fs,
374     int channels
375 ) OPUS_ARG_NONNULL(1);
376
377 /** Decode an Opus frame
378   * @param [in] st <tt>OpusDecoder*</tt>: Decoder state
379   * @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss
380   * @param [in] len <tt>opus_int32</tt>: Number of bytes in payload*
381   * @param [out] pcm <tt>opus_int16*</tt>: Output signal (interleaved if 2 channels). length
382   *  is frame_size*channels*sizeof(opus_int16)
383   * @param [in] frame_size Number of samples per channel of available space in *pcm,
384   *  if less than the maximum frame size (120ms) some frames can not be decoded
385   * @param [in] decode_fec <tt>int</tt>: Flag (0/1) to request that any in-band forward error correction data be
386   *  decoded. If no such data is available the frame is decoded as if it were lost.
387   * @returns Number of decoded samples or @ref opus_errorcodes
388   */
389 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode(
390     OpusDecoder *st,
391     const unsigned char *data,
392     opus_int32 len,
393     opus_int16 *pcm,
394     int frame_size,
395     int decode_fec
396 ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
397
398 /** Decode an opus frame with floating point output
399   * @param [in] st <tt>OpusDecoder*</tt>: Decoder state
400   * @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss
401   * @param [in] len <tt>opus_int32</tt>: Number of bytes in payload
402   * @param [out] pcm <tt>float*</tt>: Output signal (interleaved if 2 channels). length
403   *  is frame_size*channels*sizeof(float)
404   * @param [in] frame_size Number of samples per channel of available space in *pcm,
405   *  if less than the maximum frame size (120ms) some frames can not be decoded
406   * @param [in] decode_fec <tt>int</tt>: Flag (0/1) to request that any in-band forward error correction data be
407   *  decoded. If no such data is available the frame is decoded as if it were lost.
408   * @returns Number of decoded samples or @ref opus_errorcodes
409   */
410 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decode_float(
411     OpusDecoder *st,
412     const unsigned char *data,
413     opus_int32 len,
414     float *pcm,
415     int frame_size,
416     int decode_fec
417 ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
418
419 /** Perform a CTL function on an Opus decoder.
420   *
421   * Generally the request and subsequent arguments are generated
422   * by a convenience macro.
423   * @see opus_genericctls
424   */
425 OPUS_EXPORT int opus_decoder_ctl(OpusDecoder *st, int request, ...) OPUS_ARG_NONNULL(1);
426
427 /** Frees an OpusDecoder allocated by opus_decoder_create.
428   * @param[in] st <tt>OpusDecoder*</tt>: State to be freed.
429   */
430 OPUS_EXPORT void opus_decoder_destroy(OpusDecoder *st);
431
432 /** Parse an opus packet into one or more frames.
433   * Opus_decode will perform this operation internally so most applications do
434   * not need to use this function.
435   * This function does not copy the frames, the returned pointers are pointers into
436   * the input packet.
437   * @param [in] data <tt>char*</tt>: Opus packet to be parsed
438   * @param [in] len <tt>opus_int32</tt>: size of data
439   * @param [out] out_toc <tt>char*</tt>: TOC pointer
440   * @param [out] frames <tt>char*[48]</tt> encapsulated frames
441   * @param [out] size <tt>short[48]</tt> sizes of the encapsulated frames
442   * @param [out] payload_offset <tt>int*</tt>: returns the position of the payload within the packet (in bytes)
443   * @returns number of frames
444   */
445 OPUS_EXPORT int opus_packet_parse(
446    const unsigned char *data,
447    opus_int32 len,
448    unsigned char *out_toc,
449    const unsigned char *frames[48],
450    short size[48],
451    int *payload_offset
452 ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(4);
453
454 /** Gets the bandwidth of an Opus packet.
455   * @param [in] data <tt>char*</tt>: Opus packet
456   * @retval OPUS_BANDWIDTH_NARROWBAND Narrowband (4kHz bandpass)
457   * @retval OPUS_BANDWIDTH_MEDIUMBAND Mediumband (6kHz bandpass)
458   * @retval OPUS_BANDWIDTH_WIDEBAND Wideband (8kHz bandpass)
459   * @retval OPUS_BANDWIDTH_SUPERWIDEBAND Superwideband (12kHz bandpass)
460   * @retval OPUS_BANDWIDTH_FULLBAND Fullband (20kHz bandpass)
461   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
462   */
463 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_bandwidth(const unsigned char *data) OPUS_ARG_NONNULL(1);
464
465 /** Gets the number of samples per frame from an Opus packet.
466   * @param [in] data <tt>char*</tt>: Opus packet
467   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz
468   * @returns Number of samples per frame
469   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
470   */
471 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs) OPUS_ARG_NONNULL(1);
472
473 /** Gets the number of channels from an Opus packet.
474   * @param [in] data <tt>char*</tt>: Opus packet
475   * @returns Number of channels
476   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
477   */
478 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_channels(const unsigned char *data) OPUS_ARG_NONNULL(1);
479
480 /** Gets the number of frames in an Opus packet.
481   * @param [in] packet <tt>char*</tt>: Opus packet
482   * @param [in] len <tt>opus_int32</tt>: Length of packet
483   * @returns Number of frames
484   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
485   */
486 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1);
487
488 /** Gets the number of samples of an Opus packet.
489   * @param [in] dec <tt>OpusDecoder*</tt>: Decoder state
490   * @param [in] packet <tt>char*</tt>: Opus packet
491   * @param [in] len <tt>opus_int32</tt>: Length of packet
492   * @returns Number of samples
493   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
494   */
495 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);
496 /**@}*/
497
498 /** @defgroup opus_repacketizer Repacketizer
499   * @{
500   *
501   * The repacketizer can be used to merge multiple Opus packets into a single packet
502   * or alternatively to split Opus packets that have previously been merged.
503   *
504   */
505
506 typedef struct OpusRepacketizer OpusRepacketizer;
507
508 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_size(void);
509
510 OPUS_EXPORT OpusRepacketizer *opus_repacketizer_init(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1);
511
512 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusRepacketizer *opus_repacketizer_create(void);
513
514 OPUS_EXPORT void opus_repacketizer_destroy(OpusRepacketizer *rp);
515
516 OPUS_EXPORT int opus_repacketizer_cat(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
517
518 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);
519
520 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_nb_frames(OpusRepacketizer *rp) OPUS_ARG_NONNULL(1);
521
522 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1);
523
524 /**@}*/
525
526 #ifdef __cplusplus
527 }
528 #endif
529
530 #endif /* OPUS_H */