random-mirrors/winamp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
community
winamp/Src/Plugins/Portable/pmp_ipod/iPodSD.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

524 lines
14 KiB
C++
Raw Permalink Blame History

#include "iPodSD.h"
#include <math.h>
#include <assert.h>
// get 3 bytes from data (used in iTunesSD1)
static __forceinline unsigned long get3(const uint8_t * data)
{
unsigned long ret = 0;
ret += ((unsigned long) data[0]) << 16;
ret += ((unsigned long) data[1]) << 8;
ret += ((unsigned long) data[2]);
return ret;
}
//write 3 bytes normal (used in iTunesSD1)
static __forceinline void put3(const unsigned long number, uint8_t * data)
{
data[0] = (uint8_t)(number >> 16) & 0xff;
data[1] = (uint8_t)(number >> 8) & 0xff;
data[2] = (uint8_t)number & 0xff;
}
// pass data and ptr, updates ptr automatically (by reference)
static __forceinline void write_uint64_t(uint8_t *data, size_t &offset, uint64_t value)
{
memcpy(&data[offset], &value, 8);
offset+=8;
}
// pass data and ptr, updates ptr automatically (by reference)
static __forceinline void write_uint32_t(uint8_t *data, size_t &offset, uint32_t value)
{
memcpy(&data[offset], &value, 4);
offset+=4;
}
// pass data and ptr, updates ptr automatically (by reference)
static __forceinline void write_uint16_t(uint8_t *data, size_t &offset, uint16_t value)
{
memcpy(&data[offset], &value, 2);
offset+=2;
}
// pass data and ptr, updates ptr automatically (by reference)
static __forceinline void write_uint8_t(uint8_t *data, size_t &offset, uint8_t value)
{
data[offset++] = value;
}
// pass data and ptr, updates ptr automatically (by reference)
static __forceinline void write_header(uint8_t *data, size_t &offset, const char *header)
{
data[offset++] = header[0];
data[offset++] = header[1];
data[offset++] = header[2];
data[offset++] = header[3];
}
// Case insensitive version of wcsstr
static wchar_t *wcsistr (const wchar_t *s1, const wchar_t *s2)
{
wchar_t *cp = (wchar_t*) s1;
wchar_t *s, *t, *endp;
wchar_t l, r;
endp = (wchar_t*)s1 + ( lstrlen(s1) - lstrlen(s2)) ;
while (cp && *cp && (cp <= endp))
{
s = cp;
t = (wchar_t*)s2;
while (s && *s && t && *t)
{
l = towupper(*s);
r = towupper(*t);
if (l != r)
break;
s++, t++;
}
if (*t == 0)
return cp;
cp = CharNext(cp);
}
return NULL;
}
//////////////////////////////////////////////////////////////////////
// iTunesSD1 - Classes for dealing with the iPodShuffle
//////////////////////////////////////////////////////////////////////
iTunesSD1::iTunesSD1()
{
}
iTunesSD1::~iTunesSD1()
{
}
long iTunesSD1::write(const iPod_mhlt::mhit_map_t *songs, unsigned char * data, const unsigned long datasize)
{
#ifdef IPODDB_PROFILER
profiler(iPodDB__iTunesSD_write);
#endif
const unsigned int numsongs = songs->size();
const unsigned int total_size = 18 + (numsongs * 558);
ASSERT(datasize >= total_size);
if(datasize < total_size)
return(-1);
long ptr=0;
put3(numsongs, &data[ptr]);
ptr+=3;
put3(0x010600, &data[ptr]);
ptr+=3;
put3(0x12, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
iPod_mhlt::mhit_map_t::const_iterator begin = songs->begin();
iPod_mhlt::mhit_map_t::const_iterator end = songs->end();
for(iPod_mhlt::mhit_map_t::const_iterator it = begin; it != end; it++)
{
iPod_mhit *m = ((*it).second);
iTunesSD_Song song(m);
long ret = song.write(&data[ptr], datasize - ptr);
if (ret < 0)
return ret;
ptr += ret;
}
return(ptr);
}
iTunesSD_Song::iTunesSD_Song(const iPod_mhit *m) : size_total(0x22e), starttime(0), stoptime(0), volume(0x64), filetype(0), playflags(iTunesSD_Song::SHUFFLE)
{
memset(filename, 0, (SDSONG_FILENAME_LEN + 1) * sizeof(wchar_t));
iPod_mhod *mhod = m->FindString(MHOD_LOCATION);
ASSERT(mhod);
if(mhod)
{
// Convert from HFS format (:iPod_Control:Music:F00:filename) to quasi-FAT format (/iPod_Control/Music/F00/filename) filepaths
SetFilename(mhod->str);
wchar_t *w = filename;
while(w && *w != '\0')
{
if(*w == ':')
*w = '/';
w = CharNext(w);
}
SetStartTime(m->starttime);
SetStopTime(m->stoptime);
int volume = (int)m->volume;
// If Sound Check information is present, use that instead of volume
if(m->soundcheck != 0)
{
// This code converts SoundCheck back into a gain value, then into a -255 to 255 mhit::volume value
const double gain = -10.0 * log10(m->soundcheck / 1000.0);
volume = (int)(gain * 12.75); // XXX - this might not be the best way to convert the gain value...
}
if(volume < -255)
volume = -255;
else if(volume > 255)
volume = 255;
// Convert the volume value into a percentage for SetVolume
SetVolume((int)((double)volume / 2.55));
// To determine the filetype, first check the MHOD_FILETYPE type. If that isn't available, fallback to file extension
iPod_mhod *mtype = m->FindString(MHOD_FILETYPE);
if(mtype != NULL)
{
if(wcsistr(mtype->str, L"MPEG") != NULL || wcsistr(mtype->str, L"MP3") != NULL)
filetype = iTunesSD_Song::MP3;
else if(wcsistr(mtype->str, L"AAC") != NULL)
filetype = iTunesSD_Song::AAC;
else if(wcsistr(mtype->str, L"WAV") != NULL)
filetype = iTunesSD_Song::WAV;
}
if(filetype == 0)
{
if(wcsistr(mhod->str, L".mp3") != NULL)
filetype = iTunesSD_Song::MP3;
else if(wcsistr(mhod->str, L".m4a") != NULL || wcsistr(mhod->str, L".m4b") != NULL || wcsistr(mhod->str, L".m4p") != NULL)
filetype = iTunesSD_Song::AAC;
else if(wcsistr(mhod->str, L".wav") != NULL)
filetype = iTunesSD_Song::WAV;
}
ASSERT(filetype != 0);
if(filename == 0)
filetype = iTunesSD_Song::MP3; // Default to mp3
if(wcsistr(mhod->str, L".m4b") != NULL)
playflags = iTunesSD_Song::BOOKMARKABLE; // Only playback in normal mode
else
playflags = iTunesSD_Song::SHUFFLE; // Playable in normal/shuffle modes, but not bookmarkable
}
}
long iTunesSD_Song::write(unsigned char * data, const unsigned long datasize)
{
#ifdef IPODDB_PROFILER
profiler(iPodDB__iTunesSD_Song_write);
#endif
long ptr=0;
ASSERT(size_total == 0x22e);
ASSERT(filetype != 0);
put3(size_total, &data[ptr]);
ptr+=3;
put3(0x005aa501, &data[ptr]);
ptr+=3;
put3(starttime, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
put3(stoptime, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
put3(0, &data[ptr]);
ptr+=3;
put3(volume, &data[ptr]);
ptr+=3;
put3(filetype, &data[ptr]);
ptr+=3;
put3(0x200, &data[ptr]);
ptr+=3;
const unsigned int bufSize = (SDSONG_FILENAME_LEN + 1) * sizeof(wchar_t);
memcpy(&data[ptr], filename, bufSize);
ptr+=bufSize;
put3(playflags, &data[ptr]);
ptr+=3;
ASSERT(size_total == ptr);
return(ptr);
}
void iTunesSD_Song::SetFilename(const wchar_t *filename)
{
#ifdef IPODDB_PROFILER
profiler(iPodDB__iTunesStats_SetFilename);
#endif
ASSERT(filename != NULL);
if(filename == NULL)
return;
if(filename)
{
lstrcpyn(this->filename, filename, SDSONG_FILENAME_LEN);
}
else
{
memset(this->filename, 0, SDSONG_FILENAME_LEN * sizeof(wchar_t));
}
}
// Accepts values from -100 to 100, with 0 meaning no volume change
void iTunesSD_Song::SetVolume(const int percent)
{
int p = percent;
if(p > 100)
p = 100;
else if(p < -100)
p = -100;
// Volume ranges from 0 (-100%) to 100 (0%) to 200 (100%)
volume = (unsigned int)(percent + 100);
}
/* Shadow DB version 2 */
long iTunesSD2::write(const iPod_mhlt *songs, const iPod_mhlp *playlists, unsigned char * data, const unsigned long datasize)
{
uint32_t numsongs = songs->GetChildrenCount();
uint32_t numplaylists = playlists->GetChildrenCount();
size_t offset=0;
size_t ptr=0;
if (datasize < 64)
return -1;
write_header(data, ptr, "bdhs");
write_uint32_t(data, ptr, 0x02000003); /* also have seen 0x02010001, perhaps a DB version number? */
write_uint32_t(data, ptr, 64); /* length of header */
write_uint32_t(data, ptr, numsongs);
write_uint32_t(data, ptr, numplaylists); /* number of playlists */
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint8_t(data, ptr, 0); /* volume limit */
write_uint8_t(data, ptr, 1); /* voiceover */
write_uint16_t(data, ptr, 0);
write_uint32_t(data, ptr, numsongs); /* TODO number of tracks w/o podcasts and audiobooks*/
write_uint32_t(data, ptr, 64); /* track header offset */
write_uint32_t(data, ptr, 64+20 + numsongs*4+iTunesSD2_Song::header_size*numsongs); /* playlist header offset */
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
offset = 64;
uint32_t hths_header_size = 20+numsongs*4;
if (datasize - ptr < hths_header_size)
return -1;
write_header(data, ptr, "hths");
write_uint32_t(data, ptr, hths_header_size); /* header length */
write_uint32_t(data, ptr, numsongs);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
offset += hths_header_size;
/* positions for each track */
for (size_t i=0;i<numsongs;i++)
{
write_uint32_t(data, ptr, offset + iTunesSD2_Song::header_size * i);
}
/* write tracks */
for (uint32_t i=0;i<numsongs;i++)
{
iPod_mhit *m = songs->GetTrack(i);
long ret = iTunesSD2_Song::write(m, &data[ptr], datasize - ptr);
if (ret < 0)
return ret;
ptr += ret;
offset += ret;
}
uint32_t podcast_playlist_count=0;
for (size_t i=0;i<numplaylists;i++)
{
iPod_mhyp *p = playlists->GetPlaylist(i);
if (p->podcastflag)
podcast_playlist_count++;
}
uint32_t hphs_header_size = 20 + numplaylists*4;
if (datasize - ptr < hphs_header_size)
return -1;
write_header(data, ptr, "hphs");
write_uint32_t(data, ptr, hphs_header_size); /* header length */
write_uint32_t(data, ptr, numplaylists);
write_uint16_t(data, ptr, 0);
write_uint16_t(data, ptr, numplaylists-podcast_playlist_count); /* non-podcast playlists */
write_uint16_t(data, ptr, 1); /* master playlists */
write_uint16_t(data, ptr, numplaylists); /* non-audiobook playlists */
offset += hphs_header_size;
/* write offsets for each track */
for (size_t i=0;i<numplaylists;i++)
{
iPod_mhyp *p = playlists->GetPlaylist(i);
write_uint32_t(data, ptr, offset);
offset += p->GetMhipChildrenCount()*4 + 44;
}
iPod_mhyp *master_playlist = playlists->GetPlaylist(0);
/* write playlists */
for (size_t i=0;i<numplaylists;i++)
{
iPod_mhyp *p = playlists->GetPlaylist(i);
long ret = iTunesSD2_Playlist::write(master_playlist, p, &data[ptr], datasize - ptr);
if (ret < 0)
return ret;
ptr += ret;
}
return ptr;
}
uint32_t iTunesSD2_Song::header_size = 372;
long iTunesSD2_Song::write(const iPod_mhit *mhit, unsigned char *data, const unsigned long datasize)
{
if (datasize < header_size)
return -1;
size_t ptr=0;
write_header(data, ptr, "rths");
write_uint32_t(data, ptr, header_size); /* length of header */
write_uint32_t(data, ptr, mhit->starttime); /* start time, in milliseconds */
write_uint32_t(data, ptr, mhit->stoptime); /* stop time, in milliseconds */
write_uint32_t(data, ptr, mhit->volume); /* volume */
switch(mhit->filetype)
{
case FILETYPE_WAV:
write_uint32_t(data, ptr, iTunesSD_Song::WAV); /* file type */
break;
case FILETYPE_M4A:
case 0x4d344220:
case 0x4d345020:
write_uint32_t(data, ptr, iTunesSD_Song::AAC); /* file type */
break;
case FILETYPE_MP3:
default:
write_uint32_t(data, ptr, iTunesSD_Song::MP3); /* file type */
break;
}
iPod_mhod *mhod = mhit->FindString(MHOD_LOCATION);
char filename[256] = {0};
int converted = WideCharToMultiByte(CP_UTF8, 0, mhod->str, -1, filename, 256, 0, 0);
for (int i=0;i<converted;i++)
{
if (filename[i] == ':')
filename[i] = '/';
}
memcpy(&data[ptr], filename, converted);
ptr+=converted;
memset(&data[ptr], 0, 256-converted);
ptr+=256-converted;
write_uint32_t(data, ptr, mhit->bookmarktime); /* bookmark time */
write_uint8_t(data, ptr, 0); /* skip flag */
write_uint8_t(data, ptr, mhit->rememberPosition); /* remember playback position */
write_uint8_t(data, ptr, 0); /* part of gapless album */
write_uint8_t(data, ptr, 0);
write_uint32_t(data, ptr, mhit->pregap); /* pre-gap */
write_uint32_t(data, ptr, mhit->postgap); /* post-gap */
write_uint64_t(data, ptr, mhit->samplecount); /* number of samples */
write_uint32_t(data, ptr, mhit->gaplessData); /* gapless data */
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, mhit->album_id); /* album ID */
write_uint16_t(data, ptr, mhit->tracknum); /* track number */
write_uint16_t(data, ptr, mhit->cdnum); /* disc number */
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint64_t(data, ptr, mhit->dbid); /* dbid */
write_uint32_t(data, ptr, 0); /* artist ID */
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
return ptr;
}
long iTunesSD2_Playlist::write(const iPod_mhyp *master_playlist, const iPod_mhyp *playlist, unsigned char * data, const unsigned long datasize)
{
size_t ptr=0;
uint32_t tracks = playlist->GetMhipChildrenCount();
uint32_t header_size = 44 + tracks*4;
if (datasize < header_size)
return -1;
write_header(data, ptr, "lphs");
write_uint32_t(data, ptr, header_size); /* header length */
write_uint32_t(data, ptr, tracks); /* number of tracks */
/* number of music tracks TODO: special handling for master playlist */
if (playlist->podcastflag)
write_uint32_t(data, ptr, 0);
else
write_uint32_t(data, ptr, tracks);
write_uint64_t(data, ptr, playlist->playlistID); /* playlist ID */
/* playlist type */
if (playlist->podcastflag)
write_uint32_t(data, ptr, 3); /* podcast */
else if (playlist->hidden)
write_uint32_t(data, ptr, 1); /* master playlist */
else
write_uint32_t(data, ptr, 2); /* normal */
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
write_uint32_t(data, ptr, 0);
if (master_playlist == playlist)
{
for (uint32_t i=0;i<tracks;i++)
{
write_uint32_t(data, ptr, i);
}
}
else
{
for (uint32_t i=0;i<tracks;i++)
{
iPod_mhip *item = playlist->GetPlaylistEntry(i);
uint32_t master_index = master_playlist->FindPlaylistEntry(item->songindex);
assert(master_index != -1);
write_uint32_t(data, ptr, master_index);
}
}
return ptr;
}
Reference in New Issue View Git Blame Copy Permalink