cannam@154: /********************************************************************
cannam@154: * *
cannam@154: * THIS FILE IS PART OF THE libopusfile SOFTWARE CODEC SOURCE CODE. *
cannam@154: * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
cannam@154: * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
cannam@154: * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
cannam@154: * *
cannam@154: * THE libopusfile SOURCE CODE IS (C) COPYRIGHT 1994-2012 *
cannam@154: * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
cannam@154: * *
cannam@154: ********************************************************************
cannam@154:
cannam@154: function: stdio-based convenience library for opening/seeking/decoding
cannam@154: last mod: $Id: vorbisfile.h 17182 2010-04-29 03:48:32Z xiphmont $
cannam@154:
cannam@154: ********************************************************************/
cannam@154: #if !defined(_opusfile_h)
cannam@154: # define _opusfile_h (1)
cannam@154:
cannam@154: /**\mainpage
cannam@154: \section Introduction
cannam@154:
cannam@154: This is the documentation for the <tt>libopusfile</tt> C API.
cannam@154:
cannam@154: The <tt>libopusfile</tt> package provides a convenient high-level API for
cannam@154: decoding and basic manipulation of all Ogg Opus audio streams.
cannam@154: <tt>libopusfile</tt> is implemented as a layer on top of Xiph.Org's
cannam@154: reference
cannam@154: <tt><a href="https://www.xiph.org/ogg/doc/libogg/reference.html">libogg</a></tt>
cannam@154: and
cannam@154: <tt><a href="https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/index.html">libopus</a></tt>
cannam@154: libraries.
cannam@154:
cannam@154: <tt>libopusfile</tt> provides several sets of built-in routines for
cannam@154: file/stream access, and may also use custom stream I/O routines provided by
cannam@154: the embedded environment.
cannam@154: There are built-in I/O routines provided for ANSI-compliant
cannam@154: <code>stdio</code> (<code>FILE *</code>), memory buffers, and URLs
cannam@154: (including <file:> URLs, plus optionally <http:> and <https:> URLs).
cannam@154:
cannam@154: \section Organization
cannam@154:
cannam@154: The main API is divided into several sections:
cannam@154: - \ref stream_open_close
cannam@154: - \ref stream_info
cannam@154: - \ref stream_decoding
cannam@154: - \ref stream_seeking
cannam@154:
cannam@154: Several additional sections are not tied to the main API.
cannam@154: - \ref stream_callbacks
cannam@154: - \ref header_info
cannam@154: - \ref error_codes
cannam@154:
cannam@154: \section Overview
cannam@154:
cannam@154: The <tt>libopusfile</tt> API always decodes files to 48 kHz.
cannam@154: The original sample rate is not preserved by the lossy compression, though
cannam@154: it is stored in the header to allow you to resample to it after decoding
cannam@154: (the <tt>libopusfile</tt> API does not currently provide a resampler,
cannam@154: but the
cannam@154: <a href="http://www.speex.org/docs/manual/speex-manual/node7.html#SECTION00760000000000000000">the
cannam@154: Speex resampler</a> is a good choice if you need one).
cannam@154: In general, if you are playing back the audio, you should leave it at
cannam@154: 48 kHz, provided your audio hardware supports it.
cannam@154: When decoding to a file, it may be worth resampling back to the original
cannam@154: sample rate, so as not to surprise users who might not expect the sample
cannam@154: rate to change after encoding to Opus and decoding.
cannam@154:
cannam@154: Opus files can contain anywhere from 1 to 255 channels of audio.
cannam@154: The channel mappings for up to 8 channels are the same as the
cannam@154: <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
cannam@154: mappings</a>.
cannam@154: A special stereo API can convert everything to 2 channels, making it simple
cannam@154: to support multichannel files in an application which only has stereo
cannam@154: output.
cannam@154: Although the <tt>libopusfile</tt> ABI provides support for the theoretical
cannam@154: maximum number of channels, the current implementation does not support
cannam@154: files with more than 8 channels, as they do not have well-defined channel
cannam@154: mappings.
cannam@154:
cannam@154: Like all Ogg files, Opus files may be "chained".
cannam@154: That is, multiple Opus files may be combined into a single, longer file just
cannam@154: by concatenating the original files.
cannam@154: This is commonly done in internet radio streaming, as it allows the title
cannam@154: and artist to be updated each time the song changes, since each link in the
cannam@154: chain includes its own set of metadata.
cannam@154:
cannam@154: <tt>libopusfile</tt> fully supports chained files.
cannam@154: It will decode the first Opus stream found in each link of a chained file
cannam@154: (ignoring any other streams that might be concurrently multiplexed with it,
cannam@154: such as a video stream).
cannam@154:
cannam@154: The channel count can also change between links.
cannam@154: If your application is not prepared to deal with this, it can use the stereo
cannam@154: API to ensure the audio from all links will always get decoded into a
cannam@154: common format.
cannam@154: Since <tt>libopusfile</tt> always decodes to 48 kHz, you do not have to
cannam@154: worry about the sample rate changing between links (as was possible with
cannam@154: Vorbis).
cannam@154: This makes application support for chained files with <tt>libopusfile</tt>
cannam@154: very easy.*/
cannam@154:
cannam@154: # if defined(__cplusplus)
cannam@154: extern "C" {
cannam@154: # endif
cannam@154:
cannam@154: # include <stdarg.h>
cannam@154: # include <stdio.h>
cannam@154: # include <ogg/ogg.h>
cannam@154: # include <opus_multistream.h>
cannam@154:
cannam@154: /**@cond PRIVATE*/
cannam@154:
cannam@154: /*Enable special features for gcc and gcc-compatible compilers.*/
cannam@154: # if !defined(OP_GNUC_PREREQ)
cannam@154: # if defined(__GNUC__)&&defined(__GNUC_MINOR__)
cannam@154: # define OP_GNUC_PREREQ(_maj,_min) \
cannam@154: ((__GNUC__<<16)+__GNUC_MINOR__>=((_maj)<<16)+(_min))
cannam@154: # else
cannam@154: # define OP_GNUC_PREREQ(_maj,_min) 0
cannam@154: # endif
cannam@154: # endif
cannam@154:
cannam@154: # if OP_GNUC_PREREQ(4,0)
cannam@154: # pragma GCC visibility push(default)
cannam@154: # endif
cannam@154:
cannam@154: typedef struct OpusHead OpusHead;
cannam@154: typedef struct OpusTags OpusTags;
cannam@154: typedef struct OpusPictureTag OpusPictureTag;
cannam@154: typedef struct OpusServerInfo OpusServerInfo;
cannam@154: typedef struct OpusFileCallbacks OpusFileCallbacks;
cannam@154: typedef struct OggOpusFile OggOpusFile;
cannam@154:
cannam@154: /*Warning attributes for libopusfile functions.*/
cannam@154: # if OP_GNUC_PREREQ(3,4)
cannam@154: # define OP_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
cannam@154: # else
cannam@154: # define OP_WARN_UNUSED_RESULT
cannam@154: # endif
cannam@154: # if OP_GNUC_PREREQ(3,4)
cannam@154: # define OP_ARG_NONNULL(_x) __attribute__((__nonnull__(_x)))
cannam@154: # else
cannam@154: # define OP_ARG_NONNULL(_x)
cannam@154: # endif
cannam@154:
cannam@154: /**@endcond*/
cannam@154:
cannam@154: /**\defgroup error_codes Error Codes*/
cannam@154: /*@{*/
cannam@154: /**\name List of possible error codes
cannam@154: Many of the functions in this library return a negative error code when a
cannam@154: function fails.
cannam@154: This list provides a brief explanation of the common errors.
cannam@154: See each individual function for more details on what a specific error code
cannam@154: means in that context.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**A request did not succeed.*/
cannam@154: #define OP_FALSE (-1)
cannam@154: /*Currently not used externally.*/
cannam@154: #define OP_EOF (-2)
cannam@154: /**There was a hole in the page sequence numbers (e.g., a page was corrupt or
cannam@154: missing).*/
cannam@154: #define OP_HOLE (-3)
cannam@154: /**An underlying read, seek, or tell operation failed when it should have
cannam@154: succeeded.*/
cannam@154: #define OP_EREAD (-128)
cannam@154: /**A <code>NULL</code> pointer was passed where one was unexpected, or an
cannam@154: internal memory allocation failed, or an internal library error was
cannam@154: encountered.*/
cannam@154: #define OP_EFAULT (-129)
cannam@154: /**The stream used a feature that is not implemented, such as an unsupported
cannam@154: channel family.*/
cannam@154: #define OP_EIMPL (-130)
cannam@154: /**One or more parameters to a function were invalid.*/
cannam@154: #define OP_EINVAL (-131)
cannam@154: /**A purported Ogg Opus stream did not begin with an Ogg page, a purported
cannam@154: header packet did not start with one of the required strings, "OpusHead" or
cannam@154: "OpusTags", or a link in a chained file was encountered that did not
cannam@154: contain any logical Opus streams.*/
cannam@154: #define OP_ENOTFORMAT (-132)
cannam@154: /**A required header packet was not properly formatted, contained illegal
cannam@154: values, or was missing altogether.*/
cannam@154: #define OP_EBADHEADER (-133)
cannam@154: /**The ID header contained an unrecognized version number.*/
cannam@154: #define OP_EVERSION (-134)
cannam@154: /*Currently not used at all.*/
cannam@154: #define OP_ENOTAUDIO (-135)
cannam@154: /**An audio packet failed to decode properly.
cannam@154: This is usually caused by a multistream Ogg packet where the durations of
cannam@154: the individual Opus packets contained in it are not all the same.*/
cannam@154: #define OP_EBADPACKET (-136)
cannam@154: /**We failed to find data we had seen before, or the bitstream structure was
cannam@154: sufficiently malformed that seeking to the target destination was
cannam@154: impossible.*/
cannam@154: #define OP_EBADLINK (-137)
cannam@154: /**An operation that requires seeking was requested on an unseekable stream.*/
cannam@154: #define OP_ENOSEEK (-138)
cannam@154: /**The first or last granule position of a link failed basic validity checks.*/
cannam@154: #define OP_EBADTIMESTAMP (-139)
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup header_info Header Information*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**The maximum number of channels in an Ogg Opus stream.*/
cannam@154: #define OPUS_CHANNEL_COUNT_MAX (255)
cannam@154:
cannam@154: /**Ogg Opus bitstream information.
cannam@154: This contains the basic playback parameters for a stream, and corresponds to
cannam@154: the initial ID header packet of an Ogg Opus stream.*/
cannam@154: struct OpusHead{
cannam@154: /**The Ogg Opus format version, in the range 0...255.
cannam@154: The top 4 bits represent a "major" version, and the bottom four bits
cannam@154: represent backwards-compatible "minor" revisions.
cannam@154: The current specification describes version 1.
cannam@154: This library will recognize versions up through 15 as backwards compatible
cannam@154: with the current specification.
cannam@154: An earlier draft of the specification described a version 0, but the only
cannam@154: difference between version 1 and version 0 is that version 0 did
cannam@154: not specify the semantics for handling the version field.*/
cannam@154: int version;
cannam@154: /**The number of channels, in the range 1...255.*/
cannam@154: int channel_count;
cannam@154: /**The number of samples that should be discarded from the beginning of the
cannam@154: stream.*/
cannam@154: unsigned pre_skip;
cannam@154: /**The sampling rate of the original input.
cannam@154: All Opus audio is coded at 48 kHz, and should also be decoded at 48 kHz
cannam@154: for playback (unless the target hardware does not support this sampling
cannam@154: rate).
cannam@154: However, this field may be used to resample the audio back to the original
cannam@154: sampling rate, for example, when saving the output to a file.*/
cannam@154: opus_uint32 input_sample_rate;
cannam@154: /**The gain to apply to the decoded output, in dB, as a Q8 value in the range
cannam@154: -32768...32767.
cannam@154: The <tt>libopusfile</tt> API will automatically apply this gain to the
cannam@154: decoded output before returning it, scaling it by
cannam@154: <code>pow(10,output_gain/(20.0*256))</code>.
cannam@154: You can adjust this behavior with op_set_gain_offset().*/
cannam@154: int output_gain;
cannam@154: /**The channel mapping family, in the range 0...255.
cannam@154: Channel mapping family 0 covers mono or stereo in a single stream.
cannam@154: Channel mapping family 1 covers 1 to 8 channels in one or more streams,
cannam@154: using the Vorbis speaker assignments.
cannam@154: Channel mapping family 255 covers 1 to 255 channels in one or more
cannam@154: streams, but without any defined speaker assignment.*/
cannam@154: int mapping_family;
cannam@154: /**The number of Opus streams in each Ogg packet, in the range 1...255.*/
cannam@154: int stream_count;
cannam@154: /**The number of coupled Opus streams in each Ogg packet, in the range
cannam@154: 0...127.
cannam@154: This must satisfy <code>0 <= coupled_count <= stream_count</code> and
cannam@154: <code>coupled_count + stream_count <= 255</code>.
cannam@154: The coupled streams appear first, before all uncoupled streams, in an Ogg
cannam@154: Opus packet.*/
cannam@154: int coupled_count;
cannam@154: /**The mapping from coded stream channels to output channels.
cannam@154: Let <code>index=mapping[k]</code> be the value for channel <code>k</code>.
cannam@154: If <code>index<2*coupled_count</code>, then it refers to the left channel
cannam@154: from stream <code>(index/2)</code> if even, and the right channel from
cannam@154: stream <code>(index/2)</code> if odd.
cannam@154: Otherwise, it refers to the output of the uncoupled stream
cannam@154: <code>(index-coupled_count)</code>.*/
cannam@154: unsigned char mapping[OPUS_CHANNEL_COUNT_MAX];
cannam@154: };
cannam@154:
cannam@154: /**The metadata from an Ogg Opus stream.
cannam@154:
cannam@154: This structure holds the in-stream metadata corresponding to the 'comment'
cannam@154: header packet of an Ogg Opus stream.
cannam@154: The comment header is meant to be used much like someone jotting a quick
cannam@154: note on the label of a CD.
cannam@154: It should be a short, to the point text note that can be more than a couple
cannam@154: words, but not more than a short paragraph.
cannam@154:
cannam@154: The metadata is stored as a series of (tag, value) pairs, in length-encoded
cannam@154: string vectors, using the same format as Vorbis (without the final "framing
cannam@154: bit"), Theora, and Speex, except for the packet header.
cannam@154: The first occurrence of the '=' character delimits the tag and value.
cannam@154: A particular tag may occur more than once, and order is significant.
cannam@154: The character set encoding for the strings is always UTF-8, but the tag
cannam@154: names are limited to ASCII, and treated as case-insensitive.
cannam@154: See <a href="http://www.xiph.org/vorbis/doc/v-comment.html">the Vorbis
cannam@154: comment header specification</a> for details.
cannam@154:
cannam@154: In filling in this structure, <tt>libopusfile</tt> will null-terminate the
cannam@154: #user_comments strings for safety.
cannam@154: However, the bitstream format itself treats them as 8-bit clean vectors,
cannam@154: possibly containing NUL characters, so the #comment_lengths array should be
cannam@154: treated as their authoritative length.
cannam@154:
cannam@154: This structure is binary and source-compatible with a
cannam@154: <code>vorbis_comment</code>, and pointers to it may be freely cast to
cannam@154: <code>vorbis_comment</code> pointers, and vice versa.
cannam@154: It is provided as a separate type to avoid introducing a compile-time
cannam@154: dependency on the libvorbis headers.*/
cannam@154: struct OpusTags{
cannam@154: /**The array of comment string vectors.*/
cannam@154: char **user_comments;
cannam@154: /**An array of the corresponding length of each vector, in bytes.*/
cannam@154: int *comment_lengths;
cannam@154: /**The total number of comment streams.*/
cannam@154: int comments;
cannam@154: /**The null-terminated vendor string.
cannam@154: This identifies the software used to encode the stream.*/
cannam@154: char *vendor;
cannam@154: };
cannam@154:
cannam@154: /**\name Picture tag image formats*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**The MIME type was not recognized, or the image data did not match the
cannam@154: declared MIME type.*/
cannam@154: #define OP_PIC_FORMAT_UNKNOWN (-1)
cannam@154: /**The MIME type indicates the image data is really a URL.*/
cannam@154: #define OP_PIC_FORMAT_URL (0)
cannam@154: /**The image is a JPEG.*/
cannam@154: #define OP_PIC_FORMAT_JPEG (1)
cannam@154: /**The image is a PNG.*/
cannam@154: #define OP_PIC_FORMAT_PNG (2)
cannam@154: /**The image is a GIF.*/
cannam@154: #define OP_PIC_FORMAT_GIF (3)
cannam@154:
cannam@154: /*@}*/
cannam@154:
cannam@154: /**The contents of a METADATA_BLOCK_PICTURE tag.*/
cannam@154: struct OpusPictureTag{
cannam@154: /**The picture type according to the ID3v2 APIC frame:
cannam@154: <ol start="0">
cannam@154: <li>Other</li>
cannam@154: <li>32x32 pixels 'file icon' (PNG only)</li>
cannam@154: <li>Other file icon</li>
cannam@154: <li>Cover (front)</li>
cannam@154: <li>Cover (back)</li>
cannam@154: <li>Leaflet page</li>
cannam@154: <li>Media (e.g. label side of CD)</li>
cannam@154: <li>Lead artist/lead performer/soloist</li>
cannam@154: <li>Artist/performer</li>
cannam@154: <li>Conductor</li>
cannam@154: <li>Band/Orchestra</li>
cannam@154: <li>Composer</li>
cannam@154: <li>Lyricist/text writer</li>
cannam@154: <li>Recording Location</li>
cannam@154: <li>During recording</li>
cannam@154: <li>During performance</li>
cannam@154: <li>Movie/video screen capture</li>
cannam@154: <li>A bright colored fish</li>
cannam@154: <li>Illustration</li>
cannam@154: <li>Band/artist logotype</li>
cannam@154: <li>Publisher/Studio logotype</li>
cannam@154: </ol>
cannam@154: Others are reserved and should not be used.
cannam@154: There may only be one each of picture type 1 and 2 in a file.*/
cannam@154: opus_int32 type;
cannam@154: /**The MIME type of the picture, in printable ASCII characters 0x20-0x7E.
cannam@154: The MIME type may also be <code>"-->"</code> to signify that the data part
cannam@154: is a URL pointing to the picture instead of the picture data itself.
cannam@154: In this case, a terminating NUL is appended to the URL string in #data,
cannam@154: but #data_length is set to the length of the string excluding that
cannam@154: terminating NUL.*/
cannam@154: char *mime_type;
cannam@154: /**The description of the picture, in UTF-8.*/
cannam@154: char *description;
cannam@154: /**The width of the picture in pixels.*/
cannam@154: opus_uint32 width;
cannam@154: /**The height of the picture in pixels.*/
cannam@154: opus_uint32 height;
cannam@154: /**The color depth of the picture in bits-per-pixel (<em>not</em>
cannam@154: bits-per-channel).*/
cannam@154: opus_uint32 depth;
cannam@154: /**For indexed-color pictures (e.g., GIF), the number of colors used, or 0
cannam@154: for non-indexed pictures.*/
cannam@154: opus_uint32 colors;
cannam@154: /**The length of the picture data in bytes.*/
cannam@154: opus_uint32 data_length;
cannam@154: /**The binary picture data.*/
cannam@154: unsigned char *data;
cannam@154: /**The format of the picture data, if known.
cannam@154: One of
cannam@154: <ul>
cannam@154: <li>#OP_PIC_FORMAT_UNKNOWN,</li>
cannam@154: <li>#OP_PIC_FORMAT_URL,</li>
cannam@154: <li>#OP_PIC_FORMAT_JPEG,</li>
cannam@154: <li>#OP_PIC_FORMAT_PNG, or</li>
cannam@154: <li>#OP_PIC_FORMAT_GIF.</li>
cannam@154: </ul>*/
cannam@154: int format;
cannam@154: };
cannam@154:
cannam@154: /**\name Functions for manipulating header data
cannam@154:
cannam@154: These functions manipulate the #OpusHead and #OpusTags structures,
cannam@154: which describe the audio parameters and tag-value metadata, respectively.
cannam@154: These can be used to query the headers returned by <tt>libopusfile</tt>, or
cannam@154: to parse Opus headers from sources other than an Ogg Opus stream, provided
cannam@154: they use the same format.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**Parses the contents of the ID header packet of an Ogg Opus stream.
cannam@154: \param[out] _head Returns the contents of the parsed packet.
cannam@154: The contents of this structure are untouched on error.
cannam@154: This may be <code>NULL</code> to merely test the header
cannam@154: for validity.
cannam@154: \param[in] _data The contents of the ID header packet.
cannam@154: \param _len The number of bytes of data in the ID header packet.
cannam@154: \return 0 on success or a negative value on error.
cannam@154: \retval #OP_ENOTFORMAT If the data does not start with the "OpusHead"
cannam@154: string.
cannam@154: \retval #OP_EVERSION If the version field signaled a version this library
cannam@154: does not know how to parse.
cannam@154: \retval #OP_EIMPL If the channel mapping family was 255, which general
cannam@154: purpose players should not attempt to play.
cannam@154: \retval #OP_EBADHEADER If the contents of the packet otherwise violate the
cannam@154: Ogg Opus specification:
cannam@154: <ul>
cannam@154: <li>Insufficient data,</li>
cannam@154: <li>Too much data for the known minor versions,</li>
cannam@154: <li>An unrecognized channel mapping family,</li>
cannam@154: <li>Zero channels or too many channels,</li>
cannam@154: <li>Zero coded streams,</li>
cannam@154: <li>Too many coupled streams, or</li>
cannam@154: <li>An invalid channel mapping index.</li>
cannam@154: </ul>*/
cannam@154: OP_WARN_UNUSED_RESULT int opus_head_parse(OpusHead *_head,
cannam@154: const unsigned char *_data,size_t _len) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Converts a granule position to a sample offset for a given Ogg Opus stream.
cannam@154: The sample offset is simply <code>_gp-_head->pre_skip</code>.
cannam@154: Granule position values smaller than OpusHead#pre_skip correspond to audio
cannam@154: that should never be played, and thus have no associated sample offset.
cannam@154: This function returns -1 for such values.
cannam@154: This function also correctly handles extremely large granule positions,
cannam@154: which may have wrapped around to a negative number when stored in a signed
cannam@154: ogg_int64_t value.
cannam@154: \param _head The #OpusHead information from the ID header of the stream.
cannam@154: \param _gp The granule position to convert.
cannam@154: \return The sample offset associated with the given granule position
cannam@154: (counting at a 48 kHz sampling rate), or the special value -1 on
cannam@154: error (i.e., the granule position was smaller than the pre-skip
cannam@154: amount).*/
cannam@154: ogg_int64_t opus_granule_sample(const OpusHead *_head,ogg_int64_t _gp)
cannam@154: OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Parses the contents of the 'comment' header packet of an Ogg Opus stream.
cannam@154: \param[out] _tags An uninitialized #OpusTags structure.
cannam@154: This returns the contents of the parsed packet.
cannam@154: The contents of this structure are untouched on error.
cannam@154: This may be <code>NULL</code> to merely test the header
cannam@154: for validity.
cannam@154: \param[in] _data The contents of the 'comment' header packet.
cannam@154: \param _len The number of bytes of data in the 'info' header packet.
cannam@154: \retval 0 Success.
cannam@154: \retval #OP_ENOTFORMAT If the data does not start with the "OpusTags"
cannam@154: string.
cannam@154: \retval #OP_EBADHEADER If the contents of the packet otherwise violate the
cannam@154: Ogg Opus specification.
cannam@154: \retval #OP_EFAULT If there wasn't enough memory to store the tags.*/
cannam@154: OP_WARN_UNUSED_RESULT int opus_tags_parse(OpusTags *_tags,
cannam@154: const unsigned char *_data,size_t _len) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Performs a deep copy of an #OpusTags structure.
cannam@154: \param _dst The #OpusTags structure to copy into.
cannam@154: If this function fails, the contents of this structure remain
cannam@154: untouched.
cannam@154: \param _src The #OpusTags structure to copy from.
cannam@154: \retval 0 Success.
cannam@154: \retval #OP_EFAULT If there wasn't enough memory to copy the tags.*/
cannam@154: int opus_tags_copy(OpusTags *_dst,const OpusTags *_src) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Initializes an #OpusTags structure.
cannam@154: This should be called on a freshly allocated #OpusTags structure before
cannam@154: attempting to use it.
cannam@154: \param _tags The #OpusTags structure to initialize.*/
cannam@154: void opus_tags_init(OpusTags *_tags) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Add a (tag, value) pair to an initialized #OpusTags structure.
cannam@154: \note Neither opus_tags_add() nor opus_tags_add_comment() support values
cannam@154: containing embedded NULs, although the bitstream format does support them.
cannam@154: To add such tags, you will need to manipulate the #OpusTags structure
cannam@154: directly.
cannam@154: \param _tags The #OpusTags structure to add the (tag, value) pair to.
cannam@154: \param _tag A NUL-terminated, case-insensitive, ASCII string containing
cannam@154: the tag to add (without an '=' character).
cannam@154: \param _value A NUL-terminated UTF-8 containing the corresponding value.
cannam@154: \return 0 on success, or a negative value on failure.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.*/
cannam@154: int opus_tags_add(OpusTags *_tags,const char *_tag,const char *_value)
cannam@154: OP_ARG_NONNULL(1) OP_ARG_NONNULL(2) OP_ARG_NONNULL(3);
cannam@154:
cannam@154: /**Add a comment to an initialized #OpusTags structure.
cannam@154: \note Neither opus_tags_add_comment() nor opus_tags_add() support comments
cannam@154: containing embedded NULs, although the bitstream format does support them.
cannam@154: To add such tags, you will need to manipulate the #OpusTags structure
cannam@154: directly.
cannam@154: \param _tags The #OpusTags structure to add the comment to.
cannam@154: \param _comment A NUL-terminated UTF-8 string containing the comment in
cannam@154: "TAG=value" form.
cannam@154: \return 0 on success, or a negative value on failure.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.*/
cannam@154: int opus_tags_add_comment(OpusTags *_tags,const char *_comment)
cannam@154: OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Replace the binary suffix data at the end of the packet (if any).
cannam@154: \param _tags An initialized #OpusTags structure.
cannam@154: \param _data A buffer of binary data to append after the encoded user
cannam@154: comments.
cannam@154: The least significant bit of the first byte of this data must
cannam@154: be set (to ensure the data is preserved by other editors).
cannam@154: \param _len The number of bytes of binary data to append.
cannam@154: This may be zero to remove any existing binary suffix data.
cannam@154: \return 0 on success, or a negative value on error.
cannam@154: \retval #OP_EINVAL \a _len was negative, or \a _len was positive but
cannam@154: \a _data was <code>NULL</code> or the least significant
cannam@154: bit of the first byte was not set.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.*/
cannam@154: int opus_tags_set_binary_suffix(OpusTags *_tags,
cannam@154: const unsigned char *_data,int _len) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Look up a comment value by its tag.
cannam@154: \param _tags An initialized #OpusTags structure.
cannam@154: \param _tag The tag to look up.
cannam@154: \param _count The instance of the tag.
cannam@154: The same tag can appear multiple times, each with a distinct
cannam@154: value, so an index is required to retrieve them all.
cannam@154: The order in which these values appear is significant and
cannam@154: should be preserved.
cannam@154: Use opus_tags_query_count() to get the legal range for the
cannam@154: \a _count parameter.
cannam@154: \return A pointer to the queried tag's value.
cannam@154: This points directly to data in the #OpusTags structure.
cannam@154: It should not be modified or freed by the application, and
cannam@154: modifications to the structure may invalidate the pointer.
cannam@154: \retval NULL If no matching tag is found.*/
cannam@154: const char *opus_tags_query(const OpusTags *_tags,const char *_tag,int _count)
cannam@154: OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Look up the number of instances of a tag.
cannam@154: Call this first when querying for a specific tag and then iterate over the
cannam@154: number of instances with separate calls to opus_tags_query() to retrieve
cannam@154: all the values for that tag in order.
cannam@154: \param _tags An initialized #OpusTags structure.
cannam@154: \param _tag The tag to look up.
cannam@154: \return The number of instances of this particular tag.*/
cannam@154: int opus_tags_query_count(const OpusTags *_tags,const char *_tag)
cannam@154: OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Retrieve the binary suffix data at the end of the packet (if any).
cannam@154: \param _tags An initialized #OpusTags structure.
cannam@154: \param[out] _len Returns the number of bytes of binary suffix data returned.
cannam@154: \return A pointer to the binary suffix data, or <code>NULL</code> if none
cannam@154: was present.*/
cannam@154: const unsigned char *opus_tags_get_binary_suffix(const OpusTags *_tags,
cannam@154: int *_len) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Get the album gain from an R128_ALBUM_GAIN tag, if one was specified.
cannam@154: This searches for the first R128_ALBUM_GAIN tag with a valid signed,
cannam@154: 16-bit decimal integer value and returns the value.
cannam@154: This routine is exposed merely for convenience for applications which wish
cannam@154: to do something special with the album gain (i.e., display it).
cannam@154: If you simply wish to apply the album gain instead of the header gain, you
cannam@154: can use op_set_gain_offset() with an #OP_ALBUM_GAIN type and no offset.
cannam@154: \param _tags An initialized #OpusTags structure.
cannam@154: \param[out] _gain_q8 The album gain, in 1/256ths of a dB.
cannam@154: This will lie in the range [-32768,32767], and should
cannam@154: be applied in <em>addition</em> to the header gain.
cannam@154: On error, no value is returned, and the previous
cannam@154: contents remain unchanged.
cannam@154: \return 0 on success, or a negative value on error.
cannam@154: \retval #OP_FALSE There was no album gain available in the given tags.*/
cannam@154: int opus_tags_get_album_gain(const OpusTags *_tags,int *_gain_q8)
cannam@154: OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Get the track gain from an R128_TRACK_GAIN tag, if one was specified.
cannam@154: This searches for the first R128_TRACK_GAIN tag with a valid signed,
cannam@154: 16-bit decimal integer value and returns the value.
cannam@154: This routine is exposed merely for convenience for applications which wish
cannam@154: to do something special with the track gain (i.e., display it).
cannam@154: If you simply wish to apply the track gain instead of the header gain, you
cannam@154: can use op_set_gain_offset() with an #OP_TRACK_GAIN type and no offset.
cannam@154: \param _tags An initialized #OpusTags structure.
cannam@154: \param[out] _gain_q8 The track gain, in 1/256ths of a dB.
cannam@154: This will lie in the range [-32768,32767], and should
cannam@154: be applied in <em>addition</em> to the header gain.
cannam@154: On error, no value is returned, and the previous
cannam@154: contents remain unchanged.
cannam@154: \return 0 on success, or a negative value on error.
cannam@154: \retval #OP_FALSE There was no track gain available in the given tags.*/
cannam@154: int opus_tags_get_track_gain(const OpusTags *_tags,int *_gain_q8)
cannam@154: OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Clears the #OpusTags structure.
cannam@154: This should be called on an #OpusTags structure after it is no longer
cannam@154: needed.
cannam@154: It will free all memory used by the structure members.
cannam@154: \param _tags The #OpusTags structure to clear.*/
cannam@154: void opus_tags_clear(OpusTags *_tags) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Check if \a _comment is an instance of a \a _tag_name tag.
cannam@154: \see opus_tagncompare
cannam@154: \param _tag_name A NUL-terminated, case-insensitive, ASCII string containing
cannam@154: the name of the tag to check for (without the terminating
cannam@154: '=' character).
cannam@154: \param _comment The comment string to check.
cannam@154: \return An integer less than, equal to, or greater than zero if \a _comment
cannam@154: is found respectively, to be less than, to match, or be greater
cannam@154: than a "tag=value" string whose tag matches \a _tag_name.*/
cannam@154: int opus_tagcompare(const char *_tag_name,const char *_comment);
cannam@154:
cannam@154: /**Check if \a _comment is an instance of a \a _tag_name tag.
cannam@154: This version is slightly more efficient than opus_tagcompare() if the length
cannam@154: of the tag name is already known (e.g., because it is a constant).
cannam@154: \see opus_tagcompare
cannam@154: \param _tag_name A case-insensitive ASCII string containing the name of the
cannam@154: tag to check for (without the terminating '=' character).
cannam@154: \param _tag_len The number of characters in the tag name.
cannam@154: This must be non-negative.
cannam@154: \param _comment The comment string to check.
cannam@154: \return An integer less than, equal to, or greater than zero if \a _comment
cannam@154: is found respectively, to be less than, to match, or be greater
cannam@154: than a "tag=value" string whose tag matches the first \a _tag_len
cannam@154: characters of \a _tag_name.*/
cannam@154: int opus_tagncompare(const char *_tag_name,int _tag_len,const char *_comment);
cannam@154:
cannam@154: /**Parse a single METADATA_BLOCK_PICTURE tag.
cannam@154: This decodes the BASE64-encoded content of the tag and returns a structure
cannam@154: with the MIME type, description, image parameters (if known), and the
cannam@154: compressed image data.
cannam@154: If the MIME type indicates the presence of an image format we recognize
cannam@154: (JPEG, PNG, or GIF) and the actual image data contains the magic signature
cannam@154: associated with that format, then the OpusPictureTag::format field will be
cannam@154: set to the corresponding format.
cannam@154: This is provided as a convenience to avoid requiring applications to parse
cannam@154: the MIME type and/or do their own format detection for the commonly used
cannam@154: formats.
cannam@154: In this case, we also attempt to extract the image parameters directly from
cannam@154: the image data (overriding any that were present in the tag, which the
cannam@154: specification says applications are not meant to rely on).
cannam@154: The application must still provide its own support for actually decoding the
cannam@154: image data and, if applicable, retrieving that data from URLs.
cannam@154: \param[out] _pic Returns the parsed picture data.
cannam@154: No sanitation is done on the type, MIME type, or
cannam@154: description fields, so these might return invalid values.
cannam@154: The contents of this structure are left unmodified on
cannam@154: failure.
cannam@154: \param _tag The METADATA_BLOCK_PICTURE tag contents.
cannam@154: The leading "METADATA_BLOCK_PICTURE=" portion is optional,
cannam@154: to allow the function to be used on either directly on the
cannam@154: values in OpusTags::user_comments or on the return value
cannam@154: of opus_tags_query().
cannam@154: \return 0 on success or a negative value on error.
cannam@154: \retval #OP_ENOTFORMAT The METADATA_BLOCK_PICTURE contents were not valid.
cannam@154: \retval #OP_EFAULT There was not enough memory to store the picture tag
cannam@154: contents.*/
cannam@154: OP_WARN_UNUSED_RESULT int opus_picture_tag_parse(OpusPictureTag *_pic,
cannam@154: const char *_tag) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Initializes an #OpusPictureTag structure.
cannam@154: This should be called on a freshly allocated #OpusPictureTag structure
cannam@154: before attempting to use it.
cannam@154: \param _pic The #OpusPictureTag structure to initialize.*/
cannam@154: void opus_picture_tag_init(OpusPictureTag *_pic) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Clears the #OpusPictureTag structure.
cannam@154: This should be called on an #OpusPictureTag structure after it is no longer
cannam@154: needed.
cannam@154: It will free all memory used by the structure members.
cannam@154: \param _pic The #OpusPictureTag structure to clear.*/
cannam@154: void opus_picture_tag_clear(OpusPictureTag *_pic) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /*@}*/
cannam@154:
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup url_options URL Reading Options*/
cannam@154: /*@{*/
cannam@154: /**\name URL reading options
cannam@154: Options for op_url_stream_create() and associated functions.
cannam@154: These allow you to provide proxy configuration parameters, skip SSL
cannam@154: certificate checks, etc.
cannam@154: Options are processed in order, and if the same option is passed multiple
cannam@154: times, only the value specified by the last occurrence has an effect
cannam@154: (unless otherwise specified).
cannam@154: They may be expanded in the future.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**@cond PRIVATE*/
cannam@154:
cannam@154: /*These are the raw numbers used to define the request codes.
cannam@154: They should not be used directly.*/
cannam@154: #define OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST (6464)
cannam@154: #define OP_HTTP_PROXY_HOST_REQUEST (6528)
cannam@154: #define OP_HTTP_PROXY_PORT_REQUEST (6592)
cannam@154: #define OP_HTTP_PROXY_USER_REQUEST (6656)
cannam@154: #define OP_HTTP_PROXY_PASS_REQUEST (6720)
cannam@154: #define OP_GET_SERVER_INFO_REQUEST (6784)
cannam@154:
cannam@154: #define OP_URL_OPT(_request) ((_request)+(char *)0)
cannam@154:
cannam@154: /*These macros trigger compilation errors or warnings if the wrong types are
cannam@154: provided to one of the URL options.*/
cannam@154: #define OP_CHECK_INT(_x) ((void)((_x)==(opus_int32)0),(opus_int32)(_x))
cannam@154: #define OP_CHECK_CONST_CHAR_PTR(_x) ((_x)+((_x)-(const char *)(_x)))
cannam@154: #define OP_CHECK_SERVER_INFO_PTR(_x) ((_x)+((_x)-(OpusServerInfo *)(_x)))
cannam@154:
cannam@154: /**@endcond*/
cannam@154:
cannam@154: /**HTTP/Shoutcast/Icecast server information associated with a URL.*/
cannam@154: struct OpusServerInfo{
cannam@154: /**The name of the server (icy-name/ice-name).
cannam@154: This is <code>NULL</code> if there was no <code>icy-name</code> or
cannam@154: <code>ice-name</code> header.*/
cannam@154: char *name;
cannam@154: /**A short description of the server (icy-description/ice-description).
cannam@154: This is <code>NULL</code> if there was no <code>icy-description</code> or
cannam@154: <code>ice-description</code> header.*/
cannam@154: char *description;
cannam@154: /**The genre the server falls under (icy-genre/ice-genre).
cannam@154: This is <code>NULL</code> if there was no <code>icy-genre</code> or
cannam@154: <code>ice-genre</code> header.*/
cannam@154: char *genre;
cannam@154: /**The homepage for the server (icy-url/ice-url).
cannam@154: This is <code>NULL</code> if there was no <code>icy-url</code> or
cannam@154: <code>ice-url</code> header.*/
cannam@154: char *url;
cannam@154: /**The software used by the origin server (Server).
cannam@154: This is <code>NULL</code> if there was no <code>Server</code> header.*/
cannam@154: char *server;
cannam@154: /**The media type of the entity sent to the recepient (Content-Type).
cannam@154: This is <code>NULL</code> if there was no <code>Content-Type</code>
cannam@154: header.*/
cannam@154: char *content_type;
cannam@154: /**The nominal stream bitrate in kbps (icy-br/ice-bitrate).
cannam@154: This is <code>-1</code> if there was no <code>icy-br</code> or
cannam@154: <code>ice-bitrate</code> header.*/
cannam@154: opus_int32 bitrate_kbps;
cannam@154: /**Flag indicating whether the server is public (<code>1</code>) or not
cannam@154: (<code>0</code>) (icy-pub/ice-public).
cannam@154: This is <code>-1</code> if there was no <code>icy-pub</code> or
cannam@154: <code>ice-public</code> header.*/
cannam@154: int is_public;
cannam@154: /**Flag indicating whether the server is using HTTPS instead of HTTP.
cannam@154: This is <code>0</code> unless HTTPS is being used.
cannam@154: This may not match the protocol used in the original URL if there were
cannam@154: redirections.*/
cannam@154: int is_ssl;
cannam@154: };
cannam@154:
cannam@154: /**Initializes an #OpusServerInfo structure.
cannam@154: All fields are set as if the corresponding header was not available.
cannam@154: \param _info The #OpusServerInfo structure to initialize.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.*/
cannam@154: void opus_server_info_init(OpusServerInfo *_info) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Clears the #OpusServerInfo structure.
cannam@154: This should be called on an #OpusServerInfo structure after it is no longer
cannam@154: needed.
cannam@154: It will free all memory used by the structure members.
cannam@154: \param _info The #OpusServerInfo structure to clear.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.*/
cannam@154: void opus_server_info_clear(OpusServerInfo *_info) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Skip the certificate check when connecting via TLS/SSL (https).
cannam@154: \param _b <code>opus_int32</code>: Whether or not to skip the certificate
cannam@154: check.
cannam@154: The check will be skipped if \a _b is non-zero, and will not be
cannam@154: skipped if \a _b is zero.
cannam@154: \hideinitializer*/
cannam@154: #define OP_SSL_SKIP_CERTIFICATE_CHECK(_b) \
cannam@154: OP_URL_OPT(OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST),OP_CHECK_INT(_b)
cannam@154:
cannam@154: /**Proxy connections through the given host.
cannam@154: If no port is specified via #OP_HTTP_PROXY_PORT, the port number defaults
cannam@154: to 8080 (http-alt).
cannam@154: All proxy parameters are ignored for non-http and non-https URLs.
cannam@154: \param _host <code>const char *</code>: The proxy server hostname.
cannam@154: This may be <code>NULL</code> to disable the use of a proxy
cannam@154: server.
cannam@154: \hideinitializer*/
cannam@154: #define OP_HTTP_PROXY_HOST(_host) \
cannam@154: OP_URL_OPT(OP_HTTP_PROXY_HOST_REQUEST),OP_CHECK_CONST_CHAR_PTR(_host)
cannam@154:
cannam@154: /**Use the given port when proxying connections.
cannam@154: This option only has an effect if #OP_HTTP_PROXY_HOST is specified with a
cannam@154: non-<code>NULL</code> \a _host.
cannam@154: If this option is not provided, the proxy port number defaults to 8080
cannam@154: (http-alt).
cannam@154: All proxy parameters are ignored for non-http and non-https URLs.
cannam@154: \param _port <code>opus_int32</code>: The proxy server port.
cannam@154: This must be in the range 0...65535 (inclusive), or the
cannam@154: URL function this is passed to will fail.
cannam@154: \hideinitializer*/
cannam@154: #define OP_HTTP_PROXY_PORT(_port) \
cannam@154: OP_URL_OPT(OP_HTTP_PROXY_PORT_REQUEST),OP_CHECK_INT(_port)
cannam@154:
cannam@154: /**Use the given user name for authentication when proxying connections.
cannam@154: All proxy parameters are ignored for non-http and non-https URLs.
cannam@154: \param _user const char *: The proxy server user name.
cannam@154: This may be <code>NULL</code> to disable proxy
cannam@154: authentication.
cannam@154: A non-<code>NULL</code> value only has an effect
cannam@154: if #OP_HTTP_PROXY_HOST and #OP_HTTP_PROXY_PASS
cannam@154: are also specified with non-<code>NULL</code>
cannam@154: arguments.
cannam@154: \hideinitializer*/
cannam@154: #define OP_HTTP_PROXY_USER(_user) \
cannam@154: OP_URL_OPT(OP_HTTP_PROXY_USER_REQUEST),OP_CHECK_CONST_CHAR_PTR(_user)
cannam@154:
cannam@154: /**Use the given password for authentication when proxying connections.
cannam@154: All proxy parameters are ignored for non-http and non-https URLs.
cannam@154: \param _pass const char *: The proxy server password.
cannam@154: This may be <code>NULL</code> to disable proxy
cannam@154: authentication.
cannam@154: A non-<code>NULL</code> value only has an effect
cannam@154: if #OP_HTTP_PROXY_HOST and #OP_HTTP_PROXY_USER
cannam@154: are also specified with non-<code>NULL</code>
cannam@154: arguments.
cannam@154: \hideinitializer*/
cannam@154: #define OP_HTTP_PROXY_PASS(_pass) \
cannam@154: OP_URL_OPT(OP_HTTP_PROXY_PASS_REQUEST),OP_CHECK_CONST_CHAR_PTR(_pass)
cannam@154:
cannam@154: /**Parse information about the streaming server (if any) and return it.
cannam@154: Very little validation is done.
cannam@154: In particular, OpusServerInfo::url may not be a valid URL,
cannam@154: OpusServerInfo::bitrate_kbps may not really be in kbps, and
cannam@154: OpusServerInfo::content_type may not be a valid MIME type.
cannam@154: The character set of the string fields is not specified anywhere, and should
cannam@154: not be assumed to be valid UTF-8.
cannam@154: \param _info OpusServerInfo *: Returns information about the server.
cannam@154: If there is any error opening the stream, the
cannam@154: contents of this structure remain
cannam@154: unmodified.
cannam@154: On success, fills in the structure with the
cannam@154: server information that was available, if
cannam@154: any.
cannam@154: After a successful return, the contents of
cannam@154: this structure should be freed by calling
cannam@154: opus_server_info_clear().
cannam@154: \hideinitializer*/
cannam@154: #define OP_GET_SERVER_INFO(_info) \
cannam@154: OP_URL_OPT(OP_GET_SERVER_INFO_REQUEST),OP_CHECK_SERVER_INFO_PTR(_info)
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup stream_callbacks Abstract Stream Reading Interface*/
cannam@154: /*@{*/
cannam@154: /**\name Functions for reading from streams
cannam@154: These functions define the interface used to read from and seek in a stream
cannam@154: of data.
cannam@154: A stream does not need to implement seeking, but the decoder will not be
cannam@154: able to seek if it does not do so.
cannam@154: These functions also include some convenience routines for working with
cannam@154: standard <code>FILE</code> pointers, complete streams stored in a single
cannam@154: block of memory, or URLs.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**Reads up to \a _nbytes bytes of data from \a _stream.
cannam@154: \param _stream The stream to read from.
cannam@154: \param[out] _ptr The buffer to store the data in.
cannam@154: \param _nbytes The maximum number of bytes to read.
cannam@154: This function may return fewer, though it will not
cannam@154: return zero unless it reaches end-of-file.
cannam@154: \return The number of bytes successfully read, or a negative value on
cannam@154: error.*/
cannam@154: typedef int (*op_read_func)(void *_stream,unsigned char *_ptr,int _nbytes);
cannam@154:
cannam@154: /**Sets the position indicator for \a _stream.
cannam@154: The new position, measured in bytes, is obtained by adding \a _offset
cannam@154: bytes to the position specified by \a _whence.
cannam@154: If \a _whence is set to <code>SEEK_SET</code>, <code>SEEK_CUR</code>, or
cannam@154: <code>SEEK_END</code>, the offset is relative to the start of the stream,
cannam@154: the current position indicator, or end-of-file, respectively.
cannam@154: \retval 0 Success.
cannam@154: \retval -1 Seeking is not supported or an error occurred.
cannam@154: <code>errno</code> need not be set.*/
cannam@154: typedef int (*op_seek_func)(void *_stream,opus_int64 _offset,int _whence);
cannam@154:
cannam@154: /**Obtains the current value of the position indicator for \a _stream.
cannam@154: \return The current position indicator.*/
cannam@154: typedef opus_int64 (*op_tell_func)(void *_stream);
cannam@154:
cannam@154: /**Closes the underlying stream.
cannam@154: \retval 0 Success.
cannam@154: \retval EOF An error occurred.
cannam@154: <code>errno</code> need not be set.*/
cannam@154: typedef int (*op_close_func)(void *_stream);
cannam@154:
cannam@154: /**The callbacks used to access non-<code>FILE</code> stream resources.
cannam@154: The function prototypes are basically the same as for the stdio functions
cannam@154: <code>fread()</code>, <code>fseek()</code>, <code>ftell()</code>, and
cannam@154: <code>fclose()</code>.
cannam@154: The differences are that the <code>FILE *</code> arguments have been
cannam@154: replaced with a <code>void *</code>, which is to be used as a pointer to
cannam@154: whatever internal data these functions might need, that #seek and #tell
cannam@154: take and return 64-bit offsets, and that #seek <em>must</em> return -1 if
cannam@154: the stream is unseekable.*/
cannam@154: struct OpusFileCallbacks{
cannam@154: /**Used to read data from the stream.
cannam@154: This must not be <code>NULL</code>.*/
cannam@154: op_read_func read;
cannam@154: /**Used to seek in the stream.
cannam@154: This may be <code>NULL</code> if seeking is not implemented.*/
cannam@154: op_seek_func seek;
cannam@154: /**Used to return the current read position in the stream.
cannam@154: This may be <code>NULL</code> if seeking is not implemented.*/
cannam@154: op_tell_func tell;
cannam@154: /**Used to close the stream when the decoder is freed.
cannam@154: This may be <code>NULL</code> to leave the stream open.*/
cannam@154: op_close_func close;
cannam@154: };
cannam@154:
cannam@154: /**Opens a stream with <code>fopen()</code> and fills in a set of callbacks
cannam@154: that can be used to access it.
cannam@154: This is useful to avoid writing your own portable 64-bit seeking wrappers,
cannam@154: and also avoids cross-module linking issues on Windows, where a
cannam@154: <code>FILE *</code> must be accessed by routines defined in the same module
cannam@154: that opened it.
cannam@154: \param[out] _cb The callbacks to use for this file.
cannam@154: If there is an error opening the file, nothing will be
cannam@154: filled in here.
cannam@154: \param _path The path to the file to open.
cannam@154: On Windows, this string must be UTF-8 (to allow access to
cannam@154: files whose names cannot be represented in the current
cannam@154: MBCS code page).
cannam@154: All other systems use the native character encoding.
cannam@154: \param _mode The mode to open the file in.
cannam@154: \return A stream handle to use with the callbacks, or <code>NULL</code> on
cannam@154: error.*/
cannam@154: OP_WARN_UNUSED_RESULT void *op_fopen(OpusFileCallbacks *_cb,
cannam@154: const char *_path,const char *_mode) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2)
cannam@154: OP_ARG_NONNULL(3);
cannam@154:
cannam@154: /**Opens a stream with <code>fdopen()</code> and fills in a set of callbacks
cannam@154: that can be used to access it.
cannam@154: This is useful to avoid writing your own portable 64-bit seeking wrappers,
cannam@154: and also avoids cross-module linking issues on Windows, where a
cannam@154: <code>FILE *</code> must be accessed by routines defined in the same module
cannam@154: that opened it.
cannam@154: \param[out] _cb The callbacks to use for this file.
cannam@154: If there is an error opening the file, nothing will be
cannam@154: filled in here.
cannam@154: \param _fd The file descriptor to open.
cannam@154: \param _mode The mode to open the file in.
cannam@154: \return A stream handle to use with the callbacks, or <code>NULL</code> on
cannam@154: error.*/
cannam@154: OP_WARN_UNUSED_RESULT void *op_fdopen(OpusFileCallbacks *_cb,
cannam@154: int _fd,const char *_mode) OP_ARG_NONNULL(1) OP_ARG_NONNULL(3);
cannam@154:
cannam@154: /**Opens a stream with <code>freopen()</code> and fills in a set of callbacks
cannam@154: that can be used to access it.
cannam@154: This is useful to avoid writing your own portable 64-bit seeking wrappers,
cannam@154: and also avoids cross-module linking issues on Windows, where a
cannam@154: <code>FILE *</code> must be accessed by routines defined in the same module
cannam@154: that opened it.
cannam@154: \param[out] _cb The callbacks to use for this file.
cannam@154: If there is an error opening the file, nothing will be
cannam@154: filled in here.
cannam@154: \param _path The path to the file to open.
cannam@154: On Windows, this string must be UTF-8 (to allow access
cannam@154: to files whose names cannot be represented in the
cannam@154: current MBCS code page).
cannam@154: All other systems use the native character encoding.
cannam@154: \param _mode The mode to open the file in.
cannam@154: \param _stream A stream previously returned by op_fopen(), op_fdopen(),
cannam@154: or op_freopen().
cannam@154: \return A stream handle to use with the callbacks, or <code>NULL</code> on
cannam@154: error.*/
cannam@154: OP_WARN_UNUSED_RESULT void *op_freopen(OpusFileCallbacks *_cb,
cannam@154: const char *_path,const char *_mode,void *_stream) OP_ARG_NONNULL(1)
cannam@154: OP_ARG_NONNULL(2) OP_ARG_NONNULL(3) OP_ARG_NONNULL(4);
cannam@154:
cannam@154: /**Creates a stream that reads from the given block of memory.
cannam@154: This block of memory must contain the complete stream to decode.
cannam@154: This is useful for caching small streams (e.g., sound effects) in RAM.
cannam@154: \param[out] _cb The callbacks to use for this stream.
cannam@154: If there is an error creating the stream, nothing will be
cannam@154: filled in here.
cannam@154: \param _data The block of memory to read from.
cannam@154: \param _size The size of the block of memory.
cannam@154: \return A stream handle to use with the callbacks, or <code>NULL</code> on
cannam@154: error.*/
cannam@154: OP_WARN_UNUSED_RESULT void *op_mem_stream_create(OpusFileCallbacks *_cb,
cannam@154: const unsigned char *_data,size_t _size) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Creates a stream that reads from the given URL.
cannam@154: This function behaves identically to op_url_stream_create(), except that it
cannam@154: takes a va_list instead of a variable number of arguments.
cannam@154: It does not call the <code>va_end</code> macro, and because it invokes the
cannam@154: <code>va_arg</code> macro, the value of \a _ap is undefined after the call.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.
cannam@154: \param[out] _cb The callbacks to use for this stream.
cannam@154: If there is an error creating the stream, nothing will
cannam@154: be filled in here.
cannam@154: \param _url The URL to read from.
cannam@154: Currently only the <file:>, <http:>, and <https:>
cannam@154: schemes are supported.
cannam@154: Both <http:> and <https:> may be disabled at compile
cannam@154: time, in which case opening such URLs will always fail.
cannam@154: Currently this only supports URIs.
cannam@154: IRIs should be converted to UTF-8 and URL-escaped, with
cannam@154: internationalized domain names encoded in punycode,
cannam@154: before passing them to this function.
cannam@154: \param[in,out] _ap A list of the \ref url_options "optional flags" to use.
cannam@154: This is a variable-length list of options terminated
cannam@154: with <code>NULL</code>.
cannam@154: \return A stream handle to use with the callbacks, or <code>NULL</code> on
cannam@154: error.*/
cannam@154: OP_WARN_UNUSED_RESULT void *op_url_stream_vcreate(OpusFileCallbacks *_cb,
cannam@154: const char *_url,va_list _ap) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Creates a stream that reads from the given URL.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.
cannam@154: \param[out] _cb The callbacks to use for this stream.
cannam@154: If there is an error creating the stream, nothing will be
cannam@154: filled in here.
cannam@154: \param _url The URL to read from.
cannam@154: Currently only the <file:>, <http:>, and <https:> schemes
cannam@154: are supported.
cannam@154: Both <http:> and <https:> may be disabled at compile time,
cannam@154: in which case opening such URLs will always fail.
cannam@154: Currently this only supports URIs.
cannam@154: IRIs should be converted to UTF-8 and URL-escaped, with
cannam@154: internationalized domain names encoded in punycode, before
cannam@154: passing them to this function.
cannam@154: \param ... The \ref url_options "optional flags" to use.
cannam@154: This is a variable-length list of options terminated with
cannam@154: <code>NULL</code>.
cannam@154: \return A stream handle to use with the callbacks, or <code>NULL</code> on
cannam@154: error.*/
cannam@154: OP_WARN_UNUSED_RESULT void *op_url_stream_create(OpusFileCallbacks *_cb,
cannam@154: const char *_url,...) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup stream_open_close Opening and Closing*/
cannam@154: /*@{*/
cannam@154: /**\name Functions for opening and closing streams
cannam@154:
cannam@154: These functions allow you to test a stream to see if it is Opus, open it,
cannam@154: and close it.
cannam@154: Several flavors are provided for each of the built-in stream types, plus a
cannam@154: more general version which takes a set of application-provided callbacks.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**Test to see if this is an Opus stream.
cannam@154: For good results, you will need at least 57 bytes (for a pure Opus-only
cannam@154: stream).
cannam@154: Something like 512 bytes will give more reliable results for multiplexed
cannam@154: streams.
cannam@154: This function is meant to be a quick-rejection filter.
cannam@154: Its purpose is not to guarantee that a stream is a valid Opus stream, but to
cannam@154: ensure that it looks enough like Opus that it isn't going to be recognized
cannam@154: as some other format (except possibly an Opus stream that is also
cannam@154: multiplexed with other codecs, such as video).
cannam@154: \param[out] _head The parsed ID header contents.
cannam@154: You may pass <code>NULL</code> if you do not need
cannam@154: this information.
cannam@154: If the function fails, the contents of this structure
cannam@154: remain untouched.
cannam@154: \param _initial_data An initial buffer of data from the start of the
cannam@154: stream.
cannam@154: \param _initial_bytes The number of bytes in \a _initial_data.
cannam@154: \return 0 if the data appears to be Opus, or a negative value on error.
cannam@154: \retval #OP_FALSE There was not enough data to tell if this was an Opus
cannam@154: stream or not.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.
cannam@154: \retval #OP_EIMPL The stream used a feature that is not implemented,
cannam@154: such as an unsupported channel family.
cannam@154: \retval #OP_ENOTFORMAT If the data did not contain a recognizable ID
cannam@154: header for an Opus stream.
cannam@154: \retval #OP_EVERSION If the version field signaled a version this library
cannam@154: does not know how to parse.
cannam@154: \retval #OP_EBADHEADER The ID header was not properly formatted or contained
cannam@154: illegal values.*/
cannam@154: int op_test(OpusHead *_head,
cannam@154: const unsigned char *_initial_data,size_t _initial_bytes);
cannam@154:
cannam@154: /**Open a stream from the given file path.
cannam@154: \param _path The path to the file to open.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want the
cannam@154: failure code.
cannam@154: The failure code will be #OP_EFAULT if the file could not
cannam@154: be opened, or one of the other failure codes from
cannam@154: op_open_callbacks() otherwise.
cannam@154: \return A freshly opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_open_file(const char *_path,int *_error)
cannam@154: OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Open a stream from a memory buffer.
cannam@154: \param _data The memory buffer to open.
cannam@154: \param _size The number of bytes in the buffer.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want the
cannam@154: failure code.
cannam@154: See op_open_callbacks() for a full list of failure codes.
cannam@154: \return A freshly opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_open_memory(const unsigned char *_data,
cannam@154: size_t _size,int *_error);
cannam@154:
cannam@154: /**Open a stream from a URL.
cannam@154: This function behaves identically to op_open_url(), except that it
cannam@154: takes a va_list instead of a variable number of arguments.
cannam@154: It does not call the <code>va_end</code> macro, and because it invokes the
cannam@154: <code>va_arg</code> macro, the value of \a _ap is undefined after the call.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.
cannam@154: \param _url The URL to open.
cannam@154: Currently only the <file:>, <http:>, and <https:>
cannam@154: schemes are supported.
cannam@154: Both <http:> and <https:> may be disabled at compile
cannam@154: time, in which case opening such URLs will always
cannam@154: fail.
cannam@154: Currently this only supports URIs.
cannam@154: IRIs should be converted to UTF-8 and URL-escaped,
cannam@154: with internationalized domain names encoded in
cannam@154: punycode, before passing them to this function.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want
cannam@154: the failure code.
cannam@154: See op_open_callbacks() for a full list of failure
cannam@154: codes.
cannam@154: \param[in,out] _ap A list of the \ref url_options "optional flags" to
cannam@154: use.
cannam@154: This is a variable-length list of options terminated
cannam@154: with <code>NULL</code>.
cannam@154: \return A freshly opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_vopen_url(const char *_url,
cannam@154: int *_error,va_list _ap) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Open a stream from a URL.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.
cannam@154: \param _url The URL to open.
cannam@154: Currently only the <file:>, <http:>, and <https:> schemes
cannam@154: are supported.
cannam@154: Both <http:> and <https:> may be disabled at compile
cannam@154: time, in which case opening such URLs will always fail.
cannam@154: Currently this only supports URIs.
cannam@154: IRIs should be converted to UTF-8 and URL-escaped, with
cannam@154: internationalized domain names encoded in punycode,
cannam@154: before passing them to this function.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want the
cannam@154: failure code.
cannam@154: See op_open_callbacks() for a full list of failure codes.
cannam@154: \param ... The \ref url_options "optional flags" to use.
cannam@154: This is a variable-length list of options terminated with
cannam@154: <code>NULL</code>.
cannam@154: \return A freshly opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_open_url(const char *_url,
cannam@154: int *_error,...) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Open a stream using the given set of callbacks to access it.
cannam@154: \param _stream The stream to read from (e.g., a <code>FILE *</code>).
cannam@154: This value will be passed verbatim as the first
cannam@154: argument to all of the callbacks.
cannam@154: \param _cb The callbacks with which to access the stream.
cannam@154: <code><a href="#op_read_func">read()</a></code> must
cannam@154: be implemented.
cannam@154: <code><a href="#op_seek_func">seek()</a></code> and
cannam@154: <code><a href="#op_tell_func">tell()</a></code> may
cannam@154: be <code>NULL</code>, or may always return -1 to
cannam@154: indicate a stream is unseekable, but if
cannam@154: <code><a href="#op_seek_func">seek()</a></code> is
cannam@154: implemented and succeeds on a particular stream, then
cannam@154: <code><a href="#op_tell_func">tell()</a></code> must
cannam@154: also.
cannam@154: <code><a href="#op_close_func">close()</a></code> may
cannam@154: be <code>NULL</code>, but if it is not, it will be
cannam@154: called when the \c OggOpusFile is destroyed by
cannam@154: op_free().
cannam@154: It will not be called if op_open_callbacks() fails
cannam@154: with an error.
cannam@154: \param _initial_data An initial buffer of data from the start of the
cannam@154: stream.
cannam@154: Applications can read some number of bytes from the
cannam@154: start of the stream to help identify this as an Opus
cannam@154: stream, and then provide them here to allow the
cannam@154: stream to be opened, even if it is unseekable.
cannam@154: \param _initial_bytes The number of bytes in \a _initial_data.
cannam@154: If the stream is seekable, its current position (as
cannam@154: reported by
cannam@154: <code><a href="#opus_tell_func">tell()</a></code>
cannam@154: at the start of this function) must be equal to
cannam@154: \a _initial_bytes.
cannam@154: Otherwise, seeking to absolute positions will
cannam@154: generate inconsistent results.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want
cannam@154: the failure code.
cannam@154: The failure code will be one of
cannam@154: <dl>
cannam@154: <dt>#OP_EREAD</dt>
cannam@154: <dd>An underlying read, seek, or tell operation
cannam@154: failed when it should have succeeded, or we failed
cannam@154: to find data in the stream we had seen before.</dd>
cannam@154: <dt>#OP_EFAULT</dt>
cannam@154: <dd>There was a memory allocation failure, or an
cannam@154: internal library error.</dd>
cannam@154: <dt>#OP_EIMPL</dt>
cannam@154: <dd>The stream used a feature that is not
cannam@154: implemented, such as an unsupported channel
cannam@154: family.</dd>
cannam@154: <dt>#OP_EINVAL</dt>
cannam@154: <dd><code><a href="#op_seek_func">seek()</a></code>
cannam@154: was implemented and succeeded on this source, but
cannam@154: <code><a href="#op_tell_func">tell()</a></code>
cannam@154: did not, or the starting position indicator was
cannam@154: not equal to \a _initial_bytes.</dd>
cannam@154: <dt>#OP_ENOTFORMAT</dt>
cannam@154: <dd>The stream contained a link that did not have
cannam@154: any logical Opus streams in it.</dd>
cannam@154: <dt>#OP_EBADHEADER</dt>
cannam@154: <dd>A required header packet was not properly
cannam@154: formatted, contained illegal values, or was missing
cannam@154: altogether.</dd>
cannam@154: <dt>#OP_EVERSION</dt>
cannam@154: <dd>An ID header contained an unrecognized version
cannam@154: number.</dd>
cannam@154: <dt>#OP_EBADLINK</dt>
cannam@154: <dd>We failed to find data we had seen before after
cannam@154: seeking.</dd>
cannam@154: <dt>#OP_EBADTIMESTAMP</dt>
cannam@154: <dd>The first or last timestamp in a link failed
cannam@154: basic validity checks.</dd>
cannam@154: </dl>
cannam@154: \return A freshly opened \c OggOpusFile, or <code>NULL</code> on error.
cannam@154: <tt>libopusfile</tt> does <em>not</em> take ownership of the stream
cannam@154: if the call fails.
cannam@154: The calling application is responsible for closing the stream if
cannam@154: this call returns an error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_open_callbacks(void *_stream,
cannam@154: const OpusFileCallbacks *_cb,const unsigned char *_initial_data,
cannam@154: size_t _initial_bytes,int *_error) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Partially open a stream from the given file path.
cannam@154: \see op_test_callbacks
cannam@154: \param _path The path to the file to open.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want the
cannam@154: failure code.
cannam@154: The failure code will be #OP_EFAULT if the file could not
cannam@154: be opened, or one of the other failure codes from
cannam@154: op_open_callbacks() otherwise.
cannam@154: \return A partially opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_test_file(const char *_path,int *_error)
cannam@154: OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Partially open a stream from a memory buffer.
cannam@154: \see op_test_callbacks
cannam@154: \param _data The memory buffer to open.
cannam@154: \param _size The number of bytes in the buffer.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want the
cannam@154: failure code.
cannam@154: See op_open_callbacks() for a full list of failure codes.
cannam@154: \return A partially opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_test_memory(const unsigned char *_data,
cannam@154: size_t _size,int *_error);
cannam@154:
cannam@154: /**Partially open a stream from a URL.
cannam@154: This function behaves identically to op_test_url(), except that it
cannam@154: takes a va_list instead of a variable number of arguments.
cannam@154: It does not call the <code>va_end</code> macro, and because it invokes the
cannam@154: <code>va_arg</code> macro, the value of \a _ap is undefined after the call.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.
cannam@154: \see op_test_url
cannam@154: \see op_test_callbacks
cannam@154: \param _url The URL to open.
cannam@154: Currently only the <file:>, <http:>, and <https:>
cannam@154: schemes are supported.
cannam@154: Both <http:> and <https:> may be disabled at compile
cannam@154: time, in which case opening such URLs will always
cannam@154: fail.
cannam@154: Currently this only supports URIs.
cannam@154: IRIs should be converted to UTF-8 and URL-escaped,
cannam@154: with internationalized domain names encoded in
cannam@154: punycode, before passing them to this function.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want
cannam@154: the failure code.
cannam@154: See op_open_callbacks() for a full list of failure
cannam@154: codes.
cannam@154: \param[in,out] _ap A list of the \ref url_options "optional flags" to
cannam@154: use.
cannam@154: This is a variable-length list of options terminated
cannam@154: with <code>NULL</code>.
cannam@154: \return A partially opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_vtest_url(const char *_url,
cannam@154: int *_error,va_list _ap) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Partially open a stream from a URL.
cannam@154: \note If you use this function, you must link against <tt>libopusurl</tt>.
cannam@154: \see op_test_callbacks
cannam@154: \param _url The URL to open.
cannam@154: Currently only the <file:>, <http:>, and <https:>
cannam@154: schemes are supported.
cannam@154: Both <http:> and <https:> may be disabled at compile
cannam@154: time, in which case opening such URLs will always fail.
cannam@154: Currently this only supports URIs.
cannam@154: IRIs should be converted to UTF-8 and URL-escaped, with
cannam@154: internationalized domain names encoded in punycode,
cannam@154: before passing them to this function.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want the
cannam@154: failure code.
cannam@154: See op_open_callbacks() for a full list of failure
cannam@154: codes.
cannam@154: \param ... The \ref url_options "optional flags" to use.
cannam@154: This is a variable-length list of options terminated
cannam@154: with <code>NULL</code>.
cannam@154: \return A partially opened \c OggOpusFile, or <code>NULL</code> on error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_test_url(const char *_url,
cannam@154: int *_error,...) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Partially open a stream using the given set of callbacks to access it.
cannam@154: This tests for Opusness and loads the headers for the first link.
cannam@154: It does not seek (although it tests for seekability).
cannam@154: You can query a partially open stream for the few pieces of basic
cannam@154: information returned by op_serialno(), op_channel_count(), op_head(), and
cannam@154: op_tags() (but only for the first link).
cannam@154: You may also determine if it is seekable via a call to op_seekable().
cannam@154: You cannot read audio from the stream, seek, get the size or duration,
cannam@154: get information from links other than the first one, or even get the total
cannam@154: number of links until you finish opening the stream with op_test_open().
cannam@154: If you do not need to do any of these things, you can dispose of it with
cannam@154: op_free() instead.
cannam@154:
cannam@154: This function is provided mostly to simplify porting existing code that used
cannam@154: <tt>libvorbisfile</tt>.
cannam@154: For new code, you are likely better off using op_test() instead, which
cannam@154: is less resource-intensive, requires less data to succeed, and imposes a
cannam@154: hard limit on the amount of data it examines (important for unseekable
cannam@154: streams, where all such data must be buffered until you are sure of the
cannam@154: stream type).
cannam@154: \param _stream The stream to read from (e.g., a <code>FILE *</code>).
cannam@154: This value will be passed verbatim as the first
cannam@154: argument to all of the callbacks.
cannam@154: \param _cb The callbacks with which to access the stream.
cannam@154: <code><a href="#op_read_func">read()</a></code> must
cannam@154: be implemented.
cannam@154: <code><a href="#op_seek_func">seek()</a></code> and
cannam@154: <code><a href="#op_tell_func">tell()</a></code> may
cannam@154: be <code>NULL</code>, or may always return -1 to
cannam@154: indicate a stream is unseekable, but if
cannam@154: <code><a href="#op_seek_func">seek()</a></code> is
cannam@154: implemented and succeeds on a particular stream, then
cannam@154: <code><a href="#op_tell_func">tell()</a></code> must
cannam@154: also.
cannam@154: <code><a href="#op_close_func">close()</a></code> may
cannam@154: be <code>NULL</code>, but if it is not, it will be
cannam@154: called when the \c OggOpusFile is destroyed by
cannam@154: op_free().
cannam@154: It will not be called if op_open_callbacks() fails
cannam@154: with an error.
cannam@154: \param _initial_data An initial buffer of data from the start of the
cannam@154: stream.
cannam@154: Applications can read some number of bytes from the
cannam@154: start of the stream to help identify this as an Opus
cannam@154: stream, and then provide them here to allow the
cannam@154: stream to be tested more thoroughly, even if it is
cannam@154: unseekable.
cannam@154: \param _initial_bytes The number of bytes in \a _initial_data.
cannam@154: If the stream is seekable, its current position (as
cannam@154: reported by
cannam@154: <code><a href="#opus_tell_func">tell()</a></code>
cannam@154: at the start of this function) must be equal to
cannam@154: \a _initial_bytes.
cannam@154: Otherwise, seeking to absolute positions will
cannam@154: generate inconsistent results.
cannam@154: \param[out] _error Returns 0 on success, or a failure code on error.
cannam@154: You may pass in <code>NULL</code> if you don't want
cannam@154: the failure code.
cannam@154: See op_open_callbacks() for a full list of failure
cannam@154: codes.
cannam@154: \return A partially opened \c OggOpusFile, or <code>NULL</code> on error.
cannam@154: <tt>libopusfile</tt> does <em>not</em> take ownership of the stream
cannam@154: if the call fails.
cannam@154: The calling application is responsible for closing the stream if
cannam@154: this call returns an error.*/
cannam@154: OP_WARN_UNUSED_RESULT OggOpusFile *op_test_callbacks(void *_stream,
cannam@154: const OpusFileCallbacks *_cb,const unsigned char *_initial_data,
cannam@154: size_t _initial_bytes,int *_error) OP_ARG_NONNULL(2);
cannam@154:
cannam@154: /**Finish opening a stream partially opened with op_test_callbacks() or one of
cannam@154: the associated convenience functions.
cannam@154: If this function fails, you are still responsible for freeing the
cannam@154: \c OggOpusFile with op_free().
cannam@154: \param _of The \c OggOpusFile to finish opening.
cannam@154: \return 0 on success, or a negative value on error.
cannam@154: \retval #OP_EREAD An underlying read, seek, or tell operation failed
cannam@154: when it should have succeeded.
cannam@154: \retval #OP_EFAULT There was a memory allocation failure, or an
cannam@154: internal library error.
cannam@154: \retval #OP_EIMPL The stream used a feature that is not implemented,
cannam@154: such as an unsupported channel family.
cannam@154: \retval #OP_EINVAL The stream was not partially opened with
cannam@154: op_test_callbacks() or one of the associated
cannam@154: convenience functions.
cannam@154: \retval #OP_ENOTFORMAT The stream contained a link that did not have any
cannam@154: logical Opus streams in it.
cannam@154: \retval #OP_EBADHEADER A required header packet was not properly
cannam@154: formatted, contained illegal values, or was
cannam@154: missing altogether.
cannam@154: \retval #OP_EVERSION An ID header contained an unrecognized version
cannam@154: number.
cannam@154: \retval #OP_EBADLINK We failed to find data we had seen before after
cannam@154: seeking.
cannam@154: \retval #OP_EBADTIMESTAMP The first or last timestamp in a link failed basic
cannam@154: validity checks.*/
cannam@154: int op_test_open(OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Release all memory used by an \c OggOpusFile.
cannam@154: \param _of The \c OggOpusFile to free.*/
cannam@154: void op_free(OggOpusFile *_of);
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup stream_info Stream Information*/
cannam@154: /*@{*/
cannam@154: /**\name Functions for obtaining information about streams
cannam@154:
cannam@154: These functions allow you to get basic information about a stream, including
cannam@154: seekability, the number of links (for chained streams), plus the size,
cannam@154: duration, bitrate, header parameters, and meta information for each link
cannam@154: (or, where available, the stream as a whole).
cannam@154: Some of these (size, duration) are only available for seekable streams.
cannam@154: You can also query the current stream position, link, and playback time,
cannam@154: and instantaneous bitrate during playback.
cannam@154:
cannam@154: Some of these functions may be used successfully on the partially open
cannam@154: streams returned by op_test_callbacks() or one of the associated
cannam@154: convenience functions.
cannam@154: Their documention will indicate so explicitly.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**Returns whether or not the stream being read is seekable.
cannam@154: This is true if
cannam@154: <ol>
cannam@154: <li>The <code><a href="#op_seek_func">seek()</a></code> and
cannam@154: <code><a href="#op_tell_func">tell()</a></code> callbacks are both
cannam@154: non-<code>NULL</code>,</li>
cannam@154: <li>The <code><a href="#op_seek_func">seek()</a></code> callback was
cannam@154: successfully executed at least once, and</li>
cannam@154: <li>The <code><a href="#op_tell_func">tell()</a></code> callback was
cannam@154: successfully able to report the position indicator afterwards.</li>
cannam@154: </ol>
cannam@154: This function may be called on partially-opened streams.
cannam@154: \param _of The \c OggOpusFile whose seekable status is to be returned.
cannam@154: \return A non-zero value if seekable, and 0 if unseekable.*/
cannam@154: int op_seekable(const OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Returns the number of links in this chained stream.
cannam@154: This function may be called on partially-opened streams, but it will always
cannam@154: return 1.
cannam@154: The actual number of links is not known until the stream is fully opened.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the link count.
cannam@154: \return For fully-open seekable streams, this returns the total number of
cannam@154: links in the whole stream, which will be at least 1.
cannam@154: For partially-open or unseekable streams, this always returns 1.*/
cannam@154: int op_link_count(const OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Get the serial number of the given link in a (possibly-chained) Ogg Opus
cannam@154: stream.
cannam@154: This function may be called on partially-opened streams, but it will always
cannam@154: return the serial number of the Opus stream in the first link.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the serial number.
cannam@154: \param _li The index of the link whose serial number should be retrieved.
cannam@154: Use a negative number to get the serial number of the current
cannam@154: link.
cannam@154: \return The serial number of the given link.
cannam@154: If \a _li is greater than the total number of links, this returns
cannam@154: the serial number of the last link.
cannam@154: If the stream is not seekable, this always returns the serial number
cannam@154: of the current link.*/
cannam@154: opus_uint32 op_serialno(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Get the channel count of the given link in a (possibly-chained) Ogg Opus
cannam@154: stream.
cannam@154: This is equivalent to <code>op_head(_of,_li)->channel_count</code>, but
cannam@154: is provided for convenience.
cannam@154: This function may be called on partially-opened streams, but it will always
cannam@154: return the channel count of the Opus stream in the first link.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the channel count.
cannam@154: \param _li The index of the link whose channel count should be retrieved.
cannam@154: Use a negative number to get the channel count of the current
cannam@154: link.
cannam@154: \return The channel count of the given link.
cannam@154: If \a _li is greater than the total number of links, this returns
cannam@154: the channel count of the last link.
cannam@154: If the stream is not seekable, this always returns the channel count
cannam@154: of the current link.*/
cannam@154: int op_channel_count(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Get the total (compressed) size of the stream, or of an individual link in
cannam@154: a (possibly-chained) Ogg Opus stream, including all headers and Ogg muxing
cannam@154: overhead.
cannam@154: \warning If the Opus stream (or link) is concurrently multiplexed with other
cannam@154: logical streams (e.g., video), this returns the size of the entire stream
cannam@154: (or link), not just the number of bytes in the first logical Opus stream.
cannam@154: Returning the latter would require scanning the entire file.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the compressed size.
cannam@154: \param _li The index of the link whose compressed size should be computed.
cannam@154: Use a negative number to get the compressed size of the entire
cannam@154: stream.
cannam@154: \return The compressed size of the entire stream if \a _li is negative, the
cannam@154: compressed size of link \a _li if it is non-negative, or a negative
cannam@154: value on error.
cannam@154: The compressed size of the entire stream may be smaller than that
cannam@154: of the underlying stream if trailing garbage was detected in the
cannam@154: file.
cannam@154: \retval #OP_EINVAL The stream is not seekable (so we can't know the length),
cannam@154: \a _li wasn't less than the total number of links in
cannam@154: the stream, or the stream was only partially open.*/
cannam@154: opus_int64 op_raw_total(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Get the total PCM length (number of samples at 48 kHz) of the stream, or of
cannam@154: an individual link in a (possibly-chained) Ogg Opus stream.
cannam@154: Users looking for <code>op_time_total()</code> should use op_pcm_total()
cannam@154: instead.
cannam@154: Because timestamps in Opus are fixed at 48 kHz, there is no need for a
cannam@154: separate function to convert this to seconds (and leaving it out avoids
cannam@154: introducing floating point to the API, for those that wish to avoid it).
cannam@154: \param _of The \c OggOpusFile from which to retrieve the PCM offset.
cannam@154: \param _li The index of the link whose PCM length should be computed.
cannam@154: Use a negative number to get the PCM length of the entire stream.
cannam@154: \return The PCM length of the entire stream if \a _li is negative, the PCM
cannam@154: length of link \a _li if it is non-negative, or a negative value on
cannam@154: error.
cannam@154: \retval #OP_EINVAL The stream is not seekable (so we can't know the length),
cannam@154: \a _li wasn't less than the total number of links in
cannam@154: the stream, or the stream was only partially open.*/
cannam@154: ogg_int64_t op_pcm_total(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Get the ID header information for the given link in a (possibly chained) Ogg
cannam@154: Opus stream.
cannam@154: This function may be called on partially-opened streams, but it will always
cannam@154: return the ID header information of the Opus stream in the first link.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the ID header
cannam@154: information.
cannam@154: \param _li The index of the link whose ID header information should be
cannam@154: retrieved.
cannam@154: Use a negative number to get the ID header information of the
cannam@154: current link.
cannam@154: For an unseekable stream, \a _li is ignored, and the ID header
cannam@154: information for the current link is always returned, if
cannam@154: available.
cannam@154: \return The contents of the ID header for the given link.*/
cannam@154: const OpusHead *op_head(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Get the comment header information for the given link in a (possibly
cannam@154: chained) Ogg Opus stream.
cannam@154: This function may be called on partially-opened streams, but it will always
cannam@154: return the tags from the Opus stream in the first link.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the comment header
cannam@154: information.
cannam@154: \param _li The index of the link whose comment header information should be
cannam@154: retrieved.
cannam@154: Use a negative number to get the comment header information of
cannam@154: the current link.
cannam@154: For an unseekable stream, \a _li is ignored, and the comment
cannam@154: header information for the current link is always returned, if
cannam@154: available.
cannam@154: \return The contents of the comment header for the given link, or
cannam@154: <code>NULL</code> if this is an unseekable stream that encountered
cannam@154: an invalid link.*/
cannam@154: const OpusTags *op_tags(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Retrieve the index of the current link.
cannam@154: This is the link that produced the data most recently read by
cannam@154: op_read_float() or its associated functions, or, after a seek, the link
cannam@154: that the seek target landed in.
cannam@154: Reading more data may advance the link index (even on the first read after a
cannam@154: seek).
cannam@154: \param _of The \c OggOpusFile from which to retrieve the current link index.
cannam@154: \return The index of the current link on success, or a negative value on
cannam@154: failure.
cannam@154: For seekable streams, this is a number between 0 (inclusive) and the
cannam@154: value returned by op_link_count() (exclusive).
cannam@154: For unseekable streams, this value starts at 0 and increments by one
cannam@154: each time a new link is encountered (even though op_link_count()
cannam@154: always returns 1).
cannam@154: \retval #OP_EINVAL The stream was only partially open.*/
cannam@154: int op_current_link(const OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Computes the bitrate of the stream, or of an individual link in a
cannam@154: (possibly-chained) Ogg Opus stream.
cannam@154: The stream must be seekable to compute the bitrate.
cannam@154: For unseekable streams, use op_bitrate_instant() to get periodic estimates.
cannam@154: \warning If the Opus stream (or link) is concurrently multiplexed with other
cannam@154: logical streams (e.g., video), this uses the size of the entire stream (or
cannam@154: link) to compute the bitrate, not just the number of bytes in the first
cannam@154: logical Opus stream.
cannam@154: Returning the latter requires scanning the entire file, but this may be done
cannam@154: by decoding the whole file and calling op_bitrate_instant() once at the
cannam@154: end.
cannam@154: Install a trivial decoding callback with op_set_decode_callback() if you
cannam@154: wish to skip actual decoding during this process.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the bitrate.
cannam@154: \param _li The index of the link whose bitrate should be computed.
cannam@154: Use a negative number to get the bitrate of the whole stream.
cannam@154: \return The bitrate on success, or a negative value on error.
cannam@154: \retval #OP_EINVAL The stream was only partially open, the stream was not
cannam@154: seekable, or \a _li was larger than the number of
cannam@154: links.*/
cannam@154: opus_int32 op_bitrate(const OggOpusFile *_of,int _li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Compute the instantaneous bitrate, measured as the ratio of bits to playable
cannam@154: samples decoded since a) the last call to op_bitrate_instant(), b) the last
cannam@154: seek, or c) the start of playback, whichever was most recent.
cannam@154: This will spike somewhat after a seek or at the start/end of a chain
cannam@154: boundary, as pre-skip, pre-roll, and end-trimming causes samples to be
cannam@154: decoded but not played.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the bitrate.
cannam@154: \return The bitrate, in bits per second, or a negative value on error.
cannam@154: \retval #OP_FALSE No data has been decoded since any of the events
cannam@154: described above.
cannam@154: \retval #OP_EINVAL The stream was only partially open.*/
cannam@154: opus_int32 op_bitrate_instant(OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Obtain the current value of the position indicator for \a _of.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the position indicator.
cannam@154: \return The byte position that is currently being read from.
cannam@154: \retval #OP_EINVAL The stream was only partially open.*/
cannam@154: opus_int64 op_raw_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Obtain the PCM offset of the next sample to be read.
cannam@154: If the stream is not properly timestamped, this might not increment by the
cannam@154: proper amount between reads, or even return monotonically increasing
cannam@154: values.
cannam@154: \param _of The \c OggOpusFile from which to retrieve the PCM offset.
cannam@154: \return The PCM offset of the next sample to be read.
cannam@154: \retval #OP_EINVAL The stream was only partially open.*/
cannam@154: ogg_int64_t op_pcm_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup stream_seeking Seeking*/
cannam@154: /*@{*/
cannam@154: /**\name Functions for seeking in Opus streams
cannam@154:
cannam@154: These functions let you seek in Opus streams, if the underlying stream
cannam@154: support it.
cannam@154: Seeking is implemented for all built-in stream I/O routines, though some
cannam@154: individual streams may not be seekable (pipes, live HTTP streams, or HTTP
cannam@154: streams from a server that does not support <code>Range</code> requests).
cannam@154:
cannam@154: op_raw_seek() is the fastest: it is guaranteed to perform at most one
cannam@154: physical seek, but, since the target is a byte position, makes no guarantee
cannam@154: how close to a given time it will come.
cannam@154: op_pcm_seek() provides sample-accurate seeking.
cannam@154: The number of physical seeks it requires is still quite small (often 1 or
cannam@154: 2, even in highly variable bitrate streams).
cannam@154:
cannam@154: Seeking in Opus requires decoding some pre-roll amount before playback to
cannam@154: allow the internal state to converge (as if recovering from packet loss).
cannam@154: This is handled internally by <tt>libopusfile</tt>, but means there is
cannam@154: little extra overhead for decoding up to the exact position requested
cannam@154: (since it must decode some amount of audio anyway).
cannam@154: It also means that decoding after seeking may not return exactly the same
cannam@154: values as would be obtained by decoding the stream straight through.
cannam@154: However, such differences are expected to be smaller than the loss
cannam@154: introduced by Opus's lossy compression.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**Seek to a byte offset relative to the <b>compressed</b> data.
cannam@154: This also scans packets to update the PCM cursor.
cannam@154: It will cross a logical bitstream boundary, but only if it can't get any
cannam@154: packets out of the tail of the link to which it seeks.
cannam@154: \param _of The \c OggOpusFile in which to seek.
cannam@154: \param _byte_offset The byte position to seek to.
cannam@154: This must be between 0 and #op_raw_total(\a _of,\c -1)
cannam@154: (inclusive).
cannam@154: \return 0 on success, or a negative error code on failure.
cannam@154: \retval #OP_EREAD The underlying seek operation failed.
cannam@154: \retval #OP_EINVAL The stream was only partially open, or the target was
cannam@154: outside the valid range for the stream.
cannam@154: \retval #OP_ENOSEEK This stream is not seekable.
cannam@154: \retval #OP_EBADLINK Failed to initialize a decoder for a stream for an
cannam@154: unknown reason.*/
cannam@154: int op_raw_seek(OggOpusFile *_of,opus_int64 _byte_offset) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Seek to the specified PCM offset, such that decoding will begin at exactly
cannam@154: the requested position.
cannam@154: \param _of The \c OggOpusFile in which to seek.
cannam@154: \param _pcm_offset The PCM offset to seek to.
cannam@154: This is in samples at 48 kHz relative to the start of the
cannam@154: stream.
cannam@154: \return 0 on success, or a negative value on error.
cannam@154: \retval #OP_EREAD An underlying read or seek operation failed.
cannam@154: \retval #OP_EINVAL The stream was only partially open, or the target was
cannam@154: outside the valid range for the stream.
cannam@154: \retval #OP_ENOSEEK This stream is not seekable.
cannam@154: \retval #OP_EBADLINK We failed to find data we had seen before, or the
cannam@154: bitstream structure was sufficiently malformed that
cannam@154: seeking to the target destination was impossible.*/
cannam@154: int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: /**\defgroup stream_decoding Decoding*/
cannam@154: /*@{*/
cannam@154: /**\name Functions for decoding audio data
cannam@154:
cannam@154: These functions retrieve actual decoded audio data from the stream.
cannam@154: The general functions, op_read() and op_read_float() return 16-bit or
cannam@154: floating-point output, both using native endian ordering.
cannam@154: The number of channels returned can change from link to link in a chained
cannam@154: stream.
cannam@154: There are special functions, op_read_stereo() and op_read_float_stereo(),
cannam@154: which always output two channels, to simplify applications which do not
cannam@154: wish to handle multichannel audio.
cannam@154: These downmix multichannel files to two channels, so they can always return
cannam@154: samples in the same format for every link in a chained file.
cannam@154:
cannam@154: If the rest of your audio processing chain can handle floating point, the
cannam@154: floating-point routines should be preferred, as they prevent clipping and
cannam@154: other issues which might be avoided entirely if, e.g., you scale down the
cannam@154: volume at some other stage.
cannam@154: However, if you intend to consume 16-bit samples directly, the conversion in
cannam@154: <tt>libopusfile</tt> provides noise-shaping dithering and, if compiled
cannam@154: against <tt>libopus</tt> 1.1 or later, soft-clipping prevention.
cannam@154:
cannam@154: <tt>libopusfile</tt> can also be configured at compile time to use the
cannam@154: fixed-point <tt>libopus</tt> API.
cannam@154: If so, <tt>libopusfile</tt>'s floating-point API may also be disabled.
cannam@154: In that configuration, nothing in <tt>libopusfile</tt> will use any
cannam@154: floating-point operations, to simplify support on devices without an
cannam@154: adequate FPU.
cannam@154:
cannam@154: \warning HTTPS streams may be be vulnerable to truncation attacks if you do
cannam@154: not check the error return code from op_read_float() or its associated
cannam@154: functions.
cannam@154: If the remote peer does not close the connection gracefully (with a TLS
cannam@154: "close notify" message), these functions will return #OP_EREAD instead of 0
cannam@154: when they reach the end of the file.
cannam@154: If you are reading from an <https:> URL (particularly if seeking is not
cannam@154: supported), you should make sure to check for this error and warn the user
cannam@154: appropriately.*/
cannam@154: /*@{*/
cannam@154:
cannam@154: /**Indicates that the decoding callback should produce signed 16-bit
cannam@154: native-endian output samples.*/
cannam@154: #define OP_DEC_FORMAT_SHORT (7008)
cannam@154: /**Indicates that the decoding callback should produce 32-bit native-endian
cannam@154: float samples.*/
cannam@154: #define OP_DEC_FORMAT_FLOAT (7040)
cannam@154:
cannam@154: /**Indicates that the decoding callback did not decode anything, and that
cannam@154: <tt>libopusfile</tt> should decode normally instead.*/
cannam@154: #define OP_DEC_USE_DEFAULT (6720)
cannam@154:
cannam@154: /**Called to decode an Opus packet.
cannam@154: This should invoke the functional equivalent of opus_multistream_decode() or
cannam@154: opus_multistream_decode_float(), except that it returns 0 on success
cannam@154: instead of the number of decoded samples (which is known a priori).
cannam@154: \param _ctx The application-provided callback context.
cannam@154: \param _decoder The decoder to use to decode the packet.
cannam@154: \param[out] _pcm The buffer to decode into.
cannam@154: This will always have enough room for \a _nchannels of
cannam@154: \a _nsamples samples, which should be placed into this
cannam@154: buffer interleaved.
cannam@154: \param _op The packet to decode.
cannam@154: This will always have its granule position set to a valid
cannam@154: value.
cannam@154: \param _nsamples The number of samples expected from the packet.
cannam@154: \param _nchannels The number of channels expected from the packet.
cannam@154: \param _format The desired sample output format.
cannam@154: This is either #OP_DEC_FORMAT_SHORT or
cannam@154: #OP_DEC_FORMAT_FLOAT.
cannam@154: \param _li The index of the link from which this packet was decoded.
cannam@154: \return A non-negative value on success, or a negative value on error.
cannam@154: Any error codes should be the same as those returned by
cannam@154: opus_multistream_decode() or opus_multistream_decode_float().
cannam@154: Success codes are as follows:
cannam@154: \retval 0 Decoding was successful.
cannam@154: The application has filled the buffer with
cannam@154: exactly <code>\a _nsamples*\a
cannam@154: _nchannels</code> samples in the requested
cannam@154: format.
cannam@154: \retval #OP_DEC_USE_DEFAULT No decoding was done.
cannam@154: <tt>libopusfile</tt> should do the decoding
cannam@154: by itself instead.*/
cannam@154: typedef int (*op_decode_cb_func)(void *_ctx,OpusMSDecoder *_decoder,void *_pcm,
cannam@154: const ogg_packet *_op,int _nsamples,int _nchannels,int _format,int _li);
cannam@154:
cannam@154: /**Sets the packet decode callback function.
cannam@154: If set, this is called once for each packet that needs to be decoded.
cannam@154: This can be used by advanced applications to do additional processing on the
cannam@154: compressed or uncompressed data.
cannam@154: For example, an application might save the final entropy coder state for
cannam@154: debugging and testing purposes, or it might apply additional filters
cannam@154: before the downmixing, dithering, or soft-clipping performed by
cannam@154: <tt>libopusfile</tt>, so long as these filters do not introduce any
cannam@154: latency.
cannam@154:
cannam@154: A call to this function is no guarantee that the audio will eventually be
cannam@154: delivered to the application.
cannam@154: <tt>libopusfile</tt> may discard some or all of the decoded audio data
cannam@154: (i.e., at the beginning or end of a link, or after a seek), however the
cannam@154: callback is still required to provide all of it.
cannam@154: \param _of The \c OggOpusFile on which to set the decode callback.
cannam@154: \param _decode_cb The callback function to call.
cannam@154: This may be <code>NULL</code> to disable calling the
cannam@154: callback.
cannam@154: \param _ctx The application-provided context pointer to pass to the
cannam@154: callback on each call.*/
cannam@154: void op_set_decode_callback(OggOpusFile *_of,
cannam@154: op_decode_cb_func _decode_cb,void *_ctx) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Gain offset type that indicates that the provided offset is relative to the
cannam@154: header gain.
cannam@154: This is the default.*/
cannam@154: #define OP_HEADER_GAIN (0)
cannam@154:
cannam@154: /**Gain offset type that indicates that the provided offset is relative to the
cannam@154: R128_ALBUM_GAIN value (if any), in addition to the header gain.*/
cannam@154: #define OP_ALBUM_GAIN (3007)
cannam@154:
cannam@154: /**Gain offset type that indicates that the provided offset is relative to the
cannam@154: R128_TRACK_GAIN value (if any), in addition to the header gain.*/
cannam@154: #define OP_TRACK_GAIN (3008)
cannam@154:
cannam@154: /**Gain offset type that indicates that the provided offset should be used as
cannam@154: the gain directly, without applying any the header or track gains.*/
cannam@154: #define OP_ABSOLUTE_GAIN (3009)
cannam@154:
cannam@154: /**Sets the gain to be used for decoded output.
cannam@154: By default, the gain in the header is applied with no additional offset.
cannam@154: The total gain (including header gain and/or track gain, if applicable, and
cannam@154: this offset), will be clamped to [-32768,32767]/256 dB.
cannam@154: This is more than enough to saturate or underflow 16-bit PCM.
cannam@154: \note The new gain will not be applied to any already buffered, decoded
cannam@154: output.
cannam@154: This means you cannot change it sample-by-sample, as at best it will be
cannam@154: updated packet-by-packet.
cannam@154: It is meant for setting a target volume level, rather than applying smooth
cannam@154: fades, etc.
cannam@154: \param _of The \c OggOpusFile on which to set the gain offset.
cannam@154: \param _gain_type One of #OP_HEADER_GAIN, #OP_ALBUM_GAIN,
cannam@154: #OP_TRACK_GAIN, or #OP_ABSOLUTE_GAIN.
cannam@154: \param _gain_offset_q8 The gain offset to apply, in 1/256ths of a dB.
cannam@154: \return 0 on success or a negative value on error.
cannam@154: \retval #OP_EINVAL The \a _gain_type was unrecognized.*/
cannam@154: int op_set_gain_offset(OggOpusFile *_of,
cannam@154: int _gain_type,opus_int32 _gain_offset_q8) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Sets whether or not dithering is enabled for 16-bit decoding.
cannam@154: By default, when <tt>libopusfile</tt> is compiled to use floating-point
cannam@154: internally, calling op_read() or op_read_stereo() will first decode to
cannam@154: float, and then convert to fixed-point using noise-shaping dithering.
cannam@154: This flag can be used to disable that dithering.
cannam@154: When the application uses op_read_float() or op_read_float_stereo(), or when
cannam@154: the library has been compiled to decode directly to fixed point, this flag
cannam@154: has no effect.
cannam@154: \param _of The \c OggOpusFile on which to enable or disable dithering.
cannam@154: \param _enabled A non-zero value to enable dithering, or 0 to disable it.*/
cannam@154: void op_set_dither_enabled(OggOpusFile *_of,int _enabled) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Reads more samples from the stream.
cannam@154: \note Although \a _buf_size must indicate the total number of values that
cannam@154: can be stored in \a _pcm, the return value is the number of samples
cannam@154: <em>per channel</em>.
cannam@154: This is done because
cannam@154: <ol>
cannam@154: <li>The channel count cannot be known a priori (reading more samples might
cannam@154: advance us into the next link, with a different channel count), so
cannam@154: \a _buf_size cannot also be in units of samples per channel,</li>
cannam@154: <li>Returning the samples per channel matches the <code>libopus</code> API
cannam@154: as closely as we're able,</li>
cannam@154: <li>Returning the total number of values instead of samples per channel
cannam@154: would mean the caller would need a division to compute the samples per
cannam@154: channel, and might worry about the possibility of getting back samples
cannam@154: for some channels and not others, and</li>
cannam@154: <li>This approach is relatively fool-proof: if an application passes too
cannam@154: small a value to \a _buf_size, they will simply get fewer samples back,
cannam@154: and if they assume the return value is the total number of values, then
cannam@154: they will simply read too few (rather than reading too many and going
cannam@154: off the end of the buffer).</li>
cannam@154: </ol>
cannam@154: \param _of The \c OggOpusFile from which to read.
cannam@154: \param[out] _pcm A buffer in which to store the output PCM samples, as
cannam@154: signed native-endian 16-bit values at 48 kHz
cannam@154: with a nominal range of <code>[-32768,32767)</code>.
cannam@154: Multiple channels are interleaved using the
cannam@154: <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
cannam@154: channel ordering</a>.
cannam@154: This must have room for at least \a _buf_size values.
cannam@154: \param _buf_size The number of values that can be stored in \a _pcm.
cannam@154: It is recommended that this be large enough for at
cannam@154: least 120 ms of data at 48 kHz per channel (5760
cannam@154: values per channel).
cannam@154: Smaller buffers will simply return less data, possibly
cannam@154: consuming more memory to buffer the data internally.
cannam@154: <tt>libopusfile</tt> may return less data than
cannam@154: requested.
cannam@154: If so, there is no guarantee that the remaining data
cannam@154: in \a _pcm will be unmodified.
cannam@154: \param[out] _li The index of the link this data was decoded from.
cannam@154: You may pass <code>NULL</code> if you do not need this
cannam@154: information.
cannam@154: If this function fails (returning a negative value),
cannam@154: this parameter is left unset.
cannam@154: \return The number of samples read per channel on success, or a negative
cannam@154: value on failure.
cannam@154: The channel count can be retrieved on success by calling
cannam@154: <code>op_head(_of,*_li)</code>.
cannam@154: The number of samples returned may be 0 if the buffer was too small
cannam@154: to store even a single sample for all channels, or if end-of-file
cannam@154: was reached.
cannam@154: The list of possible failure codes follows.
cannam@154: Most of them can only be returned by unseekable, chained streams
cannam@154: that encounter a new link.
cannam@154: \retval #OP_HOLE There was a hole in the data, and some samples
cannam@154: may have been skipped.
cannam@154: Call this function again to continue decoding
cannam@154: past the hole.
cannam@154: \retval #OP_EREAD An underlying read operation failed.
cannam@154: This may signal a truncation attack from an
cannam@154: <https:> source.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.
cannam@154: \retval #OP_EIMPL An unseekable stream encountered a new link that
cannam@154: used a feature that is not implemented, such as
cannam@154: an unsupported channel family.
cannam@154: \retval #OP_EINVAL The stream was only partially open.
cannam@154: \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that
cannam@154: did not have any logical Opus streams in it.
cannam@154: \retval #OP_EBADHEADER An unseekable stream encountered a new link with a
cannam@154: required header packet that was not properly
cannam@154: formatted, contained illegal values, or was
cannam@154: missing altogether.
cannam@154: \retval #OP_EVERSION An unseekable stream encountered a new link with
cannam@154: an ID header that contained an unrecognized
cannam@154: version number.
cannam@154: \retval #OP_EBADPACKET Failed to properly decode the next packet.
cannam@154: \retval #OP_EBADLINK We failed to find data we had seen before.
cannam@154: \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with
cannam@154: a starting timestamp that failed basic validity
cannam@154: checks.*/
cannam@154: OP_WARN_UNUSED_RESULT int op_read(OggOpusFile *_of,
cannam@154: opus_int16 *_pcm,int _buf_size,int *_li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Reads more samples from the stream.
cannam@154: \note Although \a _buf_size must indicate the total number of values that
cannam@154: can be stored in \a _pcm, the return value is the number of samples
cannam@154: <em>per channel</em>.
cannam@154: <ol>
cannam@154: <li>The channel count cannot be known a priori (reading more samples might
cannam@154: advance us into the next link, with a different channel count), so
cannam@154: \a _buf_size cannot also be in units of samples per channel,</li>
cannam@154: <li>Returning the samples per channel matches the <code>libopus</code> API
cannam@154: as closely as we're able,</li>
cannam@154: <li>Returning the total number of values instead of samples per channel
cannam@154: would mean the caller would need a division to compute the samples per
cannam@154: channel, and might worry about the possibility of getting back samples
cannam@154: for some channels and not others, and</li>
cannam@154: <li>This approach is relatively fool-proof: if an application passes too
cannam@154: small a value to \a _buf_size, they will simply get fewer samples back,
cannam@154: and if they assume the return value is the total number of values, then
cannam@154: they will simply read too few (rather than reading too many and going
cannam@154: off the end of the buffer).</li>
cannam@154: </ol>
cannam@154: \param _of The \c OggOpusFile from which to read.
cannam@154: \param[out] _pcm A buffer in which to store the output PCM samples as
cannam@154: signed floats at 48 kHz with a nominal range of
cannam@154: <code>[-1.0,1.0]</code>.
cannam@154: Multiple channels are interleaved using the
cannam@154: <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
cannam@154: channel ordering</a>.
cannam@154: This must have room for at least \a _buf_size floats.
cannam@154: \param _buf_size The number of floats that can be stored in \a _pcm.
cannam@154: It is recommended that this be large enough for at
cannam@154: least 120 ms of data at 48 kHz per channel (5760
cannam@154: samples per channel).
cannam@154: Smaller buffers will simply return less data, possibly
cannam@154: consuming more memory to buffer the data internally.
cannam@154: If less than \a _buf_size values are returned,
cannam@154: <tt>libopusfile</tt> makes no guarantee that the
cannam@154: remaining data in \a _pcm will be unmodified.
cannam@154: \param[out] _li The index of the link this data was decoded from.
cannam@154: You may pass <code>NULL</code> if you do not need this
cannam@154: information.
cannam@154: If this function fails (returning a negative value),
cannam@154: this parameter is left unset.
cannam@154: \return The number of samples read per channel on success, or a negative
cannam@154: value on failure.
cannam@154: The channel count can be retrieved on success by calling
cannam@154: <code>op_head(_of,*_li)</code>.
cannam@154: The number of samples returned may be 0 if the buffer was too small
cannam@154: to store even a single sample for all channels, or if end-of-file
cannam@154: was reached.
cannam@154: The list of possible failure codes follows.
cannam@154: Most of them can only be returned by unseekable, chained streams
cannam@154: that encounter a new link.
cannam@154: \retval #OP_HOLE There was a hole in the data, and some samples
cannam@154: may have been skipped.
cannam@154: Call this function again to continue decoding
cannam@154: past the hole.
cannam@154: \retval #OP_EREAD An underlying read operation failed.
cannam@154: This may signal a truncation attack from an
cannam@154: <https:> source.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.
cannam@154: \retval #OP_EIMPL An unseekable stream encountered a new link that
cannam@154: used a feature that is not implemented, such as
cannam@154: an unsupported channel family.
cannam@154: \retval #OP_EINVAL The stream was only partially open.
cannam@154: \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that
cannam@154: did not have any logical Opus streams in it.
cannam@154: \retval #OP_EBADHEADER An unseekable stream encountered a new link with a
cannam@154: required header packet that was not properly
cannam@154: formatted, contained illegal values, or was
cannam@154: missing altogether.
cannam@154: \retval #OP_EVERSION An unseekable stream encountered a new link with
cannam@154: an ID header that contained an unrecognized
cannam@154: version number.
cannam@154: \retval #OP_EBADPACKET Failed to properly decode the next packet.
cannam@154: \retval #OP_EBADLINK We failed to find data we had seen before.
cannam@154: \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with
cannam@154: a starting timestamp that failed basic validity
cannam@154: checks.*/
cannam@154: OP_WARN_UNUSED_RESULT int op_read_float(OggOpusFile *_of,
cannam@154: float *_pcm,int _buf_size,int *_li) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Reads more samples from the stream and downmixes to stereo, if necessary.
cannam@154: This function is intended for simple players that want a uniform output
cannam@154: format, even if the channel count changes between links in a chained
cannam@154: stream.
cannam@154: \note \a _buf_size indicates the total number of values that can be stored
cannam@154: in \a _pcm, while the return value is the number of samples <em>per
cannam@154: channel</em>, even though the channel count is known, for consistency with
cannam@154: op_read().
cannam@154: \param _of The \c OggOpusFile from which to read.
cannam@154: \param[out] _pcm A buffer in which to store the output PCM samples, as
cannam@154: signed native-endian 16-bit values at 48 kHz
cannam@154: with a nominal range of <code>[-32768,32767)</code>.
cannam@154: The left and right channels are interleaved in the
cannam@154: buffer.
cannam@154: This must have room for at least \a _buf_size values.
cannam@154: \param _buf_size The number of values that can be stored in \a _pcm.
cannam@154: It is recommended that this be large enough for at
cannam@154: least 120 ms of data at 48 kHz per channel (11520
cannam@154: values total).
cannam@154: Smaller buffers will simply return less data, possibly
cannam@154: consuming more memory to buffer the data internally.
cannam@154: If less than \a _buf_size values are returned,
cannam@154: <tt>libopusfile</tt> makes no guarantee that the
cannam@154: remaining data in \a _pcm will be unmodified.
cannam@154: \return The number of samples read per channel on success, or a negative
cannam@154: value on failure.
cannam@154: The number of samples returned may be 0 if the buffer was too small
cannam@154: to store even a single sample for both channels, or if end-of-file
cannam@154: was reached.
cannam@154: The list of possible failure codes follows.
cannam@154: Most of them can only be returned by unseekable, chained streams
cannam@154: that encounter a new link.
cannam@154: \retval #OP_HOLE There was a hole in the data, and some samples
cannam@154: may have been skipped.
cannam@154: Call this function again to continue decoding
cannam@154: past the hole.
cannam@154: \retval #OP_EREAD An underlying read operation failed.
cannam@154: This may signal a truncation attack from an
cannam@154: <https:> source.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.
cannam@154: \retval #OP_EIMPL An unseekable stream encountered a new link that
cannam@154: used a feature that is not implemented, such as
cannam@154: an unsupported channel family.
cannam@154: \retval #OP_EINVAL The stream was only partially open.
cannam@154: \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that
cannam@154: did not have any logical Opus streams in it.
cannam@154: \retval #OP_EBADHEADER An unseekable stream encountered a new link with a
cannam@154: required header packet that was not properly
cannam@154: formatted, contained illegal values, or was
cannam@154: missing altogether.
cannam@154: \retval #OP_EVERSION An unseekable stream encountered a new link with
cannam@154: an ID header that contained an unrecognized
cannam@154: version number.
cannam@154: \retval #OP_EBADPACKET Failed to properly decode the next packet.
cannam@154: \retval #OP_EBADLINK We failed to find data we had seen before.
cannam@154: \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with
cannam@154: a starting timestamp that failed basic validity
cannam@154: checks.*/
cannam@154: OP_WARN_UNUSED_RESULT int op_read_stereo(OggOpusFile *_of,
cannam@154: opus_int16 *_pcm,int _buf_size) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /**Reads more samples from the stream and downmixes to stereo, if necessary.
cannam@154: This function is intended for simple players that want a uniform output
cannam@154: format, even if the channel count changes between links in a chained
cannam@154: stream.
cannam@154: \note \a _buf_size indicates the total number of values that can be stored
cannam@154: in \a _pcm, while the return value is the number of samples <em>per
cannam@154: channel</em>, even though the channel count is known, for consistency with
cannam@154: op_read_float().
cannam@154: \param _of The \c OggOpusFile from which to read.
cannam@154: \param[out] _pcm A buffer in which to store the output PCM samples, as
cannam@154: signed floats at 48 kHz with a nominal range of
cannam@154: <code>[-1.0,1.0]</code>.
cannam@154: The left and right channels are interleaved in the
cannam@154: buffer.
cannam@154: This must have room for at least \a _buf_size values.
cannam@154: \param _buf_size The number of values that can be stored in \a _pcm.
cannam@154: It is recommended that this be large enough for at
cannam@154: least 120 ms of data at 48 kHz per channel (11520
cannam@154: values total).
cannam@154: Smaller buffers will simply return less data, possibly
cannam@154: consuming more memory to buffer the data internally.
cannam@154: If less than \a _buf_size values are returned,
cannam@154: <tt>libopusfile</tt> makes no guarantee that the
cannam@154: remaining data in \a _pcm will be unmodified.
cannam@154: \return The number of samples read per channel on success, or a negative
cannam@154: value on failure.
cannam@154: The number of samples returned may be 0 if the buffer was too small
cannam@154: to store even a single sample for both channels, or if end-of-file
cannam@154: was reached.
cannam@154: The list of possible failure codes follows.
cannam@154: Most of them can only be returned by unseekable, chained streams
cannam@154: that encounter a new link.
cannam@154: \retval #OP_HOLE There was a hole in the data, and some samples
cannam@154: may have been skipped.
cannam@154: Call this function again to continue decoding
cannam@154: past the hole.
cannam@154: \retval #OP_EREAD An underlying read operation failed.
cannam@154: This may signal a truncation attack from an
cannam@154: <https:> source.
cannam@154: \retval #OP_EFAULT An internal memory allocation failed.
cannam@154: \retval #OP_EIMPL An unseekable stream encountered a new link that
cannam@154: used a feature that is not implemented, such as
cannam@154: an unsupported channel family.
cannam@154: \retval #OP_EINVAL The stream was only partially open.
cannam@154: \retval #OP_ENOTFORMAT An unseekable stream encountered a new link that
cannam@154: that did not have any logical Opus streams in it.
cannam@154: \retval #OP_EBADHEADER An unseekable stream encountered a new link with a
cannam@154: required header packet that was not properly
cannam@154: formatted, contained illegal values, or was
cannam@154: missing altogether.
cannam@154: \retval #OP_EVERSION An unseekable stream encountered a new link with
cannam@154: an ID header that contained an unrecognized
cannam@154: version number.
cannam@154: \retval #OP_EBADPACKET Failed to properly decode the next packet.
cannam@154: \retval #OP_EBADLINK We failed to find data we had seen before.
cannam@154: \retval #OP_EBADTIMESTAMP An unseekable stream encountered a new link with
cannam@154: a starting timestamp that failed basic validity
cannam@154: checks.*/
cannam@154: OP_WARN_UNUSED_RESULT int op_read_float_stereo(OggOpusFile *_of,
cannam@154: float *_pcm,int _buf_size) OP_ARG_NONNULL(1);
cannam@154:
cannam@154: /*@}*/
cannam@154: /*@}*/
cannam@154:
cannam@154: # if OP_GNUC_PREREQ(4,0)
cannam@154: # pragma GCC visibility pop
cannam@154: # endif
cannam@154:
cannam@154: # if defined(__cplusplus)
cannam@154: }
cannam@154: # endif
cannam@154:
cannam@154: #endif