libgui/source/sounds/Mp3Decoder.cpp

201 lines
5.6 KiB
C++
Raw Normal View History

2017-10-29 10:28:14 +01:00
/***************************************************************************
* Copyright (C) 2010
* by Dimok
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any
* damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any
* purpose, including commercial applications, and to alter it and
* redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you
* must not claim that you wrote the original software. If you use
* this software in a product, an acknowledgment in the product
* documentation would be appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and
* must not be misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source
* distribution.
*
* for WiiXplorer 2010
***************************************************************************/
#include <string>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <malloc.h>
#include <math.h>
2018-06-21 20:44:58 +02:00
#include <coreinit/time.h>
#include <coreinit/thread.h>
2019-08-14 23:24:55 +02:00
#include <gui/sounds/Mp3Decoder.hpp>
#include "fs/CFile.hpp"
2017-10-29 10:28:14 +01:00
2020-08-13 12:38:07 +02:00
Mp3Decoder::Mp3Decoder(const char *filepath)
: SoundDecoder(filepath) {
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
if (!file_fd)
return;
OpenFile();
2017-10-29 10:28:14 +01:00
}
2020-08-13 12:38:07 +02:00
Mp3Decoder::Mp3Decoder(const uint8_t *snd, int32_t len)
: SoundDecoder(snd, len) {
SoundType = SOUND_MP3;
ReadBuffer = NULL;
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
2017-10-29 10:28:14 +01:00
2020-08-13 12:38:07 +02:00
if (!file_fd)
return;
2017-10-29 10:28:14 +01:00
2020-08-13 12:38:07 +02:00
OpenFile();
2017-10-29 10:28:14 +01:00
}
2020-08-13 12:38:07 +02:00
Mp3Decoder::~Mp3Decoder() {
ExitRequested = true;
while (Decoding)
OSSleepTicks(OSMicrosecondsToTicks(100));
2017-10-29 10:28:14 +01:00
2020-08-13 12:38:07 +02:00
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
2017-10-29 10:28:14 +01:00
2020-08-13 12:38:07 +02:00
if (ReadBuffer)
free(ReadBuffer);
ReadBuffer = NULL;
2017-10-29 10:28:14 +01:00
}
2020-08-13 12:38:07 +02:00
void Mp3Decoder::OpenFile() {
GuardPtr = NULL;
ReadBuffer = (uint8_t *) memalign(32, SoundBlockSize * SoundBlocks);
if (!ReadBuffer) {
if (file_fd)
delete file_fd;
file_fd = NULL;
return;
}
uint8_t dummybuff[4096];
int32_t ret = Read(dummybuff, 4096, 0);
if (ret <= 0) {
if (file_fd)
delete file_fd;
file_fd = NULL;
return;
}
SampleRate = (uint32_t) Frame.header.samplerate;
Format = ((MAD_NCHANNELS(&Frame.header) == 2) ? (FORMAT_PCM_16_BIT | CHANNELS_STEREO) : (FORMAT_PCM_16_BIT | CHANNELS_MONO));
Rewind();
2017-10-29 10:28:14 +01:00
}
2020-08-13 12:38:07 +02:00
int32_t Mp3Decoder::Rewind() {
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
mad_timer_reset(&Timer);
mad_stream_init(&Stream);
mad_frame_init(&Frame);
mad_synth_init(&Synth);
SynthPos = 0;
GuardPtr = NULL;
if (!file_fd)
return -1;
return SoundDecoder::Rewind();
2017-10-29 10:28:14 +01:00
}
2020-08-13 12:38:07 +02:00
static inline int16_t FixedToShort(mad_fixed_t Fixed) {
/* Clipping */
if (Fixed >= MAD_F_ONE)
return (SHRT_MAX);
if (Fixed <= -MAD_F_ONE)
return (-SHRT_MAX);
2017-10-29 10:28:14 +01:00
2020-08-13 12:38:07 +02:00
Fixed = Fixed >> (MAD_F_FRACBITS - 15);
return ((int16_t) Fixed);
2017-10-29 10:28:14 +01:00
}
2020-08-13 12:38:07 +02:00
int32_t Mp3Decoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
if (!file_fd)
return -1;
if (Format == (FORMAT_PCM_16_BIT | CHANNELS_STEREO))
buffer_size &= ~0x0003;
else
buffer_size &= ~0x0001;
uint8_t *write_pos = buffer;
uint8_t *write_end = buffer + buffer_size;
while (1) {
while (SynthPos < Synth.pcm.length) {
if (write_pos >= write_end)
return write_pos - buffer;
*((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
write_pos += 2;
if (MAD_NCHANNELS(&Frame.header) == 2) {
*((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
write_pos += 2;
}
SynthPos++;
}
if (Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN) {
uint8_t *ReadStart = ReadBuffer;
int32_t ReadSize = SoundBlockSize * SoundBlocks;
int32_t Remaining = 0;
if (Stream.next_frame != NULL) {
Remaining = Stream.bufend - Stream.next_frame;
memmove(ReadBuffer, Stream.next_frame, Remaining);
ReadStart += Remaining;
ReadSize -= Remaining;
}
ReadSize = file_fd->read(ReadStart, ReadSize);
if (ReadSize <= 0) {
GuardPtr = ReadStart;
memset(GuardPtr, 0, MAD_BUFFER_GUARD);
ReadSize = MAD_BUFFER_GUARD;
}
CurPos += ReadSize;
mad_stream_buffer(&Stream, ReadBuffer, Remaining + ReadSize);
}
if (mad_frame_decode(&Frame, &Stream)) {
if (MAD_RECOVERABLE(Stream.error)) {
if (Stream.error != MAD_ERROR_LOSTSYNC || !GuardPtr)
continue;
} else {
if (Stream.error != MAD_ERROR_BUFLEN)
return -1;
else if (Stream.error == MAD_ERROR_BUFLEN && GuardPtr)
return -1;
}
}
mad_timer_add(&Timer, Frame.header.duration);
mad_synth_frame(&Synth, &Frame);
SynthPos = 0;
}
return 0;
2017-10-29 10:28:14 +01:00
}