/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1992-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _MULTIMEDIA_AUDIOTYPES_H
#define	_MULTIMEDIA_AUDIOTYPES_H

#ifdef NO_EXTERN_C

#ifdef __cplusplus
extern "C" {
#endif

#endif /* NO_EXTERN_C */

#include <math.h>
#include <stdlib.h>
#include <float.h>
#include <limits.h>
#include <fcntl.h>
#include <sys/types.h>

#include <audio_hdr.h>

// Types used in the audio API

// Values used for indeterminate size (e.g., data passed through a pipe)
const double		AUDIO_UNKNOWN_TIME = DBL_MAX;

// Error severity
enum AudioSeverity {
	InitMessage,			// debugging message from constructor
	InitFatal,			// fatal error from constructor
	Message,			// debugging message
	Warning,			// non-fatal error
	Error,				// potentially severe error
	Consistency,			// internal consistency warning
	Fatal				// fatal internal error
};

// Used in SetPosition methods
enum Whence { Absolute = 0, Relative = 1, Relative_eof = 2};

// XXX - classes that ought to be defined elsewhere

// A Boolean 'primitive type' with values TRUE and FALSE
// undefine these in case they're defined elsewhere
#undef TRUE
#undef FALSE

// use bool_t 'cause boolean_t is already used under 5.0
// Since 4/93 can't use bool_t cause rpc/types.h typedefs it
// so use aud_bool_t
enum aud_bool_t {FALSE = 0, TRUE = 1};

class Boolean {
private:
	aud_bool_t	value;		// value is TRUE or FALSE
public:
	inline Boolean(aud_bool_t x = FALSE): value(x)	// Constructor
	    { }
	inline Boolean(int x)				// Constructor from int
	    { value = (x == 0) ? FALSE : TRUE; }
	inline Boolean operator=(int x)			// Assignment from int
	    { return (value = (x == 0) ? FALSE : TRUE); }
	inline operator int()				// Cast to integer
	    { return ((value == TRUE) ? 1 : 0); }
	inline Boolean operator!()			// Logical not
	    { return ((value == TRUE) ? FALSE : TRUE); }
};

// A 'primitive type' for file access modes
enum fileaccess_t {
    NoAccess = 0, ReadOnly = 1, WriteOnly = 2, ReadWrite = 3,
    AppendOnly = 6, ReadAppend = 7
};

class FileAccess {
private:
	fileaccess_t	mode;		// combined mode
public:
	FileAccess(fileaccess_t x = NoAccess): mode(x) { }	// Constructor
	inline operator fileaccess_t()			// Cast to enum
	    { return (mode); }
	inline operator int() {				// Cast to integer
	    switch (mode) {
	    case ReadOnly: return (O_RDONLY);
	    case WriteOnly: return (O_WRONLY);
	    case ReadWrite: return (O_RDWR);
	    case AppendOnly: return (O_WRONLY | O_APPEND);
	    case ReadAppend: return (O_RDWR | O_APPEND);
	    case NoAccess:
	    default:
		return (-1);
	    }
	}
	// These tests depend on the actual enum values
	inline Boolean Readable() const			// TRUE if readable
	    { return ((int)mode & 1); }
	inline Boolean Writeable() const		// TRUE if writeable
	    { return ((int)mode & 2); }
	inline Boolean Append() const			// TRUE if append only
	    { return ((int)mode & 4); }
};


// Define a small number corresponding to minor floating-point bit errors
const double		AUDIO_MINFLOAT = .00000001;

// Define a 'double' class that allows some leeway in magnitude checking
// to try to correct for small errors due to floating-point imprecision
class Double {
private:
	double	val;
public:
	Double(double x = 0.): val(x) { }
	Double(const Double &x): val(x.val) { }
	inline int Undefined() const
	    { return (val == AUDIO_UNKNOWN_TIME); }
	inline operator double() const
	    { return (val); }
	inline Double& operator += (double y)
	    { val += y; return (*this); }
	inline Double& operator -= (double y)
	    { val -= y; return (*this); }
	Double& operator=(const Double&) = default;
};

// inline double fabs(double x)
//    { return ((x >= 0.) ? x : -x); }

inline double min(const Double& x, const Double& y) {
	return (((double)x <  (double)y) ? (double)x : (double)y);
}

inline double min(const Double& x, double y) {
	return (((double)x <  (double)y) ? (double)x : (double)y);
}
inline double min(double x, const Double& y) {
	return (((double)x <  (double)y) ? (double)x : (double)y);
}

inline double max(const Double& x, const Double& y) {
	return (((double)x >  (double)y) ? (double)x : (double)y);
}
inline double max(const Double& x, double y) {
	return (((double)x >  (double)y) ? (double)x : (double)y);
}
inline double max(double x, const Double& y) {
	return (((double)x >  (double)y) ? (double)x : (double)y);
}

inline int operator == (const Double &x, const Double &y) {
	return (fabs((double)x - (double)y) <= AUDIO_MINFLOAT);
}
inline int operator == (const Double &x, double y) {
	return (fabs((double)x - (double)y) <= AUDIO_MINFLOAT);
}
inline int operator == (double x, const Double &y) {
	return (fabs((double)x - (double)y) <= AUDIO_MINFLOAT);
}

inline int operator != (const Double &x, const Double &y) {
	return (!(x == y));
}
inline int operator != (const Double &x, double y) {
	return (!(x == y));
}
inline int operator != (double x, const Double &y) {
	return (!(x == y));
}

inline int operator <= (const Double &x, const Double &y) {
	return (((double)x < (double)y) || (x == y));
}
inline int operator <= (const Double &x, double y) {
	return (((double)x < (double)y) || (x == y));
}
inline int operator <= (double x, const Double &y)
	{ return (((double)x < (double)y) || (x == y)); }

inline int operator >= (const Double &x, const Double &y)
	{ return (((double)x > (double)y) || (x == y)); }
inline int operator >= (const Double &x, double y) {
	return (((double)x > (double)y) || (x == y));
}
inline int operator >= (double x, const Double &y) {
	return (((double)x > (double)y) || (x == y));
}

inline int operator < (const Double &x, const Double &y) {
	return (!(x >= y));
}
inline int operator < (const Double &x, double y) {
	return (!(x >= y));
}
inline int operator < (double x, const Double &y) {
	return (!(x >= y));
}

inline int operator > (const Double &x, const Double &y) {
	return (!(x <= y));
}
inline int operator > (const Double &x, double y) {
	return (!(x <= y));
}
inline int operator > (double x, const Double &y) {
	return (!(x <= y));
}

inline Double& operator += (Double &x, const Double &y) {
	return (x += (double)y);
}
inline double operator += (double &x, const Double &y) {
	return (x += (double)y);
}
inline Double& operator -= (Double &x, const Double &y) {
	return (x -= (double)y);
}
inline double operator -= (double &x, const Double &y) {
	return (x -= (double)y);
}

inline int Undefined(const Double &x) {
	return (x.Undefined());
}
inline int Undefined(double x) {
	return (x == AUDIO_UNKNOWN_TIME);
}

#ifdef NO_EXTERN_C

#ifdef __cplusplus
}
#endif

#endif /* NO_EXTERN_C */

#endif /* !_MULTIMEDIA_AUDIOTYPES_H */