moparisthebest
/
alt64
mirror of https://github.com/parasyte/alt64
1
0
Fork 0
Code Issues Releases Wiki Activity

Fix some whitespace horrors!

This commit is contained in:
Jay Oster 2014-06-29 22:37:40 -07:00
parent 174d9d96e6
commit 050db8b445
2 changed files with 3757 additions and 4931 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8276
menu.c
View File

File diff suppressed because it is too large Load Diff

412
mp3.c
View File

@ -14,8 +14,8 @@ static struct mad_synth Synth;
static mad_timer_t Timer; static mad_timer_t Timer;
typedef struct { typedef struct {
short left; short left;
short right; short right;
} Sample; } Sample;
static int eos; static int eos;
@ -39,88 +39,71 @@ extern char path[1024];
extern void c2wstrcpy(void *dst, void *src); extern void c2wstrcpy(void *dst, void *src);
extern void c2wstrcat(void *dst, void *src); extern void c2wstrcat(void *dst, void *src);
static int mp3_seek(char* fd, int offset, int whence) {
//todo filesize and mp3File_fptr;
long offs = 0;
// libff routine
switch (whence)
{
case SEEK_SET:
offs = offset;
break;
case SEEK_CUR:
offs = mp3File_fptr + offset;
break;
case SEEK_END:
offs = mp3File_fsize + offset;
break;
}
//f_lseek(&mp3File, offs);
mp3File_fptr=offs;
static int mp3_seek(char* fd, int offset, int whence) return offs;
{
//todo filesize and mp3File_fptr;
long offs = 0;
// libff routine
switch (whence)
{
case SEEK_SET:
offs = offset;
break;
case SEEK_CUR:
offs = mp3File_fptr + offset;
break;
case SEEK_END:
offs = mp3File_fsize + offset;
break;
}
//f_lseek(&mp3File, offs);
mp3File_fptr=offs;
return offs;
} }
static int mp3_size(char* fd) static int mp3_size(char* fd) {
{ FatRecord rec_tmpf;
FatRecord rec_tmpf; u8 resp=0;
u8 resp=0; resp = fatOpenFileByeName(fd, 0); //err if not found ^^
resp = fatOpenFileByeName(fd, 0); //err if not found ^^
int fsize = file.sec_available*512; //fsize in bytes
mp3File_fsize = fsize;
//todo filesize
return mp3File_fsize;
int fsize = file.sec_available*512; //fsize in bytes
mp3File_fsize = fsize;
//todo filesize
return mp3File_fsize;
} }
static void _f_read(char* fname, unsigned char *readBuffer, int size){ static void _f_read(char* fname, unsigned char *readBuffer, int size){
/* /*
FatRecord rec_tmpf; FatRecord rec_tmpf;
u8 resp=0; u8 resp=0;
resp = fatOpenFileByeName(fname, 0); //err if not found ^^ resp = fatOpenFileByeName(fname, 0); //err if not found ^^
int fsize = file.sec_available*512; //fsize in bytes int fsize = file.sec_available*512; //fsize in bytes
mp3File_fsize = fsize; mp3File_fsize = fsize;
//injecting in buffer... slow but working :/
if(file.sec_available*512>=size){
resp = fatReadPartialFile(readBuffer, size/512, mp3File_fptr);
//resp = fatReadFile(readBuffer+mp3File_fptr, size/512);//file.sec_available);
mp3File_fptr+=size;
//injecting in buffer... slow but working :/ }
if(file.sec_available*512>=size){ //dma_write_s(buffer, 0xb0000000, fsize);
resp = fatReadPartialFile(readBuffer, size/512, mp3File_fptr);
//resp = fatReadFile(readBuffer+mp3File_fptr, size/512);//file.sec_available);
mp3File_fptr+=size;
}
//dma_write_s(buffer, 0xb0000000, fsize);
*/ */
} }
static int mp3_read(char* fd, unsigned char *ptr, int size) static int mp3_read(char* fd, unsigned char *ptr, int size)
{ {
int ts=size; int ts=size;
_f_read(fd, ptr, size); _f_read(fd, ptr, size);
return ts; return ts;
} }
static int id3_tag_size(unsigned char const *buf, int remaining) static int id3_tag_size(unsigned char const *buf, int remaining) {
{ int size;
int size;
if (remaining < 10) if (remaining < 10)
return 0; return 0;
if (!strncmp((char*)buf, "ID3", 3) || !strncmp((char*)buf, "ea3", 3)) //skip past id3v2 header, which can cause a false sync to be found if (!strncmp((char*)buf, "ID3", 3) || !strncmp((char*)buf, "ea3", 3)) //skip past id3v2 header, which can cause a false sync to be found
{ {
@ -135,7 +118,7 @@ static int id3_tag_size(unsigned char const *buf, int remaining)
if (buf[5] & 0x10) //has footer if (buf[5] & 0x10) //has footer
size += 10; size += 10;
} }
return size; return size;
} }
//Seek next valid frame after ID3/EA3 header //Seek next valid frame after ID3/EA3 header
@ -164,13 +147,12 @@ static int MP3_SkipHdr(char* fd)
if (buf[5] & 0x10) //has footer if (buf[5] & 0x10) //has footer
size += 10; size += 10;
offset += size; offset += size;
} }
mp3_seek(fd, offset, SEEK_SET); mp3_seek(fd, offset, SEEK_SET);
//now seek for a sync //now seek for a sync
while(1) while(1) {
{
offset = mp3_seek(fd, 0, SEEK_CUR); offset = mp3_seek(fd, 0, SEEK_CUR);
size = mp3_read(fd, buf, sizeof(buf)); size = mp3_read(fd, buf, sizeof(buf));
@ -184,125 +166,108 @@ static int MP3_SkipHdr(char* fd)
} }
pBuffer = buf; pBuffer = buf;
for( i = 0; i < size; i++) for( i = 0; i < size; i++) {
{
//if this is a valid frame sync (0xe0 is for mpeg version 2.5,2+1) //if this is a valid frame sync (0xe0 is for mpeg version 2.5,2+1)
if ( (pBuffer[i] == 0xff) && ((pBuffer[i+1] & 0xE0) == 0xE0) ) if ( (pBuffer[i] == 0xff) && ((pBuffer[i+1] & 0xE0) == 0xE0) ) {
{
offset += i; offset += i;
mp3_seek(fd, offset, SEEK_SET); mp3_seek(fd, offset, SEEK_SET);
return offset; return offset;
} }
} }
//go back two bytes to catch any syncs that on the boundary //go back two bytes to catch any syncs that on the boundary
mp3_seek(fd, -2, SEEK_CUR); mp3_seek(fd, -2, SEEK_CUR);
} }
} }
static short convertSample(mad_fixed_t Fixed) static short convertSample(mad_fixed_t Fixed) {
{
/* Clipping */ /* Clipping */
if (Fixed >= MAD_F_ONE) if (Fixed >= MAD_F_ONE)
return (32767); return (32767);
if (Fixed <= -MAD_F_ONE) if (Fixed <= -MAD_F_ONE)
return (-32768); return (-32768);
/* Conversion. */ /* Conversion. */
Fixed = Fixed >> (MAD_F_FRACBITS - 15); Fixed = Fixed >> (MAD_F_FRACBITS - 15);
return ((short)Fixed);
return ((short)Fixed);
} }
static int fillFileBuffer() static int fillFileBuffer() {
{ int leftOver = Stream.bufend - Stream.next_frame;
int leftOver = Stream.bufend - Stream.next_frame; int want = INPUT_BUFFER_SIZE - leftOver;
int want = INPUT_BUFFER_SIZE - leftOver;
// move left-over bytes // move left-over bytes
if (leftOver > 0) if (leftOver > 0)
memmove(fileBuffer, fileBuffer + want, leftOver); memmove(fileBuffer, fileBuffer + want, leftOver);
// fill remainder of buffer // fill remainder of buffer
unsigned char* bufferPos = fileBuffer + leftOver; unsigned char* bufferPos = fileBuffer + leftOver;
while (want > 0) while (want > 0) {
{ int got = mp3_read(mp3Fd, bufferPos, want);
int got = mp3_read(mp3Fd, bufferPos, want); if (got <= 0)
if (got <= 0) return 1; // EOF
return 1; // EOF
want -= got; want -= got;
bufferPos += got; bufferPos += got;
} }
return 0; return 0;
} }
static void decode() static void decode() {
{ while (mad_frame_decode(&Frame, &Stream) == -1) {
while (mad_frame_decode(&Frame, &Stream) == -1) if ((Stream.error == MAD_ERROR_BUFLEN) || (Stream.error == MAD_ERROR_BUFPTR)) {
{ if (fillFileBuffer()) {
if ((Stream.error == MAD_ERROR_BUFLEN) || (Stream.error == MAD_ERROR_BUFPTR)) eos = 1;
{ break;
if (fillFileBuffer()) }
{ mad_stream_buffer(&Stream, fileBuffer, INPUT_BUFFER_SIZE);
eos = 1; }
break; else if (Stream.error == MAD_ERROR_LOSTSYNC) {
} /* LOSTSYNC - due to ID3 tags? */
mad_stream_buffer(&Stream, fileBuffer, INPUT_BUFFER_SIZE);
}
else if (Stream.error == MAD_ERROR_LOSTSYNC)
{
/* LOSTSYNC - due to ID3 tags? */
int tagsize = id3_tag_size(Stream.this_frame, Stream.bufend - Stream.this_frame); int tagsize = id3_tag_size(Stream.this_frame, Stream.bufend - Stream.this_frame);
if (tagsize > 0) if (tagsize > 0) {
{ mad_stream_skip (&Stream, tagsize);
mad_stream_skip (&Stream, tagsize);
continue; continue;
} }
} }
} }
mad_timer_add(&Timer, Frame.header.duration); mad_timer_add(&Timer, Frame.header.duration);
mad_synth_frame(&Synth, &Frame); mad_synth_frame(&Synth, &Frame);
} }
static void convertLeftSamples(Sample* first, Sample* last, const mad_fixed_t* src) static void convertLeftSamples(Sample* first, Sample* last, const mad_fixed_t* src) {
{ for (Sample *dst = first; dst != last; ++dst)
for (Sample *dst = first; dst != last; ++dst) dst->left = convertSample(*src++);
dst->left = convertSample(*src++);
} }
static void convertRightSamples(Sample* first, Sample* last, const mad_fixed_t* src) static void convertRightSamples(Sample* first, Sample* last, const mad_fixed_t* src) {
{ for (Sample *dst = first; dst != last; ++dst)
for (Sample *dst = first; dst != last; ++dst) dst->right = convertSample(*src++);
dst->right = convertSample(*src++);
} }
static void MP3_Callback(void *buffer, unsigned int samplesToWrite) static void MP3_Callback(void *buffer, unsigned int samplesToWrite) {
{
Sample *destination = (Sample*)buffer; Sample *destination = (Sample*)buffer;
while (samplesToWrite > 0) while (samplesToWrite > 0) {
{ while (!eos && (Synth.pcm.length == 0))
while (!eos && (Synth.pcm.length == 0)) decode();
decode();
if (eos) if (eos) {
{ // done
// done memset(destination, 0, samplesToWrite*4);
memset(destination, 0, samplesToWrite*4); break;
break; }
}
unsigned int samplesAvailable = Synth.pcm.length - samplesRead; unsigned int samplesAvailable = Synth.pcm.length - samplesRead;
if (samplesAvailable > samplesToWrite) if (samplesAvailable > samplesToWrite) {
{
convertLeftSamples(destination, destination + samplesToWrite, &Synth.pcm.samples[0][samplesRead]); convertLeftSamples(destination, destination + samplesToWrite, &Synth.pcm.samples[0][samplesRead]);
convertRightSamples(destination, destination + samplesToWrite, &Synth.pcm.samples[1][samplesRead]); convertRightSamples(destination, destination + samplesToWrite, &Synth.pcm.samples[1][samplesRead]);
samplesRead += samplesToWrite; samplesRead += samplesToWrite;
samplesToWrite = 0; samplesToWrite = 0;
} }
else else {
{
convertLeftSamples(destination, destination + samplesAvailable, &Synth.pcm.samples[0][samplesRead]); convertLeftSamples(destination, destination + samplesAvailable, &Synth.pcm.samples[0][samplesRead]);
convertRightSamples(destination, destination + samplesAvailable, &Synth.pcm.samples[1][samplesRead]); convertRightSamples(destination, destination + samplesAvailable, &Synth.pcm.samples[1][samplesRead]);
@ -310,137 +275,124 @@ static void MP3_Callback(void *buffer, unsigned int samplesToWrite)
samplesToWrite -= samplesAvailable; samplesToWrite -= samplesAvailable;
samplesRead = 0; samplesRead = 0;
decode(); decode();
} }
} }
} }
static void MP3_Init() static void MP3_Init() {
{
/* First the structures used by libmad must be initialized. */ /* First the structures used by libmad must be initialized. */
mad_stream_init(&Stream); mad_stream_init(&Stream);
mad_header_init(&Header); mad_header_init(&Header);
mad_frame_init(&Frame); mad_frame_init(&Frame);
mad_synth_init(&Synth); mad_synth_init(&Synth);
mad_timer_reset(&Timer); mad_timer_reset(&Timer);
} }
static void MP3_Exit() static void MP3_Exit() {
{
mad_synth_finish(&Synth); mad_synth_finish(&Synth);
mad_header_finish(&Header); mad_header_finish(&Header);
mad_frame_finish(&Frame); mad_frame_finish(&Frame);
mad_stream_finish(&Stream); mad_stream_finish(&Stream);
} }
static void MP3_GetInfo(long long *samples, int *rate) static void MP3_GetInfo(long long *samples, int *rate) {
{ unsigned long FrameCount = 0;
unsigned long FrameCount = 0;
int bufferSize = 1024*512; int bufferSize = 1024*512;
unsigned char *localBuffer; unsigned char *localBuffer;
long red = 0; long red = 0;
double totalBitrate = 0.0; double totalBitrate = 0.0;
double mediumBitrate = 0.0; double mediumBitrate = 0.0;
struct mad_stream stream; struct mad_stream stream;
struct mad_header header; struct mad_header header;
int size = mp3_size(mp3Fd); int size = mp3_size(mp3Fd);
long count = size; long count = size;
mad_stream_init (&stream); mad_stream_init (&stream);
mad_header_init (&header); mad_header_init (&header);
localBuffer = (unsigned char *)malloc(bufferSize); localBuffer = (unsigned char *)malloc(bufferSize);
for (int i=0; i<3; i++) for (int i=0; i<3; i++) {
{
memset(localBuffer, 0, bufferSize); memset(localBuffer, 0, bufferSize);
if (count > bufferSize) if (count > bufferSize)
red = mp3_read(mp3Fd, localBuffer, bufferSize); red = mp3_read(mp3Fd, localBuffer, bufferSize);
else else
red = mp3_read(mp3Fd, localBuffer, count); red = mp3_read(mp3Fd, localBuffer, count);
count -= red; count -= red;
if (!red) if (!red)
break; // ran out of data break; // ran out of data
mad_stream_buffer (&stream, localBuffer, red); mad_stream_buffer (&stream, localBuffer, red);
while (1) while (1) {
{ if (mad_header_decode(&header, &stream) == -1) {
if (mad_header_decode(&header, &stream) == -1) if (stream.buffer == NULL || stream.error == MAD_ERROR_BUFLEN) {
{
if (stream.buffer == NULL || stream.error == MAD_ERROR_BUFLEN)
break; break;
else if (MAD_RECOVERABLE(stream.error)) }
{ else if (MAD_RECOVERABLE(stream.error)) {
continue; continue;
} }
else else {
{ break;
break; }
} }
} if (FrameCount++ == 0)
if (FrameCount++ == 0) *rate = header.samplerate;
*rate = header.samplerate; totalBitrate += header.bitrate;
totalBitrate += header.bitrate; }
} }
}
mediumBitrate = totalBitrate / (double)FrameCount; mediumBitrate = totalBitrate / (double)FrameCount;
int secs = size * 8 / mediumBitrate; int secs = size * 8 / mediumBitrate;
*samples = *rate * secs; *samples = *rate * secs;
mad_header_finish (&header); mad_header_finish (&header);
mad_stream_finish (&stream); mad_stream_finish (&stream);
if (localBuffer) if (localBuffer)
free(localBuffer); free(localBuffer);
mp3_seek(mp3Fd, 0, SEEK_SET); mp3_seek(mp3Fd, 0, SEEK_SET);
} }
void start_mp3(char *fname, long long *samples, int *rate, int *channels) void start_mp3(char *fname, long long *samples, int *rate, int *channels) {
{ sprintf(mp3Fd, "%s", fname);
sprintf(mp3Fd, "%s", fname); //if (mp3Fd[0]!=0)
//{
useReadBuffer = 0;
MP3_GetInfo(samples, rate);
*channels = 2;
//if (mp3Fd[0]!=0) MP3_Init();
//{ MP3_SkipHdr(mp3Fd);
useReadBuffer = 0; eos = readLen = readPos = 0;
MP3_GetInfo(samples, rate); useReadBuffer = 1;
*channels = 2; return;
//}
MP3_Init(); //*samples = 0;
MP3_SkipHdr(mp3Fd);
eos = readLen = readPos = 0;
useReadBuffer = 1;
return;
//}
//*samples = 0;
//return;
} }
void stop_mp3(void) void stop_mp3(void) {
{ MP3_Exit();
MP3_Exit(); mp3File_fptr=0;
mp3File_fptr=0;
/* /*
if (mp3Fd > 0) if (mp3Fd > 0)
{ {
if (gBrowser) if (gBrowser)
f_close(&mp3File); f_close(&mp3File);
else else
dfs_close(mp3Fd); dfs_close(mp3Fd);
} }
mp3Fd = -1; mp3Fd = -1;
*/ */
} }
int update_mp3(char *buf, int bytes) int update_mp3(char *buf, int bytes) {
{ MP3_Callback(buf, bytes/4);
MP3_Callback(buf, bytes/4); return eos ? 0 : 1;
return eos ? 0 : 1;
} }