Export error type, CamelCase error names

diff --git a/decoder.go b/decoder.go
index 7d674f93c56250c7b163270214b016bd50f09b06..282ac25b90845d074b7359cadd0dda530016e125 100644 (file)
--- a/decoder.go
+++ b/decoder.go
@@ -51,7 +51,7 @@ func (dec *Decoder) Init(sample_rate int, channels int) error {
                C.opus_int32(sample_rate),
                C.int(channels))
        if errno != 0 {
-               return opusError(errno)
+               return Error(errno)
        }
        return nil
 }
@@ -76,7 +76,7 @@ func (dec *Decoder) Decode(data []byte, pcm []int16) (int, error) {
                C.int(cap(pcm)),
                0))
        if n < 0 {
-               return 0, opusError(n)
+               return 0, Error(n)
        }
        return n, nil
 }
@@ -101,7 +101,7 @@ func (dec *Decoder) DecodeFloat32(data []byte, pcm []float32) (int, error) {
                C.int(cap(pcm)),
                0))
        if n < 0 {
-               return 0, opusError(n)
+               return 0, Error(n)
        }
        return n, nil
 }

diff --git a/encoder.go b/encoder.go
index a9ced734d522977bd84f44fc008c2b6a99215c14..683ce589eaf6f8d4fedc264e58b7ff08666309ab 100644 (file)
--- a/encoder.go
+++ b/encoder.go
@@ -79,7 +79,7 @@ func (enc *Encoder) Init(sample_rate int, channels int, application Application)
                C.int(channels),
                C.int(application)))
        if errno != 0 {
-               return opusError(int(errno))
+               return Error(int(errno))
        }
        return nil
 }
@@ -109,7 +109,7 @@ func (enc *Encoder) Encode(pcm []int16, data []byte) (int, error) {
                (*C.uchar)(&data[0]),
                C.opus_int32(cap(data))))
        if n < 0 {
-               return 0, opusError(n)
+               return 0, Error(n)
        }
        return n, nil
 }
@@ -137,7 +137,7 @@ func (enc *Encoder) EncodeFloat32(pcm []float32, data []byte) (int, error) {
                (*C.uchar)(&data[0]),
                C.opus_int32(cap(data))))
        if n < 0 {
-               return 0, opusError(n)
+               return 0, Error(n)
        }
        return n, nil
 }

diff --git a/errors.go b/errors.go
index d932d6762ff5752bac312b608e601f2d91015831..169208f97145aae18fa778d02720297fbbd9206e 100644 (file)
--- a/errors.go
+++ b/errors.go
@@ -44,82 +44,115 @@ const int CONST_OP_EBADTIMESTAMP = OP_EBADTIMESTAMP;
 */
 import "C"
 
-type opusError int
+type Error int
 
-var _ error = opusError(0)
+var _ error = Error(0)
 
 // Libopus errors
 var (
-       ERR_OPUS_OK               = opusError(C.CONST_OPUS_OK)
-       ERR_OPUS_BAD_ARG          = opusError(C.CONST_OPUS_BAD_ARG)
-       ERR_OPUS_BUFFER_TOO_SMALL = opusError(C.CONST_OPUS_BUFFER_TOO_SMALL)
-       ERR_OPUS_INTERNAL_ERROR   = opusError(C.CONST_OPUS_INTERNAL_ERROR)
-       ERR_OPUS_INVALID_PACKET   = opusError(C.CONST_OPUS_INVALID_PACKET)
-       ERR_OPUS_UNIMPLEMENTED    = opusError(C.CONST_OPUS_UNIMPLEMENTED)
-       ERR_OPUS_INVALID_STATE    = opusError(C.CONST_OPUS_INVALID_STATE)
-       ERR_OPUS_ALLOC_FAIL       = opusError(C.CONST_OPUS_ALLOC_FAIL)
+       ErrOK             = Error(C.CONST_OPUS_OK)
+       ErrBadArg         = Error(C.CONST_OPUS_BAD_ARG)
+       ErrBufferTooSmall = Error(C.CONST_OPUS_BUFFER_TOO_SMALL)
+       ErrInternalError  = Error(C.CONST_OPUS_INTERNAL_ERROR)
+       ErrInvalidPacket  = Error(C.CONST_OPUS_INVALID_PACKET)
+       ErrUnimplemented  = Error(C.CONST_OPUS_UNIMPLEMENTED)
+       ErrInvalidState   = Error(C.CONST_OPUS_INVALID_STATE)
+       ErrAllocFail      = Error(C.CONST_OPUS_ALLOC_FAIL)
+)
+
+// DEPRECATED versions of the above variables. Will be removed next year. Please
+// don't use.
+var (
+       ERR_OPUS_OK               = Error(C.CONST_OPUS_OK)
+       ERR_OPUS_BAD_ARG          = Error(C.CONST_OPUS_BAD_ARG)
+       ERR_OPUS_BUFFER_TOO_SMALL = Error(C.CONST_OPUS_BUFFER_TOO_SMALL)
+       ERR_OPUS_INTERNAL_ERROR   = Error(C.CONST_OPUS_INTERNAL_ERROR)
+       ERR_OPUS_INVALID_PACKET   = Error(C.CONST_OPUS_INVALID_PACKET)
+       ERR_OPUS_UNIMPLEMENTED    = Error(C.CONST_OPUS_UNIMPLEMENTED)
+       ERR_OPUS_INVALID_STATE    = Error(C.CONST_OPUS_INVALID_STATE)
+       ERR_OPUS_ALLOC_FAIL       = Error(C.CONST_OPUS_ALLOC_FAIL)
 )
 
 // Error string (in human readable format) for libopus errors.
-func (e opusError) Error() string {
+func (e Error) Error() string {
        return fmt.Sprintf("opus: %s", C.GoString(C.opus_strerror(C.int(e))))
 }
 
-type opusFileError int
+type StreamError int
 
-var _ error = opusFileError(0)
+var _ error = StreamError(0)
 
 // Libopusfile errors. The names are copied verbatim from the libopusfile
 // library.
 var (
-       ERR_OP_FALSE         = opusFileError(C.CONST_OP_FALSE)
-       ERR_OP_EOF           = opusFileError(C.CONST_OP_EOF)
-       ERR_OP_HOLE          = opusFileError(C.CONST_OP_HOLE)
-       ERR_OP_EREAD         = opusFileError(C.CONST_OP_EREAD)
-       ERR_OP_EFAULT        = opusFileError(C.CONST_OP_EFAULT)
-       ERR_OP_EIMPL         = opusFileError(C.CONST_OP_EIMPL)
-       ERR_OP_EINVAL        = opusFileError(C.CONST_OP_EINVAL)
-       ERR_OP_ENOTFORMAT    = opusFileError(C.CONST_OP_ENOTFORMAT)
-       ERR_OP_EBADHEADER    = opusFileError(C.CONST_OP_EBADHEADER)
-       ERR_OP_EVERSION      = opusFileError(C.CONST_OP_EVERSION)
-       ERR_OP_ENOTAUDIO     = opusFileError(C.CONST_OP_ENOTAUDIO)
-       ERR_OP_EBADPACKET    = opusFileError(C.CONST_OP_EBADPACKET)
-       ERR_OP_EBADLINK      = opusFileError(C.CONST_OP_EBADLINK)
-       ERR_OP_ENOSEEK       = opusFileError(C.CONST_OP_ENOSEEK)
-       ERR_OP_EBADTIMESTAMP = opusFileError(C.CONST_OP_EBADTIMESTAMP)
+       ErrStreamFalse        = StreamError(C.CONST_OP_FALSE)
+       ErrStreamEOF          = StreamError(C.CONST_OP_EOF)
+       ErrStreamHole         = StreamError(C.CONST_OP_HOLE)
+       ErrStreamRead         = StreamError(C.CONST_OP_EREAD)
+       ErrStreamFault        = StreamError(C.CONST_OP_EFAULT)
+       ErrStreamImpl         = StreamError(C.CONST_OP_EIMPL)
+       ErrStreamInval        = StreamError(C.CONST_OP_EINVAL)
+       ErrStreamNotFormat    = StreamError(C.CONST_OP_ENOTFORMAT)
+       ErrStreamBadHeader    = StreamError(C.CONST_OP_EBADHEADER)
+       ErrStreamVersion      = StreamError(C.CONST_OP_EVERSION)
+       ErrStreamNotAudio     = StreamError(C.CONST_OP_ENOTAUDIO)
+       ErrStreamBadPacked    = StreamError(C.CONST_OP_EBADPACKET)
+       ErrStreamBadLink      = StreamError(C.CONST_OP_EBADLINK)
+       ErrStreamNoSeek       = StreamError(C.CONST_OP_ENOSEEK)
+       ErrStreamBadTimestamp = StreamError(C.CONST_OP_EBADTIMESTAMP)
+)
+
+// DEPRECATED versions of the above variables. Will be removed next year. Please
+// don't use.
+var (
+       ERR_OP_FALSE         = StreamError(C.CONST_OP_FALSE)
+       ERR_OP_EOF           = StreamError(C.CONST_OP_EOF)
+       ERR_OP_HOLE          = StreamError(C.CONST_OP_HOLE)
+       ERR_OP_EREAD         = StreamError(C.CONST_OP_EREAD)
+       ERR_OP_EFAULT        = StreamError(C.CONST_OP_EFAULT)
+       ERR_OP_EIMPL         = StreamError(C.CONST_OP_EIMPL)
+       ERR_OP_EINVAL        = StreamError(C.CONST_OP_EINVAL)
+       ERR_OP_ENOTFORMAT    = StreamError(C.CONST_OP_ENOTFORMAT)
+       ERR_OP_EBADHEADER    = StreamError(C.CONST_OP_EBADHEADER)
+       ERR_OP_EVERSION      = StreamError(C.CONST_OP_EVERSION)
+       ERR_OP_ENOTAUDIO     = StreamError(C.CONST_OP_ENOTAUDIO)
+       ERR_OP_EBADPACKET    = StreamError(C.CONST_OP_EBADPACKET)
+       ERR_OP_EBADLINK      = StreamError(C.CONST_OP_EBADLINK)
+       ERR_OP_ENOSEEK       = StreamError(C.CONST_OP_ENOSEEK)
+       ERR_OP_EBADTIMESTAMP = StreamError(C.CONST_OP_EBADTIMESTAMP)
 )
 
-func (i opusFileError) Error() string {
+func (i StreamError) Error() string {
        switch i {
-       case ERR_OP_FALSE:
+       case ErrStreamFalse:
                return "OP_FALSE"
-       case ERR_OP_EOF:
+       case ErrStreamEOF:
                return "OP_EOF"
-       case ERR_OP_HOLE:
+       case ErrStreamHole:
                return "OP_HOLE"
-       case ERR_OP_EREAD:
+       case ErrStreamRead:
                return "OP_EREAD"
-       case ERR_OP_EFAULT:
+       case ErrStreamFault:
                return "OP_EFAULT"
-       case ERR_OP_EIMPL:
+       case ErrStreamImpl:
                return "OP_EIMPL"
-       case ERR_OP_EINVAL:
+       case ErrStreamInval:
                return "OP_EINVAL"
-       case ERR_OP_ENOTFORMAT:
+       case ErrStreamNotFormat:
                return "OP_ENOTFORMAT"
-       case ERR_OP_EBADHEADER:
+       case ErrStreamBadHeader:
                return "OP_EBADHEADER"
-       case ERR_OP_EVERSION:
+       case ErrStreamVersion:
                return "OP_EVERSION"
-       case ERR_OP_ENOTAUDIO:
+       case ErrStreamNotAudio:
                return "OP_ENOTAUDIO"
-       case ERR_OP_EBADPACKET:
+       case ErrStreamBadPacked:
                return "OP_EBADPACKET"
-       case ERR_OP_EBADLINK:
+       case ErrStreamBadLink:
                return "OP_EBADLINK"
-       case ERR_OP_ENOSEEK:
+       case ErrStreamNoSeek:
                return "OP_ENOSEEK"
-       case ERR_OP_EBADTIMESTAMP:
+       case ErrStreamBadTimestamp:
                return "OP_EBADTIMESTAMP"
        default:
                return "libopusfile error: %d (unknown code)"

diff --git a/stream.go b/stream.go
index 4d84f995124ca606c60d1590011f435e9ef2239a..1264760ffbfe3c12a1618bfc674a09c715d1b9ac 100644 (file)
--- a/stream.go
+++ b/stream.go
@@ -111,7 +111,7 @@ func (s *Stream) Init(read io.Reader) error {
                0,
                &errno)
        if errno != 0 {
-               return opusFileError(errno)
+               return StreamError(errno)
        }
        s.oggfile = oggfile
        return nil
@@ -142,7 +142,7 @@ func (s *Stream) Read(pcm []int16) (int, error) {
                C.int(len(pcm)),
                nil)
        if n < 0 {
-               return 0, opusFileError(n)
+               return 0, StreamError(n)
        }
        if n == 0 {
                return 0, io.EOF
@@ -166,7 +166,7 @@ func (s *Stream) ReadFloat32(pcm []float32) (int, error) {
                C.int(len(pcm)),
                nil)
        if n < 0 {
-               return 0, opusFileError(n)
+               return 0, StreamError(n)
        }
        if n == 0 {
                return 0, io.EOF