root/lang/c/sonydb/sonydb.cpp

/*
 ** SonyDB.cpp
 **
 ** Made by (julien)
 */

#include <stdio.h>
#include <fstream>
#include "sonydb.h"

using namespace std;

#ifndef _WIN32
#define strnicmp(x, y, z) strncasecmp(x, y, z)
#define stricmp(x, y) strcasecmp(x, y)
#endif

//SORT function for song vectors
#define SKIP_THE_AND_WHITESPACE(x) { while (!isalnum(*x) && *x) x++; if (!strnicmp(x,"the ",4)) x+=4; while (*x == ' ') x++; }
static int STRCMP_NULLOK(const char *pa, const char *pb)
{
        if (!pa) pa="";
        else SKIP_THE_AND_WHITESPACE(pa)

                if (!pb) pb="";
                else SKIP_THE_AND_WHITESPACE(pb)
                        return stricmp(pa,pb);
}

static int STRCMP2_NULLOK(const char *pa, const char *pb)
{
        if (!pa) pa="";
        if (!pb) pb="";
        return stricmp(pa,pb);
}

static int STRNCMP_NULLOK(const char *pa, const char *pb, int size)
{
        if (!pa) pa="";  
        if (!pb) pb="";
        return strnicmp(pa, pb, size);
}



SonyDb::SonyDb()
{
        this->driveLetter = 0;
        this->deviceName = (char*)calloc(sizeof(char), 256);
        this->trackListLoaded = false;
        this->nbTrackToAdd = 0;
        this->nbTrackToDel = 0;
        this->lastTrackIndex = 1;
        this->codeType = ENCODING_USE_NONE;
        this->copying = false;
        this->copyIndex = 0;
        this->copyPercent = 0;
        this->addTrackTotalByte = 0;
        this->delTrackTotalByte = 0;
        this->freeSpaceDisk = 0;
        this->neededSpace = 0;
        this->totalDiskSpaceValue = 0;
        this->useAllTags = false;


        totalDiskSpace = (char*)calloc(sizeof(char), 64);
        freeDiskSpaceAfterApply = (char*)calloc(sizeof(char), 64);
        totalUsedSpaceAfterApply = (char*)calloc(sizeof(char), 64);
        delTrackTotalByteString = (char*)calloc(sizeof(char), 64);
        addTrackTotalByteString = (char*)calloc(sizeof(char), 64);
        neededSpace = (char*)calloc(sizeof(char), 64);

        //debug
        //fp = fopen("c:/Debug_ml_sony.log", "ab");
        //fprintf(fp,"+++++++++++++\n"); 
        //fflush(fp);
        fp = stderr;
}

//clean the song list before living
SonyDb::~SonyDb()
{
        //free track list 
        freeAllTracks();

        //free device Name
        free(this->deviceName);

        //free disk space info
        free(totalDiskSpace);
        free(totalUsedSpaceAfterApply);
        free(freeDiskSpaceAfterApply);
        free(delTrackTotalByteString);
        free(addTrackTotalByteString);
        free(neededSpace);

        //debug
        //fclose(fp);

        if (driveLetter) free(driveLetter);
}

//free track list
void SonyDb::freeAllTracks()
{
        for (vector<Song>::iterator i = songs.begin(); i != songs.end(); i++)
        {
                if ((*i).album) free((*i).album);
                if ((*i).artist) free((*i).artist);
                if ((*i).title) free((*i).title);
                if ((*i).genre) free((*i).genre);
                if ((*i).filename) free((*i).filename);
        }
        while (songs.size() > 0)
                songs.pop_back();
}

//free playlist
void SonyDb::freeAllPlaylist()
{
        vector<Song *> plSongs;

        for (vector<Playlist>::iterator pl = playlist.begin(); pl != playlist.end(); pl++)
        {
                plSongs = (*pl).songs;
                for (vector<Song*>::iterator i = plSongs.begin(); i != plSongs.end(); i++)
                {
                        if ((*i)->statusOfSong == MODIFIED)
                        {
                                free((*i)->filename);
                                free((*i)->artist);
                                free((*i)->album);
                                free((*i)->genre);
                                free((*i)->title);
                        }
                }
        }
        while (playlist.size() > 0)
                playlist.pop_back();
}

int  SonyDb::getId()
{
        return (this->id);
}

void SonyDb::setId(int newId)
{
        this->id = newId;
}

void SonyDb::setUseAllTags(bool value)
{
        useAllTags = value;
}

bool SonyDb::getUseAllTags()
{
        return (useAllTags);
}

vector<Playlist*> SonyDb::getPlaylist()
{    
        vector<Playlist*> ret;
        for (vector<Playlist>::iterator pl = playlist_temporary.begin(); pl != playlist_temporary.end(); pl++)
                ret.push_back(&(*pl));
        for (vector<Playlist>::iterator pl2 = playlist.begin(); pl2 != playlist.end(); pl2++)
                ret.push_back(&(*pl2));
        return (ret);
}

vector<Song*> SonyDb::getSongsInPlaylist(int source)
{
        vector<Song*> ret;
        Song *p;
        vector<Song *> plSongs;
        vector<Playlist>::iterator playlistBegin;
        vector<Playlist>::iterator playlistEnd;

        if (this->copying)
        {
                playlistBegin = playlist_temporary.begin();
                playlistEnd = playlist_temporary.end();
        }
        else
        {
                playlistBegin = playlist.begin();
                playlistEnd = playlist.end();
        }

        for (vector<Playlist>::iterator pl = playlistBegin; pl != playlistEnd; pl++)
        {
                if (pl->index  == source)
                {
                        plSongs = pl->songs;
                        for (vector<Song*>::iterator i = plSongs.begin(); i != plSongs.end(); i++)
                        {
                                if ((*i)->statusOfSong != EMPTYTRACK)
                                {
                                        //new song
                                        p = (Song *)calloc(sizeof(Song),1);
                                        p->filename = strdup((*i)->filename);
                                        p->artist = strdup((*i)->artist);
                                        p->album = strdup((*i)->album);
                                        p->genre = strdup((*i)->genre);
                                        p->title = strdup((*i)->title);

                                        p->track_nr = (*i)->track_nr;
                                        p->songlen = (*i)->songlen;
                                        p->year = (*i)->year;
                                        p->statusOfSong = (*i)->statusOfSong;
                                        p->sonyDbOrder = (*i)->sonyDbOrder;
                                        ret.push_back(p);
                                }
                        }
                        return (ret);
                }
        }

        //not found in temporary playlists so try in other playlist
        playlistBegin = playlist.begin();
        playlistEnd = playlist.end();

        for (vector<Playlist>::iterator pl2 = playlistBegin; pl2 != playlistEnd; pl2++)
        {
                if (pl2->index  == source)
                {
                        plSongs = pl2->songs;
                        for (vector<Song*>::iterator i = plSongs.begin(); i != plSongs.end(); i++)
                        {
                                if ((*i)->statusOfSong != EMPTYTRACK)
                                {
                                        //new song
                                        p = (Song *)calloc(sizeof(Song),1);
                                        p->filename = strdup((*i)->filename);
                                        p->artist = strdup((*i)->artist);
                                        p->album = strdup((*i)->album);
                                        p->genre = strdup((*i)->genre);
                                        p->title = strdup((*i)->title);

                                        p->track_nr = (*i)->track_nr;
                                        p->songlen = (*i)->songlen;
                                        p->year = (*i)->year;
                                        p->statusOfSong = (*i)->statusOfSong;
                                        p->sonyDbOrder = (*i)->sonyDbOrder;
                                        ret.push_back(p);
                                }
                        }
                        return (ret);
                }
        }

        return (ret);
}

bool SonyDb::deletePlaylist(int source, bool removeSongs)
{
        vector<Song *> plSongs;

        for (vector<Playlist>::iterator pl = playlist.begin(); pl != playlist.end(); pl++)
        {
                if (pl->index  == source)
                {
                        plSongs = pl->songs;
                        if (removeSongs)
                        {
                                for (vector<Song*>::iterator song = plSongs.begin(); song != plSongs.end(); song++)
                                {
                                        delSong(*song);
                                }
                        }
                        pl->songs.clear();
                        playlist.erase(pl);
                        return (true);
                }
        }
        return (false);

}

vector<Song*> SonyDb::getSongs()
{
        vector<Song*> ret;
        Song *p;

        if (this->copying)
        {
                for (vector<Song>::iterator i = songs_temporary.begin(); i != songs_temporary.end(); i++)
                {
                        if ((*i).statusOfSong != EMPTYTRACK)
                        {
                                //new song
                                p = (Song *)calloc(sizeof(Song),1);
                                p->filename = strdup((*i).filename);
                                p->artist = strdup((*i).artist);
                                p->album = strdup((*i).album);
                                p->genre = strdup((*i).genre);
                                p->title = strdup((*i).title);

                                p->track_nr = (*i).track_nr;
                                p->songlen = (*i).songlen;
                                p->year = (*i).year;
                                p->statusOfSong = (*i).statusOfSong;
                                p->sonyDbOrder = (*i).sonyDbOrder;
                                ret.push_back(p);
                        }
                }
        }
        else
        {
                for (vector<Song>::iterator i = songs.begin(); i != songs.end(); i++)
                {
                        if ((*i).statusOfSong != EMPTYTRACK)
                        {
                                //new song
                                p = (Song *)calloc(sizeof(Song),1);
                                p->filename = strdup((*i).filename);
                                p->artist = strdup((*i).artist);
                                p->album = strdup((*i).album);
                                p->genre = strdup((*i).genre);
                                p->title = strdup((*i).title);

                                p->track_nr = (*i).track_nr;
                                p->songlen = (*i).songlen;
                                p->year = (*i).year;
                                p->statusOfSong = (*i).statusOfSong;
                                p->sonyDbOrder = (*i).sonyDbOrder;
                                ret.push_back(p);
                        }
                }
        }
        return (ret);
}


int SonyDb::progressIndex()
{
        return (this->copyIndex);
}


int SonyDb::isTrackListLoaded()
{
        return (this->trackListLoaded);
}

int SonyDb::getNbTrackToDel()
{
        return (this->nbTrackToDel);
}

int SonyDb::getNbTrackToAdd()
{
        return (this->nbTrackToAdd);
}

bool SonyDb::updSong(Song *songToUpd)
{
        if (this->copying)
        {
                for (vector<Song>::iterator song = songs_temporary.begin(); song != songs_temporary.end(); song++)
                {
                        //song is the same
                        if (song->sonyDbOrder == songToUpd->sonyDbOrder)
                        {
                                if (song->statusOfSong != REMOVE_FROM_DEVICE &&
                                        song->statusOfSong != EMPTYTRACK)
                                {
                                        song->artist = strdup(songToUpd->artist);
                                        song->album = strdup(songToUpd->album);
                                        song->genre = strdup(songToUpd->genre);
                                        song->title = strdup(songToUpd->title);

                                        song->track_nr = songToUpd->track_nr;
                                        song->songlen = songToUpd->songlen;
                                        song->year = songToUpd->year;
                                        return (true);
                                }
                                return (false);
                        }
                }
        }
        else
        {
                for (vector<Song>::iterator song = songs.begin(); song != songs.end(); song++)
                {
                        //song is the same
                        if (song->sonyDbOrder == songToUpd->sonyDbOrder)
                        {
                                if (song->statusOfSong != REMOVE_FROM_DEVICE &&
                                        song->statusOfSong != EMPTYTRACK)
                                {
                                        song->artist = strdup(songToUpd->artist);
                                        song->album = strdup(songToUpd->album);
                                        song->genre = strdup(songToUpd->genre);
                                        song->title = strdup(songToUpd->title);

                                        song->track_nr = songToUpd->track_nr;
                                        song->songlen = songToUpd->songlen;
                                        song->year = songToUpd->year;
                                        return (true);
                                }
                                return (false);
                        }
                }
        }
        return (0);
}

int SonyDb::delSong(Song *songToDel)
{
        if (this->copying)
        {
                for (vector<Song>::iterator song = songs_temporary.begin(); song != songs_temporary.end(); song++)
                {
                        //song is the same
                        if ((STRCMP2_NULLOK((*song).album, (songToDel)->album) == 0) &&
                                        (STRCMP2_NULLOK((*song).artist, (songToDel)->artist) == 0) &&
                                        (STRCMP2_NULLOK((*song).title, (songToDel)->title) == 0))
                        {
                                if ((*song).statusOfSong == ADD_TO_DEVICE) //song is not yet on the device
                                {
                                        //remove it from the list
                                        songs_temporary.erase(song);
                                        nbTrackToAdd--;
                                        //size of the song
                                        struct stat results;
                                        if (stat((*songToDel).filename, &results) == 0)
                                                addTrackTotalByte -= results.st_size;
                                        return (2);
                                }
                        }
                }
        }
        else
        {
                for (vector<Song>::iterator song = songs.begin(); song != songs.end(); song++)
                {
                        //song is the same
                        if ((STRCMP2_NULLOK((*song).album, (songToDel)->album) == 0) &&
                                        (STRCMP2_NULLOK((*song).artist, (songToDel)->artist) == 0) &&
                                        (STRCMP2_NULLOK((*song).title, (songToDel)->title) == 0))
                        {
                                if ((*song).statusOfSong == ADD_TO_DEVICE) //song is not yet on the device
                                {
                                        //remove it from the list
                                        songs.erase(song);
                                        nbTrackToAdd--;
                                        //size of the song
                                        struct stat results;
                                        if (stat((*songToDel).filename, &results) == 0)
                                                addTrackTotalByte -= results.st_size;
                                        return (2);
                                }
                                if ((*song).statusOfSong == ON_DEVICE)
                                {
                                        (*song).statusOfSong = REMOVE_FROM_DEVICE;
                                        nbTrackToDel++;
                                        //size of the song
                                        struct stat results;
                                        if (stat((*songToDel).filename, &results) == 0)
                                                delTrackTotalByte += results.st_size;
                                        return (1);
                                }
                        }
                }
        }
        return (0);
}

int SonyDb::getNbPlaylist()
{
        return(this->playlist.size());
}

bool SonyDb::addPlaylist(Playlist *p)
{
        if (this->copying)
                playlist_temporary.push_back(*p);
        else
                playlist.push_back(*p);
        return (true);
}

bool SonyDb::addSong(Song *songToAdd)
{
        //check how much space is needed
        struct stat results;
        if (stat((*songToAdd).filename, &results) == 0)
                addTrackTotalByte += results.st_size;

        if (this->copying)
        {
                //add the song to the temporary list
                songToAdd->sonyDbOrder = 0;
                songs_temporary.push_back(*songToAdd);
                nbTrackToAdd++;
        }
        else
        {
                //check if song is already present on device
                for (vector<Song>::iterator song = songs.begin(); song != songs.end(); song++)
                {
                        //song is the same
                        if ((STRCMP2_NULLOK((*song).album, (songToAdd)->album) == 0) &&
                                        (STRCMP2_NULLOK((*song).artist, (songToAdd)->artist) == 0) &&
                                        (STRCMP2_NULLOK((*song).title, (songToAdd)->title) == 0))
                        {
                                if ((*song).statusOfSong != ADD_TO_DEVICE)
                                        (*song).statusOfSong = ON_DEVICE;
                                free(songToAdd->filename);
                                songToAdd->filename = strdup((*song).filename);
                                return (false);
                        }
                }

                //add the song
                nbTrackToAdd++;
                songToAdd->sonyDbOrder = 0; //changed when copied to the device in writeTracks
                songs.push_back(*songToAdd);
        }

        return (true);
}




/*****************************************************************************************/
/** read/write functions (common header) */

bool SonyDb::getHeader(sonyFileHeader *header, FILE *f)
{
        //read header file
        if ( fread(header, sizeof(sonyFileHeader), 1, f ) != 1)
        {
                fprintf(fp, "error could not read file header (fileheader)\n");
                fflush(fp);
                return false;
        }
        /*  else
                {
                fprintf(fp, "header\n: magic:%08x, cte: %08x ,count:%08x \n", header->magic, header->cte, header->count);

                }
                */

        return true;
}

bool SonyDb::getObjectPointer(sonyObjectPointer *Opointer, FILE *f)
{
        //read object pointer
        if ( fread(Opointer, sizeof(sonyObjectPointer), 1, f ) != 1 )
        {
                fprintf(fp, "error could not read file header (filePointer)\n");
                fflush(fp);
                return false;
        }
        else
        {
                //fprintf(fp, "objectPointer: magic:%x length:%x, offset:%x\n", Opointer->magic, Opointer->length, Opointer->offset);
                //get values from big endian
                Opointer->length = UINT32_SWAP_BE_LE(Opointer->length);
                Opointer->offset = UINT32_SWAP_BE_LE(Opointer->offset);
                //fprintf(fp, "sizeof: %i, objectPointer\n: magic:%s length:%08x, offset:%08x\n",sizeof(sonyObjectPointer), Opointer->magic, Opointer->length, Opointer->offset);
        }
        return true;
}

bool SonyDb::getObject(sonyObject *obj, FILE *f)
{
        //read object
        if ( fread(obj, sizeof(sonyObject), 1, f ) !=1 )
        {
                fprintf(fp, "error could not read file header (object)\n");
                fflush(fp);
                return false;
        }
        else
        {
                //fprintf(fp, "object: magic:%x size :%x, count:%x \n", obj->magic, obj->size, obj->count);
                //get values from big endian
                obj->size = UINT16_SWAP_BE_LE(obj->size);
                obj->count = UINT16_SWAP_BE_LE(obj->count);
                //fprintf(fp, "sizeof: %i, object\n: magic:%s size :%08x, count:%08x \n", sizeof(sonyObject), obj->magic, obj->size, obj->count);
        }   
        return true;
}

// write a file header
bool SonyDb::writeHeader(sonyFileHeader *h, FILE *f)
{
        return(writeHeader(h, f, 1));
}

// write a file header specifying the object pointer count
bool SonyDb::writeHeader(sonyFileHeader *h, FILE *f, int count)
{
        h->cte[0] = 0x01;
        h->cte[1] = 0x01;
        h->cte[2] = 0x00;
        h->cte[3] = 0x00;
        h->count = count;
        for (int i = 0; i < 7; i++)
                h->padding[i]= 0x00;

        if (fwrite(h, sizeof(sonyFileHeader), 1, f) == 1)
                return (true);
        else
                return (false);
}

// write an object pointer header
bool SonyDb::writeObjectPointer(sonyObjectPointer *p, FILE *f)
{
        p->padding = 0x00000000;

        if (fwrite(p, sizeof(sonyFileHeader), 1, f) == 1)
                return (true);
        else
                return (false);
        return (true);
}

//internal write an object header
bool SonyDb::writeObject(sonyObject *obj, FILE *f)
{
        if (fwrite(obj, sizeof(sonyFileHeader), 1, f) == 1)
                return (true);
        else
                return (false);
}


/*****************************************************************************************/

//internal write a track header
bool SonyDb::writeTrackHeader(sonyTrack *t, FILE *f)
{
        if (fwrite(t, sizeof(sonyTrack), 1, f) != 1)
        {
                fprintf(fp, "error could not write file header (object)\n");
                fflush(fp);
                return false;
        }
        return (true);
}

//internal write a track tag
bool SonyDb::writeTrackTag(sonyTrackTag *tt, char *input, FILE *f)
{  
        //init
        int size = TAGSIZE;
        utf16char *tagRecord;

        //to utf16
        tagRecord = ansi_to_utf16(input, (size - 6), true);

        //write tracktag (tagtype + encoding)
        if (fwrite(tt, sizeof(sonyTrackTag), 1, f) != 1) return (false);

        //write tag (data itself)
        if (fwrite(tagRecord, (size - 6), 1, f) != 1) return (false);
        free(tagRecord);

        return (true);
}

void SonyDb::setTable(char *TableFileName, int type)
{
        this->decodeTableFilename = strdup(TableFileName);
        this->codeType = type;

        if (type == ENCODING_USE_KEY)
        {
                FILE *t = fopen(decodeTableFilename, "rb");
                fseek(t, 0x0a, SEEK_SET);
                fread(&(this->DvId), sizeof(uint32), 1, t);
                this->DvId = UINT32_SWAP_BE_LE(this->DvId);
                fclose(t);
        }
}



//ported from gym
bool SonyDb::loadCodeTable(int id)
{
        FILE *t;
        uint8 *header1 = (uint8*)malloc(sizeof(uint8) * 134); //deserialize manually ...
        uint8 *header2 = (uint8*)malloc(sizeof(uint8) * 10);
        uint8 *tmp = (uint8*)malloc(sizeof(uint8) * 256);

        t = fopen(decodeTableFilename, "rb");
        // place cursor in place...
        fseek(t, 0x4B0 * id, SEEK_SET);
        fread(header1, sizeof(uint8), 134, t);

        for (int i = 0; i < 4; i++)
        {
                fread(tmp, sizeof(uint8), 256, t);
                for (int j = 0; j < 256; j++)
                        codeTable[(i*256) + j] = tmp[j];
                fread(header2, sizeof(uint8), 10, t);
        }

        free(header1);
        free(header2);
        free(tmp);
        fclose(t);
        return true;
}

//add mp3 file to device
bool SonyDb::addOMA(Song *s, int destination)
{
        uint32    key = 0xFFFFFFFF;
        bool      isVBR = false;

        this->copyPercent = 0;
        if (s->statusOfSong != ADD_TO_DEVICE)
                return false;

        char *filename = GetOMAFilename(destination);

        fprintf(fp, "sending %s to %s\n", s->filename, filename);
        fflush(fp);

        //createDirectory if necessary
        createDir(destination);

        //load decode table for this track
        if (this->codeType == ENCODING_USE_TABLE)
                this->loadCodeTable(destination - 1);

        //or use key
        if (this->codeType == ENCODING_USE_KEY)
                key = ( 0x2465 + destination * 0x5296E435 ) ^ this->DvId;


        FILE *fout = fopen(filename, "wb");
        if (fout == NULL)
        {
                fprintf(fp, "error can't open file %s\n", filename);
                fflush(fp);
                return false;
        }

        FILE *fin = fopen(s->filename, "rb");
        float finSize = 0;
        if (fin == NULL)
        {
                fprintf(fp, "error can't open file %s\n", s->filename);
                fflush(fp);
                fclose(fout);
                return false;
        }

        //get input file size
        struct stat results;
        if (stat(s->filename, &results) == 0)
                finSize = results.st_size;

        uint8       *header = (uint8*)malloc(sizeof(uint8) * 11);
        utf16char           *tagRecord;
        char        *tmpTag = (char*)malloc(sizeof(char) * 256);
        int         tagLength;
        int         headerLength = 0;
        long        startPoint = 0;
        int         nbFrames = 0; // estimated number of frames

        memset(header, 0, 11);
        if (fread(header, 1, 10, fin) != 10)
                return false;
        if (STRNCMP_NULLOK((char*)header, "ID3", 3) == 0)
        {
                //skip Idv2 tags
                startPoint = ((header[6] << 21) + (header[7] << 14) + (header[8] << 7) + header[9]) + 10;

        }
        else
        {
                //no idv2 tag found
                startPoint = 0;
        }

        //go to the first frame
        fseek(fin, startPoint, SEEK_SET);

        memset(header, 0, 11);
        //skip zeros
        while (header[0] == 0)
        {
                if(fread(header, sizeof(uint8), 1, fin) != 1)
                {
                        fclose(fout);
                        fclose(fin);
                        return false;
                }
        }

        if (header[0] == 0xFF)
        {
                if (fread(header, sizeof(uint8), 3, fin) != 3)
                {
                        fclose(fout);
                        fclose(fin);
                        return false;
                }

                //get mpeg type, layer type and bitrate
                if ((header[0] & 0xE0) == 0xE0) //we found the first frame
                {
                        //encoding =  mpeg version(2bits), layer version(2bits), bitrate(4bits)
                        s->encoding = ( ((header[0] & 0x1E) << 3) + ((header[1] & 0xF0) >> 4) );

                        // 00 - MPEG Version 2.5 (unofficial extension of MPEG 2)
                        // 01 - reserved
                        // 10 - MPEG Version 2 (ISO/IEC 13818-3)
                        // 11 - MPEG Version 1 (ISO/IEC 11172-3) 
                        uint8 mpegVersion = (header[0] & 0x18) >> 3;

                        //00 - reserved
                        //01 - Layer III
                        //10 - Layer II
                        //11 - Layer I
                        uint8 layerVersion = (header[0] & 0x06) >> 1;

                        uint8 samplingRateIndex = (header[1] & 0xC) >> 2;

                        if (((mpegVersion * 3) + samplingRateIndex >= 12) || ((mpegVersion * 3) + layerVersion >= 16))
                        {
                                //header is invalid
                                nbFrames = 0;
                        }
                        else
                        {
                                int  SAMPLING_RATES[] = {11025, 12000, 8000, 0, 0, 0, 22050, 24000, 16000, 44100, 48000, 32000};
                                int  SAMPLE_PER_FRAME[] = {0,576,1152,384,0,0,0,0,0,576,1152,384,0,1152,1152,384};

                                //sample per frame 0=reserved
                                //          MPG2.5 res        MPG2   MPG1 
                                //reserved  0      0          0      0
                                //Layer III 576    0          576    1152       
                                //Layer II  1152   0          1152   1152       
                                //Layer I   384    0          384    384 

                                int samplingRate = SAMPLING_RATES[(mpegVersion * 3) + samplingRateIndex];
                                int samplePerFrame = SAMPLE_PER_FRAME[(mpegVersion * 4) + layerVersion];
                                nbFrames = (s->songlen * samplingRate) / samplePerFrame;
                        }

                        //skip the the frame header
                        fseek(fin, sizeof(uint8) * 32, SEEK_CUR);

                        //check if first is "XING" for VBR files
                        memset(header, 0, 11);
                        if (fread(header, sizeof(uint8), 4, fin) != 4)
                        {
                                fclose(fout);
                                fclose(fin);
                                return false;
                        }

                        if (STRNCMP_NULLOK((char*)header, "XING", 4) == 0)
                                isVBR = true;
                }
                else
                {
                        fprintf(fp, "File format invalid, could not find first frame%s\n", s->filename);
                        fflush(fp);
                        //return false;
                }
        }
        else
        {
                fprintf(fp, "File format invalid, could not find first frame%s\n", s->filename);
                fflush(fp);
                //return false;
        }



        //go back to the start of mp3 data
        fseek(fin, startPoint, SEEK_SET);

        //write the OMA headers :
        //format is :
        //"ea3"0x03 (4bytes), sizeOfTotaltags (6bytes)
        //TIT2(4bytes) sizeOfTag(4bytes) 2flags (2bytes) 0x02(=utf16be format?) titleOftheSong
        //...
        //not all size are coded in synchsafe format


        //idv2 header
        memset(header, 0, 11);
        header[0] = 'e';
        header[1] = 'a';
        header[2] = '3';
        header[3] = 0x03;
        //...zeros
        header[8] = 0x17;
        header[9] = 0x76; //size of tag header in Synchsafe format (=3072 bytes - 10 of header)
        if (fwrite(header, sizeof(uint8), 10, fout) != 10)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }

        //title tag
        memset(header, 0, 11);
        memcpy(header, "TIT2", 4);
        tagLength = strlen(s->title);
        tagRecord = ansi_to_utf16(s->title, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;   //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);


        //artist tag
        memset(header, 0, 11);
        memcpy(header, "TPE1", 4);
        tagLength = strlen(s->artist);
        tagRecord = ansi_to_utf16(s->artist, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;   //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);

        //album tag
        memset(header, 0, 11);
        memcpy(header, "TALB", 4);
        tagLength = strlen(s->album);
        tagRecord = ansi_to_utf16(s->album, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;  //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);

        //genre tag
        memset(header, 0, 11);
        memcpy(header, "TCON", 4);
        tagLength = strlen(s->genre);
        tagRecord = ansi_to_utf16(s->genre, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;   //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);

        //track number tag //space are suppose to be replaced by 0x00 not 0x20
        sprintf(tmpTag, "OMG_TRACK %02i", s->track_nr);
        memset(header, 0, 11);
        memcpy(header, "TXXX", 4);
        tagLength = strlen(tmpTag);
        tagRecord = ansi_to_utf16(tmpTag, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;   //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);

        //fixme date of transfert? tag //space are suppose to be replaced by 0x00 not 0x20
        sprintf(tmpTag, "OMG_TRLDA 2001/01/01 00:00:00");
        memset(header, 0, 11);
        memcpy(header, "TXXX", 4);
        tagLength = strlen(tmpTag);
        tagRecord = ansi_to_utf16(tmpTag, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        tagLength = (strlen(tmpTag) + 1) * 2;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;   //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);

        //track length tag
        sprintf(tmpTag, "%i", s->songlen * 1000);
        memset(header, 0, 11);
        memcpy(header, "TLEN", 4);
        tagLength = strlen(tmpTag);
        tagRecord = ansi_to_utf16(tmpTag, tagLength + 1, true);
        tagLength = (tagLength * 2) + 1;
        header[4] = NOT_SYNCHSAFE_B1(tagLength);//size of the title
        header[5] = NOT_SYNCHSAFE_B2(tagLength);
        header[6] = NOT_SYNCHSAFE_B3(tagLength);
        header[7] = NOT_SYNCHSAFE_B4(tagLength);
        header[8] = 0;   //flag 1
        header[9] = 0;  //flag 2
        header[10] = 0x02;  //
        tagLength = (tagLength - 1 )/ 2;
        if (fwrite(header, sizeof(uint8), 11, fout) != 11)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (11 * sizeof(uint8));
        if (fwrite(tagRecord, sizeof(utf16char), tagLength, fout) != tagLength)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (tagLength * sizeof(utf16char));
        free(tagRecord);

        memset(header, 0, 11);
        //fill the rest with 0
        while (headerLength < 3062)
        {
                headerLength += sizeof(uint8);
                if (fwrite(header, sizeof(uint8), 1, fout) != 1)
                {
                        fclose(fout);
                        fclose(fin);
                        return false;
                }
        }

        //write second header fixme (some stuff are missing here... important?)
        uint8 *header2 = (uint8*)malloc(sizeof(uint8) * 16);
        headerLength = 0;
        memset(header2, 0, 16);
        //first line
        memcpy(header2, "EA3", 3);
        header2[3] = 0x02;
        header2[4] = 0;   //size of 2nd header
        header2[5] = 0x60;//size of 2nd header
        header2[6] = 0xff;// + same value as in 05CIDLST.DAT
        if (this->codeType == ENCODING_USE_NONE)
        {
                header2[7] = 0xff;// cp or sonicstage? or encoded not encoded? 505 =e  1000 =f
        }
        else
        {
                header2[7] = 0xfe;// cp or sonicstage? or encoded not encoded? 505 =e  1000 =f
        } 
        header2[12] = 0x01;
        header2[13] = 0x0F;
        header2[14] = 0x50;
        header2[15] = 0x00;// - same value as in 05CIDLST.DAT
        if (fwrite(header2, sizeof(uint8), 16, fout) != 16)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (16 * sizeof(uint8));

        //second line
        memset(header2, 0, 16);
        header2[1] = 0x04;// + same value as in 05CIDLST.DAT fixme
        //zeros...   
        header2[5] = 0x01; //fixme 01
        header2[6] = 0x02; //fixme 02
        header2[7] = 0x03; //fixme 03
        header2[8] = 0xc8;
        header2[9] = 0xd8;
        header2[10] = 0x36;
        header2[11] = 0xd8;
        header2[12] = 0x11; //fixme 11
        header2[13] = 0x22; //fixme 22
        header2[14] = 0x33; //fixme 33
        header2[15] = 0x44;// - same value as in 05CIDLST.DAT
        if (fwrite(header2, sizeof(uint8), 16, fout) != 16)
        {
                fclose(fout);
                fclose(fin);
                return false;
        }
        headerLength += (16 * sizeof(uint8));

        //third line
        memset(header2, 0, 16); 

        header2[0] = 0x03;// 3 = MP3
        header2[1] =(isVBR) ? 0x90 : 0x80 ;// VBR = 90, CBR = 80
        header2[2] = s->encoding;// mpeg version(2bits), layer version(2bits), bitrate(4bits)
        header2[3] = 0x10;//?? fixme

        //tracklength
        uint32 trackLengh = s->songlen * 1000; 
        header2[4] = (uint8) (((trackLengh) & (uint32) 0xff000000U) >> 24);
        header2[5] = (uint8) (((trackLengh) & (uint32) 0x00ff0000U) >> 16);
        header2[6] = (uint8) (((trackLengh) & (uint32) 0x0000ff00U) >>  8);
        header2[7] = (uint8) ((trackLengh) & (uint32)  0x000000ffU);

        //number of frames