VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/DrvHostDebugAudio.cpp@ 80957

Last change on this file since 80957 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: 11.6 KB
Line 
1/* $Id: DrvHostDebugAudio.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * Debug audio driver.
4 *
5 * Host backend for dumping and injecting audio data from/to the device emulation.
6 */
7
8/*
9 * Copyright (C) 2016-2019 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20#include <iprt/alloc.h>
21#include <iprt/uuid.h> /* For PDMIBASE_2_PDMDRV. */
22
23#define LOG_GROUP LOG_GROUP_DRV_HOST_AUDIO
24#include <VBox/log.h>
25#include <VBox/vmm/pdmaudioifs.h>
26
27#include "DrvAudio.h"
28#include "VBoxDD.h"
29
30
31/**
32 * Structure for keeping a debug input/output stream.
33 */
34typedef struct DEBUGAUDIOSTREAM
35{
36 /** The stream's acquired configuration. */
37 PPDMAUDIOSTREAMCFG pCfg;
38 /** Audio file to dump output to or read input from. */
39 PPDMAUDIOFILE pFile;
40 union
41 {
42 struct
43 {
44 /** Timestamp of last captured samples. */
45 uint64_t tsLastCaptured;
46 } In;
47 };
48} DEBUGAUDIOSTREAM, *PDEBUGAUDIOSTREAM;
49
50/**
51 * Debug audio driver instance data.
52 * @implements PDMIAUDIOCONNECTOR
53 */
54typedef struct DRVHOSTDEBUGAUDIO
55{
56 /** Pointer to the driver instance structure. */
57 PPDMDRVINS pDrvIns;
58 /** Pointer to host audio interface. */
59 PDMIHOSTAUDIO IHostAudio;
60} DRVHOSTDEBUGAUDIO, *PDRVHOSTDEBUGAUDIO;
61
62/*******************************************PDM_AUDIO_DRIVER******************************/
63
64
65/**
66 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
67 */
68static DECLCALLBACK(int) drvHostDebugAudioGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
69{
70 RT_NOREF(pInterface);
71 AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
72
73 RTStrPrintf2(pBackendCfg->szName, sizeof(pBackendCfg->szName), "Debug audio driver");
74
75 pBackendCfg->cbStreamOut = sizeof(DEBUGAUDIOSTREAM);
76 pBackendCfg->cbStreamIn = sizeof(DEBUGAUDIOSTREAM);
77
78 pBackendCfg->cMaxStreamsOut = 1; /* Output; writing to a file. */
79 pBackendCfg->cMaxStreamsIn = 0; /** @todo Right now we don't support any input (capturing, injecting from a file). */
80
81 return VINF_SUCCESS;
82}
83
84
85/**
86 * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
87 */
88static DECLCALLBACK(int) drvHostDebugAudioInit(PPDMIHOSTAUDIO pInterface)
89{
90 RT_NOREF(pInterface);
91
92 LogFlowFuncLeaveRC(VINF_SUCCESS);
93 return VINF_SUCCESS;
94}
95
96
97/**
98 * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
99 */
100static DECLCALLBACK(void) drvHostDebugAudioShutdown(PPDMIHOSTAUDIO pInterface)
101{
102 RT_NOREF(pInterface);
103}
104
105
106/**
107 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
108 */
109static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvHostDebugAudioGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
110{
111 RT_NOREF(enmDir);
112 AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
113
114 return PDMAUDIOBACKENDSTS_RUNNING;
115}
116
117
118static int debugCreateStreamIn(PDRVHOSTDEBUGAUDIO pDrv, PDEBUGAUDIOSTREAM pStreamDbg,
119 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
120{
121 RT_NOREF(pDrv, pStreamDbg, pCfgReq, pCfgAcq);
122
123 return VINF_SUCCESS;
124}
125
126
127static int debugCreateStreamOut(PDRVHOSTDEBUGAUDIO pDrv, PDEBUGAUDIOSTREAM pStreamDbg,
128 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
129{
130 RT_NOREF(pDrv, pCfgAcq);
131
132 char szTemp[RTPATH_MAX];
133 int rc = RTPathTemp(szTemp, sizeof(szTemp));
134 if (RT_SUCCESS(rc))
135 {
136 char szFile[RTPATH_MAX];
137 rc = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), szTemp, "DebugAudioOut",
138 pDrv->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAG_NONE);
139 if (RT_SUCCESS(rc))
140 {
141 rc = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAG_NONE, &pStreamDbg->pFile);
142 if (RT_SUCCESS(rc))
143 {
144 rc = DrvAudioHlpFileOpen(pStreamDbg->pFile, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE,
145 &pCfgReq->Props);
146 }
147
148 if (RT_FAILURE(rc))
149 LogRel(("DebugAudio: Creating output file '%s' failed with %Rrc\n", szFile, rc));
150 }
151 else
152 LogRel(("DebugAudio: Unable to build file name for temp dir '%s': %Rrc\n", szTemp, rc));
153 }
154 else
155 LogRel(("DebugAudio: Unable to retrieve temp dir: %Rrc\n", rc));
156
157 return rc;
158}
159
160
161/**
162 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
163 */
164static DECLCALLBACK(int) drvHostDebugAudioStreamCreate(PPDMIHOSTAUDIO pInterface,
165 PPDMAUDIOBACKENDSTREAM pStream,
166 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
167{
168 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
169 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
170 AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
171 AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
172
173 PDRVHOSTDEBUGAUDIO pDrv = RT_FROM_MEMBER(pInterface, DRVHOSTDEBUGAUDIO, IHostAudio);
174 PDEBUGAUDIOSTREAM pStreamDbg = (PDEBUGAUDIOSTREAM)pStream;
175
176 int rc;
177 if (pCfgReq->enmDir == PDMAUDIODIR_IN)
178 rc = debugCreateStreamIn( pDrv, pStreamDbg, pCfgReq, pCfgAcq);
179 else
180 rc = debugCreateStreamOut(pDrv, pStreamDbg, pCfgReq, pCfgAcq);
181
182 if (RT_SUCCESS(rc))
183 {
184 pStreamDbg->pCfg = DrvAudioHlpStreamCfgDup(pCfgAcq);
185 if (!pStreamDbg->pCfg)
186 rc = VERR_NO_MEMORY;
187 }
188
189 return rc;
190}
191
192
193/**
194 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
195 */
196static DECLCALLBACK(int) drvHostDebugAudioStreamPlay(PPDMIHOSTAUDIO pInterface,
197 PPDMAUDIOBACKENDSTREAM pStream, const void *pvBuf, uint32_t cxBuf,
198 uint32_t *pcxWritten)
199{
200 RT_NOREF(pInterface);
201 PDEBUGAUDIOSTREAM pStreamDbg = (PDEBUGAUDIOSTREAM)pStream;
202
203 int rc = DrvAudioHlpFileWrite(pStreamDbg->pFile, pvBuf, cxBuf, 0 /* fFlags */);
204 if (RT_FAILURE(rc))
205 {
206 LogRel(("DebugAudio: Writing output failed with %Rrc\n", rc));
207 return rc;
208 }
209
210 if (pcxWritten)
211 *pcxWritten = cxBuf;
212
213 return VINF_SUCCESS;
214}
215
216
217/**
218 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
219 */
220static DECLCALLBACK(int) drvHostDebugAudioStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
221 void *pvBuf, uint32_t cxBuf, uint32_t *pcxRead)
222{
223 RT_NOREF(pInterface, pStream, pvBuf, cxBuf);
224
225 /* Never capture anything. */
226 if (pcxRead)
227 *pcxRead = 0;
228
229 return VINF_SUCCESS;
230}
231
232
233static int debugDestroyStreamIn(PDRVHOSTDEBUGAUDIO pDrv, PDEBUGAUDIOSTREAM pStreamDbg)
234{
235 RT_NOREF(pDrv, pStreamDbg);
236 return VINF_SUCCESS;
237}
238
239
240static int debugDestroyStreamOut(PDRVHOSTDEBUGAUDIO pDrv, PDEBUGAUDIOSTREAM pStreamDbg)
241{
242 RT_NOREF(pDrv);
243
244 DrvAudioHlpFileDestroy(pStreamDbg->pFile);
245
246 return VINF_SUCCESS;
247}
248
249
250/**
251 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
252 */
253static DECLCALLBACK(int) drvHostDebugAudioStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
254{
255 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
256
257 PDRVHOSTDEBUGAUDIO pDrv = RT_FROM_MEMBER(pInterface, DRVHOSTDEBUGAUDIO, IHostAudio);
258 PDEBUGAUDIOSTREAM pStreamDbg = (PDEBUGAUDIOSTREAM)pStream;
259
260 if (!pStreamDbg->pCfg) /* Not (yet) configured? Skip. */
261 return VINF_SUCCESS;
262
263 int rc;
264 if (pStreamDbg->pCfg->enmDir == PDMAUDIODIR_IN)
265 rc = debugDestroyStreamIn (pDrv, pStreamDbg);
266 else
267 rc = debugDestroyStreamOut(pDrv, pStreamDbg);
268
269 if (RT_SUCCESS(rc))
270 {
271 DrvAudioHlpStreamCfgFree(pStreamDbg->pCfg);
272 pStreamDbg->pCfg = NULL;
273 }
274
275 return rc;
276}
277
278
279/**
280 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
281 */
282static DECLCALLBACK(int) drvHostDebugAudioStreamControl(PPDMIHOSTAUDIO pInterface,
283 PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
284{
285 RT_NOREF(enmStreamCmd);
286 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
287 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
288
289 return VINF_SUCCESS;
290}
291
292
293/**
294 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
295 */
296static DECLCALLBACK(uint32_t) drvHostDebugAudioStreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
297{
298 RT_NOREF(pInterface, pStream);
299
300 return 0; /* Never capture anything. */
301}
302
303
304/**
305 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
306 */
307static DECLCALLBACK(uint32_t) drvHostDebugAudioStreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
308{
309 RT_NOREF(pInterface, pStream);
310
311 return UINT32_MAX;
312}
313
314
315/**
316 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
317 */
318static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvHostDebugAudioStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
319{
320 RT_NOREF(pInterface, pStream);
321
322 return (PDMAUDIOSTREAMSTS_FLAG_INITIALIZED | PDMAUDIOSTREAMSTS_FLAG_ENABLED);
323}
324
325
326/**
327 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
328 */
329static DECLCALLBACK(int) drvHostDebugAudioStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
330{
331 RT_NOREF(pInterface, pStream);
332 return VINF_SUCCESS;
333}
334
335
336/**
337 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
338 */
339static DECLCALLBACK(void *) drvHostDebugAudioQueryInterface(PPDMIBASE pInterface, const char *pszIID)
340{
341 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
342 PDRVHOSTDEBUGAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDEBUGAUDIO);
343
344 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
345 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
346 return NULL;
347}
348
349
350/**
351 * Constructs a Null audio driver instance.
352 *
353 * @copydoc FNPDMDRVCONSTRUCT
354 */
355static DECLCALLBACK(int) drvHostDebugAudioConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
356{
357 RT_NOREF(pCfg, fFlags);
358 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
359 PDRVHOSTDEBUGAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTDEBUGAUDIO);
360 LogRel(("Audio: Initializing DEBUG driver\n"));
361
362 /*
363 * Init the static parts.
364 */
365 pThis->pDrvIns = pDrvIns;
366 /* IBase */
367 pDrvIns->IBase.pfnQueryInterface = drvHostDebugAudioQueryInterface;
368 /* IHostAudio */
369 PDMAUDIO_IHOSTAUDIO_CALLBACKS(drvHostDebugAudio);
370
371#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
372 RTFileDelete(VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "AudioDebugOutput.pcm");
373#endif
374
375 return VINF_SUCCESS;
376}
377
378/**
379 * Char driver registration record.
380 */
381const PDMDRVREG g_DrvHostDebugAudio =
382{
383 /* u32Version */
384 PDM_DRVREG_VERSION,
385 /* szName */
386 "DebugAudio",
387 /* szRCMod */
388 "",
389 /* szR0Mod */
390 "",
391 /* pszDescription */
392 "Debug audio host driver",
393 /* fFlags */
394 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
395 /* fClass. */
396 PDM_DRVREG_CLASS_AUDIO,
397 /* cMaxInstances */
398 ~0U,
399 /* cbInstance */
400 sizeof(DRVHOSTDEBUGAUDIO),
401 /* pfnConstruct */
402 drvHostDebugAudioConstruct,
403 /* pfnDestruct */
404 NULL,
405 /* pfnRelocate */
406 NULL,
407 /* pfnIOCtl */
408 NULL,
409 /* pfnPowerOn */
410 NULL,
411 /* pfnReset */
412 NULL,
413 /* pfnSuspend */
414 NULL,
415 /* pfnResume */
416 NULL,
417 /* pfnAttach */
418 NULL,
419 /* pfnDetach */
420 NULL,
421 /* pfnPowerOff */
422 NULL,
423 /* pfnSoftReset */
424 NULL,
425 /* u32EndVersion */
426 PDM_DRVREG_VERSION
427};
428
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