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