1/*
2 * OpenSound media addon for BeOS and Haiku
3 *
4 * Copyright (c) 2007, François Revol (revol@free.fr)
5 * Distributed under the terms of the MIT License.
6 */
7
8#include "OpenSoundDeviceEngine.h"
9
10#include "debug.h"
11#include "driver_io.h"
12#include <MediaDefs.h>
13#include <Debug.h>
14#include <errno.h>
15#include <string.h>
16
17#include "SupportFunctions.h"
18
19OpenSoundDeviceEngine::~OpenSoundDeviceEngine()
20{
21	CALLED();
22	if (fFD != 0) {
23		close(fFD);
24	}
25}
26
27OpenSoundDeviceEngine::OpenSoundDeviceEngine(oss_audioinfo *info)
28	: fNextPlay(NULL)
29	, fNextRec(NULL)
30	, fOpenMode(0)
31	, fFD(-1)
32	, fMediaFormat()
33	, fDriverBufferSize(0)
34{
35	CALLED();
36	fInitCheckStatus = B_NO_INIT;
37	memcpy(&fAudioInfo, info, sizeof(oss_audioinfo));
38
39	// XXX:REMOVEME
40	// set default format
41/*
42	SetFormat(OpenSoundDevice::select_oss_format(info->oformats));
43	SetChannels(info->max_channels);
44	SetSpeed(info->max_rate);
45*/
46	fInitCheckStatus = B_OK;
47}
48
49
50status_t OpenSoundDeviceEngine::InitCheck(void) const
51{
52	CALLED();
53	return fInitCheckStatus;
54}
55
56
57status_t OpenSoundDeviceEngine::Open(int mode)
58{
59	int omode, v;
60	CALLED();
61
62	switch (mode) {
63	case OPEN_READ:
64		if (!(Caps() & DSP_CAP_INPUT))
65			return EINVAL;
66		omode = O_RDONLY;
67		break;
68	case OPEN_WRITE:
69		if (!(Caps() & DSP_CAP_OUTPUT))
70			return EINVAL;
71		omode = O_WRONLY;
72		break;
73	case OPEN_READWRITE:
74		if (!(Caps() & DSP_CAP_OUTPUT) || !(Caps() & DSP_CAP_INPUT))
75			return EINVAL;
76		omode = O_RDWR;
77		break;
78	default:
79		return EINVAL;
80	}
81	// O_EXCL = bypass soft mixer = direct access
82	omode |= O_EXCL;
83
84	Close();
85	fOpenMode = mode;
86	fFD = open(fAudioInfo.devnode, omode);
87	if (fFD < 0) {
88		fInitCheckStatus = errno;
89		return EIO;
90	}
91	// disable format convertions
92	v = 0;
93	if (ioctl(fFD, SNDCTL_DSP_COOKEDMODE, &v, sizeof(int)) < 0) {
94		fInitCheckStatus = errno;
95		Close();
96		return EIO;
97	}
98
99	// set driver buffer size by using the "fragments" API
100	// TODO: export this setting as a BParameter?
101	uint32 bufferCount = 4;
102	uint32 bufferSize = 0x000b; // 1024 bytes
103	v = (bufferCount << 16) | bufferSize;
104	if (ioctl(fFD, SNDCTL_DSP_SETFRAGMENT, &v, sizeof(int)) < 0) {
105		fInitCheckStatus = errno;
106		Close();
107		return EIO;
108	}
109
110	fDriverBufferSize = 2048;
111		// preliminary, adjusted in AcceptFormat()
112	return B_OK;
113}
114
115
116status_t OpenSoundDeviceEngine::Close(void)
117{
118	CALLED();
119	if (fFD > -1)
120		close(fFD);
121	fFD = -1;
122	fOpenMode = 0;
123	fMediaFormat = media_format();
124	return B_OK;
125}
126
127
128ssize_t OpenSoundDeviceEngine::Read(void *buffer, size_t size)
129{
130	ssize_t done;
131	CALLED();
132	done = read(fFD, buffer, size);
133	if (done < 0)
134		return errno;
135	return done;
136}
137
138
139ssize_t
140OpenSoundDeviceEngine::Write(const void *buffer, size_t size)
141{
142	CALLED();
143
144	ASSERT(size > 0);
145
146	ssize_t done = write(fFD, buffer, size);
147	if (done < 0)
148		return errno;
149
150	return done;
151}
152
153
154status_t
155OpenSoundDeviceEngine::UpdateInfo()
156{
157	CALLED();
158
159	if (fFD < 0)
160		return ENODEV;
161
162	if (ioctl(fFD, SNDCTL_ENGINEINFO, &fAudioInfo, sizeof(oss_audioinfo)) < 0)
163		return errno;
164
165	return B_OK;
166}
167
168
169bigtime_t
170OpenSoundDeviceEngine::PlaybackLatency()
171{
172	bigtime_t latency = time_for_buffer(fDriverBufferSize, fMediaFormat);
173	bigtime_t cardLatency = CardLatency();
174	if (cardLatency == 0) {
175		// that's unrealistic, take matters into own hands
176		cardLatency = latency / 3;
177	}
178	latency += cardLatency;
179//	PRINT(("PlaybackLatency: odelay %d latency %Ld card %Ld\n",
180//		fDriverBufferSize, latency, CardLatency()));
181	return latency;
182}
183
184
185bigtime_t
186OpenSoundDeviceEngine::RecordingLatency()
187{
188	return 0LL; //XXX
189}
190
191
192int OpenSoundDeviceEngine::GetChannels(void)
193{
194	int chans = -1;
195	CALLED();
196	if (ioctl(fFD, SNDCTL_DSP_CHANNELS, &chans, sizeof(int)) < 0) {
197		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
198				__FUNCTION__, "SNDCTL_DSP_CHANNELS", strerror(errno)));
199		return -1;
200	}
201	return chans;
202}
203
204status_t OpenSoundDeviceEngine::SetChannels(int chans)
205{
206	CALLED();
207	if (ioctl(fFD, SNDCTL_DSP_CHANNELS, &chans, sizeof(int)) < 0) {
208		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
209				__FUNCTION__, "SNDCTL_DSP_CHANNELS", strerror(errno)));
210		return EIO;
211	}
212	PRINT(("OpenSoundDeviceEngine::%s: %d\n", __FUNCTION__, chans));
213	return B_OK;
214}
215
216//XXX: either GetFormat*s*() or cache SetFormat()!
217int OpenSoundDeviceEngine::GetFormat(void)
218{
219	int fmt = -1;
220	CALLED();
221	if (ioctl(fFD, SNDCTL_DSP_GETFMTS, &fmt, sizeof(int)) < 0) {
222		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
223				__FUNCTION__, "SNDCTL_DSP_GETFMTS", strerror(errno)));
224		return -1;
225	}
226	return fmt;
227}
228
229status_t OpenSoundDeviceEngine::SetFormat(int fmt)
230{
231	CALLED();
232	if (ioctl(fFD, SNDCTL_DSP_SETFMT, &fmt, sizeof(int)) < 0) {
233		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
234				__FUNCTION__, "SNDCTL_DSP_SETFMT", strerror(errno)));
235		return EIO;
236	}
237	PRINT(("OpenSoundDeviceEngine::%s: 0x%08x\n", __FUNCTION__, fmt));
238	return B_OK;
239}
240
241int OpenSoundDeviceEngine::GetSpeed(void)
242{
243	int speed = -1;
244	CALLED();
245	if (ioctl(fFD, SNDCTL_DSP_SPEED, &speed, sizeof(int)) < 0) {
246		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
247				__FUNCTION__, "SNDCTL_DSP_SPEED", strerror(errno)));
248		return -1;
249	}
250	return speed;
251}
252
253status_t OpenSoundDeviceEngine::SetSpeed(int speed)
254{
255	CALLED();
256	if (ioctl(fFD, SNDCTL_DSP_SPEED, &speed, sizeof(int)) < 0) {
257		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
258				__FUNCTION__, "SNDCTL_DSP_SPEED", strerror(errno)));
259		return EIO;
260	}
261	PRINT(("OpenSoundDeviceEngine::%s: %d\n", __FUNCTION__, speed));
262	return B_OK;
263}
264
265
266size_t OpenSoundDeviceEngine::GetISpace(audio_buf_info *info)
267{
268	audio_buf_info abinfo;
269	CALLED();
270	if (!info)
271		info = &abinfo;
272	memset(info, 0, sizeof(audio_buf_info));
273	if (!(fOpenMode & OPEN_READ))
274		return 0;
275	if (ioctl(fFD, SNDCTL_DSP_GETISPACE, info, sizeof(audio_buf_info)) < 0) {
276		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
277				__FUNCTION__, "SNDCTL_DSP_GETISPACE", strerror(errno)));
278		return EIO;
279	}
280	//PRINT(("OpenSoundDeviceEngine::%s: ISPACE: { bytes=%d, fragments=%d, fragsize=%d, fragstotal=%d }\n", __FUNCTION__, info->bytes, info->fragments, info->fragsize, info->fragstotal));
281	return info->bytes;
282}
283
284
285size_t OpenSoundDeviceEngine::GetOSpace(audio_buf_info *info)
286{
287	audio_buf_info abinfo;
288	//CALLED();
289	if (!info)
290		info = &abinfo;
291	memset(info, 0, sizeof(audio_buf_info));
292	if (!(fOpenMode & OPEN_WRITE))
293		return 0;
294	if (ioctl(fFD, SNDCTL_DSP_GETOSPACE, info, sizeof(audio_buf_info)) < 0) {
295		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
296				__FUNCTION__, "SNDCTL_DSP_GETOSPACE", strerror(errno)));
297		return EIO;
298	}
299	//PRINT(("OpenSoundDeviceEngine::%s: OSPACE: { bytes=%d, fragments=%d, fragsize=%d, fragstotal=%d }\n", __FUNCTION__, info->bytes, info->fragments, info->fragsize, info->fragstotal));
300	return info->bytes;
301}
302
303
304int64
305OpenSoundDeviceEngine::GetCurrentIPtr(int32 *fifoed, oss_count_t *info)
306{
307	oss_count_t ocount;
308	count_info cinfo;
309	CALLED();
310	if (!info)
311		info = &ocount;
312	memset(info, 0, sizeof(oss_count_t));
313	if (!(fOpenMode & OPEN_READ))
314		return 0;
315	if (ioctl(fFD, SNDCTL_DSP_CURRENT_IPTR, info, sizeof(oss_count_t)) < 0) {
316		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
317				__FUNCTION__, "SNDCTL_DSP_CURRENT_IPTR", strerror(errno)));
318		//return EIO;
319		// fallback: try GET*PTR
320		if (ioctl(fFD, SNDCTL_DSP_GETIPTR, &cinfo, sizeof(count_info)) < 0) {
321			PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
322					__FUNCTION__, "SNDCTL_DSP_GETIPTR", strerror(errno)));
323			return 0;
324		}
325		// it's probably wrong...
326		info->samples = cinfo.bytes / (fMediaFormat.u.raw_audio.channel_count
327						 		* (fMediaFormat.AudioFormat() & media_raw_audio_format::B_AUDIO_SIZE_MASK));
328		info->fifo_samples = 0;
329	}
330	PRINT(("OpenSoundDeviceEngine::%s: IPTR: { samples=%Ld, fifo_samples=%d }\n", __FUNCTION__, info->samples, info->fifo_samples));
331	if (fifoed)
332		*fifoed = info->fifo_samples;
333	return info->samples;
334}
335
336
337int64
338OpenSoundDeviceEngine::GetCurrentOPtr(int32* fifoed, size_t* fragmentPos)
339{
340	CALLED();
341
342	if (!(fOpenMode & OPEN_WRITE)) {
343		if (fifoed != NULL)
344			*fifoed = 0;
345		return 0;
346	}
347
348	oss_count_t info;
349	memset(&info, 0, sizeof(oss_count_t));
350
351	if (ioctl(fFD, SNDCTL_DSP_CURRENT_OPTR, &info, sizeof(oss_count_t)) < 0) {
352		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
353				__FUNCTION__, "SNDCTL_DSP_CURRENT_OPTR", strerror(errno)));
354
355		return 0;
356	}
357
358	if (fragmentPos != NULL) {
359		count_info cinfo;
360		if (ioctl(fFD, SNDCTL_DSP_GETOPTR, &cinfo, sizeof(count_info)) < 0) {
361			PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
362					__FUNCTION__, "SNDCTL_DSP_GETOPTR", strerror(errno)));
363			return 0;
364		}
365		*fragmentPos = cinfo.ptr;
366	}
367
368//	PRINT(("OpenSoundDeviceEngine::%s: OPTR: { samples=%Ld, "
369//		"fifo_samples=%d }\n", __FUNCTION__, info->samples,
370//		info->fifo_samples));
371	if (fifoed != NULL)
372		*fifoed = info.fifo_samples;
373	return info.samples;
374}
375
376
377int32
378OpenSoundDeviceEngine::GetIOverruns()
379{
380	audio_errinfo info;
381	CALLED();
382	memset(&info, 0, sizeof(info));
383	if (!(fOpenMode & OPEN_WRITE))
384		return 0;
385	if (ioctl(fFD, SNDCTL_DSP_GETERROR, &info, sizeof(info)) < 0) {
386		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
387				__FUNCTION__, "SNDCTL_DSP_GETERROR", strerror(errno)));
388		return 0;
389	}
390	PRINT(("OpenSoundDeviceEngine::%s: IOVERRUNS: { overruns=%d }\n", __FUNCTION__, info.rec_overruns));
391	return info.rec_overruns;
392}
393
394
395int32
396OpenSoundDeviceEngine::GetOUnderruns()
397{
398	audio_errinfo info;
399	CALLED();
400	memset(&info, 0, sizeof(info));
401	if (!(fOpenMode & OPEN_WRITE))
402		return 0;
403	if (ioctl(fFD, SNDCTL_DSP_GETERROR, &info, sizeof(info)) < 0) {
404		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
405				__FUNCTION__, "SNDCTL_DSP_GETERROR", strerror(errno)));
406		return 0;
407	}
408	//PRINT(("OpenSoundDeviceEngine::%s: OUNDERRUNS: { underruns=%d }\n", __FUNCTION__, info.play_underruns));
409	return info.play_underruns;
410}
411
412
413size_t
414OpenSoundDeviceEngine::DriverBufferSize() const
415{
416	return fDriverBufferSize;
417}
418
419
420status_t OpenSoundDeviceEngine::StartRecording(void)
421{
422	CALLED();
423	oss_syncgroup group;
424	group.id = 0;
425	group.mode = PCM_ENABLE_INPUT;
426	if (ioctl(fFD, SNDCTL_DSP_SYNCGROUP, &group, sizeof(group)) < 0) {
427		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
428				__FUNCTION__, "SNDCTL_DSP_SYNCGROUP", strerror(errno)));
429		return EIO;
430	}
431	if (ioctl(fFD, SNDCTL_DSP_SYNCSTART, &group.id, sizeof(group.id)) < 0) {
432		PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
433				__FUNCTION__, "SNDCTL_DSP_SYNCSTART", strerror(errno)));
434		return EIO;
435	}
436	return B_OK;
437}
438
439
440status_t
441OpenSoundDeviceEngine::WildcardFormatFor(int fmt, media_format &format,
442	bool rec)
443{
444	status_t err;
445	CALLED();
446	fmt &= rec ? Info()->iformats : Info()->oformats;
447	if (fmt == 0)
448		return B_MEDIA_BAD_FORMAT;
449	err = OpenSoundDevice::get_media_format_for(fmt, format);
450	if (err < B_OK)
451		return err;
452	char buf[1024];
453	string_for_format(format, buf, 1024);
454	if (format.type == B_MEDIA_RAW_AUDIO) {
455		format.u.raw_audio = media_multi_audio_format::wildcard;
456		format.u.raw_audio.byte_order = B_MEDIA_HOST_ENDIAN;
457		// single rate supported
458		if (Info()->min_rate == Info()->max_rate)
459			format.u.raw_audio.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
460	} else if (format.type == B_MEDIA_ENCODED_AUDIO) {
461		format.u.encoded_audio.output = media_multi_audio_format::wildcard;
462		//format.u.encoded_audio.output.byte_order = B_MEDIA_HOST_ENDIAN;
463		// single rate supported
464		//if (Info()->min_rate == Info()->max_rate)
465		//	format.u.encoded_audio.output.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
466	} else
467		return EINVAL;
468	PRINT(("%s: %s\n", __FUNCTION__, buf));
469	return B_OK;
470}
471
472
473status_t OpenSoundDeviceEngine::PreferredFormatFor(int fmt, media_format &format, bool rec)
474{
475	status_t err;
476	CALLED();
477	fmt &= rec ? Info()->iformats : Info()->oformats;
478	if (fmt == 0)
479		return B_MEDIA_BAD_FORMAT;
480	err = WildcardFormatFor(fmt, format);
481	if (err < B_OK)
482		return err;
483	if (format.type == B_MEDIA_RAW_AUDIO) {
484		media_multi_audio_format &raw = format.u.raw_audio;
485		//format.u.raw_audio.channel_count = Info()->max_channels;
486		raw.byte_order = B_MEDIA_HOST_ENDIAN;
487		raw.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
488		raw.buffer_size = DEFAULT_BUFFER_SIZE;
489		/*if (rec)
490			raw.buffer_size = 2048;*/
491/*
492		format.u.raw_audio.byte_order = B_MEDIA_HOST_ENDIAN;
493		format.u.raw_audio.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
494		format.u.raw_audio.buffer_size = DEFAULT_BUFFER_SIZE;
495*/
496	} else if (format.type == B_MEDIA_ENCODED_AUDIO) {
497		media_raw_audio_format &raw = format.u.encoded_audio.output;
498		//format.u.encoded_audio.output.channel_count = Info()->max_channels;
499		raw.byte_order = B_MEDIA_HOST_ENDIAN;
500		// single rate supported
501		if (Info()->min_rate == Info()->max_rate)
502			raw.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
503		raw.buffer_size = DEFAULT_BUFFER_SIZE;
504	} else
505		return EINVAL;
506	char buf[1024];
507	string_for_format(format, buf, 1024);
508	PRINT(("%s: %s\n", __FUNCTION__, buf));
509	return B_OK;
510}
511
512
513status_t OpenSoundDeviceEngine::AcceptFormatFor(int fmt, media_format &format, bool rec)
514{
515	status_t err;
516	int afmt = 0;
517	char buf[1024];
518	CALLED();
519	fmt &= rec ? Info()->iformats : Info()->oformats;
520
521	if (fmt == 0)
522		return B_MEDIA_BAD_FORMAT;
523	media_format wc;
524	err = WildcardFormatFor(fmt, wc);
525	if (err < B_OK)
526		return err;
527
528	err = Open(rec ? OPEN_READ : OPEN_WRITE);
529	if (err < B_OK)
530		return err;
531
532	if (format.type == B_MEDIA_RAW_AUDIO) {
533		media_multi_audio_format &raw = format.u.raw_audio;
534
535		// channel count
536		raw.channel_count = MAX((unsigned)(Info()->min_channels), MIN((unsigned)(Info()->max_channels), raw.channel_count));
537		err = SetChannels(raw.channel_count);
538		if (err < B_OK) {
539			Close();
540			return err;
541		}
542
543		PRINT(("%s:step1  fmt=0x%08x, raw.format=0x%08" B_PRIx32 "\n",
544			__FUNCTION__, fmt, raw.format));
545		// if specified, try it
546		if (raw.format)
547			afmt = OpenSoundDevice::convert_media_format_to_oss_format(raw.format);
548		afmt &= fmt;
549		PRINT(("%s:step2 afmt=0x%08x\n", __FUNCTION__, afmt));
550		// select the best as default
551		if (afmt == 0) {
552			afmt = OpenSoundDevice::select_oss_format(fmt);
553			raw.format = OpenSoundDevice::convert_oss_format_to_media_format(afmt);
554			//Close();
555			//return B_MEDIA_BAD_FORMAT;
556		}
557		PRINT(("%s:step3 afmt=0x%08x\n", __FUNCTION__, afmt));
558		// convert back
559		raw.format = OpenSoundDevice::convert_oss_format_to_media_format(afmt);
560		PRINT(("%s:step4 afmt=0x%08x, raw.format=0x%08" B_PRIx32 "\n",
561			__FUNCTION__, afmt, raw.format));
562		raw.valid_bits = OpenSoundDevice::convert_oss_format_to_valid_bits(afmt);
563
564		err = SetFormat(afmt);
565		if (err < B_OK) {
566			Close();
567			return err;
568		}
569
570		// endianness
571		raw.byte_order = OpenSoundDevice::convert_oss_format_to_endian(afmt);
572
573		// sample rate
574		raw.frame_rate = OpenSoundDevice::select_oss_rate(Info(), raw.frame_rate);		// measured in Hertz
575		//raw.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
576		err = SetSpeed(OpenSoundDevice::convert_media_rate_to_oss_rate(raw.frame_rate));
577		if (err < B_OK) {
578			Close();
579			return err;
580		}
581
582		// retrieve the driver buffer size (it's important to do this
583		// after all the other setup, since OSS may have adjusted it, and
584		// also weird things happen if this ioctl() is done before other
585		// setup itctl()s)
586		audio_buf_info abinfo;
587		memset(&abinfo, 0, sizeof(audio_buf_info));
588		if (ioctl(fFD, SNDCTL_DSP_GETOSPACE, &abinfo, sizeof(audio_buf_info)) < 0) {
589			fprintf(stderr, "failed to retrieve driver buffer size!\n");
590			abinfo.bytes = 0;
591		}
592		fDriverBufferSize = abinfo.bytes;
593
594		raw.buffer_size = fDriverBufferSize;
595
596	} else if (format.type == B_MEDIA_ENCODED_AUDIO) {
597		media_raw_audio_format &raw = format.u.encoded_audio.output;
598		// XXX: do we really have to do this ?
599		raw.channel_count = MAX((unsigned)(Info()->min_channels), MIN((unsigned)(Info()->max_channels), raw.channel_count));
600		raw.byte_order = B_MEDIA_HOST_ENDIAN;
601		raw.frame_rate = OpenSoundDevice::select_oss_rate(Info(), raw.frame_rate);		// measured in Hertz
602		//raw.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
603		raw.buffer_size = DEFAULT_BUFFER_SIZE;
604
605	} else {
606		PRINT(("%s: unknown media type\n", __FUNCTION__));
607		Close();
608		return EINVAL;
609	}
610	// cache it
611	fMediaFormat = format;
612
613	string_for_format(format, buf, 1024);
614	PRINT(("%s: %s\n", __FUNCTION__, buf));
615	return B_OK;
616}
617
618
619status_t OpenSoundDeviceEngine::SpecializeFormatFor(int fmt, media_format &format, bool rec)
620{
621	status_t err;
622	int afmt = 0;
623	CALLED();
624	fmt &= rec ? Info()->iformats : Info()->oformats;
625	if (fmt == 0)
626		return B_MEDIA_BAD_FORMAT;
627	media_format wc;
628	err = WildcardFormatFor(fmt, wc);
629	if (err < B_OK)
630		return err;
631
632	err = Open(rec ? OPEN_READ : OPEN_WRITE);
633	if (err < B_OK)
634		return err;
635
636	if (format.type == B_MEDIA_RAW_AUDIO) {
637		media_multi_audio_format &raw = format.u.raw_audio;
638
639		PRINT(("%s:step1  fmt=0x%08x, raw.format=0x%08" B_PRIx32 "\n",
640			__FUNCTION__, fmt, raw.format));
641		// select the best as default
642		if (!raw.format) {
643			afmt = OpenSoundDevice::select_oss_format(fmt);
644			raw.format = OpenSoundDevice::convert_oss_format_to_media_format(afmt);
645		}
646		// if specified, try it
647		if (raw.format)
648			afmt = OpenSoundDevice::convert_media_format_to_oss_format(raw.format);
649		afmt &= fmt;
650		PRINT(("%s:step2 afmt=0x%08x\n", __FUNCTION__, afmt));
651		if (afmt == 0) {
652			Close();
653			return B_MEDIA_BAD_FORMAT;
654		}
655		// convert back
656		raw.format = OpenSoundDevice::convert_oss_format_to_media_format(afmt);
657		PRINT(("%s:step4 afmt=0x%08x, raw.format=0x%08" B_PRIx32 "\n",
658			__FUNCTION__, afmt, raw.format));
659		if (!raw.valid_bits)
660			raw.valid_bits = OpenSoundDevice::convert_oss_format_to_valid_bits(afmt);
661		if (raw.valid_bits != OpenSoundDevice::convert_oss_format_to_valid_bits(afmt)) {
662			Close();
663			return B_MEDIA_BAD_FORMAT;
664		}
665
666		err = SetFormat(afmt);
667		if (err < B_OK) {
668			Close();
669			return err;
670		}
671
672		// endianness
673		if (!raw.byte_order)
674			raw.byte_order = OpenSoundDevice::convert_oss_format_to_endian(afmt);
675		if ((int)raw.byte_order != OpenSoundDevice::convert_oss_format_to_endian(afmt)) {
676			Close();
677			return B_MEDIA_BAD_FORMAT;
678		}
679
680		// channel count
681		if (raw.channel_count == 0)
682			raw.channel_count = (unsigned)Info()->min_channels;
683		if ((int)raw.channel_count < Info()->min_channels
684			|| (int)raw.channel_count > Info()->max_channels)
685			return B_MEDIA_BAD_FORMAT;
686		err = SetChannels(raw.channel_count);
687		if (err < B_OK) {
688			Close();
689			return err;
690		}
691
692		// sample rate
693		if (!raw.frame_rate)
694			raw.frame_rate = Info()->max_rate;
695		//raw.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
696		err = SetSpeed(OpenSoundDevice::convert_media_rate_to_oss_rate(raw.frame_rate));
697		if (err < B_OK) {
698			Close();
699			return err;
700		}
701
702#if 0
703		raw.buffer_size = DEFAULT_BUFFER_SIZE
704						* (raw.format & media_raw_audio_format::B_AUDIO_SIZE_MASK)
705						* raw.channel_count;
706#endif
707		audio_buf_info abinfo;
708		if (ioctl(fFD, rec?SNDCTL_DSP_GETISPACE:SNDCTL_DSP_GETOSPACE, &abinfo, sizeof(abinfo)) < 0) {
709			PRINT(("OpenSoundDeviceEngine::%s: %s: %s\n",
710				__FUNCTION__, "SNDCTL_DSP_GET?SPACE", strerror(errno)));
711			return -1;
712		}
713		PRINT(("OSS: %cSPACE: { bytes=%d, fragments=%d, fragsize=%d, fragstotal=%d }\n", rec?'I':'O', abinfo.bytes, abinfo.fragments, abinfo.fragsize, abinfo.fragstotal));
714		// cache the first one in the Device
715		// so StartThread() knows the number of frags
716		//if (!fFragments.fragstotal)
717		//	memcpy(&fFragments, &abinfo, sizeof(abinfo));
718
719		// make sure buffer size is less than the driver's own buffer ( /2 to keep some margin )
720		if (/*rec && raw.buffer_size &&*/ (int)raw.buffer_size > abinfo.fragsize * abinfo.fragstotal / 4)
721			return B_MEDIA_BAD_FORMAT;
722		if (!raw.buffer_size)
723			raw.buffer_size = abinfo.fragsize;//XXX
724/*						* (raw.format & media_raw_audio_format::B_AUDIO_SIZE_MASK)
725						* raw.channel_count;*/
726	} else if (format.type == B_MEDIA_ENCODED_AUDIO) {
727		media_raw_audio_format &raw = format.u.encoded_audio.output;
728		// XXX: do we really have to do this ?
729		raw.channel_count = MAX((unsigned)(Info()->min_channels), MIN((unsigned)(Info()->max_channels), raw.channel_count));
730		raw.byte_order = B_MEDIA_HOST_ENDIAN;
731		raw.frame_rate = OpenSoundDevice::select_oss_rate(Info(), raw.frame_rate);		// measured in Hertz
732		//raw.frame_rate = OpenSoundDevice::convert_oss_rate_to_media_rate(Info()->max_rate);		// measured in Hertz
733		raw.buffer_size = DEFAULT_BUFFER_SIZE;
734
735	} else {
736		Close();
737		return EINVAL;
738	}
739	// cache it
740	fMediaFormat = format;
741	char buf[1024];
742	string_for_format(format, buf, 1024);
743	PRINT(("%s: %s\n", __FUNCTION__, buf));
744	return B_OK;
745}
746
747