[audio-opusfile.git] / lib / Audio / Opusfile.pm

package Audio::Opusfile;

use 5.014000;
use strict;
use warnings;
use Carp;

use parent qw/Exporter/;
use AutoLoader;

my @constants =
  qw/OPUS_CHANNEL_COUNT_MAX
	 OP_ABSOLUTE_GAIN
	 OP_DEC_FORMAT_FLOAT
	 OP_DEC_FORMAT_SHORT
	 OP_DEC_USE_DEFAULT
	 OP_EBADHEADER
	 OP_EBADLINK
	 OP_EBADPACKET
	 OP_EBADTIMESTAMP
	 OP_EFAULT
	 OP_EIMPL
	 OP_EINVAL
	 OP_ENOSEEK
	 OP_ENOTAUDIO
	 OP_ENOTFORMAT
	 OP_EOF
	 OP_EREAD
	 OP_EVERSION
	 OP_FALSE
	 OP_GET_SERVER_INFO_REQUEST
	 OP_HEADER_GAIN
	 OP_HOLE
	 OP_HTTP_PROXY_HOST_REQUEST
	 OP_HTTP_PROXY_PASS_REQUEST
	 OP_HTTP_PROXY_PORT_REQUEST
	 OP_HTTP_PROXY_USER_REQUEST
	 OP_PIC_FORMAT_GIF
	 OP_PIC_FORMAT_JPEG
	 OP_PIC_FORMAT_PNG
	 OP_PIC_FORMAT_UNKNOWN
	 OP_PIC_FORMAT_URL
	 OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST
	 OP_TRACK_GAIN/;

our @EXPORT_OK = @constants;
our @EXPORT = @constants;

our $VERSION = '1.000';

sub AUTOLOAD { ## no critic (ProhibitAutoloading)
	my $constname;
	our $AUTOLOAD;
	($constname = $AUTOLOAD) =~ s/.*:://s;
	croak '&Audio::Opusfile::constant not defined' if $constname eq 'constant';
	my ($error, $val) = constant($constname);
	if ($error) { croak $error; }
	{
		no strict 'refs'; ## no critic (ProhibitNoStrict)
		*$AUTOLOAD = sub { $val };
	}
	goto &$AUTOLOAD;
}

require XSLoader;
XSLoader::load('Audio::Opusfile', $VERSION);
require Audio::Opusfile::Head;
require Audio::Opusfile::Tags;
require Audio::Opusfile::PictureTag;

sub new_from_file {
	my ($class, $file) = @_;
	open_file($file)
}

sub new_from_memory {
	my ($class, $buf) = @_;
	open_memory($buf)
}

1;
__END__

=encoding utf-8

=head1 NAME

Audio::Opusfile - partial interface to the libopusfile Ogg Opus library

=head1 SYNOPSIS

  use Audio::Opusfile;
  my $of = Audio::Opusfile->new_from_file('silence.opus');
  my $tags = $of->tags;
  say $tags->query('TITLE'); # Cellule

=head1 DESCRIPTION

Opus is a totally open, royalty-free, highly versatile audio codec.
Opus is unmatched for interactive speech and music transmission over
the Internet, but is also intended for storage and streaming
applications. It is standardized by the Internet Engineering Task
Force (IETF) as RFC 6716 which incorporated technology from Skype's
SILK codec and Xiph.Org's CELT codec.

libopusfile is a library for decoding and basic manipulation of Ogg
Opus files.

Audio::Opusfile is an interface to libopusfile. It exports nearly all
of the functions for obtaining metadata of an Opus file or buffer in
that library. Future versions will additionally provide functions for
decoding Opus data into PCM.

The API might change in future versions.

=head1 METHODS

=over

=item Audio::Opusfile->B<new_from_file>(I<$file>)

Creates a new Audio::Opusfile object from an Ogg Opus file.

Dies if the given file does not exist or is not a valid Ogg Opus file.

=item Audio::Opusfile->B<new_from_memory>(I<$buffer>)

Creates a new Audio::Opusfile object from a buffer containing Ogg Opus
data.

Dies if the given buffer does not contain valid data.

=item Audio::Opusfile::test(I<$buffer>)

Returns true if the given buffer looks like the beginning of a valid
Ogg Opus file, false otherwise.

Dies if the given buffer does not have sufficient data to tell if it
is an Opus stream or if it looks like a Opus stream but parsing it
failed.

=item $of->B<head>

Returns an L<Audio::Opusfile::Head> object corresponding to the file.

=item $of->B<tags>

Returns an L<Audio::Opusfile::Tags> object corresponding to the file.

=item $of->B<seekable>

Returns whether or not the data source being read is seekable.

=item $of->B<link_count>

Returns the number of links in this chained stream. Always returns 1
for unseekable sources.

=item $of->B<serialno>([I<$link_index>])

Get the serial number of the given link in a (possibly-chained) Ogg
Opus stream. If the given index is greater than the total number of
links, this returns the serial number of the last link.

If the source is not seekable, I<$link_index> is negative, or
I<$link_index> is not given, then this function returns the serial
number of the current link.

=item $of->B<raw_total>([I<$link_index>])

Get the total (compressed) size of the stream (with no arguments), or
of an individual link in a (possibly-chained) Ogg Opus stream (with
one nonnegative argument), including all headers and Ogg muxing
overhead.

The stream must be seekable to get the total. A negative value is
returned if the stream is not seekable.

B<Warning:> If the Opus stream (or link) is concurrently multiplexed
with other logical streams (e.g., video), this returns the size of the
entire stream (or link), not just the number of bytes in the first
logical Opus stream. Returning the latter would require scanning the
entire file.

=item $of->B<pcm_total>([I<$link_index>])

Get the total PCM length (number of samples at 48 kHz) of the stream
(with no arguments), or of an individual link in a (possibly-chained)
Ogg Opus stream (with one nonnegative argument).

Users looking for op_time_total() should use this function instead.
Because timestamps in Opus are fixed at 48 kHz, there is no need for a
separate function to convert this to seconds.

The stream must be seekable to get the total. A negative value is
returned if the stream is not seekable.

=item $of->B<current_link>

Retrieve the index of the current link.

This is the link that produced the data most recently read by
op_read_float() or its associated functions, or, after a seek, the
link that the seek target landed in. Reading more data may advance the
link index (even on the first read after a seek).

=item $of->B<bitrate>([I<$link_index>])

Computes the bitrate of the stream (with no arguments), or of an
individual link in a (possibly-chained) Ogg Opus stream (with one
nonnegative argument).

The stream must be seekable to compute the bitrate. A negative value
is returned if the stream is not seekable.

B<Warning:> If the Opus stream (or link) is concurrently multiplexed with
other logical streams (e.g., video), this uses the size of the entire
stream (or link) to compute the bitrate, not just the number of bytes
in the first logical Opus stream.

=item $of->B<bitrate_instant>

Compute the instantaneous bitrate, measured as the ratio of bits to
playable samples decoded since a) the last call to B<bitrate_instant>,
b) the last seek, or c) the start of playback, whichever was most
recent.

This will spike somewhat after a seek or at the start/end of a chain
boundary, as pre-skip, pre-roll, and end-trimming causes samples to be
decoded but not played.

=item $of->B<raw_tell>

Obtain the current value of the position indicator of I<$of>. This is
the byte position that is currently being read from.

=item $of->B<pcm_tell>

Obtain the PCM offset of the next sample to be read.

If the stream is not properly timestamped, this might not increment by
the proper amount between reads, or even return monotonically
increasing values.

=item $of->B<raw_seek>(I<$offset>)

Seek to a byte offset relative to the compressed data.

This also scans packets to update the PCM cursor. It will cross a
logical bitstream boundary, but only if it can't get any packets out
of the tail of the link to which it seeks.

=item $of->B<pcm_seek>(I<$offset>)

Seek to the specified PCM offset, such that decoding will begin at
exactly the requested position. The PCM offset is in samples at 48 kHz
relative to the start of the stream.

=item $of->B<set_gain_offset>(I<$gain_type>, I<$gain_offset>)

Sets the gain to be used for decoded output.

By default, the gain in the header is applied with no additional
offset. The total gain (including header gain and/or track gain, if
applicable, and this offset), will be clamped to [-32768,32767]/256
dB. This is more than enough to saturate or underflow 16-bit PCM.

B<Note:> The new gain will not be applied to any already buffered,
decoded output. This means you cannot change it sample-by-sample, as
at best it will be updated packet-by-packet. It is meant for setting a
target volume level, rather than applying smooth fades, etc.

I<$gain_type> is one of OP_HEADER_GAIN, OP_TRACK_GAIN, or
OP_ABSOLUTE_GAIN. I<$gain_offset> is in 1/256ths of a dB.

=item $of->B<set_dither_enabled>(I<$enabled>)

Sets whether or not dithering is enabled for 16-bit decoding.

By default, when libopusfile is compiled to use floating-point
internally, calling read() or read_stereo() will first decode to
float, and then convert to fixed-point using noise-shaping dithering.
This flag can be used to disable that dithering. When the application
uses read_float() or read_float_stereo(), or when the library has been
compiled to decode directly to fixed point, this flag has no effect.

=item $of->B<read>([I<$bufsize>])

It is recommended to use B<read_float> instead of this method if the
rest of your audio processing chain can handle floating point.

Reads more samples from the stream. I<$bufsize> is the maximum number
of samples read, and it defaults to 1048576. Returns a list whose
first element is the link index this data was decoded from, and the
rest of the elements are PCM samples, as signed 16-bit values at 48
kHz with a nominal range of [-32768,32767). Multiple channels are
interleaved using the L<Vorbis channel ordering|https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9>.

You can use C<< $of->head($li)->channel_count >> to find out the
channel count of a given link index.

=item $of->B<read_float>([I<$bufsize>])

Like B<read>, but samples are signed floats with a nominal range of
[-1.0, 1.0].

=item $of->B<read_stereo>([I<$bufsize>])

Like B<read>, but downmixes the stream to stereo (therefore you will
always get two channels) and does NOT return the link index (the first
return value is the first sample).

=item $of->B<read_float_stereo>([I<$bufsize>])

Like B<read_float>, but downmixes the stream to stereo (therefore you
will always get two channels) and does NOT return the link index (the
first return value is the first sample).

=back

=head1 EXPORT

All constants are exported by default:

  OPUS_CHANNEL_COUNT_MAX
  OP_ABSOLUTE_GAIN
  OP_DEC_FORMAT_FLOAT
  OP_DEC_FORMAT_SHORT
  OP_DEC_USE_DEFAULT
  OP_EBADHEADER
  OP_EBADLINK
  OP_EBADPACKET
  OP_EBADTIMESTAMP
  OP_EFAULT
  OP_EIMPL
  OP_EINVAL
  OP_ENOSEEK
  OP_ENOTAUDIO
  OP_ENOTFORMAT
  OP_EOF
  OP_EREAD
  OP_EVERSION
  OP_FALSE
  OP_GET_SERVER_INFO_REQUEST
  OP_HEADER_GAIN
  OP_HOLE
  OP_HTTP_PROXY_HOST_REQUEST
  OP_HTTP_PROXY_PASS_REQUEST
  OP_HTTP_PROXY_PORT_REQUEST
  OP_HTTP_PROXY_USER_REQUEST
  OP_PIC_FORMAT_GIF
  OP_PIC_FORMAT_JPEG
  OP_PIC_FORMAT_PNG
  OP_PIC_FORMAT_UNKNOWN
  OP_PIC_FORMAT_URL
  OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST
  OP_TRACK_GAIN


=head1 SEE ALSO

L<Audio::Opusfile::Head>,
L<Audio::Opusfile::Tags>,
L<http://opus-codec.org/>,
L<http://opus-codec.org/docs/opusfile_api-0.7/index.html>

=head1 AUTHOR

Marius Gavrilescu, E<lt>marius@ieval.roE<gt>

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2016-2017 by Marius Gavrilescu

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.24.0 or,
at your option, any later version of Perl 5 you may have available.


=cut
Commit	Line	Data
a3f1cbda MG	1	package Audio::Opusfile;
	2
	3	use 5.014000;
	4	use strict;
	5	use warnings;
	6	use Carp;
	7
	8	use parent qw/Exporter/;
	9	use AutoLoader;
	10
	11	my @constants =
	12	qw/OPUS_CHANNEL_COUNT_MAX
	13	OP_ABSOLUTE_GAIN
	14	OP_DEC_FORMAT_FLOAT
	15	OP_DEC_FORMAT_SHORT
	16	OP_DEC_USE_DEFAULT
	17	OP_EBADHEADER
	18	OP_EBADLINK
	19	OP_EBADPACKET
	20	OP_EBADTIMESTAMP
	21	OP_EFAULT
	22	OP_EIMPL
	23	OP_EINVAL
	24	OP_ENOSEEK
	25	OP_ENOTAUDIO
	26	OP_ENOTFORMAT
	27	OP_EOF
	28	OP_EREAD
	29	OP_EVERSION
	30	OP_FALSE
	31	OP_GET_SERVER_INFO_REQUEST
	32	OP_HEADER_GAIN
	33	OP_HOLE
	34	OP_HTTP_PROXY_HOST_REQUEST
	35	OP_HTTP_PROXY_PASS_REQUEST
	36	OP_HTTP_PROXY_PORT_REQUEST
	37	OP_HTTP_PROXY_USER_REQUEST
	38	OP_PIC_FORMAT_GIF
	39	OP_PIC_FORMAT_JPEG
	40	OP_PIC_FORMAT_PNG
	41	OP_PIC_FORMAT_UNKNOWN
	42	OP_PIC_FORMAT_URL
	43	OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST
	44	OP_TRACK_GAIN/;
	45
	46	our @EXPORT_OK = @constants;
	47	our @EXPORT = @constants;
	48
a3133f60 MG	49	our $VERSION = '1.000';
	50
	51	sub AUTOLOAD { ## no critic (ProhibitAutoloading)
	52	my $constname;
	53	our $AUTOLOAD;
	54	($constname = $AUTOLOAD) =~ s/.*:://s;
	55	croak '&Audio::Opusfile::constant not defined' if $constname eq 'constant';
	56	my ($error, $val) = constant($constname);
	57	if ($error) { croak $error; }
	58	{
	59	no strict 'refs'; ## no critic (ProhibitNoStrict)
	60	*$AUTOLOAD = sub { $val };
	61	}
	62	goto &$AUTOLOAD;
a3f1cbda MG	63	}
	64
	65	require XSLoader;
	66	XSLoader::load('Audio::Opusfile', $VERSION);
b9bd6a0d	67	require Audio::Opusfile::Head;
a3f1cbda	68	require Audio::Opusfile::Tags;
2f4b5b1b	69	require Audio::Opusfile::PictureTag;
a3f1cbda	70
a3f1cbda MG	71	sub new_from_file {
	72	my ($class, $file) = @_;
	73	open_file($file)
	74	}
	75
5fbea9a2 MG	76	sub new_from_memory {
	77	my ($class, $buf) = @_;
	78	open_memory($buf)
	79	}
	80
a3f1cbda MG	81	1;
	82	__END__
	83
	84	=encoding utf-8
	85
	86	=head1 NAME
	87
196e0b27	88	Audio::Opusfile - partial interface to the libopusfile Ogg Opus library
a3f1cbda MG	89
	90	=head1 SYNOPSIS
	91
	92	use Audio::Opusfile;
	93	my $of = Audio::Opusfile->new_from_file('silence.opus');
	94	my $tags = $of->tags;
	95	say $tags->query('TITLE'); # Cellule
	96
	97	=head1 DESCRIPTION
	98
	99	Opus is a totally open, royalty-free, highly versatile audio codec.
	100	Opus is unmatched for interactive speech and music transmission over
	101	the Internet, but is also intended for storage and streaming
	102	applications. It is standardized by the Internet Engineering Task
	103	Force (IETF) as RFC 6716 which incorporated technology from Skype's
	104	SILK codec and Xiph.Org's CELT codec.
	105
	106	libopusfile is a library for decoding and basic manipulation of Ogg
	107	Opus files.
	108
196e0b27 MG	109	Audio::Opusfile is an interface to libopusfile. It exports nearly all
	110	of the functions for obtaining metadata of an Opus file or buffer in
	111	that library. Future versions will additionally provide functions for
	112	decoding Opus data into PCM.
a3f1cbda	113
196e0b27	114	The API might change in future versions.
a3f1cbda MG	115
	116	=head1 METHODS
	117
	118	=over
	119
	120	=item Audio::Opusfile->B<new_from_file>(I<$file>)
	121
	122	Creates a new Audio::Opusfile object from an Ogg Opus file.
	123
	124	Dies if the given file does not exist or is not a valid Ogg Opus file.
	125
33fac129 MG	126	=item Audio::Opusfile->B<new_from_memory>(I<$buffer>)
	127
	128	Creates a new Audio::Opusfile object from a buffer containing Ogg Opus
	129	data.
	130
	131	Dies if the given buffer does not contain valid data.
	132
	133	=item Audio::Opusfile::test(I<$buffer>)
	134
	135	Returns true if the given buffer looks like the beginning of a valid
	136	Ogg Opus file, false otherwise.
	137
	138	Dies if the given buffer does not have sufficient data to tell if it
	139	is an Opus stream or if it looks like a Opus stream but parsing it
	140	failed.
	141
10773025	142	=item $of->B<head>
2f4b5b1b MG	143
	144	Returns an L<Audio::Opusfile::Head> object corresponding to the file.
	145
10773025	146	=item $of->B<tags>
a3f1cbda MG	147
	148	Returns an L<Audio::Opusfile::Tags> object corresponding to the file.
	149
10773025	150	=item $of->B<seekable>
33fac129 MG	151
	152	Returns whether or not the data source being read is seekable.
	153
10773025	154	=item $of->B<link_count>
33fac129 MG	155
	156	Returns the number of links in this chained stream. Always returns 1
	157	for unseekable sources.
	158
10773025	159	=item $of->B<serialno>([I<$link_index>])
33fac129 MG	160
	161	Get the serial number of the given link in a (possibly-chained) Ogg
	162	Opus stream. If the given index is greater than the total number of
	163	links, this returns the serial number of the last link.
	164
	165	If the source is not seekable, I<$link_index> is negative, or
	166	I<$link_index> is not given, then this function returns the serial
	167	number of the current link.
	168
10773025	169	=item $of->B<raw_total>([I<$link_index>])
dc986a40 MG	170
	171	Get the total (compressed) size of the stream (with no arguments), or
	172	of an individual link in a (possibly-chained) Ogg Opus stream (with
	173	one nonnegative argument), including all headers and Ogg muxing
	174	overhead.
	175
	176	The stream must be seekable to get the total. A negative value is
	177	returned if the stream is not seekable.
	178
	179	B<Warning:> If the Opus stream (or link) is concurrently multiplexed
	180	with other logical streams (e.g., video), this returns the size of the
	181	entire stream (or link), not just the number of bytes in the first
	182	logical Opus stream. Returning the latter would require scanning the
	183	entire file.
	184
10773025	185	=item $of->B<pcm_total>([I<$link_index>])
dc986a40 MG	186
	187	Get the total PCM length (number of samples at 48 kHz) of the stream
	188	(with no arguments), or of an individual link in a (possibly-chained)
	189	Ogg Opus stream (with one nonnegative argument).
	190
	191	Users looking for op_time_total() should use this function instead.
	192	Because timestamps in Opus are fixed at 48 kHz, there is no need for a
	193	separate function to convert this to seconds.
	194
	195	The stream must be seekable to get the total. A negative value is
	196	returned if the stream is not seekable.
	197
9fc88b29 MG	198	=item $of->B<current_link>
	199
	200	Retrieve the index of the current link.
	201
	202	This is the link that produced the data most recently read by
	203	op_read_float() or its associated functions, or, after a seek, the
	204	link that the seek target landed in. Reading more data may advance the
	205	link index (even on the first read after a seek).
	206
10773025	207	=item $of->B<bitrate>([I<$link_index>])
dc986a40 MG	208
	209	Computes the bitrate of the stream (with no arguments), or of an
	210	individual link in a (possibly-chained) Ogg Opus stream (with one
	211	nonnegative argument).
	212
	213	The stream must be seekable to compute the bitrate. A negative value
	214	is returned if the stream is not seekable.
	215
	216	B<Warning:> If the Opus stream (or link) is concurrently multiplexed with
	217	other logical streams (e.g., video), this uses the size of the entire
	218	stream (or link) to compute the bitrate, not just the number of bytes
	219	in the first logical Opus stream.
	220
10773025 MG	221	=item $of->B<bitrate_instant>
	222
	223	Compute the instantaneous bitrate, measured as the ratio of bits to
	224	playable samples decoded since a) the last call to B<bitrate_instant>,
	225	b) the last seek, or c) the start of playback, whichever was most
	226	recent.
	227
	228	This will spike somewhat after a seek or at the start/end of a chain
	229	boundary, as pre-skip, pre-roll, and end-trimming causes samples to be
	230	decoded but not played.
	231
	232	=item $of->B<raw_tell>
	233
	234	Obtain the current value of the position indicator of I<$of>. This is
	235	the byte position that is currently being read from.
	236
	237	=item $of->B<pcm_tell>
	238
	239	Obtain the PCM offset of the next sample to be read.
	240
	241	If the stream is not properly timestamped, this might not increment by
	242	the proper amount between reads, or even return monotonically
	243	increasing values.
	244
	245	=item $of->B<raw_seek>(I<$offset>)
	246
	247	Seek to a byte offset relative to the compressed data.
	248
	249	This also scans packets to update the PCM cursor. It will cross a
	250	logical bitstream boundary, but only if it can't get any packets out
	251	of the tail of the link to which it seeks.
	252
	253	=item $of->B<pcm_seek>(I<$offset>)
	254
	255	Seek to the specified PCM offset, such that decoding will begin at
	256	exactly the requested position. The PCM offset is in samples at 48 kHz
	257	relative to the start of the stream.
	258
	259	=item $of->B<set_gain_offset>(I<$gain_type>, I<$gain_offset>)
	260
	261	Sets the gain to be used for decoded output.
	262
	263	By default, the gain in the header is applied with no additional
	264	offset. The total gain (including header gain and/or track gain, if
	265	applicable, and this offset), will be clamped to [-32768,32767]/256
	266	dB. This is more than enough to saturate or underflow 16-bit PCM.
	267
	268	B<Note:> The new gain will not be applied to any already buffered,
	269	decoded output. This means you cannot change it sample-by-sample, as
	270	at best it will be updated packet-by-packet. It is meant for setting a
	271	target volume level, rather than applying smooth fades, etc.
	272
	273	I<$gain_type> is one of OP_HEADER_GAIN, OP_TRACK_GAIN, or
	274	OP_ABSOLUTE_GAIN. I<$gain_offset> is in 1/256ths of a dB.
	275
	276	=item $of->B<set_dither_enabled>(I<$enabled>)
	277
	278	Sets whether or not dithering is enabled for 16-bit decoding.
	279
	280	By default, when libopusfile is compiled to use floating-point
	281	internally, calling read() or read_stereo() will first decode to
	282	float, and then convert to fixed-point using noise-shaping dithering.
	283	This flag can be used to disable that dithering. When the application
	284	uses read_float() or read_float_stereo(), or when the library has been
285	compiled to decode directly to fixed point, this flag has no effect.
286
287	=item $of->B<read>([I<$bufsize>])
288
289	It is recommended to use B<read_float> instead of this method if the
290	rest of your audio processing chain can handle floating point.
291
292	Reads more samples from the stream. I<$bufsize> is the maximum number
293	of samples read, and it defaults to 1048576. Returns a list whose
294	first element is the link index this data was decoded from, and the
295	rest of the elements are PCM samples, as signed 16-bit values at 48
296	kHz with a nominal range of [-32768,32767). Multiple channels are
297	interleaved using the L<Vorbis channel ordering\|https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9>.
298
299	You can use C<< $of->head($li)->channel_count >> to find out the
300	channel count of a given link index.
301
302	=item $of->B<read_float>([I<$bufsize>])
303
304	Like B<read>, but samples are signed floats with a nominal range of
305	[-1.0, 1.0].
306
307	=item $of->B<read_stereo>([I<$bufsize>])
308
309	Like B<read>, but downmixes the stream to stereo (therefore you will
310	always get two channels) and does NOT return the link index (the first
311	return value is the first sample).
312
313	=item $of->B<read_float_stereo>([I<$bufsize>])
314
315	Like B<read_float>, but downmixes the stream to stereo (therefore you
316	will always get two channels) and does NOT return the link index (the
317	first return value is the first sample).
318
a3f1cbda MG	319	=back
	320
	321	=head1 EXPORT
	322
	323	All constants are exported by default:
	324
	325	OPUS_CHANNEL_COUNT_MAX
	326	OP_ABSOLUTE_GAIN
	327	OP_DEC_FORMAT_FLOAT
	328	OP_DEC_FORMAT_SHORT
	329	OP_DEC_USE_DEFAULT
	330	OP_EBADHEADER
	331	OP_EBADLINK
	332	OP_EBADPACKET
	333	OP_EBADTIMESTAMP
	334	OP_EFAULT
	335	OP_EIMPL
	336	OP_EINVAL
	337	OP_ENOSEEK
	338	OP_ENOTAUDIO
	339	OP_ENOTFORMAT
	340	OP_EOF
	341	OP_EREAD
	342	OP_EVERSION
	343	OP_FALSE
	344	OP_GET_SERVER_INFO_REQUEST
	345	OP_HEADER_GAIN
	346	OP_HOLE
	347	OP_HTTP_PROXY_HOST_REQUEST
	348	OP_HTTP_PROXY_PASS_REQUEST
	349	OP_HTTP_PROXY_PORT_REQUEST
	350	OP_HTTP_PROXY_USER_REQUEST
	351	OP_PIC_FORMAT_GIF
	352	OP_PIC_FORMAT_JPEG
	353	OP_PIC_FORMAT_PNG
	354	OP_PIC_FORMAT_UNKNOWN
	355	OP_PIC_FORMAT_URL
	356	OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST
	357	OP_TRACK_GAIN
	358
	359
	360	=head1 SEE ALSO
	361
b9bd6a0d	362	L<Audio::Opusfile::Head>,
a3f1cbda MG	363	L<Audio::Opusfile::Tags>,
	364	L<http://opus-codec.org/>,
	365	L<http://opus-codec.org/docs/opusfile_api-0.7/index.html>
	366
	367	=head1 AUTHOR
	368
	369	Marius Gavrilescu, E<lt>marius@ieval.roE<gt>
	370
	371	=head1 COPYRIGHT AND LICENSE
	372
36bdc941	373	Copyright (C) 2016-2017 by Marius Gavrilescu
a3f1cbda MG	374
	375	This library is free software; you can redistribute it and/or modify
	376	it under the same terms as Perl itself, either Perl version 5.24.0 or,
	377	at your option, any later version of Perl 5 you may have available.
	378
	379
	380	=cut