Method DecodeAndTime

engine/sound/src/test/test_sound_perf.cpp:69–150

    char m_UnCache[4*1024*1024];

    void DecodeAndTime(const dmSoundCodec::DecoderInfo *decoder, unsigned char *buf, uint32_t size, const char *decoder_name, dmSound::SoundDataType sound_datatype,  bool skip, const char *test_name)
    {
        int junk = 0;
        for (unsigned int i=0;i<size;i+=4096)
            junk += buf[i];
        for (unsigned int i=0;i<sizeof(m_UnCache);i++)
            m_UnCache[i] += junk;

        // Setup two output buffers (dummy) so we can support interleaved and non-interleaved data output
        char tmp_l[4096*2];
        char tmp_r[4096*2];
        char* tmp_ptr[] = {tmp_l, tmp_r};
        dmSoundCodec::HDecodeStream stream;

        dmSound::HSoundData sd = 0;
        dmSound::NewSoundData(buf, size, sound_datatype, &sd, dmHashString64(test_name));

        const uint64_t time_beg = dmTime::GetMonotonicTime();
        ASSERT_EQ(decoder->m_OpenStream(sd, &stream), dmSoundCodec::RESULT_OK);
        const uint64_t time_open = dmTime::GetMonotonicTime();

        // select output buffer size depending if we have int16_t or float data being produced (we are not interested in PCM8 here) to make sure we 'chunk' the decode the same for both

        dmSoundCodec::Info info;
        decoder->m_GetStreamInfo(stream, &info);

        // Make sure we get half the buffers only if we decode to int16 not float (to keep chunking the same)
        uint32_t out_size = sizeof(tmp_l) / (32 / info.m_BitsPerSample);
        if (!info.m_IsInterleaved)
        {
            // Half the buffer size if we have non-interleaved data (as we use per channel buffers)
            out_size /= info.m_Channels;
            assert(info.m_Channels <= 2);
        }

        uint64_t max_chunk_time = 0;
        uint64_t iterations = 0;
        uint64_t total_decoded = 0;

        while (true)
        {
            iterations++;

            uint32_t decoded;

            const uint64_t chunk_begin = dmTime::GetMonotonicTime();

            if (skip)
                decoder->m_SkipInStream(stream, out_size, &decoded);
            else
                decoder->m_DecodeStream(stream, tmp_ptr, out_size, &decoded);

            total_decoded += decoded * (info.m_IsInterleaved ? 1 : info.m_Channels);

            if (decoded != out_size)
                break;

            const uint64_t chunk_time = dmTime::GetMonotonicTime() - chunk_begin;