VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/DrvAudioVideoRec.cpp@ 73541

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

Build fix.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 37.2 KB
Line 
1/* $Id: DrvAudioVideoRec.cpp 73541 2018-08-07 11:45:00Z vboxsync $ */
2/** @file
3 * Video recording audio backend for Main.
4 */
5
6/*
7 * Copyright (C) 2016-2017 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
18/* This code makes use of the Opus codec (libopus):
19 *
20 * Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic,
21 * Jean-Marc Valin, Timothy B. Terriberry,
22 * CSIRO, Gregory Maxwell, Mark Borgerding,
23 * Erik de Castro Lopo
24 *
25 * Redistribution and use in source and binary forms, with or without
26 * modification, are permitted provided that the following conditions
27 * are met:
28 *
29 * - Redistributions of source code must retain the above copyright
30 * notice, this list of conditions and the following disclaimer.
31 *
32 * - Redistributions in binary form must reproduce the above copyright
33 * notice, this list of conditions and the following disclaimer in the
34 * documentation and/or other materials provided with the distribution.
35 *
36 * - Neither the name of Internet Society, IETF or IETF Trust, nor the
37 * names of specific contributors, may be used to endorse or promote
38 * products derived from this software without specific prior written
39 * permission.
40 *
41 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
42 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
43 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
44 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
45 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
46 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
47 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
48 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
49 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
50 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
51 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 *
53 * Opus is subject to the royalty-free patent licenses which are
54 * specified at:
55 *
56 * Xiph.Org Foundation:
57 * https://datatracker.ietf.org/ipr/1524/
58 *
59 * Microsoft Corporation:
60 * https://datatracker.ietf.org/ipr/1914/
61 *
62 * Broadcom Corporation:
63 * https://datatracker.ietf.org/ipr/1526/
64 *
65 */
66
67/**
68 * This driver is part of Main and is responsible for providing audio
69 * data to Main's video capturing feature.
70 *
71 * The driver itself implements a PDM host audio backend, which in turn
72 * provides the driver with the required audio data and audio events.
73 *
74 * For now there is support for the following destinations (called "sinks"):
75 *
76 * - Direct writing of .webm files to the host.
77 * - Communicating with Main via the Console object to send the encoded audio data to.
78 * The Console object in turn then will route the data to the Display / video capturing interface then.
79 */
80
81
82/*********************************************************************************************************************************
83* Header Files *
84*********************************************************************************************************************************/
85#define LOG_GROUP LOG_GROUP_DRV_HOST_AUDIO
86#include "LoggingNew.h"
87
88#include "DrvAudioVideoRec.h"
89#include "ConsoleImpl.h"
90
91#include "../../Devices/Audio/DrvAudio.h"
92#include "WebMWriter.h"
93
94#include <iprt/mem.h>
95#include <iprt/cdefs.h>
96
97#include <VBox/vmm/pdmaudioifs.h>
98#include <VBox/vmm/pdmdrv.h>
99#include <VBox/vmm/cfgm.h>
100#include <VBox/err.h>
101
102#ifdef VBOX_WITH_LIBOPUS
103# include <opus.h>
104#endif
105
106
107/*********************************************************************************************************************************
108* Defines *
109*********************************************************************************************************************************/
110
111#define AVREC_OPUS_HZ_MAX 48000 /** Maximum sample rate (in Hz) Opus can handle. */
112
113
114/*********************************************************************************************************************************
115* Structures and Typedefs *
116*********************************************************************************************************************************/
117
118/**
119 * Enumeration for specifying the recording container type.
120 */
121typedef enum AVRECCONTAINERTYPE
122{
123 /** Unknown / invalid container type. */
124 AVRECCONTAINERTYPE_UNKNOWN = 0,
125 /** Recorded data goes to Main / Console. */
126 AVRECCONTAINERTYPE_MAIN_CONSOLE = 1,
127 /** Recorded data will be written to a .webm file. */
128 AVRECCONTAINERTYPE_WEBM = 2
129} AVRECCONTAINERTYPE;
130
131/**
132 * Structure for keeping generic container parameters.
133 */
134typedef struct AVRECCONTAINERPARMS
135{
136 /** The container's type. */
137 AVRECCONTAINERTYPE enmType;
138
139} AVRECCONTAINERPARMS, *PAVRECCONTAINERPARMS;
140
141/**
142 * Structure for keeping container-specific data.
143 */
144typedef struct AVRECCONTAINER
145{
146 /** Generic container parameters. */
147 AVRECCONTAINERPARMS Parms;
148
149 union
150 {
151 struct
152 {
153 /** Pointer to Console. */
154 Console *pConsole;
155 } Main;
156
157 struct
158 {
159 /** Pointer to WebM container to write recorded audio data to.
160 * See the AVRECMODE enumeration for more information. */
161 WebMWriter *pWebM;
162 /** Assigned track number from WebM container. */
163 uint8_t uTrack;
164 } WebM;
165 };
166} AVRECCONTAINER, *PAVRECCONTAINER;
167
168/**
169 * Structure for keeping generic codec parameters.
170 */
171typedef struct AVRECCODECPARMS
172{
173 /** The encoding rate to use. */
174 uint32_t uHz;
175 /** Number of audio channels to encode.
176 * Currently we only supported stereo (2) channels. */
177 uint8_t cChannels;
178 /** Bits per sample. */
179 uint8_t cBits;
180 /** The codec's bitrate. 0 if not used / cannot be specified. */
181 uint32_t uBitrate;
182
183} AVRECCODECPARMS, *PAVRECCODECPARMS;
184
185/**
186 * Structure for keeping codec-specific data.
187 */
188typedef struct AVRECCODEC
189{
190 /** Generic codec parameters. */
191 AVRECCODECPARMS Parms;
192 union
193 {
194#ifdef VBOX_WITH_LIBOPUS
195 struct
196 {
197 /** Encoder we're going to use. */
198 OpusEncoder *pEnc;
199 /** Time (in ms) an (encoded) frame takes.
200 *
201 * For Opus, valid frame sizes are:
202 * ms Frame size
203 * 2.5 120
204 * 5 240
205 * 10 480
206 * 20 (Default) 960
207 * 40 1920
208 * 60 2880
209 */
210 uint32_t msFrame;
211 } Opus;
212#endif /* VBOX_WITH_LIBOPUS */
213 };
214
215#ifdef VBOX_WITH_STATISTICS /** @todo Make these real STAM values. */
216 struct
217 {
218 /** Number of frames encoded. */
219 uint64_t cEncFrames;
220 /** Total time (in ms) of already encoded audio data. */
221 uint64_t msEncTotal;
222 } STAM;
223#endif /* VBOX_WITH_STATISTICS */
224
225} AVRECCODEC, *PAVRECCODEC;
226
227typedef struct AVRECSINK
228{
229 /** @todo Add types for container / codec as soon as we implement more stuff. */
230
231 /** Container data to use for data processing. */
232 AVRECCONTAINER Con;
233 /** Codec data this sink uses for encoding. */
234 AVRECCODEC Codec;
235 /** Timestamp (in ms) of when the sink was created. */
236 uint64_t tsStartMs;
237} AVRECSINK, *PAVRECSINK;
238
239/**
240 * Audio video recording (output) stream.
241 */
242typedef struct AVRECSTREAM
243{
244 /** The stream's acquired configuration. */
245 PPDMAUDIOSTREAMCFG pCfg;
246 /** (Audio) frame buffer. */
247 PRTCIRCBUF pCircBuf;
248 /** Pointer to sink to use for writing. */
249 PAVRECSINK pSink;
250 /** Last encoded PTS (in ms). */
251 uint64_t uLastPTSMs;
252} AVRECSTREAM, *PAVRECSTREAM;
253
254/**
255 * Video recording audio driver instance data.
256 */
257typedef struct DRVAUDIOVIDEOREC
258{
259 /** Pointer to audio video recording object. */
260 AudioVideoRec *pAudioVideoRec;
261 /** Pointer to the driver instance structure. */
262 PPDMDRVINS pDrvIns;
263 /** Pointer to host audio interface. */
264 PDMIHOSTAUDIO IHostAudio;
265 /** Pointer to the console object. */
266 ComPtr<Console> pConsole;
267 /** Pointer to the DrvAudio port interface that is above us. */
268 PPDMIAUDIOCONNECTOR pDrvAudio;
269 /** The driver's sink for writing output to. */
270 AVRECSINK Sink;
271} DRVAUDIOVIDEOREC, *PDRVAUDIOVIDEOREC;
272
273/** Makes DRVAUDIOVIDEOREC out of PDMIHOSTAUDIO. */
274#define PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface) /* (clang doesn't think it is a POD, thus _DYN.) */ \
275 ( (PDRVAUDIOVIDEOREC)((uintptr_t)pInterface - RT_UOFFSETOF_DYN(DRVAUDIOVIDEOREC, IHostAudio)) )
276
277/**
278 * Initializes a recording sink.
279 *
280 * @returns IPRT status code.
281 * @param pThis Driver instance.
282 * @param pSink Sink to initialize.
283 * @param pConParms Container parameters to set.
284 * @param pCodecParms Codec parameters to set.
285 */
286static int avRecSinkInit(PDRVAUDIOVIDEOREC pThis, PAVRECSINK pSink, PAVRECCONTAINERPARMS pConParms, PAVRECCODECPARMS pCodecParms)
287{
288 uint32_t uHz = pCodecParms->uHz;
289 uint8_t cBits = pCodecParms->cBits;
290 uint8_t cChannels = pCodecParms->cChannels;
291 uint32_t uBitrate = pCodecParms->uBitrate;
292
293 /* Opus only supports certain input sample rates in an efficient manner.
294 * So make sure that we use those by resampling the data to the requested rate. */
295 if (uHz > 24000) uHz = AVREC_OPUS_HZ_MAX;
296 else if (uHz > 16000) uHz = 24000;
297 else if (uHz > 12000) uHz = 16000;
298 else if (uHz > 8000 ) uHz = 12000;
299 else uHz = 8000;
300
301 if (cChannels > 2)
302 {
303 LogRel(("VideoRec: More than 2 (stereo) channels are not supported at the moment\n"));
304 cChannels = 2;
305 }
306
307 LogRel2(("VideoRec: Recording audio in %RU16Hz, %RU8 channels, %RU32 bitrate\n", uHz, cChannels, uBitrate));
308
309 int orc;
310 OpusEncoder *pEnc = opus_encoder_create(uHz, cChannels, OPUS_APPLICATION_AUDIO, &orc);
311 if (orc != OPUS_OK)
312 {
313 LogRel(("VideoRec: Audio codec failed to initialize: %s\n", opus_strerror(orc)));
314 return VERR_AUDIO_BACKEND_INIT_FAILED;
315 }
316
317 AssertPtr(pEnc);
318
319 opus_encoder_ctl(pEnc, OPUS_SET_BITRATE(uBitrate));
320 if (orc != OPUS_OK)
321 {
322 opus_encoder_destroy(pEnc);
323 pEnc = NULL;
324
325 LogRel(("VideoRec: Audio codec failed to set bitrate (%RU32): %s\n", uBitrate, opus_strerror(orc)));
326 return VERR_AUDIO_BACKEND_INIT_FAILED;
327 }
328
329 int rc = VINF_SUCCESS;
330
331 try
332 {
333 switch (pConParms->enmType)
334 {
335 case AVRECCONTAINERTYPE_MAIN_CONSOLE:
336 {
337 if (pThis->pConsole)
338 {
339 pSink->Con.Main.pConsole = pThis->pConsole;
340 }
341 else
342 rc = VERR_NOT_SUPPORTED;
343 break;
344 }
345
346 case AVRECCONTAINERTYPE_WEBM:
347 {
348#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
349 /* If we only record audio, create our own WebM writer instance here. */
350 if (!pSink->Con.WebM.pWebM) /* Do we already have our WebM writer instance? */
351 {
352 char szFile[RTPATH_MAX];
353 if (RTStrPrintf(szFile, sizeof(szFile), "%s%s",
354 VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH, "DrvAudioVideoRec.webm"))
355 {
356 /** @todo Add sink name / number to file name. */
357
358 pSink->Con.WebM.pWebM = new WebMWriter();
359 rc = pSink->Con.WebM.pWebM->Create(szFile,
360 /** @todo Add option to add some suffix if file exists instead of overwriting? */
361 RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE,
362 WebMWriter::AudioCodec_Opus, WebMWriter::VideoCodec_None);
363 if (RT_SUCCESS(rc))
364 {
365 rc = pSink->Con.WebM.pWebM->AddAudioTrack(uHz, cChannels, cBits,
366 &pSink->Con.WebM.uTrack);
367 if (RT_SUCCESS(rc))
368 {
369 LogRel(("VideoRec: Recording audio to file '%s'\n", szFile));
370 }
371 else
372 LogRel(("VideoRec: Error creating audio track for file '%s' (%Rrc)\n", szFile, rc));
373 }
374 else
375 LogRel(("VideoRec: Error creating audio file '%s' (%Rrc)\n", szFile, rc));
376 }
377 else
378 {
379 AssertFailed(); /* Should never happen. */
380 LogRel(("VideoRec: Error creating audio file path\n"));
381 }
382 }
383#else
384 rc = VERR_NOT_SUPPORTED;
385#endif /* VBOX_AUDIO_DEBUG_DUMP_PCM_DATA */
386 break;
387 }
388
389 default:
390 rc = VERR_NOT_SUPPORTED;
391 break;
392 }
393 }
394 catch (std::bad_alloc &)
395 {
396#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
397 rc = VERR_NO_MEMORY;
398#endif
399 }
400
401 if (RT_SUCCESS(rc))
402 {
403 pSink->Con.Parms.enmType = pConParms->enmType;
404
405 pSink->Codec.Parms.uHz = uHz;
406 pSink->Codec.Parms.cChannels = cChannels;
407 pSink->Codec.Parms.cBits = cBits;
408 pSink->Codec.Parms.uBitrate = uBitrate;
409
410 pSink->Codec.Opus.pEnc = pEnc;
411 pSink->Codec.Opus.msFrame = 20; /** @todo 20 ms of audio data. Make this configurable? */
412
413#ifdef VBOX_WITH_STATISTICS
414 pSink->Codec.STAM.cEncFrames = 0;
415 pSink->Codec.STAM.msEncTotal = 0;
416#endif
417
418 pSink->tsStartMs = RTTimeMilliTS();
419 }
420 else
421 {
422 if (pEnc)
423 {
424 opus_encoder_destroy(pEnc);
425 pEnc = NULL;
426 }
427
428 LogRel(("VideoRec: Error creating sink (%Rrc)\n", rc));
429 }
430
431 return rc;
432}
433
434
435/**
436 * Shuts down (closes) a recording sink,
437 *
438 * @returns IPRT status code.
439 * @param pSink Recording sink to shut down.
440 */
441static void avRecSinkShutdown(PAVRECSINK pSink)
442{
443 AssertPtrReturnVoid(pSink);
444
445#ifdef VBOX_WITH_LIBOPUS
446 if (pSink->Codec.Opus.pEnc)
447 {
448 opus_encoder_destroy(pSink->Codec.Opus.pEnc);
449 pSink->Codec.Opus.pEnc = NULL;
450 }
451#endif
452 switch (pSink->Con.Parms.enmType)
453 {
454 case AVRECCONTAINERTYPE_WEBM:
455 {
456 if (pSink->Con.WebM.pWebM)
457 {
458 LogRel2(("VideoRec: Finished recording audio to file '%s' (%zu bytes)\n",
459 pSink->Con.WebM.pWebM->GetFileName().c_str(), pSink->Con.WebM.pWebM->GetFileSize()));
460
461 int rc2 = pSink->Con.WebM.pWebM->Close();
462 AssertRC(rc2);
463
464 delete pSink->Con.WebM.pWebM;
465 pSink->Con.WebM.pWebM = NULL;
466 }
467 break;
468 }
469
470 case AVRECCONTAINERTYPE_MAIN_CONSOLE:
471 default:
472 break;
473 }
474}
475
476
477/**
478 * Creates an audio output stream and associates it with the specified recording sink.
479 *
480 * @returns IPRT status code.
481 * @param pThis Driver instance.
482 * @param pStreamAV Audio output stream to create.
483 * @param pSink Recording sink to associate audio output stream to.
484 * @param pCfgReq Requested configuration by the audio backend.
485 * @param pCfgAcq Acquired configuration by the audio output stream.
486 */
487static int avRecCreateStreamOut(PDRVAUDIOVIDEOREC pThis, PAVRECSTREAM pStreamAV,
488 PAVRECSINK pSink, PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
489{
490 AssertPtrReturn(pThis, VERR_INVALID_POINTER);
491 AssertPtrReturn(pStreamAV, VERR_INVALID_POINTER);
492 AssertPtrReturn(pSink, VERR_INVALID_POINTER);
493 AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
494 AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
495
496 if (pCfgReq->DestSource.Dest != PDMAUDIOPLAYBACKDEST_FRONT)
497 {
498 AssertFailed();
499
500 LogRel2(("VideoRec: Support for surround audio not implemented yet\n"));
501 return VERR_NOT_SUPPORTED;
502 }
503
504 int rc = VINF_SUCCESS;
505
506#ifdef VBOX_WITH_LIBOPUS
507 const unsigned cFrames = 2; /** @todo Use the PreRoll param for that? */
508
509 const uint32_t csFrame = pSink->Codec.Parms.uHz / (1000 /* s in ms */ / pSink->Codec.Opus.msFrame);
510 const uint32_t cbFrame = csFrame * pSink->Codec.Parms.cChannels * (pSink->Codec.Parms.cBits / 8 /* Bytes */);
511
512 rc = RTCircBufCreate(&pStreamAV->pCircBuf, cbFrame * cFrames);
513 if (RT_SUCCESS(rc))
514 {
515 pStreamAV->pSink = pSink; /* Assign sink to stream. */
516 pStreamAV->uLastPTSMs = 0;
517
518 if (pCfgAcq)
519 {
520 /* Make sure to let the driver backend know that we need the audio data in
521 * a specific sampling rate Opus is optimized for. */
522 pCfgAcq->Props.uHz = pSink->Codec.Parms.uHz;
523 pCfgAcq->Props.cShift = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfgAcq->Props.cBytes, pCfgAcq->Props.cChannels);
524
525 /* Every Opus frame marks a period for now. Optimize this later. */
526 pCfgAcq->Backend.cfPeriod = DrvAudioHlpMilliToFrames(pSink->Codec.Opus.msFrame, &pCfgAcq->Props); /** @todo Make this configurable. */
527 }
528 }
529#else
530 RT_NOREF(pThis, pSink, pStreamAV, pCfgReq, pCfgAcq);
531 rc = VERR_NOT_SUPPORTED;
532#endif /* VBOX_WITH_LIBOPUS */
533
534 LogFlowFuncLeaveRC(rc);
535 return rc;
536}
537
538
539/**
540 * Destroys (closes) an audio output stream.
541 *
542 * @returns IPRT status code.
543 * @param pThis Driver instance.
544 * @param pStreamAV Audio output stream to destroy.
545 */
546static int avRecDestroyStreamOut(PDRVAUDIOVIDEOREC pThis, PAVRECSTREAM pStreamAV)
547{
548 RT_NOREF(pThis);
549
550 if (pStreamAV->pCircBuf)
551 {
552 RTCircBufDestroy(pStreamAV->pCircBuf);
553 pStreamAV->pCircBuf = NULL;
554 }
555
556 return VINF_SUCCESS;
557}
558
559
560/**
561 * Controls an audio output stream
562 *
563 * @returns IPRT status code.
564 * @param pThis Driver instance.
565 * @param pStreamAV Audio output stream to control.
566 * @param enmStreamCmd Stream command to issue.
567 */
568static int avRecControlStreamOut(PDRVAUDIOVIDEOREC pThis,
569 PAVRECSTREAM pStreamAV, PDMAUDIOSTREAMCMD enmStreamCmd)
570{
571 RT_NOREF(pThis, pStreamAV);
572
573 int rc = VINF_SUCCESS;
574
575 switch (enmStreamCmd)
576 {
577 case PDMAUDIOSTREAMCMD_ENABLE:
578 case PDMAUDIOSTREAMCMD_DISABLE:
579 case PDMAUDIOSTREAMCMD_RESUME:
580 case PDMAUDIOSTREAMCMD_PAUSE:
581 break;
582
583 default:
584 rc = VERR_NOT_SUPPORTED;
585 break;
586 }
587 }
588
589 return rc;
590}
591
592
593/**
594 * @interface_method_impl{PDMIHOSTAUDIO,pfnInit}
595 */
596static DECLCALLBACK(int) drvAudioVideoRecInit(PPDMIHOSTAUDIO pInterface)
597{
598 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
599
600 LogFlowFuncEnter();
601
602 PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
603
604 AVRECCONTAINERPARMS ContainerParms;
605 ContainerParms.enmType = AVRECCONTAINERTYPE_MAIN_CONSOLE; /** @todo Make this configurable. */
606
607 AVRECCODECPARMS CodecParms;
608 CodecParms.uHz = AVREC_OPUS_HZ_MAX; /** @todo Make this configurable. */
609 CodecParms.cChannels = 2; /** @todo Make this configurable. */
610 CodecParms.cBits = 16; /** @todo Make this configurable. */
611 CodecParms.uBitrate = 196000; /** @todo Make this configurable. */
612
613 int rc = avRecSinkInit(pThis, &pThis->Sink, &ContainerParms, &CodecParms);
614 if (RT_FAILURE(rc))
615 {
616 LogRel(("VideoRec: Audio recording driver failed to initialize, rc=%Rrc\n", rc));
617 }
618 else
619 LogRel2(("VideoRec: Audio recording driver initialized\n"));
620
621 return rc;
622}
623
624
625/**
626 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCapture}
627 */
628static DECLCALLBACK(int) drvAudioVideoRecStreamCapture(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
629 void *pvBuf, uint32_t cxBuf, uint32_t *pcxRead)
630{
631 RT_NOREF(pInterface, pStream, pvBuf, cxBuf);
632
633 if (pcxRead)
634 *pcxRead = 0;
635
636 return VINF_SUCCESS;
637}
638
639
640/**
641 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamPlay}
642 */
643static DECLCALLBACK(int) drvAudioVideoRecStreamPlay(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
644 const void *pvBuf, uint32_t cxBuf, uint32_t *pcxWritten)
645{
646 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
647 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
648 AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
649 AssertReturn(cxBuf, VERR_INVALID_PARAMETER);
650 /* pcxWritten is optional. */
651
652 PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
653 RT_NOREF(pThis);
654 PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream;
655
656 int rc = VINF_SUCCESS;
657
658 uint32_t cbWrittenTotal = 0;
659
660 /*
661 * Call the encoder with the data.
662 */
663#ifdef VBOX_WITH_LIBOPUS
664 PAVRECSINK pSink = pStreamAV->pSink;
665 AssertPtr(pSink);
666 PRTCIRCBUF pCircBuf = pStreamAV->pCircBuf;
667 AssertPtr(pCircBuf);
668
669 void *pvCircBuf;
670 size_t cbCircBuf;
671
672 uint32_t cbToWrite = cxBuf;
673
674 /*
675 * Fetch as much as we can into our internal ring buffer.
676 */
677 while ( cbToWrite
678 && RTCircBufFree(pCircBuf))
679 {
680 RTCircBufAcquireWriteBlock(pCircBuf, cbToWrite, &pvCircBuf, &cbCircBuf);
681
682 if (cbCircBuf)
683 {
684 memcpy(pvCircBuf, (uint8_t *)pvBuf + cbWrittenTotal, cbCircBuf),
685 cbWrittenTotal += (uint32_t)cbCircBuf;
686 Assert(cbToWrite >= cbCircBuf);
687 cbToWrite -= (uint32_t)cbCircBuf;
688 }
689
690 RTCircBufReleaseWriteBlock(pCircBuf, cbCircBuf);
691
692 if ( RT_FAILURE(rc)
693 || !cbCircBuf)
694 {
695 break;
696 }
697 }
698
699 /*
700 * Process our internal ring buffer and encode the data.
701 */
702
703 uint8_t abSrc[_64K]; /** @todo Fix! */
704 size_t cbSrc;
705
706 const uint32_t csFrame = pSink->Codec.Parms.uHz / (1000 /* s in ms */ / pSink->Codec.Opus.msFrame);
707 const uint32_t cbFrame = csFrame * pSink->Codec.Parms.cChannels * (pSink->Codec.Parms.cBits / 8 /* Bytes */);
708
709 /* Only encode data if we have data for the given time period (or more). */
710 while (RTCircBufUsed(pCircBuf) >= cbFrame)
711 {
712 cbSrc = 0;
713
714 while (cbSrc < cbFrame)
715 {
716 RTCircBufAcquireReadBlock(pCircBuf, cbFrame - cbSrc, &pvCircBuf, &cbCircBuf);
717
718 if (cbCircBuf)
719 {
720 memcpy(&abSrc[cbSrc], pvCircBuf, cbCircBuf);
721
722 cbSrc += cbCircBuf;
723 Assert(cbSrc <= sizeof(abSrc));
724 }
725
726 RTCircBufReleaseReadBlock(pCircBuf, cbCircBuf);
727
728 if (!cbCircBuf)
729 break;
730 }
731
732# ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
733 RTFILE fh;
734 RTFileOpen(&fh, VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "DrvAudioVideoRec.pcm",
735 RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
736 RTFileWrite(fh, abSrc, cbSrc, NULL);
737 RTFileClose(fh);
738# endif
739
740 Assert(cbSrc == cbFrame);
741
742 /*
743 * Opus always encodes PER FRAME, that is, exactly 2.5, 5, 10, 20, 40 or 60 ms of audio data.
744 *
745 * A packet can have up to 120ms worth of audio data.
746 * Anything > 120ms of data will result in a "corrupted package" error message by
747 * by decoding application.
748 */
749 uint8_t abDst[_64K]; /** @todo Fix! */
750 size_t cbDst = sizeof(abDst);
751
752 /* Call the encoder to encode one frame per iteration. */
753 opus_int32 cbWritten = opus_encode(pSink->Codec.Opus.pEnc,
754 (opus_int16 *)abSrc, csFrame, abDst, (opus_int32)cbDst);
755 if (cbWritten > 0)
756 {
757 /* Get overall frames encoded. */
758 const uint32_t cEncFrames = opus_packet_get_nb_frames(abDst, cbWritten);
759
760# ifdef VBOX_WITH_STATISTICS
761 pSink->Codec.STAM.cEncFrames += cEncFrames;
762 pSink->Codec.STAM.msEncTotal += pSink->Codec.Opus.msFrame * cEncFrames;
763
764 LogFunc(("%RU64ms [%RU64 frames]: cbSrc=%zu, cbDst=%zu, cEncFrames=%RU32\n",
765 pSink->Codec.STAM.msEncTotal, pSink->Codec.STAM.cEncFrames, cbSrc, cbDst, cEncFrames));
766# endif
767 Assert((uint32_t)cbWritten <= cbDst);
768 cbDst = RT_MIN((uint32_t)cbWritten, cbDst); /* Update cbDst to actual bytes encoded (written). */
769
770 Assert(cEncFrames == 1); /* At the moment we encode exactly *one* frame per frame. */
771
772 if (pStreamAV->uLastPTSMs == 0)
773 pStreamAV->uLastPTSMs = RTTimeMilliTS() - pSink->tsStartMs;
774
775 const uint64_t uDurationMs = pSink->Codec.Opus.msFrame * cEncFrames;
776 const uint64_t uPTSMs = pStreamAV->uLastPTSMs + uDurationMs;
777
778 pStreamAV->uLastPTSMs += uDurationMs;
779
780 switch (pSink->Con.Parms.enmType)
781 {
782 case AVRECCONTAINERTYPE_MAIN_CONSOLE:
783 {
784 HRESULT hr = pSink->Con.Main.pConsole->i_audioVideoRecSendAudio(abDst, cbDst, uPTSMs);
785 Assert(hr == S_OK);
786 RT_NOREF(hr);
787
788 break;
789 }
790
791 case AVRECCONTAINERTYPE_WEBM:
792 {
793 WebMWriter::BlockData_Opus blockData = { abDst, cbDst, uPTSMs };
794 rc = pSink->Con.WebM.pWebM->WriteBlock(pSink->Con.WebM.uTrack, &blockData, sizeof(blockData));
795 AssertRC(rc);
796
797 break;
798 }
799
800 default:
801 AssertFailedStmt(rc = VERR_NOT_IMPLEMENTED);
802 break;
803 }
804 }
805 else if (cbWritten < 0)
806 {
807 AssertMsgFailed(("Encoding failed: %s\n", opus_strerror(cbWritten)));
808 rc = VERR_INVALID_PARAMETER;
809 }
810
811 if (RT_FAILURE(rc))
812 break;
813 }
814
815 if (pcxWritten)
816 *pcxWritten = cbWrittenTotal;
817#else
818 /* Report back all data as being processed. */
819 if (pcxWritten)
820 *pcxWritten = cxBuf;
821
822 rc = VERR_NOT_SUPPORTED;
823#endif /* VBOX_WITH_LIBOPUS */
824
825 LogFlowFunc(("csReadTotal=%RU32, rc=%Rrc\n", cbWrittenTotal, rc));
826 return rc;
827}
828
829
830/**
831 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetConfig}
832 */
833static DECLCALLBACK(int) drvAudioVideoRecGetConfig(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDCFG pBackendCfg)
834{
835 RT_NOREF(pInterface);
836 AssertPtrReturn(pBackendCfg, VERR_INVALID_POINTER);
837
838 pBackendCfg->cbStreamOut = sizeof(AVRECSTREAM);
839 pBackendCfg->cbStreamIn = 0;
840 pBackendCfg->cMaxStreamsIn = 0;
841 pBackendCfg->cMaxStreamsOut = UINT32_MAX;
842
843 return VINF_SUCCESS;
844}
845
846
847/**
848 * @interface_method_impl{PDMIHOSTAUDIO,pfnShutdown}
849 */
850static DECLCALLBACK(void) drvAudioVideoRecShutdown(PPDMIHOSTAUDIO pInterface)
851{
852 LogFlowFuncEnter();
853
854 PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
855
856 avRecSinkShutdown(&pThis->Sink);
857}
858
859
860/**
861 * @interface_method_impl{PDMIHOSTAUDIO,pfnGetStatus}
862 */
863static DECLCALLBACK(PDMAUDIOBACKENDSTS) drvAudioVideoRecGetStatus(PPDMIHOSTAUDIO pInterface, PDMAUDIODIR enmDir)
864{
865 RT_NOREF(enmDir);
866 AssertPtrReturn(pInterface, PDMAUDIOBACKENDSTS_UNKNOWN);
867
868 return PDMAUDIOBACKENDSTS_RUNNING;
869}
870
871
872/**
873 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamCreate}
874 */
875static DECLCALLBACK(int) drvAudioVideoRecStreamCreate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream,
876 PPDMAUDIOSTREAMCFG pCfgReq, PPDMAUDIOSTREAMCFG pCfgAcq)
877{
878 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
879 AssertPtrReturn(pCfgReq, VERR_INVALID_POINTER);
880 AssertPtrReturn(pCfgAcq, VERR_INVALID_POINTER);
881
882 if (pCfgReq->enmDir == PDMAUDIODIR_IN)
883 return VERR_NOT_SUPPORTED;
884
885 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
886
887 PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
888 PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream;
889
890 /* For now we only have one sink, namely the driver's one.
891 * Later each stream could have its own one, to e.g. router different stream to different sinks .*/
892 PAVRECSINK pSink = &pThis->Sink;
893
894 int rc = avRecCreateStreamOut(pThis, pStreamAV, pSink, pCfgReq, pCfgAcq);
895 if (RT_SUCCESS(rc))
896 {
897 pStreamAV->pCfg = DrvAudioHlpStreamCfgDup(pCfgAcq);
898 if (!pStreamAV->pCfg)
899 rc = VERR_NO_MEMORY;
900 }
901
902 return rc;
903}
904
905
906/**
907 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamDestroy}
908 */
909static DECLCALLBACK(int) drvAudioVideoRecStreamDestroy(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
910{
911 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
912 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
913
914 PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
915 PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream;
916
917 if (!pStreamAV->pCfg) /* Not (yet) configured? Skip. */
918 return VINF_SUCCESS;
919
920 int rc = VINF_SUCCESS;
921
922 if (pStreamAV->pCfg->enmDir == PDMAUDIODIR_OUT)
923 rc = avRecDestroyStreamOut(pThis, pStreamAV);
924
925 if (RT_SUCCESS(rc))
926 {
927 DrvAudioHlpStreamCfgFree(pStreamAV->pCfg);
928 pStreamAV->pCfg = NULL;
929 }
930
931 return rc;
932}
933
934
935/**
936 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamControl}
937 */
938static DECLCALLBACK(int) drvAudioVideoRecStreamControl(PPDMIHOSTAUDIO pInterface,
939 PPDMAUDIOBACKENDSTREAM pStream, PDMAUDIOSTREAMCMD enmStreamCmd)
940{
941 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
942 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
943
944 PDRVAUDIOVIDEOREC pThis = PDMIHOSTAUDIO_2_DRVAUDIOVIDEOREC(pInterface);
945 PAVRECSTREAM pStreamAV = (PAVRECSTREAM)pStream;
946
947 if (!pStreamAV->pCfg) /* Not (yet) configured? Skip. */
948 return VINF_SUCCESS;
949
950 if (pStreamAV->pCfg->enmDir == PDMAUDIODIR_OUT)
951 return avRecControlStreamOut(pThis, pStreamAV, enmStreamCmd);
952
953 return VINF_SUCCESS;
954}
955
956
957/**
958 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetReadable}
959 */
960static DECLCALLBACK(uint32_t) drvAudioVideoRecStreamGetReadable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
961{
962 RT_NOREF(pInterface, pStream);
963
964 return 0; /* Video capturing does not provide any input. */
965}
966
967
968/**
969 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetWritable}
970 */
971static DECLCALLBACK(uint32_t) drvAudioVideoRecStreamGetWritable(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
972{
973 RT_NOREF(pInterface, pStream);
974
975 return UINT32_MAX;
976}
977
978
979/**
980 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamGetStatus}
981 */
982static DECLCALLBACK(PDMAUDIOSTREAMSTS) drvAudioVideoRecStreamGetStatus(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
983{
984 RT_NOREF(pInterface, pStream);
985
986 return (PDMAUDIOSTREAMSTS_FLAG_INITIALIZED | PDMAUDIOSTREAMSTS_FLAG_ENABLED);
987}
988
989
990/**
991 * @interface_method_impl{PDMIHOSTAUDIO,pfnStreamIterate}
992 */
993static DECLCALLBACK(int) drvAudioVideoRecStreamIterate(PPDMIHOSTAUDIO pInterface, PPDMAUDIOBACKENDSTREAM pStream)
994{
995 AssertPtrReturn(pInterface, VERR_INVALID_POINTER);
996 AssertPtrReturn(pStream, VERR_INVALID_POINTER);
997
998 LogFlowFuncEnter();
999
1000 /* Nothing to do here for video recording. */
1001 return VINF_SUCCESS;
1002}
1003
1004
1005/**
1006 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
1007 */
1008static DECLCALLBACK(void *) drvAudioVideoRecQueryInterface(PPDMIBASE pInterface, const char *pszIID)
1009{
1010 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1011 PDRVAUDIOVIDEOREC pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVIDEOREC);
1012
1013 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1014 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTAUDIO, &pThis->IHostAudio);
1015 return NULL;
1016}
1017
1018
1019AudioVideoRec::AudioVideoRec(Console *pConsole)
1020 : AudioDriver(pConsole)
1021 , mpDrv(NULL)
1022{
1023}
1024
1025
1026AudioVideoRec::~AudioVideoRec(void)
1027{
1028 if (mpDrv)
1029 {
1030 mpDrv->pAudioVideoRec = NULL;
1031 mpDrv = NULL;
1032 }
1033}
1034
1035
1036/**
1037 * @copydoc AudioDriver::configureDriver
1038 */
1039int AudioVideoRec::configureDriver(PCFGMNODE pLunCfg)
1040{
1041 CFGMR3InsertInteger(pLunCfg, "Object", (uintptr_t)mpConsole->i_getAudioVideoRec());
1042 CFGMR3InsertInteger(pLunCfg, "ObjectConsole", (uintptr_t)mpConsole);
1043
1044 return VINF_SUCCESS;
1045}
1046
1047
1048/**
1049 * Construct a audio video recording driver instance.
1050 *
1051 * @copydoc FNPDMDRVCONSTRUCT
1052 */
1053/* static */
1054DECLCALLBACK(int) AudioVideoRec::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1055{
1056 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1057 PDRVAUDIOVIDEOREC pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVIDEOREC);
1058 RT_NOREF(fFlags);
1059
1060 LogRel(("Audio: Initializing video recording audio driver\n"));
1061 LogFlowFunc(("fFlags=0x%x\n", fFlags));
1062
1063 AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
1064 ("Configuration error: Not possible to attach anything to this driver!\n"),
1065 VERR_PDM_DRVINS_NO_ATTACH);
1066
1067 /*
1068 * Init the static parts.
1069 */
1070 pThis->pDrvIns = pDrvIns;
1071 /* IBase */
1072 pDrvIns->IBase.pfnQueryInterface = drvAudioVideoRecQueryInterface;
1073 /* IHostAudio */
1074 PDMAUDIO_IHOSTAUDIO_CALLBACKS(drvAudioVideoRec);
1075
1076 /*
1077 * Get the Console object pointer.
1078 */
1079 void *pvUser;
1080 int rc = CFGMR3QueryPtr(pCfg, "ObjectConsole", &pvUser); /** @todo r=andy Get rid of this hack and use IHostAudio::SetCallback. */
1081 AssertRCReturn(rc, rc);
1082
1083 /* CFGM tree saves the pointer to Console in the Object node of AudioVideoRec. */
1084 pThis->pConsole = (Console *)pvUser;
1085 AssertReturn(!pThis->pConsole.isNull(), VERR_INVALID_POINTER);
1086
1087 /*
1088 * Get the pointer to the audio driver instance.
1089 */
1090 rc = CFGMR3QueryPtr(pCfg, "Object", &pvUser); /** @todo r=andy Get rid of this hack and use IHostAudio::SetCallback. */
1091 AssertRCReturn(rc, rc);
1092
1093 pThis->pAudioVideoRec = (AudioVideoRec *)pvUser;
1094 AssertPtrReturn(pThis->pAudioVideoRec, VERR_INVALID_POINTER);
1095
1096 pThis->pAudioVideoRec->mpDrv = pThis;
1097
1098 /*
1099 * Get the interface for the above driver (DrvAudio) to make mixer/conversion calls.
1100 * Described in CFGM tree.
1101 */
1102 pThis->pDrvAudio = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIAUDIOCONNECTOR);
1103 AssertMsgReturn(pThis->pDrvAudio, ("Configuration error: No upper interface specified!\n"), VERR_PDM_MISSING_INTERFACE_ABOVE);
1104
1105#ifdef VBOX_AUDIO_DEBUG_DUMP_PCM_DATA
1106 RTFileDelete(VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "DrvAudioVideoRec.webm");
1107 RTFileDelete(VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH "DrvAudioVideoRec.pcm");
1108#endif
1109
1110 return VINF_SUCCESS;
1111}
1112
1113
1114/**
1115 * @interface_method_impl{PDMDRVREG,pfnDestruct}
1116 */
1117/* static */
1118DECLCALLBACK(void) AudioVideoRec::drvDestruct(PPDMDRVINS pDrvIns)
1119{
1120 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1121 PDRVAUDIOVIDEOREC pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIOVIDEOREC);
1122 LogFlowFuncEnter();
1123
1124 /*
1125 * If the AudioVideoRec object is still alive, we must clear it's reference to
1126 * us since we'll be invalid when we return from this method.
1127 */
1128 if (pThis->pAudioVideoRec)
1129 {
1130 pThis->pAudioVideoRec->mpDrv = NULL;
1131 pThis->pAudioVideoRec = NULL;
1132 }
1133}
1134
1135
1136/**
1137 * @interface_method_impl{PDMDRVREG,pfnAttach}
1138 */
1139/* static */
1140DECLCALLBACK(int) AudioVideoRec::drvAttach(PPDMDRVINS pDrvIns, uint32_t fFlags)
1141{
1142 RT_NOREF(pDrvIns, fFlags);
1143
1144 LogFlowFuncEnter();
1145
1146 return VINF_SUCCESS;
1147}
1148
1149/**
1150 * @interface_method_impl{PDMDRVREG,pfnDetach}
1151 */
1152/* static */
1153DECLCALLBACK(void) AudioVideoRec::drvDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
1154{
1155 RT_NOREF(pDrvIns, fFlags);
1156
1157 LogFlowFuncEnter();
1158}
1159
1160/**
1161 * Video recording audio driver registration record.
1162 */
1163const PDMDRVREG AudioVideoRec::DrvReg =
1164{
1165 PDM_DRVREG_VERSION,
1166 /* szName */
1167 "AudioVideoRec",
1168 /* szRCMod */
1169 "",
1170 /* szR0Mod */
1171 "",
1172 /* pszDescription */
1173 "Audio driver for video recording",
1174 /* fFlags */
1175 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1176 /* fClass. */
1177 PDM_DRVREG_CLASS_AUDIO,
1178 /* cMaxInstances */
1179 ~0U,
1180 /* cbInstance */
1181 sizeof(DRVAUDIOVIDEOREC),
1182 /* pfnConstruct */
1183 AudioVideoRec::drvConstruct,
1184 /* pfnDestruct */
1185 AudioVideoRec::drvDestruct,
1186 /* pfnRelocate */
1187 NULL,
1188 /* pfnIOCtl */
1189 NULL,
1190 /* pfnPowerOn */
1191 NULL,
1192 /* pfnReset */
1193 NULL,
1194 /* pfnSuspend */
1195 NULL,
1196 /* pfnResume */
1197 NULL,
1198 /* pfnAttach */
1199 AudioVideoRec::drvAttach,
1200 /* pfnDetach */
1201 AudioVideoRec::drvDetach,
1202 /* pfnPowerOff */
1203 NULL,
1204 /* pfnSoftReset */
1205 NULL,
1206 /* u32EndVersion */
1207 PDM_DRVREG_VERSION
1208};
1209
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use