Improved doxygen doc for opus.h
[opus.git] / src / 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 FOUNDATION OR
19    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 opusencoder
67  * @li @ref opusdecoder
68  * @li @ref repacketizer
69  * @li @ref libinfo
70  */
71
72 /** @defgroup opusencoder Opus Encoder
73   * @{
74   *
75   * Since Opus is a stateful codec, the encoding process starts with creating an encoder
76   * state. This can be done with:
77   *
78   * @code
79   * int          error;
80   * OpusEncoder *enc;
81   * enc = opus_encoder_create(Fs, channels, application, &error);
82   * @endcode
83   *
84   * where
85   * <ul>
86   * <li>Fs is the sampling rate and must be 8000, 12000, 16000, 24000, or 48000</li>
87   * <li>channels is the number of channels (1 or 2)</li>
88   * <li>application is either OPUS_APPLICATION_VOIP or OPUS_APPLICATION_AUDIO</li>
89   * <li>error will hold the error code in case or failure (or OPUS_OK on success)</li>
90   * <li>the return value is a newly created encoder state to be used for encoding</li>
91   * </ul>
92   *
93   *
94   * While opus_encoder_create() allocates memory for the state, it's also possible
95   * to initialize pre-allocated memory:
96   *
97   * @code
98   * int          size;
99   * int          error;
100   * OpusEncoder *enc;
101   * size = opus_encoder_get_size(channels);
102   * enc = malloc(size);
103   * error = opus_encoder_init(enc, Fs, channels, application);
104   * @endcode
105   *
106   * where opus_encoder_get_size() returns the required size for the encoder state. Note that
107   * future versions of this code may change the size, so no assuptions should be made about it.
108   *
109   * The encoder state is always continuous in memory and only a shallow copy is sufficient
110   * to copy it (e.g. memcpy())
111   *
112   * It is possible to change some of the encoder's settings using the opus_encoder_ctl()
113   * interface. All these settings already default to the recommended value, so they should
114   * only be changed when necessary. The most common settings one may want to change are:
115   *
116   * @code
117   * opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrate));
118   * opus_encoder_ctl(enc, OPUS_SET_COMPLEXITY(complexity));
119   * opus_encoder_ctl(enc, OPUS_SET_SIGNAL(signal_type));
120   * @endcode
121   *
122   * where
123   * <ul>
124   * <li>bitrate is in bits per second (b/s)</li>
125   * <li>complexity is a value from 1 to 10 where 1 is the lowest complexity and 10 is the highest</li>
126   * <li>signal_type is either OPUS_AUTO (default), OPUS_SIGNAL_VOICE, or OPUS_SIGNAL_MUSIC</li>
127   * </ul>
128   * 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.
129   *
130   * 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:
131   * @code
132   * len = opus_encode(enc, audio_frame, frame_size, packet, max_packet);
133   * @endcode
134   *
135   * where
136   * <ul>
137   * <li>audio_frame is the audio data in opus_int16 (or float for opus_encode_float())</li>
138   * <li>frame_size is the duration of the frame in samples (per channel)</li>
139   * <li>packet is the byte array to which the compressed data is written</li>
140   * <li>max_packet is the maximum number of bytes that can be written in the packet (1276 bytes is recommended)</li>
141   * </ul>
142   *
143   * opus_encode() and opus_encode_frame() return the number of bytes actually written to the packet.
144   * If that value is negative, then an error has occured. If the value is 1, 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  * OPUS_APPLICATION_VOIP gives best quality at a given bitrate for voice
173  *    signals. It enhances the  input signal by high-pass filtering and
174  *    emphasizing formants and harmonics. Optionally  it includes in-band
175  *    forward error correction to protect against packet loss. Use this
176  *    mode for typical VoIP applications. Because of the enhancement,
177  *    even at high bitrates the output may sound different from the input.
178  * OPUS_APPLICATION_AUDIO gives best quality at a given bitrate for most
179  *    non-voice signals like music. Use this mode for music and mixed
180  *    (music/voice) content, broadcast, and applications requiring less
181  *    than 15 ms of coding delay.
182  * OPUS_APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that
183  *    disables the speech-optimized mode in exchange for slightly reduced delay.
184  * This is useful when the caller knows that the speech-optimized modes will not be needed (use with caution).
185  * @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
186  * @param [in] channels <tt>int</tt>: Number of channels (1/2) in input signal
187  * @param [in] application <tt>int</tt>: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)
188  * @param [out] error <tt>int*</tt>: Error code
189  */
190 OPUS_EXPORT OpusEncoder *opus_encoder_create(
191     opus_int32 Fs,
192     int channels,
193     int application,
194     int *error
195 );
196
197 /** Initializes a previously allocated encoder state
198   * The memory pointed to by st must be the size returned by opus_encoder_get_size.
199   * This is intended for applications which use their own allocator instead of malloc. @see opus_encoder_create,opus_encoder_get_size
200   * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
201   * @param [in] st <tt>OpusEncoder*</tt>: Encoder state
202   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
203   * @param [in] channels <tt>int</tt>: Number of channels (1/2) in input signal
204   * @param [in] application <tt>int</tt>: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)
205   * @retval OPUS_OK Success.
206   */
207 OPUS_EXPORT int opus_encoder_init(
208     OpusEncoder *st,
209     opus_int32 Fs,
210     int channels,
211     int application
212 );
213
214 /** Encodes an Opus frame.
215   * The passed frame_size must an opus frame size for the encoder's sampling rate.
216   * For example, at 48kHz the permitted values are 120, 240, 480, or 960.
217   * Passing in a duration of less than 10ms (480 samples at 48kHz) will
218   * prevent the encoder from using the LPC or hybrid modes.
219   * @param [in] st <tt>OpusEncoder*</tt>: Encoder state
220   * @param [in] pcm <tt>opus_int16*</tt>: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(opus_int16)
221   * @param [in] frame_size <tt>int</tt>: Number of samples per frame of input signal
222   * @param [out] data <tt>char*</tt>: Output payload (at least max_data_bytes long)
223   * @param [in] max_data_bytes <tt>int</tt>: Allocated memory for payload; don't use for controlling bitrate
224   * @returns length of the data payload (in bytes)
225   */
226 OPUS_EXPORT int opus_encode(
227     OpusEncoder *st,
228     const opus_int16 *pcm,
229     int frame_size,
230     unsigned char *data,
231     int max_data_bytes
232 );
233
234 /** Encodes an Opus frame from floating point input.
235   * The passed frame_size must an opus frame size for the encoder's sampling rate.
236   * For example, at 48kHz the permitted values are 120, 240, 480, or 960.
237   * Passing in a duration of less than 10ms (480 samples at 48kHz) will
238   * prevent the encoder from using the LPC or hybrid modes.
239   * @param [in] st <tt>OpusEncoder*</tt>: Encoder state
240   * @param [in] pcm <tt>float*</tt>: Input signal (interleaved if 2 channels). length is frame_size*channels*sizeof(float)
241   * @param [in] frame_size <tt>int</tt>: Number of samples per frame of input signal
242   * @param [out] data <tt>char*</tt>: Output payload (at least max_data_bytes long)
243   * @param [in] max_data_bytes <tt>int</tt>: Allocated memory for payload; don't use for controlling bitrate
244   * @returns length of the data payload (in bytes)
245   */
246 OPUS_EXPORT int opus_encode_float(
247     OpusEncoder *st,
248     const float *pcm,
249     int frame_size,
250     unsigned char *data,
251     int max_data_bytes
252 );
253
254 /** Frees an OpusEncoder allocated by opus_encoder_create.
255   * @param[in] st <tt>OpusEncoder*</tt>: State to be freed.
256   */
257 OPUS_EXPORT void opus_encoder_destroy(OpusEncoder *st);
258
259 /** Perform a CTL function on an Opus encoder.
260   * @see encoderctls
261   */
262 OPUS_EXPORT int opus_encoder_ctl(OpusEncoder *st, int request, ...);
263 /**@}*/
264
265 /** @defgroup opusdecoder Opus Decoder
266   * @{
267   *
268   *
269   * The decoding process also starts with creating a decoder
270   * state. This can be done with:
271   * @code
272   * int          error;
273   * OpusDecoder *dec;
274   * dec = opus_decoder_create(Fs, channels, &error);
275   * @endcode
276   * where
277   * @li Fs is the sampling rate and must be 8000, 12000, 16000, 24000, or 48000
278   * @li channels is the number of channels (1 or 2)
279   * @li error will hold the error code in case or failure (or OPUS_OK on success)
280   * @li the return value is a newly created decoder state to be used for decoding
281   *
282   * While opus_decoder_create() allocates memory for the state, it's also possible
283   * to initialize pre-allocated memory:
284   * @code
285   * int          size;
286   * int          error;
287   * OpusDecoder *dec;
288   * size = opus_decoder_get_size(channels);
289   * dec = malloc(size);
290   * error = opus_decoder_init(dec, Fs, channels);
291   * @endcode
292   * where opus_decoder_get_size() returns the required size for the decoder state. Note that
293   * future versions of this code may change the size, so no assuptions should be made about it.
294   *
295   * The decoder state is always continuous in memory and only a shallow copy is sufficient
296   * to copy it (e.g. memcpy())
297   *
298   * To decode a frame, opus_decode() or opus_decode_float() must be called with a packet of compressed audio data:
299   * @code
300   * frame_size = opus_decode(enc, packet, len, decoded, max_size);
301   * @endcode
302   * where
303   *
304   * @li packet is the byte array containing the compressed data
305   * @li len is the exact number of bytes contained in the packet
306   * @li decoded is the decoded audio data in opus_int16 (or float for opus_decode_float())
307   * @li max_size is the max duration of the frame in samples (per channel) that can fit into the decoded_frame array
308   *
309   * opus_decode() and opus_decode_frame() return the number of samples ()per channel) decoded from the packet.
310   * If that value is negative, then an error has occured. This can occur if the packet is corrupted or if the audio
311   * buffer is too small to hold the decoded audio.
312
313 */
314
315 /** Opus decoder state.
316   * This contains the complete state of an Opus decoder.
317   * It is position independent and can be freely copied.
318   * @see opus_decoder_create,opus_decoder_init
319   */
320 typedef struct OpusDecoder OpusDecoder;
321
322 /** Gets the size of an OpusDecoder structure.
323   * @param [in] channels <tt>int</tt>: Number of channels
324   * @returns size
325   */
326 OPUS_EXPORT int opus_decoder_get_size(int channels);
327
328 /** Allocates and initializes a decoder state.
329   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
330   * @param [in] channels <tt>int</tt>: Number of channels (1/2) in input signal
331   * @param [out] error <tt>int*</tt>: Error code
332   */
333 OPUS_EXPORT OpusDecoder *opus_decoder_create(
334     opus_int32 Fs,
335     int channels,
336     int *error
337 );
338
339 /** Initializes a previously allocated decoder state.
340   * The state must be the size returned by opus_decoder_get_size.
341   * This is intended for applications which use their own allocator instead of malloc. @see opus_decoder_create,opus_decoder_get_size
342   * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
343   * @param [in] st <tt>OpusDecoder*</tt>: Decoder state.
344   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate of input signal (Hz)
345   * @param [in] channels <tt>int</tt>: Number of channels (1/2) in input signal
346   * @retval OPUS_OK Success.
347   */
348 OPUS_EXPORT int opus_decoder_init(
349     OpusDecoder *st,
350     opus_int32 Fs,
351     int channels
352 );
353
354 /** Decode an Opus frame
355   * @param [in] st <tt>OpusDecoder*</tt>: Decoder state
356   * @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss
357   * @param [in] len <tt>int</tt>: Number of bytes in payload*
358   * @param [out] pcm <tt>opus_int16*</tt>: Output signal (interleaved if 2 channels). length
359   *  is frame_size*channels*sizeof(opus_int16)
360   * @param [in] frame_size Number of samples per channel of available space in *pcm,
361   *  if less than the maximum frame size (120ms) some frames can not be decoded
362   * @param [in] decode_fec <tt>int</tt>: Flag (0/1) to request that any in-band forward error correction data be
363   *  decoded. If no such data is available the frame is decoded as if it were lost.
364   * @returns Number of decoded samples
365   */
366 OPUS_EXPORT int opus_decode(
367     OpusDecoder *st,
368     const unsigned char *data,
369     int len,
370     opus_int16 *pcm,
371     int frame_size,
372     int decode_fec
373 );
374
375 /** Decode an opus frame with floating point output
376   * @param [in] st <tt>OpusDecoder*</tt>: Decoder state
377   * @param [in] data <tt>char*</tt>: Input payload. Use a NULL pointer to indicate packet loss
378   * @param [in] len <tt>int</tt>: Number of bytes in payload
379   * @param [out] pcm <tt>float*</tt>: Output signal (interleaved if 2 channels). length
380   *  is frame_size*channels*sizeof(float)
381   * @param [in] frame_size Number of samples per channel of available space in *pcm,
382   *  if less than the maximum frame size (120ms) some frames can not be decoded
383   * @param [in] decode_fec <tt>int</tt>: Flag (0/1) to request that any in-band forward error correction data be
384   *  decoded. If no such data is available the frame is decoded as if it were lost.
385   * @returns Number of decoded samples
386   */
387 OPUS_EXPORT int opus_decode_float(
388     OpusDecoder *st,
389     const unsigned char *data,
390     int len,
391     float *pcm,
392     int frame_size,
393     int decode_fec
394 );
395
396 /** Perform a CTL function on an Opus decoder.
397   * @see decoderctls
398   */
399 OPUS_EXPORT int opus_decoder_ctl(OpusDecoder *st, int request, ...);
400
401 /** Frees an OpusDecoder allocated by opus_decoder_create.
402   * @param[in] st <tt>OpusDecoder*</tt>: State to be freed.
403   */
404 OPUS_EXPORT void opus_decoder_destroy(OpusDecoder *st);
405
406 /** Parse an opus packet into one or more frames.
407   * Opus_decode will perform this operation internally so most applications do
408   * not need to use this function.
409   * This function does not copy the frames, the returned pointers are pointers into
410   * the input packet.
411   * @param [in] data <tt>char*</tt>: Opus packet to be parsed
412   * @param [in] len <tt>int</tt>: size of data
413   * @param [out] out_toc <tt>char*</tt>: TOC pointer
414   * @param [out] frames <tt>char*[48]</tt> encapsulated frames
415   * @param [out] size <tt>short[48]</tt> sizes of the encapsulated frames
416   * @param [out] payload_offset <tt>int*</tt>: returns the position of the payload within the packet (in bytes)
417   * @returns number of frames
418   */
419 OPUS_EXPORT int opus_packet_parse(
420    const unsigned char *data,
421    int len,
422    unsigned char *out_toc,
423    const unsigned char *frames[48],
424    short size[48],
425    int *payload_offset
426 );
427
428 /** Gets the bandwidth of an Opus packet.
429   * @param [in] data <tt>char*</tt>: Opus packet
430   * @retval OPUS_BANDWIDTH_NARROWBAND Narrowband (4kHz bandpass)
431   * @retval OPUS_BANDWIDTH_MEDIUMBAND Mediumband (6kHz bandpass)
432   * @retval OPUS_BANDWIDTH_WIDEBAND Wideband (8kHz bandpass)
433   * @retval OPUS_BANDWIDTH_SUPERWIDEBAND Superwideband (12kHz bandpass)
434   * @retval OPUS_BANDWIDTH_FULLBAND Fullband (20kHz bandpass)
435   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
436   */
437 OPUS_EXPORT int opus_packet_get_bandwidth(const unsigned char *data);
438
439 /** Gets the number of samples per frame from an Opus packet.
440   * @param [in] data <tt>char*</tt>: Opus packet
441   * @param [in] Fs <tt>opus_int32</tt>: Sampling rate in Hz
442   * @returns Number of samples per frame
443   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
444   */
445 OPUS_EXPORT int opus_packet_get_samples_per_frame(const unsigned char *data, opus_int32 Fs);
446
447 /** Gets the number of channels from an Opus packet.
448   * @param [in] data <tt>char*</tt>: Opus packet
449   * @returns Number of channels
450   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
451   */
452 OPUS_EXPORT int opus_packet_get_nb_channels(const unsigned char *data);
453
454 /** Gets the number of frame in an Opus packet.
455   * @param [in] packet <tt>char*</tt>: Opus packet
456   * @param [in] len <tt>int</tt>: Length of packet
457   * @returns Number of frames
458   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
459   */
460 OPUS_EXPORT int opus_packet_get_nb_frames(const unsigned char packet[], int len);
461
462 /** Gets the number of samples of an Opus packet.
463   * @param [in] dec <tt>OpusDecoder*</tt>: Decoder state
464   * @param [in] packet <tt>char*</tt>: Opus packet
465   * @param [in] len <tt>int</tt>: Length of packet
466   * @returns Number of samples
467   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
468   */
469 OPUS_EXPORT int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], int len);
470 /**@}*/
471
472 /** @defgroup repacketizer Repacketizer
473   * @{
474   *
475   * The repacketizer can be used to merge multiple Opus packets into a single packet
476   * or alternatively to split Opus packets that have previously been merged.
477   *
478   */
479
480 typedef struct OpusRepacketizer OpusRepacketizer;
481
482 OPUS_EXPORT int opus_repacketizer_get_size(void);
483
484 OPUS_EXPORT OpusRepacketizer *opus_repacketizer_init(OpusRepacketizer *rp);
485
486 OPUS_EXPORT OpusRepacketizer *opus_repacketizer_create(void);
487
488 OPUS_EXPORT void opus_repacketizer_destroy(OpusRepacketizer *rp);
489
490 OPUS_EXPORT int opus_repacketizer_cat(OpusRepacketizer *rp, const unsigned char *data, int len);
491
492 OPUS_EXPORT int opus_repacketizer_out_range(OpusRepacketizer *rp, int begin, int end, unsigned char *data, int maxlen);
493
494 OPUS_EXPORT int opus_repacketizer_get_nb_frames(OpusRepacketizer *rp);
495
496 OPUS_EXPORT int opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, int maxlen);
497
498 /**@}*/
499
500 #ifdef __cplusplus
501 }
502 #endif
503
504 #endif /* OPUS_H */