VirtualBox

source: vbox/trunk/src/VBox/ValidationKit/utils/audio/ntPlayToneWaveX.cpp@ 78241

Last change on this file since 78241 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.8 KB
Line 
1/* $Id: ntPlayToneWaveX.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * ????
4 */
5
6/*
7 * Copyright (C) 2012-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <iprt/win/windows.h>
32
33#include <iprt/getopt.h>
34#include <iprt/initterm.h>
35#include <iprt/message.h>
36#include <iprt/stream.h>
37#include <iprt/errcore.h>
38
39#define _USE_MATH_DEFINES
40#include <math.h>
41
42
43/*********************************************************************************************************************************
44* Global Variables *
45*********************************************************************************************************************************/
46uint32_t g_cSamplesPerSec = 44100;
47uint32_t g_cSamplesPerPeriod = 100; // 441.0Hz for 44.1kHz
48uint32_t g_cSamplesInBuffer = 4096;
49double g_rdSecDuration = 5.0;
50
51uint32_t g_cbSample; // assuming 16-bit stereo (for now)
52
53HWAVEOUT g_hWaveOut;
54HANDLE g_hWavEvent;
55
56
57int main(int argc, char **argv)
58{
59 int rc = RTR3InitExe(argc, &argv, 0);
60 if (RT_FAILURE(rc))
61 return RTMsgInitFailure(rc);
62
63 static const RTGETOPTDEF s_aOptions[] =
64 {
65 { "--samples-per-sec", 's', RTGETOPT_REQ_UINT32 },
66 { "--period-in-samples", 'p', RTGETOPT_REQ_UINT32 },
67 { "--bufsize-in-samples", 'b', RTGETOPT_REQ_UINT32 },
68 { "--total-duration-in-secs", 'd', RTGETOPT_REQ_UINT32 }
69 };
70
71 RTGETOPTSTATE State;
72 RTGetOptInit(&State, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
73 RTGETOPTUNION ValueUnion;
74 int chOpt;
75 while ((chOpt = RTGetOpt(&State, &ValueUnion)) != 0)
76 {
77 switch (chOpt)
78 {
79 case 's': g_cSamplesPerSec = ValueUnion.u32; break;
80 case 'p': g_cSamplesPerPeriod = ValueUnion.u32; break;
81 case 'b': g_cSamplesInBuffer = ValueUnion.u32; break;
82 case 'd': g_rdSecDuration = ValueUnion.u32; break;
83 case 'h':
84 RTPrintf("usage: ntPlayToneWaveX.exe\n"
85 "[-s|--samples-per-sec]\n"
86 "[-p|--period-in-samples]\n"
87 "[-b|--bufsize-in-samples]\n"
88 "[-d|--total-duration-in-secs]\n"
89 "\n"
90 "Plays sine tone using ancient waveX API\n");
91 return 0;
92
93 default:
94 return RTGetOptPrintError(chOpt, &ValueUnion);
95 }
96 }
97
98
99 WAVEFORMATEX waveFormatEx = { 0 };
100 MMRESULT mmresult;
101
102 waveFormatEx.wFormatTag = WAVE_FORMAT_PCM;
103 waveFormatEx.nChannels = 2;
104 waveFormatEx.nSamplesPerSec = g_cSamplesPerSec;
105 waveFormatEx.wBitsPerSample = 16;
106 waveFormatEx.nBlockAlign = g_cbSample = waveFormatEx.nChannels * waveFormatEx.wBitsPerSample / 8;
107 waveFormatEx.nAvgBytesPerSec = waveFormatEx.nBlockAlign * waveFormatEx.nSamplesPerSec;
108 waveFormatEx.cbSize = 0;
109
110 g_hWavEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
111 mmresult = waveOutOpen(&g_hWaveOut, WAVE_MAPPER, &waveFormatEx, (DWORD_PTR)g_hWavEvent, NULL, CALLBACK_EVENT);
112
113 if (mmresult != MMSYSERR_NOERROR)
114 {
115 RTMsgError("waveOutOpen failed with 0x%X\n", mmresult);
116 return -1;
117 }
118
119
120 uint32_t ui32SamplesToPlayTotal = (uint32_t)(g_rdSecDuration * g_cSamplesPerSec);
121 uint32_t ui32SamplesToPlay = ui32SamplesToPlayTotal;
122 uint32_t ui32SamplesPlayed = 0;
123 uint32_t ui32SamplesForWavBuf;
124
125 WAVEHDR waveHdr1 = {0}, waveHdr2 = {0}, *pWaveHdr, *pWaveHdrPlaying, *pWaveHdrWaiting;
126 uint32_t i, k;
127 DWORD res;
128
129 int16_t *i16Samples1 = (int16_t *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_cSamplesInBuffer * g_cbSample);
130 int16_t *i16Samples2 = (int16_t *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_cSamplesInBuffer * g_cbSample);
131
132 k = 0; // This is discrete time really!!!
133
134 for (i = 0; i < g_cSamplesInBuffer; i++, k++)
135 {
136 i16Samples1[2 * i] = (uint16_t)(10000.0 * sin(2.0 * M_PI * k / g_cSamplesPerPeriod));
137 i16Samples1[2 * i + 1] = i16Samples1[2 * i];
138 }
139
140 ui32SamplesForWavBuf = min(ui32SamplesToPlay, g_cSamplesInBuffer);
141
142 waveHdr1.lpData = (LPSTR)i16Samples1;
143 waveHdr1.dwBufferLength = ui32SamplesForWavBuf * g_cbSample;
144 waveHdr1.dwFlags = 0;
145 waveHdr1.dwLoops = 0;
146
147 ui32SamplesToPlay -= ui32SamplesForWavBuf;
148 ui32SamplesPlayed += ui32SamplesForWavBuf;
149
150 pWaveHdrPlaying = &waveHdr1;
151
152 mmresult = waveOutPrepareHeader(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR));
153 mmresult = waveOutWrite(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR));
154 //RTMsgInfo("waveOutWrite completes with %d\n", mmresult);
155
156 res = WaitForSingleObject(g_hWavEvent, INFINITE);
157 //RTMsgInfo("WaitForSingleObject completes with %d\n\n", res);
158
159 waveHdr2.lpData = (LPSTR)i16Samples2;
160 waveHdr2.dwBufferLength = 0;
161 waveHdr2.dwFlags = 0;
162 waveHdr2.dwLoops = 0;
163
164 pWaveHdrWaiting = &waveHdr2;
165
166 while (ui32SamplesToPlay > 0)
167 {
168 int16_t *i16Samples = (int16_t *)pWaveHdrWaiting->lpData;
169
170 for (i = 0; i < g_cSamplesInBuffer; i++, k++)
171 {
172 i16Samples[2 * i] = (uint16_t)(10000.0 * sin(2.0 * M_PI * k / g_cSamplesPerPeriod));
173 i16Samples[2 * i + 1] = i16Samples[2 * i];
174 }
175
176 ui32SamplesForWavBuf = min(ui32SamplesToPlay, g_cSamplesInBuffer);
177
178 pWaveHdrWaiting->dwBufferLength = ui32SamplesForWavBuf * g_cbSample;
179 pWaveHdrWaiting->dwFlags = 0;
180 pWaveHdrWaiting->dwLoops = 0;
181
182
183 ui32SamplesToPlay -= ui32SamplesForWavBuf;
184 ui32SamplesPlayed += ui32SamplesForWavBuf;
185
186 mmresult = waveOutPrepareHeader(g_hWaveOut, pWaveHdrWaiting, sizeof(WAVEHDR));
187 mmresult = waveOutWrite(g_hWaveOut, pWaveHdrWaiting, sizeof(WAVEHDR));
188 //RTMsgInfo("waveOutWrite completes with %d\n", mmresult);
189
190 res = WaitForSingleObject(g_hWavEvent, INFINITE);
191 //RTMsgInfo("WaitForSingleObject completes with %d\n\n", res);
192
193 mmresult = waveOutUnprepareHeader(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR));
194 //RTMsgInfo("waveOutUnprepareHeader completes with %d\n", mmresult);
195
196 pWaveHdr = pWaveHdrWaiting;
197 pWaveHdrWaiting = pWaveHdrPlaying;
198 pWaveHdrPlaying = pWaveHdr;
199 }
200
201 while (mmresult = waveOutUnprepareHeader(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR)))
202 {
203 //Expecting WAVERR_STILLPLAYING
204 //RTMsgInfo("waveOutUnprepareHeader failed with 0x%X\n", mmresult);
205 Sleep(100);
206 }
207
208 if (mmresult == MMSYSERR_NOERROR)
209 {
210 waveOutClose(g_hWaveOut);
211 }
212
213 HeapFree(GetProcessHeap(), 0, i16Samples1);
214 HeapFree(GetProcessHeap(), 0, i16Samples2);
215}
216
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette