libao2/ao_win32.c

   1 /*
   2  * Windows waveOut interface
   3  *
   4  * Copyright (c) 2002 - 2004 Sascha Sommer <saschasommer@freenet.de>
   5  *
   6  * This file is part of MPlayer.
   7  *
   8  * MPlayer is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * MPlayer is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <windows.h>
  26 #include <mmsystem.h>
  27
  28 #include "config.h"
  29 #include "libaf/af_format.h"
  30 #include "audio_out.h"
  31 #include "audio_out_internal.h"
  32 #include "mp_msg.h"
  33 #include "libvo/fastmemcpy.h"
  34 #include "osdep/timer.h"
  35
  36 #define WAVE_FORMAT_DOLBY_AC3_SPDIF 0x0092
  37 #define WAVE_FORMAT_EXTENSIBLE      0xFFFE
  38
  39 static const  GUID KSDATAFORMAT_SUBTYPE_PCM = {
  40         0x1,0x0000,0x0010,{0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71}
  41 };
  42
  43 typedef struct {
  44   WAVEFORMATEX  Format;
  45   union {
  46     WORD  wValidBitsPerSample;
  47     WORD  wSamplesPerBlock;
  48     WORD  wReserved;
  49   } Samples;
  50   DWORD  dwChannelMask;
  51   GUID  SubFormat;
  52 } WAVEFORMATEXTENSIBLE, *PWAVEFORMATEXTENSIBLE;
  53
  54 #define SPEAKER_FRONT_LEFT              0x1
  55 #define SPEAKER_FRONT_RIGHT             0x2
  56 #define SPEAKER_FRONT_CENTER            0x4
  57 #define SPEAKER_LOW_FREQUENCY           0x8
  58 #define SPEAKER_BACK_LEFT               0x10
  59 #define SPEAKER_BACK_RIGHT              0x20
  60 #define SPEAKER_FRONT_LEFT_OF_CENTER    0x40
  61 #define SPEAKER_FRONT_RIGHT_OF_CENTER   0x80
  62 #define SPEAKER_BACK_CENTER             0x100
  63 #define SPEAKER_SIDE_LEFT               0x200
  64 #define SPEAKER_SIDE_RIGHT              0x400
  65 #define SPEAKER_TOP_CENTER              0x800
  66 #define SPEAKER_TOP_FRONT_LEFT          0x1000
  67 #define SPEAKER_TOP_FRONT_CENTER        0x2000
  68 #define SPEAKER_TOP_FRONT_RIGHT         0x4000
  69 #define SPEAKER_TOP_BACK_LEFT           0x8000
  70 #define SPEAKER_TOP_BACK_CENTER         0x10000
  71 #define SPEAKER_TOP_BACK_RIGHT          0x20000
  72
  73 static const int channel_mask[] = {
  74   SPEAKER_FRONT_LEFT   | SPEAKER_FRONT_RIGHT  | SPEAKER_LOW_FREQUENCY,
  75   SPEAKER_FRONT_LEFT   | SPEAKER_FRONT_CENTER | SPEAKER_FRONT_RIGHT  | SPEAKER_LOW_FREQUENCY,
  76   SPEAKER_FRONT_LEFT   | SPEAKER_FRONT_CENTER | SPEAKER_FRONT_RIGHT  | SPEAKER_BACK_CENTER  | SPEAKER_LOW_FREQUENCY,
  77   SPEAKER_FRONT_LEFT   | SPEAKER_FRONT_CENTER | SPEAKER_FRONT_RIGHT  | SPEAKER_BACK_LEFT    | SPEAKER_BACK_RIGHT     | SPEAKER_LOW_FREQUENCY
  78 };
  79
  80
  81
  82 #define SAMPLESIZE   1024
  83 #define BUFFER_SIZE  4096
  84 #define BUFFER_COUNT 16
  85
  86
  87 static WAVEHDR*     waveBlocks;         //pointer to our ringbuffer memory
  88 static HWAVEOUT     hWaveOut;           //handle to the waveout device
  89 static unsigned int buf_write=0;
  90 static volatile int buf_read=0;
  91
  92
  93 static const ao_info_t info =
  94 {
  95         "Windows waveOut audio output",
  96         "win32",
  97         "Sascha Sommer <saschasommer@freenet.de>",
  98         ""
  99 };
 100
 101 LIBAO_EXTERN(win32)
 102
 103 static void CALLBACK waveOutProc(HWAVEOUT hWaveOut,UINT uMsg,DWORD dwInstance,
 104     DWORD dwParam1,DWORD dwParam2)
 105 {
 106         if(uMsg != WOM_DONE)
 107         return;
 108         buf_read = (buf_read + 1) % BUFFER_COUNT;
 109 }
 110
 111 // to set/get/query special features/parameters
 112 static int control(int cmd,void *arg)
 113 {
 114         DWORD volume;
 115         switch (cmd)
 116         {
 117                 case AOCONTROL_GET_VOLUME:
 118                 {
 119                         ao_control_vol_t* vol = (ao_control_vol_t*)arg;
 120                         waveOutGetVolume(hWaveOut,&volume);
 121                         vol->left = (float)(LOWORD(volume)/655.35);
 122                         vol->right = (float)(HIWORD(volume)/655.35);
 123                         mp_msg(MSGT_AO, MSGL_DBG2,"ao_win32: volume left:%f volume right:%f\n",vol->left,vol->right);
 124                         return CONTROL_OK;
 125                 }
 126                 case AOCONTROL_SET_VOLUME:
 127                 {
 128                         ao_control_vol_t* vol = (ao_control_vol_t*)arg;
 129                         volume = MAKELONG(vol->left*655.35,vol->right*655.35);
 130                         waveOutSetVolume(hWaveOut,volume);
 131                         return CONTROL_OK;
 132                 }
 133         }
 134     return -1;
 135 }
 136
 137 // open & setup audio device
 138 // return: 1=success 0=fail
 139 static int init(int rate,int channels,int format,int flags)
 140 {
 141         WAVEFORMATEXTENSIBLE wformat;
 142         MMRESULT result;
 143         unsigned char* buffer;
 144         int i;
 145
 146         if (AF_FORMAT_IS_AC3(format))
 147                 format = AF_FORMAT_AC3_NE;
 148         switch(format){
 149                 case AF_FORMAT_AC3_NE:
 150                 case AF_FORMAT_S24_LE:
 151                 case AF_FORMAT_S16_LE:
 152                 case AF_FORMAT_U8:
 153                         break;
 154                 default:
 155                         mp_msg(MSGT_AO, MSGL_V,"ao_win32: format %s not supported defaulting to Signed 16-bit Little-Endian\n",af_fmt2str_short(format));
 156                         format=AF_FORMAT_S16_LE;
 157         }
 158
 159         // FIXME multichannel mode is buggy
 160         if(channels > 2)
 161                 channels = 2;
 162
 163         //fill global ao_data
 164         ao_data.channels=channels;
 165         ao_data.samplerate=rate;
 166         ao_data.format=format;
 167         ao_data.bps=channels*rate;
 168         if(format != AF_FORMAT_U8 && format != AF_FORMAT_S8)
 169           ao_data.bps*=2;
 170         ao_data.outburst = BUFFER_SIZE;
 171         if(ao_data.buffersize==-1)
 172         {
 173                 ao_data.buffersize=af_fmt2bits(format)/8;
 174         ao_data.buffersize*= channels;
 175                 ao_data.buffersize*= SAMPLESIZE;
 176         }
 177         mp_msg(MSGT_AO, MSGL_V,"ao_win32: Samplerate:%iHz Channels:%i Format:%s\n",rate, channels, af_fmt2str_short(format));
 178     mp_msg(MSGT_AO, MSGL_V,"ao_win32: Buffersize:%d\n",ao_data.buffersize);
 179
 180         //fill waveformatex
 181     ZeroMemory( &wformat, sizeof(WAVEFORMATEXTENSIBLE));
 182     wformat.Format.cbSize          = (channels>2)?sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX):0;
 183     wformat.Format.nChannels       = channels;
 184     wformat.Format.nSamplesPerSec  = rate;
 185     if(AF_FORMAT_IS_AC3(format))
 186     {
 187         wformat.Format.wFormatTag      = WAVE_FORMAT_DOLBY_AC3_SPDIF;
 188         wformat.Format.wBitsPerSample  = 16;
 189         wformat.Format.nBlockAlign     = 4;
 190     }
 191     else
 192     {
 193         wformat.Format.wFormatTag      = (channels>2)?WAVE_FORMAT_EXTENSIBLE:WAVE_FORMAT_PCM;
 194         wformat.Format.wBitsPerSample  = af_fmt2bits(format);
 195         wformat.Format.nBlockAlign     = wformat.Format.nChannels * (wformat.Format.wBitsPerSample >> 3);
 196     }
 197         if(channels>2)
 198         {
 199         wformat.dwChannelMask = channel_mask[channels-3];
 200         wformat.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 201             wformat.Samples.wValidBitsPerSample=af_fmt2bits(format);
 202     }
 203
 204     wformat.Format.nAvgBytesPerSec = wformat.Format.nSamplesPerSec * wformat.Format.nBlockAlign;
 205
 206     //open sound device
 207     //WAVE_MAPPER always points to the default wave device on the system
 208     result = waveOutOpen(&hWaveOut,WAVE_MAPPER,(WAVEFORMATEX*)&wformat,(DWORD_PTR)waveOutProc,0,CALLBACK_FUNCTION);
 209         if(result == WAVERR_BADFORMAT)
 210         {
 211                 mp_msg(MSGT_AO, MSGL_ERR,"ao_win32: format not supported switching to default\n");
 212         ao_data.channels = wformat.Format.nChannels = 2;
 213             ao_data.samplerate = wformat.Format.nSamplesPerSec = 44100;
 214             ao_data.format = AF_FORMAT_S16_LE;
 215                 ao_data.bps=ao_data.channels * ao_data.samplerate*2;
 216             wformat.Format.wBitsPerSample=16;
 217         wformat.Format.wFormatTag=WAVE_FORMAT_PCM;
 218                 wformat.Format.nBlockAlign     = wformat.Format.nChannels * (wformat.Format.wBitsPerSample >> 3);
 219         wformat.Format.nAvgBytesPerSec = wformat.Format.nSamplesPerSec * wformat.Format.nBlockAlign;
 220                 ao_data.buffersize=(wformat.Format.wBitsPerSample>>3)*wformat.Format.nChannels*SAMPLESIZE;
 221         result = waveOutOpen(&hWaveOut,WAVE_MAPPER,(WAVEFORMATEX*)&wformat,(DWORD_PTR)waveOutProc,0,CALLBACK_FUNCTION);
 222         }
 223         if(result != MMSYSERR_NOERROR)
 224         {
 225                 mp_msg(MSGT_AO, MSGL_ERR,"ao_win32: unable to open wave mapper device (result=%i)\n",result);
 226                 return 0;
 227     }
 228         //allocate buffer memory as one big block
 229         buffer = calloc(BUFFER_COUNT, BUFFER_SIZE + sizeof(WAVEHDR));
 230     //and setup pointers to each buffer
 231     waveBlocks = (WAVEHDR*)buffer;
 232     buffer += sizeof(WAVEHDR) * BUFFER_COUNT;
 233     for(i = 0; i < BUFFER_COUNT; i++) {
 234         waveBlocks[i].lpData = buffer;
 235         buffer += BUFFER_SIZE;
 236     }
 237     buf_write=0;
 238     buf_read=0;
 239
 240     return 1;
 241 }
 242
 243 // close audio device
 244 static void uninit(int immed)
 245 {
 246     if(!immed)
 247         usec_sleep(get_delay() * 1000 * 1000);
 248     else
 249         waveOutReset(hWaveOut);
 250     while (waveOutClose(hWaveOut) == WAVERR_STILLPLAYING) usec_sleep(0);
 251         mp_msg(MSGT_AO, MSGL_V,"waveOut device closed\n");
 252     free(waveBlocks);
 253         mp_msg(MSGT_AO, MSGL_V,"buffer memory freed\n");
 254 }
 255
 256 // stop playing and empty buffers (for seeking/pause)
 257 static void reset(void)
 258 {
 259         waveOutReset(hWaveOut);
 260         buf_write=0;
 261         buf_read=0;
 262 }
 263
 264 // stop playing, keep buffers (for pause)
 265 static void audio_pause(void)
 266 {
 267     waveOutPause(hWaveOut);
 268 }
 269
 270 // resume playing, after audio_pause()
 271 static void audio_resume(void)
 272 {
 273         waveOutRestart(hWaveOut);
 274 }
 275
 276 // return: how many bytes can be played without blocking
 277 static int get_space(void)
 278 {
 279     int free = buf_read - buf_write - 1;
 280     if (free < 0) free += BUFFER_COUNT;
 281     return free * BUFFER_SIZE;
 282 }
 283
 284 //writes data into buffer, based on ringbuffer code in ao_sdl.c
 285 static int write_waveOutBuffer(unsigned char* data,int len){
 286   WAVEHDR* current;
 287   int len2=0;
 288   int x;
 289   while(len>0){
 290     int buf_next = (buf_write + 1) % BUFFER_COUNT;
 291     current = &waveBlocks[buf_write];
 292     if(buf_next == buf_read) break;
 293     //unprepare the header if it is prepared
 294         if(current->dwFlags & WHDR_PREPARED)
 295            waveOutUnprepareHeader(hWaveOut, current, sizeof(WAVEHDR));
 296         x=BUFFER_SIZE;
 297     if(x>len) x=len;
 298     fast_memcpy(current->lpData,data+len2,x);
 299     len2+=x; len-=x;
 300         //prepare header and write data to device
 301         current->dwBufferLength = x;
 302         waveOutPrepareHeader(hWaveOut, current, sizeof(WAVEHDR));
 303         waveOutWrite(hWaveOut, current, sizeof(WAVEHDR));
 304
 305        buf_write = buf_next;
 306   }
 307   return len2;
 308 }
 309
 310 // plays 'len' bytes of 'data'
 311 // it should round it down to outburst*n
 312 // return: number of bytes played
 313 static int play(void* data,int len,int flags)
 314 {
 315         if (!(flags & AOPLAY_FINAL_CHUNK))
 316         len = (len/ao_data.outburst)*ao_data.outburst;
 317         return write_waveOutBuffer(data,len);
 318 }
 319
 320 // return: delay in seconds between first and last sample in buffer
 321 static float get_delay(void)
 322 {
 323         int used = buf_write - buf_read;
 324         if (used < 0) used += BUFFER_COUNT;
 325         return (float)(used * BUFFER_SIZE + ao_data.buffersize)/(float)ao_data.bps;
 326 }