[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