[xiph-commits] r12981 - trunk/ao/src
ben at svn.xiph.org
ben at svn.xiph.org
Thu May 24 03:04:44 PDT 2007
Author: ben
Date: 2007-05-24 03:04:44 -0700 (Thu, 24 May 2007)
New Revision: 12981
Added:
trunk/ao/src/ao_wmm.c
Log:
This is the new win32 driver. Currently it should be compile as a buil-tin driver because of the lack of portable DSO loader. This driver is for Window Multi Media API (WMM) not for DirectSound.
Added: trunk/ao/src/ao_wmm.c
===================================================================
--- trunk/ao/src/ao_wmm.c (rev 0)
+++ trunk/ao/src/ao_wmm.c 2007-05-24 10:04:44 UTC (rev 12981)
@@ -0,0 +1,726 @@
+/*
+ *
+ * ao_wmm.c
+ *
+ * Copyright (C) Benjamin Gerard - March 2007
+ *
+ * This file is part of libao, a cross-platform library. See
+ * README for a history of this source code.
+ *
+ * libao is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * libao is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Make; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+//#define PREPARE_EACH
+#define _CRT_SECURE_NO_DEPRECATE
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <mmsystem.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "ao/ao.h"
+/* #include "ao/plugin.h" */
+
+#define GALLOC_WVHD_TYPE (GHND)
+#define GALLOC_DATA_TYPE (GHND)
+
+static int debug_flag = 1;
+
+static void debug(const char * fmt, ...)
+{
+ if (debug_flag) {
+ va_list list;
+ va_start(list,fmt);
+ vfprintf(stderr,fmt,list);
+ va_end(list);
+ }
+}
+
+static const char * mmerror(MMRESULT mmrError)
+{
+ static char mmbuffer[1024];
+ int len;
+ sprintf(mmbuffer,"mm:%d ",(int)mmrError);
+ len = (int)strlen(mmbuffer);
+ waveOutGetErrorText(mmrError, mmbuffer+len, sizeof(mmbuffer)-len);
+ mmbuffer[sizeof(mmbuffer)-1] = 0;
+ return mmbuffer;
+}
+
+static char * ao_wmm_options[] = {"dev","id"};
+static ao_info ao_wmm_info =
+ {
+ /* type */ AO_TYPE_LIVE,
+ /* name */ "WMM audio driver output ",
+ /* short-name */ "wmm",
+ /* author */ "Benjamin Gerard <benjihan at users.sourceforge.net>",
+ /* comment */ "Outputs audio to the Windows MultiMedia driver.",
+ /* prefered format */ AO_FMT_LITTLE,
+ /* priority */ 20,
+ /* options */ ao_wmm_options,
+ /* # of options */ sizeof(ao_wmm_options)/sizeof(*ao_wmm_options)
+ };
+
+typedef struct {
+ WAVEHDR wh; /* waveheader */
+ char * data; /* sample data ptr */
+ int idx; /* index of this header */
+ int count; /* current byte count */
+ int length; /* size of data */
+ int sent; /* set when header is sent to device */
+} myWH_t;
+
+typedef struct ao_wmm_internal {
+ UINT id; /* device id */
+ HWAVEOUT hwo; /* waveout handler */
+ WAVEOUTCAPS caps; /* device caps */
+ WAVEFORMATEX wavefmt; /* sample format */
+
+ int opened; /* device has been opened */
+ int prepared; /* waveheaders have been prepared */
+ int blocks; /* number of blocks (wave headers) */
+ int splPerBlock; /* sample per blocks. */
+ int msPerBlock; /* millisecond per block (approx.) */
+
+ void * bigbuffer; /* Allocated buffer for waveheaders and sound data */
+ myWH_t * wh; /* Pointer to waveheaders in bigbuffer */
+ BYTE * spl; /* Pointer to sound data in bigbuffer */
+
+ int sent_blocks; /* Number of waveheader sent (not ack). */
+ int full_blocks; /* Number of waveheader full (ready to send). */
+ int widx; /* Index to the block being currently filled. */
+ int ridx; /* Index to the block being sent. */
+
+} ao_wmm_internal;
+
+int ao_wmm_test(void)
+{
+ debug("ao_wmm_test() {} => [success]\n");
+ return 1; /* This plugin works in default mode */
+}
+
+ao_info *ao_wmm_driver_info(void)
+{
+ debug("ao_wmm_driver_info() {} => [success]\n");
+ return &ao_wmm_info;
+}
+
+int ao_wmm_set_option(ao_device *device,
+ const char *key, const char *value)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ int res = 0;
+
+ debug("ao_wmm_set_option(%s,%s) {\n", key, value);
+ if (!strcmp(key, "dev")) {
+ if (!strcmp(value,"default")) {
+ key = "id";
+ value = "0";
+ } else {
+ WAVEOUTCAPS caps;
+ int i, max = waveOutGetNumDevs();
+
+ debug("ao_wmm_set_option: search device %s among %d\n", value, max);
+ for (i=0; i<max; ++i) {
+ MMRESULT mmres
+ = waveOutGetDevCaps(i, &caps, sizeof(caps));
+ if (mmres == MMSYSERR_NOERROR) {
+ res = !strcmp(value, caps.szPname);
+ debug("ao_wmm_set_option:\n"
+ " id : %d\n"
+ " name : %s\n"
+ " ver : %d.%d\n"
+ " => [%sfound]\n",i,caps.szPname,
+ caps.vDriverVersion>>8,caps.vDriverVersion&255,
+ res?"":"not ");
+ if (res) {
+ internal->id = i;
+ internal->caps = caps;
+ break;
+ }
+ } else {
+ debug("ao_wmm_set_option: waveOutGetDevCaps(%d) => [error]\n",i);
+ debug(" => %s\n", mmerror(mmres));
+ }
+ }
+ goto finish;
+ }
+ }
+
+ if (!strcmp(key,"id")) {
+ MMRESULT mmres;
+ WAVEOUTCAPS caps;
+
+ int id = strtol(value,0,0);
+ int max = waveOutGetNumDevs();
+
+ debug("ao_wmm_set_option: search device %d among %d\n", id, max);
+
+ if (id >= 0 && id <= max) {
+ if (id-- == 0) {
+ debug("ao_wmm_set_option: set default wavemapper\n");
+ id = WAVE_MAPPER;
+ }
+ mmres = waveOutGetDevCaps(id, &caps, sizeof(caps));
+
+ if (mmres == MMSYSERR_NOERROR) {
+ res = 1;
+ debug("ao_wmm_set_option:\n"
+ " id : %d\n"
+ " name : %s\n"
+ " ver : %d.%d\n",
+ id,caps.szPname,caps.vDriverVersion>>8,caps.vDriverVersion&255);
+ internal->id = id;
+ internal->caps = caps;
+ } else {
+ debug(" waveOutGetDevCaps(%d) => %s\n",id, mmerror(mmres));
+ }
+ }
+ }
+
+ finish:
+ debug("} ao_wmm_set_option() => [%s]\n", res?"success":"error");
+ return res;
+}
+
+
+int ao_wmm_device_init(ao_device *device)
+{
+ ao_wmm_internal *internal;
+ int res;
+
+ debug("ao_wmm_device_init() {\n");
+
+ internal = (ao_wmm_internal *) malloc(sizeof(ao_wmm_internal));
+ device->internal = internal;
+ if (internal != NULL) {
+ memset(internal,0,sizeof(ao_wmm_internal));
+ internal->id = WAVE_MAPPER;
+ internal->blocks = 32;
+ internal->splPerBlock = 512;
+ /* set default device */
+ ao_wmm_set_option(device,"id","0");
+ }
+
+ res = internal != NULL;
+ debug("} ao_wmm_device_init() => [%s]\n",res?"success":"error" );
+
+ return res;
+}
+
+#if 0
+static void CALLBACK
+waveOutProc(HWAVEOUT hwo,
+ UINT uMsg, DWORD_PTR dwInstance,
+ DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+{
+ ao_device *device = (ao_device *) dwInstance;
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+
+ switch (uMsg) {
+
+ case WOM_OPEN:
+ /* Sent when the device is opened using the waveOutOpen function. */
+ {
+ debug("WOM_OPEN\n");
+ } break;
+
+ case WOM_CLOSE:
+ /* Sent when the device is closed using the waveOutClose function. */
+ {
+ debug("WOM_CLOSE\n");
+ } break;
+
+ case WOM_DONE:
+ /* Sent when the device driver is finished with a data block sent
+ using the waveOutWrite function. */
+ {
+ LPWAVEHDR lpwvhdr = (LPWAVEHDR) dwParam1;
+ int me = lpwvhdr - internal->wh;
+ debug("WOM_DONE #%d\n",me);
+ lpwvhdr->dwBytesRecorded = 0;
+ } break;
+
+ default:
+ {
+ debug("WOM_???\n");
+ } break;
+ }
+}
+#endif
+
+static int _ao_open_device(ao_device *device)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ int res;
+ MMRESULT mmres;
+
+ debug("_ao_open_device() {\n");
+ mmres =
+ waveOutOpen(&internal->hwo,
+ internal->id,
+ &internal->wavefmt,
+ (DWORD_PTR)0/* waveOutProc */,
+ (DWORD_PTR)device,
+ CALLBACK_NULL/* |WAVE_FORMAT_DIRECT */|WAVE_ALLOWSYNC);
+
+ debug("_ao_open_device: waveOutOpen\n"
+ " id : %d\n"
+ " channels : %d\n"
+ " bits : %d\n"
+ " rate : %d => [%s]\n",
+ internal->id,
+ internal->wavefmt.nChannels,
+ internal->wavefmt.wBitsPerSample,
+ internal->wavefmt.nSamplesPerSec,
+ mmres == MMSYSERR_NOERROR?"success":"error");
+
+ if (mmres == MMSYSERR_NOERROR) {
+ UINT id;
+ if (MMSYSERR_NOERROR == waveOutGetID(internal->hwo,&id)) {
+ debug("_ao_open_device: waveOutGetID() => [%d]\n",id);
+ internal->id = id;
+ }
+ } else {
+ debug(" waveOutOpen(%d)\n => %s\n", internal->id, mmerror(mmres));
+ }
+
+ res = (mmres == MMSYSERR_NOERROR);
+ debug("} _ao_open_device() => [%s]\n",res?"success":"error");
+ return res;
+}
+
+static int _ao_close_device(ao_device *device)
+{
+ ao_wmm_internal * internal = (ao_wmm_internal *) device->internal;
+ int res;
+ MMRESULT mmres;
+
+ debug("_ao_close_device() {\n");
+
+ mmres = waveOutClose(internal->hwo);
+ if (mmres != MMSYSERR_NOERROR) {
+ debug(" waveOutClose(%d)\n => %s\n", internal->id, mmerror(mmres));
+ }
+ res = (mmres == MMSYSERR_NOERROR);
+ debug("} _ao_close_device() => [%s]\n",res?"success":"error");
+
+ return res;
+}
+
+static int _ao_alloc_wave_headers(ao_device *device)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ int bytesPerBlock = internal->wavefmt.nBlockAlign * internal->splPerBlock;
+ /* int bytes = internal->blocks * (sizeof(WAVEHDR) + bytesPerBlock); */
+ int bytes = internal->blocks * (sizeof(*internal->wh) + bytesPerBlock);
+ int res;
+ MMRESULT mmres;
+
+ debug("_ao_alloc_wave_headers() {\n"
+ " blocks : %d\n"
+ " bytes/blocks : %d\n"
+ " total : %d\n",internal->blocks,bytesPerBlock,bytes);
+
+ internal->bigbuffer = malloc(bytes);
+ if (internal->bigbuffer != NULL) {
+ int i;
+ BYTE * b;
+
+ memset(internal->bigbuffer,0,bytes);
+ internal->wh = internal->bigbuffer;
+ internal->spl = (LPBYTE) (internal->wh+internal->blocks);
+ for (i=0, b=internal->spl; i<internal->blocks; ++i, b+=bytesPerBlock) {
+ internal->wh[i].data = b;
+ internal->wh[i].wh.lpData = internal->wh[i].data;
+ internal->wh[i].length = bytesPerBlock;
+ internal->wh[i].wh.dwBufferLength = internal->wh[i].length;
+ internal->wh[i].wh.dwUser = (DWORD_PTR)device;
+ mmres = waveOutPrepareHeader(internal->hwo,
+ &internal->wh[i].wh,sizeof(WAVEHDR));
+ if (MMSYSERR_NOERROR != mmres) {
+ debug("_ao_alloc_wave_headers:"
+ " waveOutPrepareHeader(%d) => [error]\n",i);
+ debug(" => %s\n", mmerror(mmres));
+ break;
+ }
+ }
+ if (i<internal->blocks) {
+ while (--i >= 0) {
+ waveOutUnprepareHeader(internal->hwo,
+ &internal->wh[i].wh,sizeof(WAVEHDR));
+ }
+ free(internal->bigbuffer);
+ internal->wh = 0;
+ internal->spl = 0;
+ internal->bigbuffer = 0;
+ } else {
+ /* all ok ! */
+ }
+ } else {
+ debug("_ao_alloc_wave_headers: malloc() => [error]\n");
+ }
+
+ res = (internal->bigbuffer != NULL);
+ debug("} _ao_alloc_wave_headers() => [%s]\n", res?"success":"error");
+ return res;
+}
+
+static int _ao_get_free_block(ao_device * device);
+static int _ao_wait_wave_headers(ao_device *device, int wait_all)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ int res = 1;
+
+ debug("_ao_wait_wave_headers: wait for %d blocks (%swait all)\n",
+ internal->sent_blocks,wait_all?"":"not ");
+
+ while (internal->sent_blocks > 0) {
+ int n;
+ _ao_get_free_block(device);
+ n = internal->sent_blocks;
+ if (n > 0) {
+ unsigned int ms = (internal->msPerBlock>>1)+1;
+ if (wait_all) ms *= n;
+ debug("_ao_wait_wave_headers: sleep for %ums wait on %d blocks\n",ms, internal->sent_blocks);
+ Sleep(ms);
+ }
+ }
+
+ res &= !internal->sent_blocks;
+ debug("_ao_wait_wave_headers: => [%s]\n",res?"success":"error");
+ return res;
+}
+
+static int _ao_free_wave_headers(ao_device *device)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ MMRESULT mmres;
+ int res = 1;
+ debug("_ao_free_wave_headers() {\n");
+
+ if (internal->wh) {
+ int i;
+
+ /* Reset so we dont need to wait ... Just a satefy net
+ * since _ao_wait_wave_headers() has been called once before.
+ */
+ mmres = waveOutReset(internal->hwo);
+ debug(" waveOutReset(%d) => %s\n", internal->id, mmerror(mmres));
+ /* Wait again to be sure reseted waveheaders has been released. */
+ _ao_wait_wave_headers(device,0);
+
+ for (i=internal->blocks; --i>=0; ) {
+ mmres = waveOutUnprepareHeader(internal->hwo,
+ &internal->wh[i].wh,sizeof(WAVEHDR));
+ if (mmres != MMSYSERR_NOERROR) {
+ debug("_ao_free_wave_headers:"
+ " waveOutUnprepareHeader(%d)\n",i);
+ debug(" => %s\n", mmerror(mmres));
+ }
+
+ res &= mmres == MMSYSERR_NOERROR;
+ }
+ internal->wh = 0;
+ internal->spl = 0;
+ }
+
+ debug("} _ao_alloc_wave_headers() => [%s]\n", res?"success":"error");
+ return res;
+}
+
+
+/*
+ * open the audio device for writing to
+ */
+int ao_wmm_open(ao_device * device, ao_sample_format * format)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ int res = 0;
+ WAVEFORMATEX wavefmt;
+
+ debug("ao_wmm_open(%p,%p) {\n",device,format);
+
+ debug("ao_wmm_open:\n"
+ " channels : %d\n"
+ " bits : %d\n"
+ " rate : %d\n"
+ " format : %d(%s)\n",
+ format->channels,format->bits,format->rate,format->byte_format,
+ format->byte_format==AO_FMT_LITTLE
+ ?"little"
+ :(format->byte_format==AO_FMT_NATIVE
+ ?"native"
+ :(format->byte_format==AO_FMT_BIG?"big":"unknown")));
+
+ if(internal->opened) {
+ debug("ao_wmm_open: already opened\n");
+ goto error_no_close;
+ }
+
+ /* Force LITTLE as specified by WIN32 API */
+ format->byte_format = AO_FMT_LITTLE;
+ device->driver_byte_format = AO_FMT_LITTLE;
+
+ if (! (format->channels == 1 || format->channels == 2) ||
+ ! (format->bits == 8 || format->bits == 16) ||
+ ! (format->rate >= 6000 && format->rate <= 50000)
+ ) {
+ debug("ao_wmm_open: weird format\n");
+ goto error;
+ }
+
+ /* $$$ WMM 8 bit samples are unsigned... Not sure for ao ... */
+
+ /* Make sample format */
+ memset(&wavefmt,0,sizeof(wavefmt));
+ wavefmt.wFormatTag = WAVE_FORMAT_PCM;
+ wavefmt.nChannels = format->channels;
+ wavefmt.wBitsPerSample = format->bits;
+ wavefmt.nSamplesPerSec = format->rate;
+ wavefmt.nBlockAlign = (wavefmt.wBitsPerSample>>3)*wavefmt.nChannels;
+ wavefmt.nAvgBytesPerSec = wavefmt.nSamplesPerSec*wavefmt.nBlockAlign;
+ wavefmt.cbSize = 0;
+ internal->wavefmt = wavefmt;
+
+ /* $$$ later this should be optionnal parms */
+ internal->blocks = 64;
+ internal->splPerBlock = 512;
+ internal->msPerBlock =
+ (internal->splPerBlock * 1000 + format->rate - 1) / format->rate;
+
+ /* Open device */
+ if(!_ao_open_device(device)) {
+ debug("ao_wmm_open: _ao_open_device() => [error]\n");
+ goto error;
+ }
+ internal->opened = 1;
+
+ /* Allocate buffers */
+ if (!_ao_alloc_wave_headers(device)) {
+ debug("ao_wmm_open: _ao_alloc_wave_headers() => [error]\n");
+ goto error;
+ }
+ internal->prepared = 1;
+
+ res = 1;
+ error:
+ if (!res) {
+ if (internal->prepared) {
+ _ao_free_wave_headers(device);
+ internal->prepared = 0;
+ }
+ if (internal->opened) {
+ _ao_close_device(device);
+ internal->opened = 0;
+ }
+ }
+
+ error_no_close:
+ debug("} ao_wmm_open() => [%s]\n",res?"success":"error");
+ return res;
+}
+
+
+
+/* Send a block to audio hardware */
+static int _ao_send_block(ao_device *device, const int idx)
+{
+ ao_wmm_internal * internal = (ao_wmm_internal *) device->internal;
+ MMRESULT mmres;
+
+ /* Satanity checks */
+ if (internal->wh[idx].sent) {
+ debug("_ao_send_block: block %d marked SENT\n",idx);
+ return 0;
+ }
+ if (!!(internal->wh[idx].wh.dwFlags & WHDR_DONE)) {
+ debug("_ao_send_block: block %d marked DONE\n",idx);
+ return 0;
+ }
+
+ /* count <= 0, just pretend it's been sent */
+ if (internal->wh[idx].count <= 0) {
+ internal->wh[idx].sent = 2; /* set with 2 so we can track these special cases */
+ internal->wh[idx].wh.dwFlags |= WHDR_DONE;
+ ++internal->sent_blocks;
+ return 1;
+ }
+
+ internal->wh[idx].wh.dwBufferLength = internal->wh[idx].count;
+ internal->wh[idx].count = 0;
+ mmres = waveOutWrite(internal->hwo,
+ &internal->wh[idx].wh, sizeof(WAVEHDR));
+ internal->wh[idx].sent = (mmres == MMSYSERR_NOERROR);
+ /*&& !(internal->wh[idx].wh.dwFlags & WHDR_DONE);*/
+ internal->sent_blocks += internal->wh[idx].sent;
+ if (mmres != MMSYSERR_NOERROR) {
+ debug("_ao_send_block:: waveOutWrite(%d)\n",idx);
+ debug(" => %s\n",mmerror(mmres));
+ }
+ return mmres == MMSYSERR_NOERROR;
+}
+
+/* Get idx of next free block. */
+static int _ao_get_free_block(ao_device * device)
+{
+ ao_wmm_internal * internal = (ao_wmm_internal *) device->internal;
+ const int idx = internal->widx;
+ int ridx = internal->ridx;
+
+ while (internal->wh[ridx].sent && !!(internal->wh[ridx].wh.dwFlags & WHDR_DONE)) {
+ /* block successfully sent to hardware, release it */
+ /*debug("_ao_get_free_block: release block %d\n",ridx);*/
+ internal->wh[ridx].sent = 0;
+ internal->wh[ridx].wh.dwFlags &= ~WHDR_DONE;
+
+ --internal->full_blocks;
+ if (internal->full_blocks<0) {
+ debug("_ao_get_free_block: internal error with full block counter\n");
+ internal->full_blocks = 0;
+ }
+
+ --internal->sent_blocks;
+ if (internal->sent_blocks<0) {
+ debug("_ao_get_free_block: internal error with sent block counter\n");
+ internal->sent_blocks = 0;
+ }
+ if (++ridx >= internal->blocks) ridx = 0;
+ }
+ internal->ridx = ridx;
+
+ return internal->wh[idx].sent
+ ? -1
+ : idx;
+}
+
+/*
+ * play the sample to the already opened file descriptor
+ */
+int ao_wmm_play(ao_device *device,
+ const char *output_samples, uint_32 num_bytes)
+{
+ int ret = 1;
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+
+ while(ret && num_bytes > 0) {
+ int n;
+ const int idx = _ao_get_free_block(device);
+
+ if (idx == -1) {
+ /* debug("sleep %dms, rem %d bytes\n",internal->msPerBlock,num_bytes); */
+ Sleep(internal->msPerBlock);
+ continue;
+ }
+
+ /* Get free bytes in the block */
+ n = internal->wh[idx].wh.dwBufferLength
+ - internal->wh[idx].count;
+
+ /* debug("free in block %d : %d/%d\n", */
+ /* idx,n,internal->wh[idx].dwBufferLength); */
+
+ /* Get amount to copy */
+ if (n > (int)num_bytes) {
+ n = num_bytes;
+ }
+ /* debug("copy = %d\n",n); */
+
+
+ /* Do copy */
+ CopyMemory((char*)internal->wh[idx].wh.lpData
+ + internal->wh[idx].count,
+ output_samples, n);
+
+ /* Updates pointers and counters */
+ output_samples += n;
+ num_bytes -= n;
+ /* debug("rem = %d\n",num_bytes); */
+ internal->wh[idx].count += n;
+
+ /* Is this block full ? */
+ if (internal->wh[idx].count
+ == internal->wh[idx].wh.dwBufferLength) {
+ ++internal->full_blocks;
+ /* debug("blocks %d full, total:%d\n",internal->widx,internal->full_blocks); */
+ if (++internal->widx == internal->blocks) {
+ internal->widx = 0;
+ }
+ ret = _ao_send_block(device,idx);
+ }
+ }
+
+ /* debug("ao_wmm_play => %d rem => [%s]\n",num_bytes,ret?"success":"error"); */
+ return ret;
+
+}
+
+int ao_wmm_close(ao_device *device)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+ int ret = 0;
+
+ debug("ao_wmm_close() {\n");
+
+ if (internal->opened && internal->prepared) {
+ _ao_wait_wave_headers(device, 1);
+ }
+
+ if (internal->prepared) {
+ ret = _ao_free_wave_headers(device);
+ internal->prepared = 0;
+ }
+
+ if (internal->opened) {
+ ret = _ao_close_device(device);
+ internal->opened = 0;
+ }
+
+ debug("} ao_wmm_close() => [%s]\n",ret?"success":"error");
+
+ return ret;
+}
+
+void ao_wmm_device_clear(ao_device *device)
+{
+ ao_wmm_internal *internal = (ao_wmm_internal *) device->internal;
+
+ debug("ao_wmm_device_clear() {\n");
+
+ if (internal->bigbuffer) {
+ free(internal->bigbuffer); internal->bigbuffer = NULL;
+ }
+ free(internal);
+
+ debug("} ao_wmm_device_clear()\n");
+
+}
+
+ao_functions ao_wmm = {
+ ao_wmm_test,
+ ao_wmm_driver_info,
+ ao_wmm_device_init,
+ ao_wmm_set_option,
+ ao_wmm_open,
+ ao_wmm_play,
+ ao_wmm_close,
+ ao_wmm_device_clear
+};
More information about the commits
mailing list