winamp/Src/Plugins/Input/in_mp4/ExtendedRead.cpp
2024-09-24 14:54:57 +02:00

240 lines
6.8 KiB
C++

#include <stddef.h>
#include "main.h"
#include "mpeg4audio.h"
#include "api__in_mp4.h"
#include <api/service/waservicefactory.h>
#include <assert.h>
#include "../nu/GaplessRingBuffer.h"
#include "virtualIO.h"
struct ExtendedRead
{
ExtendedRead() : mp4(0), mp4track(0), sampleId(1),
samples(0), audio(0), audioFactory(0), frameSize(0), reader(0),
sample_rate(0), timescale(0), max_sample_size(0), sample_buffer(0), decode_buffer(0)
{}
~ExtendedRead()
{
if (mp4) MP4Close(mp4); mp4 = 0;
if (reader) DestroyUnicodeReader(reader); reader=0;
if (audio)
{
audio->Close();
audioFactory->releaseInterface(audio);
}
audioFactory = 0;
audio = 0;
free(sample_buffer);
sample_buffer=0;
free(decode_buffer);
}
bool Open(const wchar_t *fn, int *size, int *bps, int *nch, int *srate, bool useFloat);
MP4AudioDecoder *audio;
MP4FileHandle mp4;
MP4TrackId mp4track;
MP4SampleId sampleId, samples;
GaplessRingBuffer ringBuffer;
void *reader;
waServiceFactory *audioFactory;
size_t frameSize;
unsigned int sample_rate;
uint32_t timescale;
uint32_t max_sample_size;
void *sample_buffer;
uint8_t *decode_buffer;
};
bool ExtendedRead::Open(const wchar_t *fn, int *size, int *bps, int *nch, int *srate, bool useFloat)
{
unsigned __int32 pregap, postgap;
int numBits = *bps;
int numChannels = *nch;
reader = CreateUnicodeReader(fn);
if (!reader)
return false;
mp4 = MP4ReadEx(fn, reader, &UnicodeIO);
if (!mp4)
{
DestroyUnicodeReader(reader);
return false;
}
mp4track = GetAudioTrack(mp4);
if (mp4track == MP4_INVALID_TRACK_ID) return false;
if (!CreateDecoder(mp4, mp4track, audio, audioFactory))
return false;
int result;
result = audio->OpenMP4(mp4, mp4track, numBits, numChannels, useFloat);
if (result != MP4_SUCCESS)
return false;
GetGaps(mp4, pregap, postgap);
ConfigureDecoderASC(mp4, mp4track, audio);
timescale = MP4GetTrackTimeScale(mp4, mp4track);
samples = MP4GetTrackNumberOfSamples(mp4, mp4track);
MP4SampleId sample = 0;
// some codecs require a frame or two to get decoded. so we'll go until GetOutputProperties is valid
for (MP4SampleId sample = 1;sample <= samples; sample++)
{
int ret;
if (useFloat)
{
bool verifyFloat = false;
ret = audio->GetOutputPropertiesEx(&sample_rate, reinterpret_cast<unsigned int *>(nch), reinterpret_cast<unsigned int *>(bps), &verifyFloat);
if (ret == MP4_SUCCESS && !verifyFloat)
return false;
}
else
{
ret = audio->GetOutputProperties(&sample_rate, reinterpret_cast<unsigned int *>(nch), reinterpret_cast<unsigned int *>(bps));
}
if (ret == MP4_SUCCESS)
{
MP4Duration duration = MP4GetTrackDuration(mp4, mp4track);
*srate = sample_rate;
frameSize = (*nch) * (*bps / 8);
size_t outputFrameSize;
*size = duration * frameSize;
if (audio->OutputFrameSize(&outputFrameSize) == MP4_SUCCESS)
{
}
else
{
outputFrameSize = 65536; // err on the side of caution
}
decode_buffer = (uint8_t *)malloc(outputFrameSize*frameSize);
ringBuffer.Initialize(outputFrameSize, *bps, *nch, pregap, postgap);
max_sample_size = MP4GetTrackMaxSampleSize(mp4, mp4track);
sample_buffer = malloc(max_sample_size);
if (sample != 1) {
audio->Flush();
}
return true;
}
unsigned char *buffer = NULL;
unsigned __int32 buffer_size = 0;
if (MP4ReadSample(mp4, mp4track, sample, (unsigned __int8 **)&buffer, &buffer_size))
{
unsigned char tempBuf[65536];
size_t outSize = 65536;
int err = audio->DecodeSample(buffer, buffer_size, tempBuf, &outSize);
MP4Free(buffer);
if (err != MP4_SUCCESS)
continue;
}
}
return false;
}
extern "C"
{
//returns handle!=0 if successful, 0 if error
//size will return the final nb of bytes written to the output, -1 if unknown
__declspec( dllexport ) intptr_t winampGetExtendedRead_openW(const wchar_t *fn, int *size, int *bps, int *nch, int *srate)
{
ExtendedRead *ext = new ExtendedRead;
if (ext->Open(fn, size, bps, nch, srate, false))
return reinterpret_cast<intptr_t>(ext);
delete ext;
return 0;
}
//returns handle!=0 if successful, 0 if error
//size will return the final nb of bytes written to the output, -1 if unknown
__declspec( dllexport ) intptr_t winampGetExtendedRead_openW_float(const wchar_t *fn, int *size, int *bps, int *nch, int *srate)
{
ExtendedRead *ext = new ExtendedRead;
if (ext->Open(fn, size, bps, nch, srate, true))
return reinterpret_cast<intptr_t>(ext);
delete ext;
return 0;
}
//returns nb of bytes read. -1 if read error (like CD ejected). if (ret == 0), EOF is assumed
__declspec( dllexport ) intptr_t winampGetExtendedRead_getData(intptr_t handle, char *dest, int len, volatile int *killswitch)
{
ExtendedRead *ext = (ExtendedRead *)handle;
int bytesCopied = 0;
int skip = 0;
len -= (len % ext->frameSize); // round down to the nearest whole frame size
while (len && !*killswitch)
{
size_t copySize = ext->ringBuffer.Read(dest, len);
len -= copySize;
dest += copySize;
bytesCopied += copySize;
if (ext->ringBuffer.Empty())
{
size_t outSize = 0;
MP4Duration offset=0,duration=INT_MAX;
if (ext->sampleId <= ext->samples) {
unsigned char *buffer = (unsigned char *)ext->sample_buffer;
unsigned __int32 buffer_size = ext->max_sample_size;
MP4ReadSample(ext->mp4, ext->mp4track, ext->sampleId++, (unsigned __int8 **) & buffer, &buffer_size, 0, &duration, &offset);
ext->audio->DecodeSample(buffer, buffer_size, ext->decode_buffer, &outSize); // TODO error check
} else {
#if 0 // TODO Drain decode
ext->audio->DecodeSample(0, 0, decode_buffer, &outSize); // TODO Drain method?
#else
#endif
return bytesCopied;
}
// convert to the track timescale for purposes of duration/offset/gap stuff
int outSamples = MulDiv(outSize, ext->timescale, ext->sample_rate * ext->frameSize);
if (offset > 0)
outSamples -= min(outSamples, offset);
if (outSamples > duration)
outSamples = duration;
// convert back to sample rate timescale
outSize = MulDiv(ext->sample_rate * ext->frameSize, outSamples, ext->timescale);
ext->ringBuffer.Write(ext->decode_buffer+offset*ext->frameSize, outSize);
}
}
return bytesCopied;
}
// return nonzero on success, zero on failure.
__declspec( dllexport ) int winampGetExtendedRead_setTime(intptr_t handle, int millisecs)
{
ExtendedRead *ext = (ExtendedRead *)handle;
MP4Duration duration = MP4ConvertToTrackDuration(ext->mp4, ext->mp4track, millisecs, MP4_MSECS_TIME_SCALE);
if(duration == MP4_INVALID_DURATION) return 0;
MP4SampleId newSampleId = MP4GetSampleIdFromTime(ext->mp4, ext->mp4track, duration);
if(newSampleId > ext->samples) return 0;
ext->sampleId = newSampleId;
ext->audio->Flush();
// ext->bufferUsed=0;
ext->ringBuffer.Reset();
return 1;
}
__declspec( dllexport ) void winampGetExtendedRead_close(intptr_t handle)
{
ExtendedRead *ext = (ExtendedRead *)handle;
delete ext;
}
}