mirror of
https://github.com/ZDoom/gzdoom-gles.git
synced 2024-12-13 13:50:59 +00:00
5fa63c396d
This allowed to remove a lot of bad pointer voodoo in the music loader, because the new class does not allow duplication of the reader object
448 lines
13 KiB
C++
448 lines
13 KiB
C++
/*
|
|
** music_libsndfile.cpp
|
|
** Uses libsndfile for streaming music formats
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 2017 Christoph Oelckers
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
*/
|
|
|
|
// HEADER FILES ------------------------------------------------------------
|
|
|
|
#include "i_musicinterns.h"
|
|
#include "c_cvars.h"
|
|
#include "critsec.h"
|
|
#include "v_text.h"
|
|
#include "templates.h"
|
|
#include "m_fixed.h"
|
|
|
|
// MACROS ------------------------------------------------------------------
|
|
|
|
// TYPES -------------------------------------------------------------------
|
|
|
|
class SndFileSong : public StreamSong
|
|
{
|
|
public:
|
|
SndFileSong(FileRdr &reader, SoundDecoder *decoder, uint32_t loop_start, uint32_t loop_end, bool startass, bool endass);
|
|
~SndFileSong();
|
|
bool SetSubsong(int subsong);
|
|
void Play(bool looping, int subsong);
|
|
FString GetStats();
|
|
|
|
protected:
|
|
FCriticalSection CritSec;
|
|
FileRdr Reader;
|
|
SoundDecoder *Decoder;
|
|
int Channels;
|
|
int SampleRate;
|
|
|
|
uint32_t Loop_Start;
|
|
uint32_t Loop_End;
|
|
|
|
int CalcSongLength();
|
|
|
|
static bool Read(SoundStream *stream, void *buff, int len, void *userdata);
|
|
};
|
|
|
|
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
|
|
|
|
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
|
|
|
|
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
|
|
|
|
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
|
|
|
|
// PUBLIC DATA DEFINITIONS -------------------------------------------------
|
|
|
|
CUSTOM_CVAR(Int, snd_streambuffersize, 64, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
|
{
|
|
if (self < 16)
|
|
{
|
|
self = 16;
|
|
}
|
|
else if (self > 1024)
|
|
{
|
|
self = 1024;
|
|
}
|
|
}
|
|
|
|
// PRIVATE DATA DEFINITIONS ------------------------------------------------
|
|
|
|
// CODE --------------------------------------------------------------------
|
|
|
|
//==========================================================================
|
|
//
|
|
// Try to find the LOOP_START/LOOP_END tags in a Vorbis Comment block
|
|
//
|
|
// We have to parse through the FLAC or Ogg headers manually, since sndfile
|
|
// doesn't provide proper access to the comments and we'd rather not require
|
|
// using libFLAC and libvorbisfile directly.
|
|
//
|
|
//==========================================================================
|
|
|
|
static void ParseVorbisComments(FileRdr &fr, uint32_t *start, bool *startass, uint32_t *end, bool *endass)
|
|
{
|
|
uint8_t vc_data[4];
|
|
|
|
// The VC block starts with a 32LE integer for the vendor string length,
|
|
// followed by the vendor string
|
|
if(fr.Read(vc_data, 4) != 4)
|
|
return;
|
|
uint32_t vndr_len = vc_data[0] | (vc_data[1]<<8) | (vc_data[2]<<16) | (vc_data[3]<<24);
|
|
|
|
// Skip vendor string
|
|
if(fr.Seek(vndr_len, FileRdr::SeekCur) == -1)
|
|
return;
|
|
|
|
// Following the vendor string is a 32LE integer for the number of
|
|
// comments, followed by each comment.
|
|
if(fr.Read(vc_data, 4) != 4)
|
|
return;
|
|
size_t count = vc_data[0] | (vc_data[1]<<8) | (vc_data[2]<<16) | (vc_data[3]<<24);
|
|
|
|
for(size_t i = 0; i < count; i++)
|
|
{
|
|
// Each comment is a 32LE integer for the comment length, followed by
|
|
// the comment text (not null terminated!)
|
|
if(fr.Read(vc_data, 4) != 4)
|
|
return;
|
|
uint32_t length = vc_data[0] | (vc_data[1]<<8) | (vc_data[2]<<16) | (vc_data[3]<<24);
|
|
|
|
if(length >= 128)
|
|
{
|
|
// If the comment is "big", skip it
|
|
if(fr.Seek(length, FileRdr::SeekCur) == -1)
|
|
return;
|
|
continue;
|
|
}
|
|
|
|
char strdat[128];
|
|
if(fr.Read(strdat, length) != (long)length)
|
|
return;
|
|
strdat[length] = 0;
|
|
|
|
if(strnicmp(strdat, "LOOP_START=", 11) == 0)
|
|
S_ParseTimeTag(strdat + 11, startass, start);
|
|
else if(strnicmp(strdat, "LOOP_END=", 9) == 0)
|
|
S_ParseTimeTag(strdat + 9, endass, end);
|
|
}
|
|
}
|
|
|
|
static void FindFlacComments(FileRdr &fr, uint32_t *loop_start, bool *startass, uint32_t *loop_end, bool *endass)
|
|
{
|
|
// Already verified the fLaC marker, so we're 4 bytes into the file
|
|
bool lastblock = false;
|
|
uint8_t header[4];
|
|
|
|
while(!lastblock && fr.Read(header, 4) == 4)
|
|
{
|
|
// The first byte of the block header contains the type and a flag
|
|
// indicating the last metadata block
|
|
char blocktype = header[0]&0x7f;
|
|
lastblock = !!(header[0]&0x80);
|
|
// Following the type is a 24BE integer for the size of the block
|
|
uint32_t blocksize = (header[1]<<16) | (header[2]<<8) | header[3];
|
|
|
|
// FLAC__METADATA_TYPE_VORBIS_COMMENT is 4
|
|
if(blocktype == 4)
|
|
{
|
|
ParseVorbisComments(fr, loop_start, startass, loop_end, endass);
|
|
return;
|
|
}
|
|
|
|
if(fr.Seek(blocksize, FileRdr::SeekCur) == -1)
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void FindOggComments(FileRdr &fr, uint32_t *loop_start, bool *startass, uint32_t *loop_end, bool *endass)
|
|
{
|
|
uint8_t ogghead[27];
|
|
|
|
// We already read and verified the OggS marker, so skip the first 4 bytes
|
|
// of the Ogg page header.
|
|
while(fr.Read(ogghead+4, 23) == 23)
|
|
{
|
|
// The 19th byte of the Ogg header is a 32LE integer for the page
|
|
// number, and the 27th is a uint8 for the number of segments in the
|
|
// page.
|
|
uint32_t ogg_pagenum = ogghead[18] | (ogghead[19]<<8) | (ogghead[20]<<16) |
|
|
(ogghead[21]<<24);
|
|
uint8_t ogg_segments = ogghead[26];
|
|
|
|
// Following the Ogg page header is a series of uint8s for the length of
|
|
// each segment in the page. The page segment data follows contiguously
|
|
// after.
|
|
uint8_t segsizes[256];
|
|
if(fr.Read(segsizes, ogg_segments) != ogg_segments)
|
|
break;
|
|
|
|
// Find the segment with the Vorbis Comment packet (type 3)
|
|
for(int i = 0; i < ogg_segments; ++i)
|
|
{
|
|
uint8_t segsize = segsizes[i];
|
|
|
|
if(segsize > 16)
|
|
{
|
|
uint8_t vorbhead[7];
|
|
if(fr.Read(vorbhead, 7) != 7)
|
|
return;
|
|
|
|
if(vorbhead[0] == 3 && memcmp(vorbhead+1, "vorbis", 6) == 0)
|
|
{
|
|
// If the packet is 'laced', it spans multiple segments (a
|
|
// segment size of 255 indicates the next segment continues
|
|
// the packet, ending with a size less than 255). Vorbis
|
|
// packets always start and end on segment boundaries. A
|
|
// packet that's an exact multiple of 255 ends with a
|
|
// segment of 0 size.
|
|
while(segsize == 255 && ++i < ogg_segments)
|
|
segsize = segsizes[i];
|
|
|
|
// TODO: A Vorbis packet can theoretically span multiple
|
|
// Ogg pages (e.g. start in the last segment of one page
|
|
// and end in the first segment of a following page). That
|
|
// will require extra logic to decode as the VC block will
|
|
// be broken up with non-Vorbis data in-between. For now,
|
|
// just handle the common case where it's all in one page.
|
|
if(i < ogg_segments)
|
|
ParseVorbisComments(fr, loop_start, startass, loop_end, endass);
|
|
return;
|
|
}
|
|
|
|
segsize -= 7;
|
|
}
|
|
if(fr.Seek(segsize, FileRdr::SeekCur) == -1)
|
|
return;
|
|
}
|
|
|
|
// Don't keep looking after the third page
|
|
if(ogg_pagenum >= 2)
|
|
break;
|
|
|
|
if(fr.Read(ogghead, 4) != 4 || memcmp(ogghead, "OggS", 4) != 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
void FindLoopTags(FileRdr &fr, uint32_t *start, bool *startass, uint32_t *end, bool *endass)
|
|
{
|
|
uint8_t signature[4];
|
|
|
|
fr.Read(signature, 4);
|
|
if(memcmp(signature, "fLaC", 4) == 0)
|
|
FindFlacComments(fr, start, startass, end, endass);
|
|
else if(memcmp(signature, "OggS", 4) == 0)
|
|
FindOggComments(fr, start, startass, end, endass);
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFile_OpenSong
|
|
//
|
|
//==========================================================================
|
|
|
|
MusInfo *SndFile_OpenSong(FileRdr &fr)
|
|
{
|
|
fr.Seek(0, FileRdr::SeekSet);
|
|
|
|
uint32_t loop_start = 0, loop_end = ~0u;
|
|
bool startass = false, endass = false;
|
|
FindLoopTags(fr, &loop_start, &startass, &loop_end, &endass);
|
|
|
|
fr.Seek(0, FileRdr::SeekSet);
|
|
auto decoder = SoundRenderer::CreateDecoder(fr);
|
|
if (decoder == nullptr) return nullptr;
|
|
return new SndFileSong(fr, decoder, loop_start, loop_end, startass, endass);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFileSong - Constructor
|
|
//
|
|
//==========================================================================
|
|
|
|
SndFileSong::SndFileSong(FileRdr &reader, SoundDecoder *decoder, uint32_t loop_start, uint32_t loop_end, bool startass, bool endass)
|
|
{
|
|
ChannelConfig iChannels;
|
|
SampleType Type;
|
|
|
|
decoder->getInfo(&SampleRate, &iChannels, &Type);
|
|
|
|
if (!startass) loop_start = Scale(loop_start, SampleRate, 1000);
|
|
if (!endass) loop_end = Scale(loop_end, SampleRate, 1000);
|
|
|
|
Loop_Start = loop_start;
|
|
Loop_End = clamp<uint32_t>(loop_end, 0, (uint32_t)decoder->getSampleLength());
|
|
Reader = std::move(reader);
|
|
Decoder = decoder;
|
|
Channels = iChannels == ChannelConfig_Stereo? 2:1;
|
|
m_Stream = GSnd->CreateStream(Read, snd_streambuffersize * 1024, iChannels == ChannelConfig_Stereo? 0 : SoundStream::Mono, SampleRate, this);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFileSong - Destructor
|
|
//
|
|
//==========================================================================
|
|
|
|
SndFileSong::~SndFileSong()
|
|
{
|
|
Stop();
|
|
if (m_Stream != nullptr)
|
|
{
|
|
delete m_Stream;
|
|
m_Stream = nullptr;
|
|
}
|
|
if (Decoder != nullptr)
|
|
{
|
|
delete Decoder;
|
|
}
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFileSong :: Play
|
|
//
|
|
//==========================================================================
|
|
|
|
void SndFileSong::Play(bool looping, int track)
|
|
{
|
|
m_Status = STATE_Stopped;
|
|
m_Looping = looping;
|
|
if (m_Stream->Play(looping, 1))
|
|
{
|
|
m_Status = STATE_Playing;
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFileSong :: SetSubsong
|
|
//
|
|
//==========================================================================
|
|
|
|
bool SndFileSong::SetSubsong(int track)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFileSong :: GetStats
|
|
//
|
|
//==========================================================================
|
|
|
|
FString SndFileSong::GetStats()
|
|
{
|
|
FString out;
|
|
|
|
size_t SamplePos;
|
|
|
|
SamplePos = Decoder->getSampleOffset();
|
|
int time = int (SamplePos / SampleRate);
|
|
|
|
out.Format(
|
|
"Track: " TEXTCOLOR_YELLOW "%s, %dHz" TEXTCOLOR_NORMAL
|
|
" Time:" TEXTCOLOR_YELLOW "%02d:%02d" TEXTCOLOR_NORMAL,
|
|
Channels == 2? "Stereo" : "Mono", SampleRate,
|
|
time/60,
|
|
time % 60);
|
|
return out;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// SndFileSong :: Read STATIC
|
|
//
|
|
//==========================================================================
|
|
|
|
bool SndFileSong::Read(SoundStream *stream, void *vbuff, int ilen, void *userdata)
|
|
{
|
|
char *buff = (char*)vbuff;
|
|
SndFileSong *song = (SndFileSong *)userdata;
|
|
song->CritSec.Enter();
|
|
|
|
size_t len = size_t(ilen);
|
|
size_t currentpos = song->Decoder->getSampleOffset();
|
|
size_t framestoread = len / (song->Channels*2);
|
|
bool err = false;
|
|
if (!song->m_Looping)
|
|
{
|
|
size_t maxpos = song->Decoder->getSampleLength();
|
|
if (currentpos == maxpos)
|
|
{
|
|
memset(buff, 0, len);
|
|
song->CritSec.Leave();
|
|
return false;
|
|
}
|
|
if (currentpos + framestoread > maxpos)
|
|
{
|
|
size_t got = song->Decoder->read(buff, (maxpos - currentpos) * song->Channels * 2);
|
|
memset(buff + got, 0, len - got);
|
|
}
|
|
else
|
|
{
|
|
size_t got = song->Decoder->read(buff, len);
|
|
err = (got != len);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This looks a bit more complicated than necessary because libmpg123 will not read the full requested length for the last block in the file.
|
|
if (currentpos + framestoread > song->Loop_End)
|
|
{
|
|
size_t endblock = (song->Loop_End - currentpos) * song->Channels * 2;
|
|
size_t endlen = song->Decoder->read(buff, endblock);
|
|
|
|
// Even if zero bytes was read give it a chance to start from the beginning
|
|
buff = buff + endlen;
|
|
len -= endlen;
|
|
song->Decoder->seek(song->Loop_Start, false, true);
|
|
}
|
|
while (len > 0)
|
|
{
|
|
size_t readlen = song->Decoder->read(buff, len);
|
|
if (readlen == 0)
|
|
{
|
|
song->CritSec.Leave();
|
|
return false;
|
|
}
|
|
buff += readlen;
|
|
len -= readlen;
|
|
if (len > 0)
|
|
{
|
|
song->Decoder->seek(song->Loop_Start, false, true);
|
|
}
|
|
}
|
|
}
|
|
song->CritSec.Leave();
|
|
return true;
|
|
}
|