VirtualBox

Ignore:
Timestamp:
Jul 27, 2017 8:15:43 AM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
117212
Message:

Audio: Renamed audio samples to audio frame because that's what they really are. No actual code changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp

    r67697 r68132  
    6262    RTTESTI_CHECK_RC_OK(AudioMixBufInit(&mb, "Single", &config, cBufSize));
    6363    RTTESTI_CHECK(AudioMixBufSize(&mb) == cBufSize);
    64     RTTESTI_CHECK(AUDIOMIXBUF_B2S(&mb, AudioMixBufSizeBytes(&mb)) == cBufSize);
    65     RTTESTI_CHECK(AUDIOMIXBUF_S2B(&mb, AudioMixBufSize(&mb)) == AudioMixBufSizeBytes(&mb));
     64    RTTESTI_CHECK(AUDIOMIXBUF_B2F(&mb, AudioMixBufSizeBytes(&mb)) == cBufSize);
     65    RTTESTI_CHECK(AUDIOMIXBUF_F2B(&mb, AudioMixBufSize(&mb)) == AudioMixBufSizeBytes(&mb));
    6666    RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize);
    67     RTTESTI_CHECK(AUDIOMIXBUF_S2B(&mb, AudioMixBufFree(&mb)) == AudioMixBufFreeBytes(&mb));
     67    RTTESTI_CHECK(AUDIOMIXBUF_F2B(&mb, AudioMixBufFree(&mb)) == AudioMixBufFreeBytes(&mb));
    6868
    6969    /*
    7070     * Absolute writes.
    7171     */
    72     uint32_t cSamplesRead  = 0, cSamplesWritten = 0, cSamplesWrittenAbs = 0;
    73     int8_t  samples8 [2] = { 0x12, 0x34 };
    74     int16_t samples16[2] = { 0xAA, 0xBB };
    75     int32_t samples32[2] = { 0xCC, 0xDD };
    76     /* int64_t samples64[2] = { 0xEE, 0xFF }; - unused */
    77 
    78     RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, &samples8, sizeof(samples8), &cSamplesWritten));
    79     RTTESTI_CHECK(cSamplesWritten == 0 /* Samples */);
     72    uint32_t cFramesRead  = 0, cFramesWritten = 0, cFramesWrittenAbs = 0;
     73    int8_t  aFrames8 [2] = { 0x12, 0x34 };
     74    int16_t aFrames16[2] = { 0xAA, 0xBB };
     75    int32_t aFrames32[2] = { 0xCC, 0xDD };
     76
     77    RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, &aFrames8, sizeof(aFrames8), &cFramesWritten));
     78    RTTESTI_CHECK(cFramesWritten == 0 /* Frames */);
    8079    RTTESTI_CHECK(AudioMixBufUsed(&mb) == 0);
    8180
    82     RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, &samples16, sizeof(samples16), &cSamplesWritten));
    83     RTTESTI_CHECK(cSamplesWritten == 1 /* Samples */);
     81    RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, &aFrames16, sizeof(aFrames16), &cFramesWritten));
     82    RTTESTI_CHECK(cFramesWritten == 1 /* Frames */);
    8483    RTTESTI_CHECK(AudioMixBufUsed(&mb) == 1);
    8584
    86     RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 2 /* Offset */, &samples32, sizeof(samples32), &cSamplesWritten));
    87     RTTESTI_CHECK(cSamplesWritten == 2 /* Samples */);
     85    RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 2 /* Offset */, &aFrames32, sizeof(aFrames32), &cFramesWritten));
     86    RTTESTI_CHECK(cFramesWritten == 2 /* Frames */);
    8887    RTTESTI_CHECK(AudioMixBufUsed(&mb) == 2);
    8988
    9089    /* Beyond buffer. */
    91     RTTESTI_CHECK_RC(AudioMixBufWriteAt(&mb, AudioMixBufSize(&mb) + 1, &samples16, sizeof(samples16),
    92                                         &cSamplesWritten), VERR_BUFFER_OVERFLOW);
    93 
    94     /* Offset wrap-around: When writing as much (or more) samples the mixing buffer can hold. */
     90    RTTESTI_CHECK_RC(AudioMixBufWriteAt(&mb, AudioMixBufSize(&mb) + 1, &aFrames16, sizeof(aFrames16),
     91                                        &cFramesWritten), VERR_BUFFER_OVERFLOW);
     92
     93    /* Offset wrap-around: When writing as much (or more) frames the mixing buffer can hold. */
    9594    uint32_t  cbSamples = cBufSize * sizeof(int16_t) * 2 /* Channels */;
    9695    RTTESTI_CHECK(cbSamples);
    9796    uint16_t *paSamples = (uint16_t *)RTMemAlloc(cbSamples);
    9897    RTTESTI_CHECK(paSamples);
    99     RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, paSamples, cbSamples, &cSamplesWritten));
    100     RTTESTI_CHECK(cSamplesWritten == cBufSize /* Samples */);
     98    RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 0 /* Offset */, paSamples, cbSamples, &cFramesWritten));
     99    RTTESTI_CHECK(cFramesWritten == cBufSize /* Frames */);
    101100    RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize);
    102101    RTTESTI_CHECK(AudioMixBufReadPos(&mb) == 0);
    … …  
    110109    AudioMixBufReset(&mb);
    111110
    112     RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 2 /* Offset */, &samples32, sizeof(samples32), &cSamplesWritten));
    113     RTTESTI_CHECK(cSamplesWritten == 2 /* Samples */);
     111    RTTESTI_CHECK_RC_OK(AudioMixBufWriteAt(&mb, 2 /* Offset */, &aFrames32, sizeof(aFrames32), &cFramesWritten));
     112    RTTESTI_CHECK(cFramesWritten == 2 /* Frames */);
    114113    RTTESTI_CHECK(AudioMixBufUsed(&mb) == 2);
    115114
    116     cSamplesWrittenAbs = AudioMixBufUsed(&mb);
    117 
    118     uint32_t cToWrite = AudioMixBufSize(&mb) - cSamplesWrittenAbs - 1; /* -1 as padding plus -2 samples for above. */
     115    cFramesWrittenAbs = AudioMixBufUsed(&mb);
     116
     117    uint32_t cToWrite = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1; /* -1 as padding plus -2 frames for above. */
    119118    for (uint32_t i = 0; i < cToWrite; i++)
    120119    {
    121         RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&mb, &samples16, sizeof(samples16), &cSamplesWritten));
    122         RTTESTI_CHECK(cSamplesWritten == 1);
     120        RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&mb, &aFrames16, sizeof(aFrames16), &cFramesWritten));
     121        RTTESTI_CHECK(cFramesWritten == 1);
    123122    }
    124123    RTTESTI_CHECK(!AudioMixBufIsEmpty(&mb));
    125124    RTTESTI_CHECK(AudioMixBufFree(&mb) == 1);
    126     RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, 1U));
    127     RTTESTI_CHECK(AudioMixBufUsed(&mb) == cToWrite + cSamplesWrittenAbs /* + last absolute write */);
    128 
    129     RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&mb, &samples16, sizeof(samples16), &cSamplesWritten));
    130     RTTESTI_CHECK(cSamplesWritten == 1);
     125    RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 1U));
     126    RTTESTI_CHECK(AudioMixBufUsed(&mb) == cToWrite + cFramesWrittenAbs /* + last absolute write */);
     127
     128    RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&mb, &aFrames16, sizeof(aFrames16), &cFramesWritten));
     129    RTTESTI_CHECK(cFramesWritten == 1);
    131130    RTTESTI_CHECK(AudioMixBufFree(&mb) == 0);
    132     RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, 0U));
     131    RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, 0U));
    133132    RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize);
    134133
    135134    /* Circular reads. */
    136     uint32_t cToRead = AudioMixBufSize(&mb) - cSamplesWrittenAbs - 1;
     135    uint32_t cToRead = AudioMixBufSize(&mb) - cFramesWrittenAbs - 1;
    137136    for (uint32_t i = 0; i < cToRead; i++)
    138137    {
    139         RTTESTI_CHECK_RC_OK(AudioMixBufReadCirc(&mb, &samples16, sizeof(samples16), &cSamplesRead));
    140         RTTESTI_CHECK(cSamplesRead == 1);
    141         AudioMixBufFinish(&mb, cSamplesRead);
     138        RTTESTI_CHECK_RC_OK(AudioMixBufReadCirc(&mb, &aFrames16, sizeof(aFrames16), &cFramesRead));
     139        RTTESTI_CHECK(cFramesRead == 1);
     140        AudioMixBufFinish(&mb, cFramesRead);
    142141    }
    143142    RTTESTI_CHECK(!AudioMixBufIsEmpty(&mb));
    144     RTTESTI_CHECK(AudioMixBufFree(&mb) == AudioMixBufSize(&mb) - cSamplesWrittenAbs - 1);
    145     RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, cBufSize - cSamplesWrittenAbs - 1));
     143    RTTESTI_CHECK(AudioMixBufFree(&mb) == AudioMixBufSize(&mb) - cFramesWrittenAbs - 1);
     144    RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs - 1));
    146145    RTTESTI_CHECK(AudioMixBufUsed(&mb) == cBufSize - cToRead);
    147146
    148     RTTESTI_CHECK_RC_OK(AudioMixBufReadCirc(&mb, &samples16, sizeof(samples16), &cSamplesRead));
    149     RTTESTI_CHECK(cSamplesRead == 1);
    150     AudioMixBufFinish(&mb, cSamplesRead);
    151     RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize - cSamplesWrittenAbs);
    152     RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_S2B(&mb, cBufSize - cSamplesWrittenAbs));
    153     RTTESTI_CHECK(AudioMixBufUsed(&mb) == cSamplesWrittenAbs);
     147    RTTESTI_CHECK_RC_OK(AudioMixBufReadCirc(&mb, &aFrames16, sizeof(aFrames16), &cFramesRead));
     148    RTTESTI_CHECK(cFramesRead == 1);
     149    AudioMixBufFinish(&mb, cFramesRead);
     150    RTTESTI_CHECK(AudioMixBufFree(&mb) == cBufSize - cFramesWrittenAbs);
     151    RTTESTI_CHECK(AudioMixBufFreeBytes(&mb) == AUDIOMIXBUF_F2B(&mb, cBufSize - cFramesWrittenAbs));
     152    RTTESTI_CHECK(AudioMixBufUsed(&mb) == cFramesWrittenAbs);
    154153
    155154    AudioMixBufDestroy(&mb);
    … …  
    191190    RTTESTI_CHECK(DrvAudioHlpPCMPropsAreValid(&cfg_c1));
    192191
    193     uint32_t cSamples      = 16;
    194     uint32_t cChildBufSize = RTRandU32Ex(cSamples /* Min */, 64 /* Max */);
     192    uint32_t cFrames      = 16;
     193    uint32_t cChildBufSize = RTRandU32Ex(cFrames /* Min */, 64 /* Max */);
    195194
    196195    PDMAUDIOMIXBUF child1;
    … …  
    220219    uint32_t cbBuf = _1K;
    221220    char pvBuf[_1K];
    222     int16_t samples[32] = { 0xAA, 0xBB };
    223     uint32_t cSamplesRead, cSamplesWritten, cSamplesMixed;
    224 
    225     uint32_t cSamplesChild1  = cSamples;
    226     uint32_t cSamplesChild2  = cSamples;
     221    int16_t aFrames16[32] = { 0xAA, 0xBB };
     222    uint32_t cFramesRead, cFramesWritten, cFramesMixed;
     223
     224    uint32_t cFramesChild1  = cFrames;
     225    uint32_t cFramesChild2  = cFrames;
    227226
    228227    uint32_t t = RTRandU32() % 32;
    229228
    230229    RTTestPrintf(hTest, RTTESTLVL_DEBUG,
    231                  "cParentBufSize=%RU32, cChildBufSize=%RU32, %RU32 samples -> %RU32 iterations total\n",
    232                  cParentBufSize, cChildBufSize, cSamples, t);
     230                 "cParentBufSize=%RU32, cChildBufSize=%RU32, %RU32 frames -> %RU32 iterations total\n",
     231                 cParentBufSize, cChildBufSize, cFrames, t);
    233232
    234233    /*
    … …  
    248247        {
    249248            /* Child 1. */
    250             RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&child1, 0, &samples, sizeof(samples), &cSamplesWritten));
    251             RTTESTI_CHECK_MSG_BREAK(cSamplesWritten == cSamplesChild1, ("Child1: Expected %RU32 written samples, got %RU32\n", cSamplesChild1, cSamplesWritten));
    252             RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&child1, cSamplesWritten, &cSamplesMixed));
    253 
    254             cChildrenSamplesMixedTotal += cSamplesMixed;
    255 
    256             RTTESTI_CHECK_MSG_BREAK(cSamplesWritten == cSamplesMixed, ("Child1: Expected %RU32 mixed samples, got %RU32\n", cSamplesWritten, cSamplesMixed));
    257             RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&child1) == 0, ("Child1: Expected %RU32 used samples, got %RU32\n", 0, AudioMixBufUsed(&child1)));
     249            RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&child1, 0, &aFrames16, sizeof(aFrames16), &cFramesWritten));
     250            RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesChild1, ("Child1: Expected %RU32 written frames, got %RU32\n", cFramesChild1, cFramesWritten));
     251            RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&child1, cFramesWritten, &cFramesMixed));
     252
     253            cChildrenSamplesMixedTotal += cFramesMixed;
     254
     255            RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesMixed, ("Child1: Expected %RU32 mixed frames, got %RU32\n", cFramesWritten, cFramesMixed));
     256            RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&child1) == 0, ("Child1: Expected %RU32 used frames, got %RU32\n", 0, AudioMixBufUsed(&child1)));
    258257        }
    259258
    … …  
    263262        {
    264263            /* Child 2. */
    265             RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&child2, 0, &samples, sizeof(samples), &cSamplesWritten));
    266             RTTESTI_CHECK_MSG_BREAK(cSamplesWritten == cSamplesChild2, ("Child2: Expected %RU32 written samples, got %RU32\n", cSamplesChild2, cSamplesWritten));
    267             RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&child2, cSamplesWritten, &cSamplesMixed));
    268 
    269             cChildrenSamplesMixedTotal += cSamplesMixed;
    270 
    271             RTTESTI_CHECK_MSG_BREAK(cSamplesWritten == cSamplesMixed, ("Child2: Expected %RU32 mixed samples, got %RU32\n", cSamplesWritten, cSamplesMixed));
    272             RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&child2) == 0, ("Child2: Expected %RU32 used samples, got %RU32\n", 0, AudioMixBufUsed(&child2)));
     264            RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufWriteAt(&child2, 0, &aFrames16, sizeof(aFrames16), &cFramesWritten));
     265            RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesChild2, ("Child2: Expected %RU32 written frames, got %RU32\n", cFramesChild2, cFramesWritten));
     266            RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufMixToParent(&child2, cFramesWritten, &cFramesMixed));
     267
     268            cChildrenSamplesMixedTotal += cFramesMixed;
     269
     270            RTTESTI_CHECK_MSG_BREAK(cFramesWritten == cFramesMixed, ("Child2: Expected %RU32 mixed frames, got %RU32\n", cFramesWritten, cFramesMixed));
     271            RTTESTI_CHECK_MSG_BREAK(AudioMixBufUsed(&child2) == 0, ("Child2: Expected %RU32 used frames, got %RU32\n", 0, AudioMixBufUsed(&child2)));
    273272        }
    274273
    275274        /*
    276          * Read out all samples from the parent buffer and also mark the just-read samples as finished
     275         * Read out all frames from the parent buffer and also mark the just-read frames as finished
    277276         * so that both connected children buffers can keep track of their stuff.
    278277         */
    … …  
    280279        while (cParentSamples)
    281280        {
    282             RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, pvBuf, cbBuf, &cSamplesRead));
    283             if (!cSamplesRead)
     281            RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, pvBuf, cbBuf, &cFramesRead));
     282            if (!cFramesRead)
    284283                break;
    285284
    286             AudioMixBufFinish(&parent, cSamplesRead);
    287 
    288             RTTESTI_CHECK(cParentSamples >= cSamplesRead);
    289             cParentSamples -= cSamplesRead;
     285            AudioMixBufFinish(&parent, cFramesRead);
     286
     287            RTTESTI_CHECK(cParentSamples >= cFramesRead);
     288            cParentSamples -= cFramesRead;
    290289        }
    291290
    … …  
    331330     * take shortcuts and performs conversion. Because conversion to double
    332331     * the sample rate effectively inserts one additional sample between every
    333      * two source samples, N source samples will be converted to N * 2 - 1
    334      * samples. However, the last source sample will be saved for later
     332     * two source frames, N source frames will be converted to N * 2 - 1
     333     * frames. However, the last source sample will be saved for later
    335334     * interpolation and not immediately output.
    336335     */
    … …  
    353352    RTTESTI_CHECK_RC_OK(AudioMixBufLinkTo(&child, &parent));
    354353
    355     /* 8-bit unsigned samples. Often used with SB16 device. */
    356     uint8_t samples[16]  = { 0xAA, 0xBB, 0, 1, 43, 125, 126, 127,
    357                              128, 129, 130, 131, 132, UINT8_MAX - 1, UINT8_MAX, 0 };
     354    /* 8-bit unsigned frames. Often used with SB16 device. */
     355    uint8_t aFrames8U[16]  = { 0xAA, 0xBB, 0, 1, 43, 125, 126, 127,
     356                               128, 129, 130, 131, 132, UINT8_MAX - 1, UINT8_MAX, 0 };
    358357
    359358    /*
    … …  
    362361    uint32_t    cbBuf = 256;
    363362    char        achBuf[256];
    364     uint32_t    cSamplesRead, cSamplesWritten, cSamplesMixed;
    365 
    366     uint32_t cSamplesChild  = 16;
    367     uint32_t cSamplesParent = cSamplesChild * 2 - 2;
    368     uint32_t cSamplesTotalRead   = 0;
     363    uint32_t    cFramesRead, cFramesWritten, cFramesMixed;
     364
     365    uint32_t cFramesChild  = 16;
     366    uint32_t cFramesParent = cFramesChild * 2 - 2;
     367    uint32_t cFramesTotalRead   = 0;
    369368
    370369    /**** 8-bit unsigned samples ****/
    371370    RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Conversion test %uHz %uch 8-bit\n", cfg_c.uHz, cfg_c.cChannels);
    372     RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &samples, sizeof(samples), &cSamplesWritten));
    373     RTTESTI_CHECK_MSG(cSamplesWritten == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, cSamplesWritten));
    374     RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cSamplesWritten, &cSamplesMixed));
    375     uint32_t cSamples = AudioMixBufUsed(&parent);
    376     RTTESTI_CHECK_MSG(AudioMixBufLive(&child) == cSamples, ("Child: Expected %RU32 mixed samples, got %RU32\n", AudioMixBufLive(&child), cSamples));
     371    RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames8U, sizeof(aFrames8U), &cFramesWritten));
     372    RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten));
     373    RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed));
     374    uint32_t cFrames = AudioMixBufUsed(&parent);
     375    RTTESTI_CHECK_MSG(AudioMixBufLive(&child) == cFrames, ("Child: Expected %RU32 mixed frames, got %RU32\n", AudioMixBufLive(&child), cFrames));
    377376
    378377    RTTESTI_CHECK(AudioMixBufUsed(&parent) == AudioMixBufLive(&child));
    … …  
    380379    for (;;)
    381380    {
    382         RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cSamplesRead));
    383         if (!cSamplesRead)
     381        RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cFramesRead));
     382        if (!cFramesRead)
    384383            break;
    385         cSamplesTotalRead += cSamplesRead;
    386         AudioMixBufFinish(&parent, cSamplesRead);
    387     }
    388 
    389     RTTESTI_CHECK_MSG(cSamplesTotalRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesTotalRead));
    390 
    391     /* Check that the samples came out unharmed. Every other sample is interpolated and we ignore it. */
     384        cFramesTotalRead += cFramesRead;
     385        AudioMixBufFinish(&parent, cFramesRead);
     386    }
     387
     388    RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead));
     389
     390    /* Check that the frames came out unharmed. Every other sample is interpolated and we ignore it. */
    392391    /* NB: This also checks that the default volume setting is 0dB attenuation. */
    393     uint8_t *pSrc8 = &samples[0];
     392    uint8_t *pSrc8 = &aFrames8U[0];
    394393    uint8_t *pDst8 = (uint8_t *)achBuf;
    395394
    396     for (i = 0; i < cSamplesChild - 1; ++i)
     395    for (i = 0; i < cFramesChild - 1; ++i)
    397396    {
    398397        RTTESTI_CHECK_MSG(*pSrc8 == *pDst8, ("index %u: Dst=%d, Src=%d\n", i, *pDst8, *pSrc8));
    … …  
    452451
    453452    /* 16-bit signed. More or less exclusively used as output, and usually as input, too. */
    454     int16_t     samples[16] = { 0xAA, 0xBB, INT16_MIN, INT16_MIN + 1, INT16_MIN / 2, -3, -2, -1,
    455                                 0, 1, 2, 3, INT16_MAX / 2, INT16_MAX - 1, INT16_MAX, 0 };
     453    int16_t     aFrames16S[16] = { 0xAA, 0xBB, INT16_MIN, INT16_MIN + 1, INT16_MIN / 2, -3, -2, -1,
     454                                   0, 1, 2, 3, INT16_MAX / 2, INT16_MAX - 1, INT16_MAX, 0 };
    456455
    457456    /*
    … …  
    460459    uint32_t    cbBuf = 256;
    461460    char        achBuf[256];
    462     uint32_t    cSamplesRead, cSamplesWritten, cSamplesMixed;
    463 
    464     uint32_t cSamplesChild  = 16;
    465     uint32_t cSamplesParent = cSamplesChild * 2 - 2;
    466     uint32_t cSamplesTotalRead   = 0;
     461    uint32_t    cFramesRead, cFramesWritten, cFramesMixed;
     462
     463    uint32_t cFramesChild  = 16;
     464    uint32_t cFramesParent = cFramesChild * 2 - 2;
     465    uint32_t cFramesTotalRead   = 0;
    467466
    468467    /**** 16-bit signed samples ****/
    469468    RTTestPrintf(hTest, RTTESTLVL_DEBUG, "Conversion test %uHz %uch 16-bit\n", cfg_c.uHz, cfg_c.cChannels);
    470     RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &samples, sizeof(samples), &cSamplesWritten));
    471     RTTESTI_CHECK_MSG(cSamplesWritten == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, cSamplesWritten));
    472     RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cSamplesWritten, &cSamplesMixed));
    473     uint32_t cSamples = AudioMixBufUsed(&parent);
    474     RTTESTI_CHECK_MSG(AudioMixBufLive(&child) == cSamples, ("Child: Expected %RU32 mixed samples, got %RU32\n", AudioMixBufLive(&child), cSamples));
     469    RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames16S, sizeof(aFrames16S), &cFramesWritten));
     470    RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten));
     471    RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed));
     472    uint32_t cFrames = AudioMixBufUsed(&parent);
     473    RTTESTI_CHECK_MSG(AudioMixBufLive(&child) == cFrames, ("Child: Expected %RU32 mixed frames, got %RU32\n", AudioMixBufLive(&child), cFrames));
    475474
    476475    RTTESTI_CHECK(AudioMixBufUsed(&parent) == AudioMixBufLive(&child));
    … …  
    478477    for (;;)
    479478    {
    480         RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cSamplesRead));
    481         if (!cSamplesRead)
     479        RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cFramesRead));
     480        if (!cFramesRead)
    482481            break;
    483         cSamplesTotalRead += cSamplesRead;
    484         AudioMixBufFinish(&parent, cSamplesRead);
    485     }
    486     RTTESTI_CHECK_MSG(cSamplesTotalRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesTotalRead));
    487 
    488     /* Check that the samples came out unharmed. Every other sample is interpolated and we ignore it. */
     482        cFramesTotalRead += cFramesRead;
     483        AudioMixBufFinish(&parent, cFramesRead);
     484    }
     485    RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead));
     486
     487    /* Check that the frames came out unharmed. Every other sample is interpolated and we ignore it. */
    489488    /* NB: This also checks that the default volume setting is 0dB attenuation. */
    490     int16_t *pSrc16 = &samples[0];
     489    int16_t *pSrc16 = &aFrames16S[0];
    491490    int16_t *pDst16 = (int16_t *)achBuf;
    492491
    493     for (i = 0; i < cSamplesChild - 1; ++i)
     492    for (i = 0; i < cFramesChild - 1; ++i)
    494493    {
    495494        RTTESTI_CHECK_MSG(*pSrc16 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16));
    … …  
    538537
    539538    /* A few 16-bit signed samples. */
    540     int16_t     samples[16] = { INT16_MIN, INT16_MIN + 1, -128, -64, -4, -1, 0, 1,
    541                                 2, 255, 256, INT16_MAX / 2, INT16_MAX - 2, INT16_MAX - 1, INT16_MAX, 0 };
     539    int16_t     aFrames16S[16] = { INT16_MIN, INT16_MIN + 1, -128, -64, -4, -1, 0, 1,
     540                                   2, 255, 256, INT16_MAX / 2, INT16_MAX - 2, INT16_MAX - 1, INT16_MAX, 0 };
    542541
    543542    /*
    … …  
    546545    uint32_t    cbBuf = 256;
    547546    char        achBuf[256];
    548     uint32_t    cSamplesRead, cSamplesWritten, cSamplesMixed;
    549 
    550     uint32_t cSamplesChild  = 8;
    551     uint32_t cSamplesParent = cSamplesChild;
    552     uint32_t cSamplesTotalRead;
     547    uint32_t    cFramesRead, cFramesWritten, cFramesMixed;
     548
     549    uint32_t cFramesChild  = 8;
     550    uint32_t cFramesParent = cFramesChild;
     551    uint32_t cFramesTotalRead;
    553552    int16_t *pSrc16;
    554553    int16_t *pDst16;
    … …  
    561560    AudioMixBufSetVolume(&child, &vol);
    562561
    563     RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &samples, sizeof(samples), &cSamplesWritten));
    564     RTTESTI_CHECK_MSG(cSamplesWritten == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, cSamplesWritten));
    565     RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cSamplesWritten, &cSamplesMixed));
    566 
    567     cSamplesTotalRead = 0;
     562    RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames16S, sizeof(aFrames16S), &cFramesWritten));
     563    RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten));
     564    RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed));
     565
     566    cFramesTotalRead = 0;
    568567    for (;;)
    569568    {
    570         RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cSamplesRead));
    571         if (!cSamplesRead)
     569        RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cFramesRead));
     570        if (!cFramesRead)
    572571            break;
    573         cSamplesTotalRead += cSamplesRead;
    574         AudioMixBufFinish(&parent, cSamplesRead);
    575     }
    576     RTTESTI_CHECK_MSG(cSamplesTotalRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesTotalRead));
    577 
    578     /* Check that at 0dB the samples came out unharmed. */
    579     pSrc16 = &samples[0];
     572        cFramesTotalRead += cFramesRead;
     573        AudioMixBufFinish(&parent, cFramesRead);
     574    }
     575    RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead));
     576
     577    /* Check that at 0dB the frames came out unharmed. */
     578    pSrc16 = &aFrames16S[0];
    580579    pDst16 = (int16_t *)achBuf;
    581580
    582     for (i = 0; i < cSamplesParent * 2 /* stereo */; ++i)
     581    for (i = 0; i < cFramesParent * 2 /* stereo */; ++i)
    583582    {
    584583        RTTESTI_CHECK_MSG(*pSrc16 == *pDst16, ("index %u: Dst=%d, Src=%d\n", i, *pDst16, *pSrc16));
    … …  
    592591    AudioMixBufSetVolume(&child, &vol);
    593592
    594     RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &samples, sizeof(samples), &cSamplesWritten));
    595     RTTESTI_CHECK_MSG(cSamplesWritten == cSamplesChild, ("Child: Expected %RU32 written samples, got %RU32\n", cSamplesChild, cSamplesWritten));
    596     RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cSamplesWritten, &cSamplesMixed));
    597 
    598     cSamplesTotalRead = 0;
     593    RTTESTI_CHECK_RC_OK(AudioMixBufWriteCirc(&child, &aFrames16S, sizeof(aFrames16S), &cFramesWritten));
     594    RTTESTI_CHECK_MSG(cFramesWritten == cFramesChild, ("Child: Expected %RU32 written frames, got %RU32\n", cFramesChild, cFramesWritten));
     595    RTTESTI_CHECK_RC_OK(AudioMixBufMixToParent(&child, cFramesWritten, &cFramesMixed));
     596
     597    cFramesTotalRead = 0;
    599598    for (;;)
    600599    {
    601         RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cSamplesRead));
    602         if (!cSamplesRead)
     600        RTTESTI_CHECK_RC_OK_BREAK(AudioMixBufReadCirc(&parent, achBuf, cbBuf, &cFramesRead));
     601        if (!cFramesRead)
    603602            break;
    604         cSamplesTotalRead += cSamplesRead;
    605         AudioMixBufFinish(&parent, cSamplesRead);
    606     }
    607     RTTESTI_CHECK_MSG(cSamplesTotalRead == cSamplesParent, ("Parent: Expected %RU32 mixed samples, got %RU32\n", cSamplesParent, cSamplesTotalRead));
     603        cFramesTotalRead += cFramesRead;
     604        AudioMixBufFinish(&parent, cFramesRead);
     605    }
     606    RTTESTI_CHECK_MSG(cFramesTotalRead == cFramesParent, ("Parent: Expected %RU32 mixed frames, got %RU32\n", cFramesParent, cFramesTotalRead));
    608607
    609608    /* Check that at -6dB the sample values are halved. */
    610     pSrc16 = &samples[0];
     609    pSrc16 = &aFrames16S[0];
    611610    pDst16 = (int16_t *)achBuf;
    612611
    613     for (i = 0; i < cSamplesParent * 2 /* stereo */; ++i)
     612    for (i = 0; i < cFramesParent * 2 /* stereo */; ++i)
    614613    {
    615614        /* Watch out! For negative values, x >> 1 is not the same as x / 2. */
Note: See TracChangeset for help on using the changeset viewer.

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