path: root/Src/Plugins/Portable/pmp_ipod/iPodSD.cpp

#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;
}