1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License").  You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22/*
23 * Copyright (c) 1992-2001 by Sun Microsystems, Inc.
24 * All rights reserved.
25 */
26
27#ifndef _MULTIMEDIA_AUDIOTYPES_H
28#define	_MULTIMEDIA_AUDIOTYPES_H
29
30#pragma ident	"%Z%%M%	%I%	%E% SMI"
31
32#ifdef NO_EXTERN_C
33
34#ifdef __cplusplus
35extern "C" {
36#endif
37
38#endif /* NO_EXTERN_C */
39
40#include <math.h>
41#include <stdlib.h>
42#include <float.h>
43#include <limits.h>
44#include <fcntl.h>
45#include <sys/types.h>
46
47#include <audio_hdr.h>
48
49// Types used in the audio API
50
51// Values used for indeterminate size (e.g., data passed through a pipe)
52const double		AUDIO_UNKNOWN_TIME = DBL_MAX;
53
54// Error severity
55enum AudioSeverity {
56	InitMessage,			// debugging message from constructor
57	InitFatal,			// fatal error from constructor
58	Message,			// debugging message
59	Warning,			// non-fatal error
60	Error,				// potentially severe error
61	Consistency,			// internal consistency warning
62	Fatal				// fatal internal error
63};
64
65// Used in SetPosition methods
66enum Whence { Absolute = 0, Relative = 1, Relative_eof = 2};
67
68// XXX - classes that ought to be defined elsewhere
69
70// A Boolean 'primitive type' with values TRUE and FALSE
71// undefine these in case they're defined elsewhere
72#undef TRUE
73#undef FALSE
74
75// use bool_t 'cause boolean_t is already used under 5.0
76// Since 4/93 can't use bool_t cause rpc/types.h typedefs it
77// so use aud_bool_t
78enum aud_bool_t {FALSE = 0, TRUE = 1};
79
80class Boolean {
81private:
82	aud_bool_t	value;		// value is TRUE or FALSE
83public:
84	inline Boolean(aud_bool_t x = FALSE): value(x)	// Constructor
85	    { }
86	inline Boolean(int x)				// Constructor from int
87	    { value = (x == 0) ? FALSE : TRUE; }
88	inline Boolean operator=(int x)			// Assignment from int
89	    { return (value = (x == 0) ? FALSE : TRUE); }
90	inline operator int()				// Cast to integer
91	    { return ((value == TRUE) ? 1 : 0); }
92	inline Boolean operator!()			// Logical not
93	    { return ((value == TRUE) ? FALSE : TRUE); }
94};
95
96// A 'primitive type' for file access modes
97enum fileaccess_t {
98    NoAccess = 0, ReadOnly = 1, WriteOnly = 2, ReadWrite = 3,
99    AppendOnly = 6, ReadAppend = 7
100};
101
102class FileAccess {
103private:
104	fileaccess_t	mode;		// combined mode
105public:
106	FileAccess(fileaccess_t x = NoAccess): mode(x) { }	// Constructor
107	inline operator fileaccess_t()			// Cast to enum
108	    { return (mode); }
109	inline operator int() {				// Cast to integer
110	    switch (mode) {
111	    case NoAccess: return (-1);
112	    case ReadOnly: return (O_RDONLY);
113	    case WriteOnly: return (O_WRONLY);
114	    case ReadWrite: return (O_RDWR);
115	    case AppendOnly: return (O_WRONLY | O_APPEND);
116	    case ReadAppend: return (O_RDWR | O_APPEND);
117	    }
118	}
119	// These tests depend on the actual enum values
120	inline Boolean Readable() const			// TRUE if readable
121	    { return ((int)mode & 1); }
122	inline Boolean Writeable() const		// TRUE if writeable
123	    { return ((int)mode & 2); }
124	inline Boolean Append() const			// TRUE if append only
125	    { return ((int)mode & 4); }
126};
127
128
129// Define a small number corresponding to minor floating-point bit errors
130const double		AUDIO_MINFLOAT = .00000001;
131
132// Define a 'double' class that allows some leeway in magnitude checking
133// to try to correct for small errors due to floating-point imprecision
134class Double {
135private:
136	double	val;
137public:
138	Double(double x = 0.): val(x) { }
139	Double(const Double &x): val(x.val) { }
140	inline int Undefined() const
141	    { return (val == AUDIO_UNKNOWN_TIME); }
142	inline operator double() const
143	    { return (val); }
144	inline Double& operator += (double y)
145	    { val += y; return (*this); }
146	inline Double& operator -= (double y)
147	    { val -= y; return (*this); }
148};
149
150// inline double fabs(double x)
151//    { return ((x >= 0.) ? x : -x); }
152
153inline double min(const Double& x, const Double& y) {
154	return (((double)x <  (double)y) ? (double)x : (double)y);
155}
156
157inline double min(const Double& x, double y) {
158	return (((double)x <  (double)y) ? (double)x : (double)y);
159}
160inline double min(double x, const Double& y) {
161	return (((double)x <  (double)y) ? (double)x : (double)y);
162}
163
164inline double max(const Double& x, const Double& y) {
165	return (((double)x >  (double)y) ? (double)x : (double)y);
166}
167inline double max(const Double& x, double y) {
168	return (((double)x >  (double)y) ? (double)x : (double)y);
169}
170inline double max(double x, const Double& y) {
171	return (((double)x >  (double)y) ? (double)x : (double)y);
172}
173
174inline int operator == (const Double &x, const Double &y) {
175	return (fabs((double)x - (double)y) <= AUDIO_MINFLOAT);
176}
177inline int operator == (const Double &x, double y) {
178	return (fabs((double)x - (double)y) <= AUDIO_MINFLOAT);
179}
180inline int operator == (double x, const Double &y) {
181	return (fabs((double)x - (double)y) <= AUDIO_MINFLOAT);
182}
183
184inline int operator != (const Double &x, const Double &y) {
185	return (!(x == y));
186}
187inline int operator != (const Double &x, double y) {
188	return (!(x == y));
189}
190inline int operator != (double x, const Double &y) {
191	return (!(x == y));
192}
193
194inline int operator <= (const Double &x, const Double &y) {
195	return (((double)x < (double)y) || (x == y));
196}
197inline int operator <= (const Double &x, double y) {
198	return (((double)x < (double)y) || (x == y));
199}
200inline int operator <= (double x, const Double &y)
201	{ return (((double)x < (double)y) || (x == y)); }
202
203inline int operator >= (const Double &x, const Double &y)
204	{ return (((double)x > (double)y) || (x == y)); }
205inline int operator >= (const Double &x, double y) {
206	return (((double)x > (double)y) || (x == y));
207}
208inline int operator >= (double x, const Double &y) {
209	return (((double)x > (double)y) || (x == y));
210}
211
212inline int operator < (const Double &x, const Double &y) {
213	return (!(x >= y));
214}
215inline int operator < (const Double &x, double y) {
216	return (!(x >= y));
217}
218inline int operator < (double x, const Double &y) {
219	return (!(x >= y));
220}
221
222inline int operator > (const Double &x, const Double &y) {
223	return (!(x <= y));
224}
225inline int operator > (const Double &x, double y) {
226	return (!(x <= y));
227}
228inline int operator > (double x, const Double &y) {
229	return (!(x <= y));
230}
231
232inline Double& operator += (Double &x, const Double &y) {
233	return (x += (double)y);
234}
235inline double operator += (double &x, const Double &y) {
236	return (x += (double)y);
237}
238inline Double& operator -= (Double &x, const Double &y) {
239	return (x -= (double)y);
240}
241inline double operator -= (double &x, const Double &y) {
242	return (x -= (double)y);
243}
244
245inline int Undefined(const Double &x) {
246	return (x.Undefined());
247}
248inline int Undefined(double x) {
249	return (x == AUDIO_UNKNOWN_TIME);
250}
251
252#ifdef NO_EXTERN_C
253
254#ifdef __cplusplus
255}
256#endif
257
258#endif /* NO_EXTERN_C */
259
260#endif /* !_MULTIMEDIA_AUDIOTYPES_H */
261