VirtualBox

Changeset 96285 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Aug 18, 2022 8:01:23 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
153099
Message:

Recording: Removed support for Opus. bugref:10275

Location:
trunk/src/VBox/Main
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/Makefile.kmk

    r96212 r96285  
    10221022  # Needed in VBoxSVC for ISystemProperties.
    10231023  src-server/SystemPropertiesImpl.cpp_DEFS += VBOX_WITH_AUDIO_RECORDING
    1024   ifdef VBOX_WITH_LIBOPUS
    1025    VBoxC_SDKS += VBOX_OPUS
    1026    VBoxC_DEFS += VBOX_WITH_LIBOPUS
    1027    # Needed in VBoxSVC for ISystemProperties.
    1028    src-server/SystemPropertiesImpl.cpp_DEFS += VBOX_WITH_LIBOPUS
    1029   endif
    10301024  ifdef VBOX_WITH_LIBOGG
    10311025   VBOX_MAIN_DEFS += VBOX_WITH_LIBOGG
     
    12581252 VBoxClient-x86_PCH_HDR := $(PATH_SUB_CURRENT)/src-client/win/precomp_vcc.h
    12591253endif
    1260  VBoxClient-x86_SDKS = $(filter-out VBOX_OPUS VBOX_VPX,$(VBoxC_SDKS))
     1254 VBoxClient-x86_SDKS = $(filter-out VBOX_VPX,$(VBoxC_SDKS))
    12611255 VBoxClient-x86_DEFS = VBOX_COM_INPROC_API_CLIENT \
    12621256        $(filter-out VBOX_WITH_RECORDING VBOX_WITH_AUDIO_RECORDING \
    1263                  VBOX_WITH_LIBVPX VBOX_WITH_LIBOPUS,$(VBoxC_DEFS))
     1257                 VBOX_WITH_LIBVPX,$(VBoxC_DEFS))
    12641258 VBoxClient-x86_INCS.win = \
    12651259        $(VBoxClient-x86_0_OUTDIR) \
  • trunk/src/VBox/Main/include/RecordingInternals.h

    r96284 r96285  
    3939#endif /* VBOX_WITH_LIBVPX */
    4040
    41 #ifdef VBOX_WITH_LIBOPUS
    42 # include <opus.h>
    43 #endif
    44 
    4541#ifdef VBOX_WITH_LIBVORBIS
    4642# include "vorbis/vorbisenc.h"
     
    5147*   Defines                                                                                                                      *
    5248*********************************************************************************************************************************/
    53 #define VBOX_RECORDING_OPUS_HZ_MAX               48000   /**< Maximum sample rate (in Hz) Opus can handle. */
    54 #define VBOX_RECORDING_OPUS_FRAME_MS_DEFAULT     20      /**< Default Opus frame size (in ms). */
    55 
    5649#define VBOX_RECORDING_VORBIS_HZ_MAX             48000   /**< Maximum sample rate (in Hz) Vorbis can handle. */
    5750#define VBOX_RECORDING_VORBIS_FRAME_MS_DEFAULT   20      /**< Default Vorbis frame size (in ms). */
     
    206199    /** Time (in ms) the encoder expects us to send data to encode.
    207200     *
    208      *  For Opus, valid frame sizes are:
    209      *  ms           Frame size
    210      *  2.5          120
    211      *  5            240
    212      *  10           480
    213      *  20 (Default) 960
    214      *  40           1920
    215      *  60           2880
    216      *
    217201     *  For Vorbis, valid frame sizes are powers of two from 64 to 8192 bytes.
    218202     */
     
    247231#endif /* VBOX_WITH_LIBVPX */
    248232
    249 #ifdef VBOX_WITH_LIBOPUS
    250 /**
    251  * Opus encoder state (needs libvorbis).
    252  */
    253 typedef struct RECORDINGCODECOPUS
    254 {
    255     /** Encoder we're going to use. */
    256     OpusEncoder    *pEnc;
    257 } RECORDINGCODECOPUS;
    258 /** Pointer to an Opus encoder state. */
    259 typedef RECORDINGCODECOPUS *PRECORDINGCODECOPUS;
    260 #endif /* VBOX_WITH_LIBOPUS */
    261 
    262233#ifdef VBOX_WITH_LIBVORBIS
    263234/**
     
    314285    union
    315286    {
    316 # ifdef VBOX_WITH_LIBOPUS
    317         RECORDINGCODECOPUS      Opus;
    318 # endif /* VBOX_WITH_LIBOPUS */
    319287# ifdef VBOX_WITH_LIBVORBIS
    320288        RECORDINGCODECVORBIS    Vorbis;
     
    488456uint32_t recordingCodecGetWritable(PRECORDINGCODEC pCodec, uint64_t msTimestamp);
    489457#endif /* !MAIN_INCLUDED_RecordingInternals_h */
    490 
  • trunk/src/VBox/Main/include/WebMWriter.h

    r96230 r96285  
    6565 *  With signed 16-bit timecodes and a default timecode scale of 1ms per unit this makes 65536ms. */
    6666#define VBOX_WEBM_BLOCK_MAX_LEN_MS          UINT16_MAX
    67 
    68 #ifdef VBOX_WITH_LIBOPUS
    69 # pragma pack(push)
    70 # pragma pack(1)
    71     /** Opus codec private data within the MKV (WEBM) container.
    72      *  Taken from: https://wiki.xiph.org/MatroskaOpus */
    73     typedef struct WEBMOPUSPRIVDATA
    74     {
    75         WEBMOPUSPRIVDATA(uint32_t a_u32SampleRate, uint8_t a_u8Channels)
    76         {
    77             au64Head        = RT_MAKE_U64_FROM_U8('O', 'p', 'u', 's', 'H', 'e', 'a', 'd');
    78             u8Version       = 1;
    79             u8Channels      = a_u8Channels;
    80             u16PreSkip      = 0;
    81             u32SampleRate   = a_u32SampleRate;
    82             u16Gain         = 0;
    83             u8MappingFamily = 0;
    84         }
    85 
    86         uint64_t au64Head;          /**< Defaults to "OpusHead". */
    87         uint8_t  u8Version;         /**< Must be set to 1. */
    88         uint8_t  u8Channels;
    89         uint16_t u16PreSkip;
    90         /** Sample rate *before* encoding to Opus.
    91          *  Note: This rate has nothing to do with the playback rate later! */
    92         uint32_t u32SampleRate;
    93         uint16_t u16Gain;
    94         /** Must stay 0 -- otherwise a mapping table must be appended
    95          *  right after this header. */
    96         uint8_t  u8MappingFamily;
    97     } WEBMOPUSPRIVDATA, *PWEBMOPUSPRIVDATA;
    98     AssertCompileSize(WEBMOPUSPRIVDATA, 19);
    99 # pragma pack(pop)
    100 #endif /* VBOX_WITH_LIBOPUS */
    10167
    10268#ifdef VBOX_WITH_LIBVORBIS
  • trunk/src/VBox/Main/src-client/DrvAudioRec.cpp

    r96284 r96285  
    2626 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
    2727 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    28  */
    29 
    30 /* This code makes use of the Vorbis (libvorbis) and Opus codec (libopus):
    31  *
    32  * Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic,
    33  *                     Jean-Marc Valin, Timothy B. Terriberry,
    34  *                     CSIRO, Gregory Maxwell, Mark Borgerding,
    35  *                     Erik de Castro Lopo
    36  *
    37  * Redistribution and use in source and binary forms, with or without
    38  * modification, are permitted provided that the following conditions
    39  * are met:
    40  *
    41  * - Redistributions of source code must retain the above copyright
    42  * notice, this list of conditions and the following disclaimer.
    43  *
    44  * - Redistributions in binary form must reproduce the above copyright
    45  * notice, this list of conditions and the following disclaimer in the
    46  * documentation and/or other materials provided with the distribution.
    47  *
    48  * - Neither the name of Internet Society, IETF or IETF Trust, nor the
    49  * names of specific contributors, may be used to endorse or promote
    50  * products derived from this software without specific prior written
    51  * permission.
    52  *
    53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    54  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    55  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    56  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
    57  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    58  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
    59  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
    60  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
    61  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
    62  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    63  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    64  *
    65  * Opus is subject to the royalty-free patent licenses which are
    66  * specified at:
    67  *
    68  * Xiph.Org Foundation:
    69  * https://datatracker.ietf.org/ipr/1524/
    70  *
    71  * Microsoft Corporation:
    72  * https://datatracker.ietf.org/ipr/1914/
    73  *
    74  * Broadcom Corporation:
    75  * https://datatracker.ietf.org/ipr/1526/
    76  *
    7728 */
    7829
     
    1011962    PDM_DRVREG_VERSION
    1012963};
    1013 
  • trunk/src/VBox/Main/src-client/RecordingCodec.cpp

    r96284 r96285  
    1414 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
     16 */
     17
     18/* This code makes use of the Vorbis (libvorbis):
     19 *
     20 * Copyright (c) 2002-2020 Xiph.org Foundation
     21 *
     22 * Redistribution and use in source and binary forms, with or without
     23 * modification, are permitted provided that the following conditions
     24 * are met:
     25 *
     26 * - Redistributions of source code must retain the above copyright
     27 * notice, this list of conditions and the following disclaimer.
     28 *
     29 * - Redistributions in binary form must reproduce the above copyright
     30 * notice, this list of conditions and the following disclaimer in the
     31 * documentation and/or other materials provided with the distribution.
     32 *
     33 * - Neither the name of the Xiph.org Foundation nor the names of its
     34 * contributors may be used to endorse or promote products derived from
     35 * this software without specific prior written permission.
     36 *
     37 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     38 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     39 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     40 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
     41 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     44 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     45 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     46 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     47 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    1648 */
    1749
     
    212244}
    213245#endif /* VBOX_WITH_LIBVPX */
    214 
    215 
    216 /*********************************************************************************************************************************
    217 *   Opus codec                                                                                                                   *
    218 *********************************************************************************************************************************/
    219 
    220 #ifdef VBOX_WITH_LIBOPUS
    221 /** @copydoc RECORDINGCODECOPS::pfnInit */
    222 static DECLCALLBACK(int) recordingCodecOpusInit(PRECORDINGCODEC pCodec)
    223 {
    224     pCodec->cbScratch = _4K;
    225     pCodec->pvScratch = RTMemAlloc(pCodec->cbScratch);
    226     AssertPtrReturn(pCodec->pvScratch, VERR_NO_MEMORY);
    227 
    228     const PPDMAUDIOPCMPROPS pProps = &pCodec->Parms.Audio.PCMProps;
    229 
    230     uint32_t       uHz       = PDMAudioPropsHz(pProps);
    231     uint8_t  const cChannels = PDMAudioPropsChannels(pProps);
    232 
    233     /* Opus only supports certain input sample rates in an efficient manner.
    234      * So make sure that we use those by resampling the data to the requested rate. */
    235     if      (uHz > 24000) uHz = VBOX_RECORDING_OPUS_HZ_MAX;
    236     else if (uHz > 16000) uHz = 24000;
    237     else if (uHz > 12000) uHz = 16000;
    238     else if (uHz > 8000 ) uHz = 12000;
    239     else     uHz = 8000;
    240 
    241     int opus_rc;
    242     OpusEncoder *pEnc = opus_encoder_create(uHz, cChannels, OPUS_APPLICATION_AUDIO, &opus_rc);
    243     if (opus_rc != OPUS_OK)
    244     {
    245         LogRel(("Recording: Audio codec failed to initialize: %s\n", opus_strerror(opus_rc)));
    246         return VERR_RECORDING_CODEC_INIT_FAILED;
    247     }
    248 
    249     AssertPtr(pEnc);
    250 
    251     if (pCodec->Parms.uBitrate) /* Only explicitly set the bitrate management if we specified one. Otherwise let Opus decide. */
    252     {
    253         opus_encoder_ctl(pEnc, OPUS_SET_BITRATE(pCodec->Parms.uBitrate));
    254         if (opus_rc != OPUS_OK)
    255         {
    256             opus_encoder_destroy(pEnc);
    257             pEnc = NULL;
    258 
    259             LogRel(("Recording: Audio codec failed to set bitrate (%RU32): %s\n", pCodec->Parms.uBitrate, opus_strerror(opus_rc)));
    260             return VERR_RECORDING_CODEC_INIT_FAILED;
    261         }
    262     }
    263 
    264     opus_rc = opus_encoder_ctl(pEnc, OPUS_SET_VBR(pCodec->Parms.uBitrate == 0 ? 1 : 0));
    265     if (opus_rc != OPUS_OK)
    266     {
    267         LogRel(("Recording: Audio codec failed to %s VBR mode: %s\n",
    268                 pCodec->Parms.uBitrate == 0 ? "disable" : "enable", opus_strerror(opus_rc)));
    269         return VERR_RECORDING_CODEC_INIT_FAILED;
    270     }
    271 
    272     pCodec->Audio.Opus.pEnc = pEnc;
    273 
    274     PDMAudioPropsInit(pProps,
    275                       PDMAudioPropsSampleSize(pProps), PDMAudioPropsIsSigned(pProps), PDMAudioPropsChannels(pProps), uHz);
    276 
    277     if (!pCodec->Parms.msFrame) /* No ms per frame defined? Use default. */
    278         pCodec->Parms.msFrame = VBOX_RECORDING_OPUS_FRAME_MS_DEFAULT;
    279 
    280     return VINF_SUCCESS;
    281 }
    282 
    283 /** @copydoc RECORDINGCODECOPS::pfnDestroy */
    284 static DECLCALLBACK(int) recordingCodecOpusDestroy(PRECORDINGCODEC pCodec)
    285 {
    286     PRECORDINGCODECOPUS pOpus = &pCodec->Audio.Opus;
    287 
    288     if (pOpus->pEnc)
    289     {
    290         opus_encoder_destroy(pOpus->pEnc);
    291         pOpus->pEnc = NULL;
    292     }
    293 
    294     return VINF_SUCCESS;
    295 }
    296 
    297 /** @copydoc RECORDINGCODECOPS::pfnEncode */
    298 static DECLCALLBACK(int) recordingCodecOpusEncode(PRECORDINGCODEC pCodec,
    299                                                   const PRECORDINGFRAME pFrame, size_t *pcEncoded, size_t *pcbEncoded)
    300 {
    301     const PPDMAUDIOPCMPROPS pPCMProps = &pCodec->Parms.Audio.PCMProps;
    302 
    303     Assert         (pCodec->Parms.cbFrame);
    304     AssertReturn   (pFrame->Audio.cbBuf % pCodec->Parms.cbFrame == 0, VERR_INVALID_PARAMETER);
    305     Assert         (pFrame->Audio.cbBuf);
    306     AssertReturn   (pFrame->Audio.cbBuf % pPCMProps->cbFrame == 0, VERR_INVALID_PARAMETER);
    307     AssertReturn(pCodec->cbScratch >= pFrame->Audio.cbBuf, VERR_INVALID_PARAMETER);
    308     AssertPtrReturn(pcEncoded,  VERR_INVALID_POINTER);
    309     AssertPtrReturn(pcbEncoded, VERR_INVALID_POINTER);
    310 
    311     int vrc = VINF_SUCCESS;
    312 
    313     size_t cBlocksEncoded = 0;
    314     size_t cBytesEncoded  = 0;
    315 
    316     /*
    317      * Opus always encodes PER "OPUS FRAME", that is, exactly 2.5, 5, 10, 20, 40 or 60 ms of audio data.
    318      *
    319      * A packet can have up to 120ms worth of audio data.
    320      * Anything > 120ms of data will result in a "corrupted package" error message by
    321      * by decoding application.
    322      */
    323     opus_int32 cbWritten = opus_encode(pCodec->Audio.Opus.pEnc,
    324                                        (opus_int16 *)pFrame->Audio.pvBuf, (int)(pFrame->Audio.cbBuf / pPCMProps->cbFrame /* Number of audio frames */),
    325                                        (uint8_t *)pCodec->pvScratch, (opus_int32)pCodec->cbScratch);
    326     if (cbWritten < 0)
    327     {
    328         LogRel(("Recording: opus_encode() failed (%s)\n", opus_strerror(cbWritten)));
    329         return VERR_RECORDING_ENCODING_FAILED;
    330     }
    331 
    332     if (cbWritten)
    333     {
    334         vrc = pCodec->Callbacks.pfnWriteData(pCodec, pCodec->pvScratch, (size_t)cbWritten, pCodec->State.tsLastWrittenMs,
    335                                              RECORDINGCODEC_ENC_F_BLOCK_IS_KEY /* Every Opus frame is a key frame */,
    336                                              pCodec->Callbacks.pvUser);
    337     }
    338 
    339     if (RT_SUCCESS(vrc))
    340     {
    341         /* Get overall frames encoded. */
    342         cBlocksEncoded = opus_packet_get_nb_frames((uint8_t *)pCodec->pvScratch, cbWritten);
    343         cBytesEncoded  = cbWritten;
    344 
    345         if (pcEncoded)
    346             *pcEncoded  = cBlocksEncoded;
    347         if (pcbEncoded)
    348             *pcbEncoded = cBytesEncoded;
    349     }
    350 
    351     if (RT_FAILURE(vrc))
    352         LogRel(("Recording: Encoding Opus data failed, rc=%Rrc\n", vrc));
    353 
    354     Log3Func(("cbSrc=%zu, cbDst=%zu, cEncoded=%zu, cbEncoded=%zu, vrc=%Rrc\n",
    355               pFrame->Audio.cbBuf, pCodec->cbScratch, cBlocksEncoded, cBytesEncoded, vrc));
    356 
    357     return vrc;
    358 }
    359 #endif /* VBOX_WITH_LIBOPUS */
    360246
    361247
     
    762648    switch (enmAudioCodec)
    763649    {
    764 # ifdef VBOX_WITH_LIBOPUS
    765         case RecordingAudioCodec_Opus:
    766         {
    767             pCodec->Ops.pfnInit         = recordingCodecOpusInit;
    768             pCodec->Ops.pfnDestroy      = recordingCodecOpusDestroy;
    769             pCodec->Ops.pfnParseOptions = recordingCodecAudioParseOptions;
    770             pCodec->Ops.pfnEncode       = recordingCodecOpusEncode;
    771 
    772             vrc = VINF_SUCCESS;
    773             break;
    774         }
    775 # endif /* VBOX_WITH_LIBOPUS */
    776 
    777650# ifdef VBOX_WITH_LIBVORBIS
    778651        case RecordingAudioCodec_OggVorbis:
     
    999872    return pCodec->Parms.cbFrame;
    1000873}
    1001 
  • trunk/src/VBox/Main/src-client/WebMWriter.cpp

    r96231 r96285  
    162162int WebMWriter::AddAudioTrack(PRECORDINGCODEC pCodec, uint16_t uHz, uint8_t cChannels, uint8_t cBits, uint8_t *puTrack)
    163163{
    164 #if defined(VBOX_WITH_LIBOPUS) || defined(VBOX_WITH_LIBVORBIS)
     164#if defined(VBOX_WITH_LIBVORBIS)
    165165    AssertReturn(uHz,       VERR_INVALID_PARAMETER);
    166166    AssertReturn(cBits,     VERR_INVALID_PARAMETER);
     
    196196        switch (m_enmAudioCodec)
    197197        {
    198 # ifdef VBOX_WITH_LIBOPUS
    199             case RecordingAudioCodec_Opus:
    200             {
    201                 /*
    202                  * Adjust the handed-in Hz rate to values which are supported by the Opus codec.
    203                  *
    204                  * Only the following values are supported by an Opus standard build
    205                  * -- every other rate only is supported by a custom build.
    206                  *
    207                  * See opus_encoder_create() for more information.
    208                  */
    209                 if      (uHz > 24000) uHz = VBOX_RECORDING_OPUS_HZ_MAX;
    210                 else if (uHz > 16000) uHz = 24000;
    211                 else if (uHz > 12000) uHz = 16000;
    212                 else if (uHz > 8000 ) uHz = 12000;
    213                 else     uHz = 8000;
    214 
    215                 WEBMOPUSPRIVDATA opusPrivData(uHz, cChannels);
    216 
    217                 pTrack->Audio.msPerBlock = 0; /** @todo */
    218                 if (!pTrack->Audio.msPerBlock) /* No ms per frame defined? Use default. */
    219                     pTrack->Audio.msPerBlock = VBOX_RECORDING_OPUS_FRAME_MS_DEFAULT;
    220 
    221                 serializeString(MkvElem_CodecID,    "A_OPUS");
    222                 serializeData(MkvElem_CodecPrivate, &opusPrivData, sizeof(opusPrivData));
    223                 break;
    224             }
    225 # endif /* VBOX_WITH_LIBOPUS */
    226198# ifdef VBOX_WITH_LIBVORBIS
    227199            case RecordingAudioCodec_OggVorbis:
     
    326298        delete pTrack;
    327299    return vrc;
    328 #else /* defined(VBOX_WITH_LIBOPUS) || defined(VBOX_WITH_LIBVORBIS) */
     300#else /* !defined(VBOX_WITH_LIBVORBIS) */
    329301    RT_NOREF(pCodec, uHz, cChannels, cBits, puTrack);
    330302    return VERR_NOT_SUPPORTED;
     
    425397int WebMWriter::init(RecordingAudioCodec_T enmAudioCodec, RecordingVideoCodec_T enmVideoCodec)
    426398{
    427 #ifndef VBOX_WITH_LIBOPUS
    428     AssertReturn(enmAudioCodec != RecordingAudioCodec_Opus, VERR_NOT_SUPPORTED);
    429 #endif
    430399#ifndef VBOX_WITH_LIBVORBIS
    431400    AssertReturn(enmAudioCodec != RecordingAudioCodec_OggVorbis, VERR_NOT_SUPPORTED);
     
    934903        .subEnd(MkvElem_Info);
    935904}
    936 
  • trunk/src/VBox/Main/src-server/RecordingScreenSettingsImpl.cpp

    r96175 r96285  
    583583        return setError(E_INVALIDARG, tr("Cannot change audio codec while recording is enabled"));
    584584
    585     if (aCodec != RecordingAudioCodec_Opus)
     585    if (aCodec != RecordingAudioCodec_OggVorbis)
    586586        return setError(E_INVALIDARG, tr("Audio codec not supported"));
    587587
     
    12321232    return ASMAtomicReadS32(&m->cRefs);
    12331233}
    1234 
  • trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

    r96143 r96285  
    16021602        RecordingAudioCodec_WavPCM,
    16031603#endif
    1604 #ifdef VBOX_WITH_LIBOPUS
    1605         RecordingAudioCodec_Opus,
    1606 #endif
    16071604#ifdef VBOX_WITH_LIBVORBIS
    16081605        RecordingAudioCodec_OggVorbis,
     
    23982395#endif
    23992396}
    2400 
  • trunk/src/VBox/Main/xml/Settings.cpp

    r96175 r96285  
    30263026    Video.ulFPS          = 25;
    30273027#ifdef VBOX_WITH_AUDIO_RECORDING
    3028     /* When both codecs are defined, prefer Ogg Vorbis as a default. */
    30293028# if   defined(VBOX_WITH_LIBVORBIS)
    30303029    Audio.enmCodec       = RecordingAudioCodec_OggVorbis;
    3031 # elif defined(VBOX_WITH_LIBOPUS)
    3032     Audio.enmCodec       = RecordingAudioCodec_Opus;
    30333030# else
    30343031    Audio.enmCodec       = RecordingAudioCodec_None;
     
    30733070           && Video.ulFPS                                     == 25
    30743071#ifdef VBOX_WITH_AUDIO_RECORDING
    3075 /* When both codecs are defined, prefer Ogg Vorbis as a default. */
    30763072# if   defined(VBOX_WITH_LIBVORBIS)
    30773073           && Audio.enmCodec                                  == RecordingAudioCodec_OggVorbis
    3078 # elif defined(VBOX_WITH_LIBOPUS)
    3079            && Audio.enmCodec                                  == RecordingAudioCodec_Opus
    30803074# else
    30813075           && Audio.enmCodec                                  == RecordingAudioCodec_None
Note: See TracChangeset for help on using the changeset viewer.

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