steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Portable/pmp_ipod/iPodArtworkDB.cpp

915 lines
22 KiB
C++
Raw Blame History

/*
*
*
* Copyright (c) 2007 Will Fisher (will.fisher@gmail.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
*
*/
#include "iPodArtworkDB.h"
#include <algorithm>
#include <strsafe.h>
//utilities
#define SAFEDELETE(x) {if(x) delete (x); (x)=0;}
#define SAFEFREE(x) {if(x) free(x); (x)=0;}
static __forceinline unsigned short rev1(const BYTE *data)
{
return ((unsigned short) data[0]);
}
static __forceinline unsigned short rev1i(const BYTE *data, int &ptr)
{
unsigned short ret = rev1(data+ptr);
ptr+=1;
return ret;
}
static __forceinline unsigned short rev2(const BYTE *data)
{
unsigned short ret;
ret = ((unsigned short) data[1]) << 8;
ret += ((unsigned short) data[0]);
return ret;
}
static __forceinline unsigned short rev2i(const BYTE *data, int &ptr)
{
unsigned short ret = rev2(data+ptr);
ptr+=2;
return ret;
}
// get 4 bytes from data, reversed
static __forceinline unsigned int rev4(const BYTE * data)
{
unsigned int ret;
ret = ((unsigned long) data[3]) << 24;
ret += ((unsigned long) data[2]) << 16;
ret += ((unsigned long) data[1]) << 8;
ret += ((unsigned long) data[0]);
return ret;
}
static __forceinline unsigned int rev4i(const BYTE * data, int &ptr)
{
unsigned int ret = rev4(data+ptr);
ptr+=4;
return ret;
}
// get 4 bytes from data
static __forceinline unsigned long get4(const unsigned char * data)
{
unsigned long ret;
ret = ((unsigned long) data[0]) << 24;
ret += ((unsigned long) data[1]) << 16;
ret += ((unsigned long) data[2]) << 8;
ret += ((unsigned long) data[3]);
return ret;
}
static __forceinline unsigned long get4i(const unsigned char * data, int &ptr)
{
unsigned long ret = get4(data+ptr);
ptr+=4;
return ret;
}
// get 8 bytes from data
static __forceinline unsigned __int64 get8(const unsigned char * data)
{
unsigned __int64 ret;
ret = get4(data);
ret = ret << 32;
ret+= get4(data+4);
return ret;
}
// get 8 bytes from data
static __forceinline unsigned __int64 get8i(const unsigned char * data, int &ptr)
{
unsigned __int64 ret = get8(data+ptr);
ptr+=8;
return ret;
}
// reverse 8 bytes in place
static __forceinline unsigned __int64 rev8(unsigned __int64 number)
{
unsigned __int64 ret;
ret = (number&0x00000000000000FF) << 56;
ret+= (number&0x000000000000FF00) << 40;
ret+= (number&0x0000000000FF0000) << 24;
ret+= (number&0x00000000FF000000) << 8;
ret+= (number&0x000000FF00000000) >> 8;
ret+= (number&0x0000FF0000000000) >> 24;
ret+= (number&0x00FF000000000000) >> 40;
ret+= (number&0xFF00000000000000) >> 56;
return ret;
}
static __forceinline void putmh(const char* x, BYTE *data, int &ptr) {
data[0+ptr]=x[0];
data[1+ptr]=x[1];
data[2+ptr]=x[2];
data[3+ptr]=x[3];
ptr+=4;
}
//write 4 bytes reversed
static __forceinline void rev4(const unsigned long number, unsigned char * data)
{
data[3] = (unsigned char)(number >> 24) & 0xff;
data[2] = (unsigned char)(number >> 16) & 0xff;
data[1] = (unsigned char)(number >> 8) & 0xff;
data[0] = (unsigned char)number & 0xff;
}
static __forceinline void rev4i(const unsigned int number, BYTE* data, int &ptr)
{
rev4(number,data+ptr);
ptr+=4;
}
static __forceinline void rev2(const unsigned short number, unsigned char * data)
{
data[1] = (unsigned char)(number >> 8) & 0xff;
data[0] = (unsigned char)number & 0xff;
}
static __forceinline void rev2i(const unsigned short number, BYTE* data, int &ptr)
{
rev2(number,data+ptr);
ptr+=2;
}
static __forceinline void rev1(const unsigned char number, unsigned char * data)
{
data[0] = number;
}
static __forceinline void rev1i(const unsigned char number, BYTE* data, int &ptr)
{
rev1(number,data+ptr);
ptr+=1;
}
// write 8 bytes normal
static __forceinline void put8(unsigned __int64 number, unsigned char * data)
{
data[0] = (unsigned char)(number >> 56) & 0xff;
data[1] = (unsigned char)(number >> 48) & 0xff;
data[2] = (unsigned char)(number >> 40) & 0xff;
data[3] = (unsigned char)(number >> 32) & 0xff;
data[4] = (unsigned char)(number >> 24) & 0xff;
data[5] = (unsigned char)(number >> 16) & 0xff;
data[6] = (unsigned char)(number >> 8) & 0xff;
data[7] = (unsigned char)number & 0xff;
}
static __forceinline void put8i(unsigned __int64 number, unsigned char * data, int &ptr) {
put8(number,data+ptr);
ptr+=8;
}
static __forceinline void pad(BYTE * data, int endpoint, int& startpoint) {
if(endpoint == startpoint) return;
ZeroMemory(data+startpoint, endpoint - startpoint);
startpoint = endpoint;
}
///////////////////////////////////////////////////////////////////////////////
// ArtDB
ArtDB::ArtDB() :
headerlen(0x84),
totallen(0),
unk1(0),
unk2(2),
unk3(0),
nextid(0x40),
unk5(0),
unk6(0),
unk7(0),
unk8(0),
unk9(0),
unk10(0),
unk11(0),
imageListDS(0),
albumListDS(0),
fileListDS(0)
{
}
ArtDB::~ArtDB() {
SAFEDELETE(imageListDS);
SAFEDELETE(albumListDS);
SAFEDELETE(fileListDS);
}
int ArtDB::parse(BYTE * data, int len, wchar_t drive) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhfd",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x84) return -1;
totallen = rev4i(data,ptr);
unk1 = rev4i(data,ptr);
unk2 = rev4i(data,ptr);
int numchildren = rev4i(data,ptr);
unk3 = rev4i(data,ptr);
nextid = rev4i(data,ptr);
unk5 = rev8(get8i(data,ptr));
unk6 = rev8(get8i(data,ptr));
unk7 = rev4i(data,ptr);
unk8 = rev4i(data,ptr);
unk9 = rev4i(data,ptr);
unk10 = rev4i(data,ptr);
unk11 = rev4i(data,ptr);
ptr=headerlen;
for(int i=0; i<numchildren; i++) {
ArtDataSet * d = new ArtDataSet;
int p = d->parse(data+ptr,len-ptr);
if(p == -1) return -1;
switch(d->index) {
case 1: imageListDS = d; break;
case 2: albumListDS = d; break;
case 3: fileListDS = d; break;
default: delete d;
}
ptr+=p;
}
if(!imageListDS) imageListDS = new ArtDataSet(1);
if(!albumListDS) albumListDS = new ArtDataSet(2);
if(!fileListDS) fileListDS = new ArtDataSet(3);
for(ArtImageList::ArtImageMapIterator i = imageListDS->imageList->images.begin(); i!=imageListDS->imageList->images.end(); i++) {
if(i->second) {
for(auto j = i->second->dataobjs.begin(); j != i->second->dataobjs.end(); j++) {
if((*j)->image) {
ArtFile *f = fileListDS->fileList->getFile((*j)->image->corrid);
if(!f) {
f = new ArtFile();
f->corrid = (*j)->image->corrid;
fileListDS->fileList->files.push_back(f);
}
f->images.push_back(new ArtFileImage((*j)->image->ithmboffset,(*j)->image->imagesize,1));
}
}
}
}
for(auto i = fileListDS->fileList->files.begin(); i!=fileListDS->fileList->files.end(); i++) {
wchar_t file[MAX_PATH] = {0};
StringCchPrintfW(file, MAX_PATH, L"%c:\\iPod_Control\\Artwork\\F%04d_1.ithmb",drive,(*i)->corrid);
(*i)->file = _wcsdup(file);
(*i)->sortImages();
}
return totallen;
}
int ArtDB::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhfd",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(0,data,ptr); // fill total len here later
rev4i(unk1,data,ptr);
rev4i(unk2,data,ptr); // always seems to be "2" when iTunes writes it
rev4i(3,data,ptr); // num children
rev4i(unk3,data,ptr);
rev4i(nextid,data,ptr);
put8i(rev8(unk5),data,ptr);
put8i(rev8(unk6),data,ptr);
rev4i(unk7,data,ptr);
rev4i(unk8,data,ptr);
rev4i(unk9,data,ptr);
rev4i(unk10,data,ptr);
rev4i(unk11,data,ptr);
pad(data,headerlen,ptr);
// write out children
int p;
p = imageListDS->write(data+ptr,len-ptr);
if(p<0) return -1;
ptr+=p;
p = albumListDS->write(data+ptr,len-ptr);
if(p<0) return -1;
ptr+=p;
p = fileListDS->write(data+ptr,len-ptr);
if(p<0) return -1;
ptr+=p;
rev4(ptr,&data[8]); // fill in total length
return ptr;
}
void ArtDB::makeEmptyDB(wchar_t drive) {
imageListDS = new ArtDataSet(1);
albumListDS = new ArtDataSet(2);
fileListDS = new ArtDataSet(3);
for(auto i = fileListDS->fileList->files.begin(); i!=fileListDS->fileList->files.end(); i++) {
wchar_t file[MAX_PATH] = {0};
StringCchPrintfW(file, MAX_PATH, L"%c:\\iPod_Control\\Artwork\\F%04d_1.ithmb",drive,(*i)->corrid);
(*i)->file = _wcsdup(file);
}
}
///////////////////////////////////////////////////////////////////////////////
// ArtDatSet
ArtDataSet::ArtDataSet() :
headerlen(0x60),
totallen(0),
index(0),
imageList(0),
albumList(0),
fileList(0)
{
}
ArtDataSet::ArtDataSet(int idx) :
headerlen(0x60),
totallen(0),
index(idx),
imageList(0),
albumList(0),
fileList(0)
{
switch(idx) {
case 1: imageList = new ArtImageList; break;
case 2: albumList = new ArtAlbumList; break;
case 3: fileList = new ArtFileList; break;
default: index=0;
}
}
ArtDataSet::~ArtDataSet() {
SAFEDELETE(imageList);
SAFEDELETE(albumList);
SAFEDELETE(fileList);
}
int ArtDataSet::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhsd",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x60) return -1;
totallen = rev4i(data,ptr);
index = rev4i(data,ptr);
ptr=headerlen;
int p=0;
switch(index) {
case 1: imageList = new ArtImageList; p = imageList->parse(data+ptr, len-ptr); break;
case 2: albumList = new ArtAlbumList; p = albumList->parse(data+ptr, len-ptr); break;
case 3: fileList = new ArtFileList; p = fileList->parse(data+ptr, len-ptr); break;
}
if(p < 0) return -1;
return totallen;
}
int ArtDataSet::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhsd",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(0,data,ptr); // fill total len here later
rev4i(index,data,ptr);
pad(data,headerlen,ptr);
int p=0;
switch(index) {
case 1: p=imageList->write(data+ptr, len-ptr); break;
case 2: p=albumList->write(data+ptr, len-ptr); break;
case 3: p=fileList->write(data+ptr, len-ptr); break;
}
if(p<0) return -1;
ptr+=p;
rev4(ptr,&data[8]); // fill in total length
return ptr;
}
///////////////////////////////////////////////////////////////////////////////
// ArtImageList
ArtImageList::ArtImageList() :
headerlen(0x5c)
{
}
ArtImageList::~ArtImageList() {
for(ArtImageMapIterator f = images.begin(); f != images.end(); f++)
delete f->second;
images.clear();
}
int ArtImageList::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhli",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x5c) return -1;
int children = rev4i(data,ptr);
ptr=headerlen;
for(int i=0; i<children; i++) {
ArtImage * f = new ArtImage;
int p = f->parse(data+ptr,len-ptr);
if(p<0) {delete f; return -1;}
ptr+=p;
images.insert(ArtImageMapPair(f->songid,f));
}
return ptr;
}
int ArtImageList::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhli",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(images.size(),data,ptr);
pad(data,headerlen,ptr);
for(ArtImageMapIterator f = images.begin(); f != images.end(); f++) {
int p = f->second->write(data+ptr,len-ptr);
if(p<0) return -1;
ptr+=p;
}
return ptr;
}
///////////////////////////////////////////////////////////////////////////////
// ArtImage
ArtImage::ArtImage() :
headerlen(0x98),
totallen(0),
id(0),
songid(0),
unk4(0),
rating(0),
unk6(0),
originalDate(0),
digitizedDate(0),
srcImageSize(0)
{
}
ArtImage::~ArtImage()
{
for (auto obj : dataobjs)
{
delete obj;
}
dataobjs.clear();
}
int ArtImage::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhii",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x98) return -1;
totallen = rev4i(data,ptr);
int numchildren = rev4i(data,ptr);
id = rev4i(data,ptr);
songid = rev8(get8i(data,ptr));
unk4 = rev4i(data,ptr);
rating = rev4i(data,ptr);
unk6 = rev4i(data,ptr);
originalDate = rev4i(data,ptr);
digitizedDate = rev4i(data,ptr);
srcImageSize = rev4i(data,ptr);
ptr = headerlen;
for(int i=0; i<numchildren; i++) {
ArtDataObject *d = new ArtDataObject;
int p = d->parse(data+ptr,len-ptr);
if(p<0) { delete d; return -1; }
ptr+=p;
// fuck with d. ugh.
if((d->type == 2 || d->type == 5) && d->data) { // this is a container mhod
d->image = new ArtImageName;
int p2 = d->image->parse(d->data,d->datalen);
if(p2>0) {
SAFEFREE(d->data);
d->datalen=0;
} else SAFEDELETE(d->image);
}
dataobjs.push_back(d);
}
return totallen;
}
template<class T>
BYTE *expandMemWrite(T * x, int &len, int maxsize=1024000) {
int s = 1024;
for(;;) {
BYTE *r = (BYTE*)malloc(s);
int p = x->write(r,s);
if(p>0) {
len=p;
return r;
}
free(r);
s = s+s;
if(s > maxsize) break;
}
return NULL;
}
int ArtImage::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhii",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(0,data,ptr); // fill in total length later
rev4i(dataobjs.size(),data,ptr);
rev4i(id,data,ptr);
put8i(rev8(songid),data,ptr);
rev4i(unk4,data,ptr);
rev4i(rating,data,ptr);
rev4i(unk6,data,ptr);
rev4i(originalDate,data,ptr);
rev4i(digitizedDate,data,ptr);
rev4i(srcImageSize,data,ptr);
pad(data,headerlen,ptr);
for(auto f = dataobjs.begin(); f != dataobjs.end(); f++) {
if((*f)->image) {
int len=0;
BYTE *b = expandMemWrite((*f)->image,len);
if(!b) return -1;
(*f)->data = b;
(*f)->datalen = len;
}
int p = (*f)->write(data+ptr,len-ptr);
if((*f)->image) {
SAFEFREE((*f)->data);
(*f)->datalen=0;
}
if(p<0) return -1;
ptr+=p;
}
rev4(ptr,&data[8]); // fill in total length
return ptr;
}
///////////////////////////////////////////////////////////////////////////////
// ArtDataObj
ArtDataObject::ArtDataObject() :
headerlen(0x18),
type(0),
data(0),
datalen(0),
image(0),
unk1(0)
{
}
ArtDataObject::~ArtDataObject() {
SAFEDELETE(image);
SAFEFREE(data);
}
int ArtDataObject::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhod",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x18) return -1;
int totallen = rev4i(data,ptr);
if(len < totallen) return -1;
type = rev2i(data,ptr);
unk1 = (unsigned char)rev1i(data,ptr);
short padding = rev1i(data,ptr);
ptr = headerlen;
if(type == 3 && rev2(&data[totallen-2]) == 0)
datalen = wcslen((wchar_t*)(data+ptr+12))*sizeof(wchar_t) + 12;
else
datalen = totallen - headerlen - padding;
if(datalen > 0x400 || datalen < 0) return -1;
this->data = (BYTE*)malloc(datalen);
memcpy(this->data,data+ptr,datalen);
return totallen;
}
int ArtDataObject::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhod",data,ptr);
rev4i(headerlen,data,ptr);
short padding = (4 - ((headerlen + datalen) % 4));// % 4;
if(padding == 4) padding = 0;
rev4i(headerlen+datalen+padding,data,ptr);
rev2i(type,data,ptr);
rev1i(unk1,data,ptr);
rev1i((unsigned char)padding,data,ptr);
pad(data,headerlen,ptr);
//write data
memcpy(data+ptr,this->data,datalen);
ptr+=datalen;
//add padding...
pad(data,ptr+padding,ptr);
return ptr;
}
void ArtDataObject::GetString(wchar_t * str, int len) {
if(rev4(data+4) != 2) { str[0]=0; return; }//not utf-16!
int l = (rev4(data)/sizeof(wchar_t));
StringCchCopyN(str, len, (wchar_t*)&data[12], l);
//lstrcpyn(str,(wchar_t*)&data[12],min(l,len));
}
void ArtDataObject::SetString(wchar_t * str) {
SAFEFREE(data);
datalen = wcslen(str)*sizeof(wchar_t) + 12;
data = (BYTE*)malloc(datalen);
rev4(wcslen(str)*sizeof(wchar_t),data);
rev4(2,data+4); //type 2 means utf-16
rev4(0,data+8); //unk
memcpy(data+12,str,wcslen(str)*sizeof(wchar_t));
}
///////////////////////////////////////////////////////////////////////////////
// ArtImageName
ArtImageName::ArtImageName() :
headerlen(0x4c),
totallen(0),
corrid(0),
ithmboffset(0),
imagesize(0),
vpad(0),
hpad(0),
imgh(0),
imgw(0),
filename(0)
{
}
ArtImageName::~ArtImageName() {
SAFEDELETE(filename);
}
int ArtImageName::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhni",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x4c) return -1;
totallen = rev4i(data,ptr);
int children = rev4i(data,ptr);
corrid = rev4i(data,ptr);
ithmboffset = rev4i(data,ptr);
imagesize = rev4i(data,ptr);
vpad = (short)rev2i(data,ptr);
hpad = (short)rev2i(data,ptr);
imgw = rev2i(data,ptr);
imgh = rev2i(data,ptr);
ptr = headerlen;
if(children) {
filename = new ArtDataObject();
int p = filename->parse(data+ptr,len-ptr);
if(p<0) SAFEDELETE(filename);
}
return totallen;
}
int ArtImageName::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhni",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(0,data,ptr); // fill in totallen later
rev4i(filename?1:0,data,ptr); //num children
rev4i(corrid,data,ptr);
rev4i(ithmboffset,data,ptr);
rev4i(imagesize,data,ptr);
rev2i(vpad,data,ptr);
rev2i(hpad,data,ptr);
rev2i(imgw,data,ptr);
rev2i(imgh,data,ptr);
pad(data,headerlen,ptr);
if(filename) {
int p = filename->write(data+ptr,len-ptr);
if(p<0) return -1;
ptr+=p;
}
rev4(ptr,&data[8]); // fill in totallen
return ptr;
}
///////////////////////////////////////////////////////////////////////////////
// ArtAlbumList
ArtAlbumList::ArtAlbumList() :
headerlen(0x5c)
{
}
ArtAlbumList::~ArtAlbumList() {}
int ArtAlbumList::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhla",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x5c) return -1;
int children = rev4i(data,ptr);
if(children != 0) return -1;
return headerlen;
}
int ArtAlbumList::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhla",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(0,data,ptr); // num children
pad(data,headerlen,ptr);
return ptr;
}
///////////////////////////////////////////////////////////////////////////////
// ArtFileList
ArtFileList::ArtFileList() :
headerlen(0x5c)
{
}
ArtFileList::~ArtFileList()
{
for (auto file : files)
{
delete file;
}
files.clear();
}
int ArtFileList::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhlf",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x5c) return -1;
int children = rev4i(data,ptr);
ptr = headerlen;
for(int i=0; i<children; i++) {
ArtFile * f = new ArtFile;
int p = f->parse(data+ptr,len-ptr);
if(p<0) { delete f; return -1; }
ptr+=p;
files.push_back(f);
}
return ptr;
}
int ArtFileList::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhlf",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(files.size(),data,ptr); // num children
pad(data,headerlen,ptr);
for(auto f = files.begin(); f != files.end(); f++) {
int p = (*f)->write(data+ptr,len-ptr);
if(p<0) return -1;
ptr+=p;
}
return ptr;
}
ArtFile * ArtFileList::getFile(int corrid) {
for(auto i = files.begin(); i!=files.end(); i++) {
if((*i)->corrid == corrid) return *i;
}
return NULL;
}
///////////////////////////////////////////////////////////////////////////////
// ArtFile
ArtFile::ArtFile() :
headerlen(0x7c),
corrid(0),
imagesize(0),
file(0)
{
}
ArtFile::~ArtFile() {
SAFEFREE(file);
}
int ArtFile::parse(BYTE *data, int len) {
int ptr=4;
if(len < headerlen) return -1;
if (_strnicmp((char *)data,"mhif",4)) return -1;
headerlen = rev4i(data,ptr);
if(headerlen < 0x7c) return -1;
int totallen = rev4i(data,ptr);
rev4i(data,ptr); // might not be numchildren, it's really unk1
corrid = rev4i(data,ptr);
imagesize = rev4i(data,ptr);
return totallen;
}
int ArtFile::write(BYTE *data, int len) {
int ptr=0;
if(headerlen > len) return -1;
putmh("mhif",data,ptr);
rev4i(headerlen,data,ptr);
rev4i(0,data,ptr); // total len, fill in later
rev4i(0,data,ptr); // numchildren/unk1
rev4i(corrid,data,ptr);
rev4i(imagesize,data,ptr);
pad(data,headerlen,ptr);
// write children, if we had any...
rev4(ptr,&data[8]); // fill in total len
return ptr;
}
struct ArtFileImageSort {
bool operator()(ArtFileImage*& ap,ArtFileImage*& bp) {
return ap->start < bp->start;
}
};
void ArtFile::sortImages() {
std::sort(images.begin(),images.end(),ArtFileImageSort());
for(size_t i = 1; i != images.size(); i++)
{
if(images[i]->start == images[i-1]->start)
{
images.erase(images.begin() + i);
i--;
images[i]->refcount++;
}
}
}
size_t ArtFile::getNextHole(size_t size) {
size_t s=0;
for(auto i = images.begin(); i!=images.end(); i++) {
if((*i)->start - s >= size) return s;
s = (*i)->start + (*i)->len;
}
return s;
}
bool writeDataToThumb(wchar_t *file, unsigned short * data, int len) {
FILE * f = _wfopen(file,L"ab");
if(!f) return false;
fwrite(data,len,sizeof(short),f);
fclose(f);
return true;
}
Reference in New Issue View Git Blame Copy Permalink