/*! Reads a file with the given \a fileName and loads the data into \a pattern.
* Returns \c true if successful, otherwise returns \c false. */
int readSst(EmbPattern* pattern, const char* fileName)
{
int fileLength;
EmbFile* file = 0;
if(!pattern) { embLog_error("format-sst.c readSst(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-sst.c readSst(), fileName argument is null\n"); return 0; }
file = embFile_open(fileName, "rb");
if(!file)
{
embLog_error("format-sst.c readSst(), cannot open %s for reading\n", fileName);
return 0;
}
embPattern_loadExternalColorFile(pattern, fileName);
embFile_seek(file, 0, SEEK_END);
fileLength = embFile_tell(file);
embFile_seek(file, 0xA0, SEEK_SET); /* skip the all zero header */
while(embFile_tell(file) < fileLength)
{
int stitchType = NORMAL;
int b1 = (int) binaryReadByte(file);
int b2 = (int) binaryReadByte(file);
unsigned char commandByte = binaryReadByte(file);
if(commandByte == 0x04)
{
embPattern_addStitchRel(pattern, 0, 0, END, 1);
break;
}
if((commandByte & 0x01) == 0x01)
stitchType = STOP;
if((commandByte & 0x02) == 0x02)
stitchType = JUMP;
if((commandByte & 0x10) != 0x10)
b2 = -b2;
if((commandByte & 0x40) == 0x40)
b1 = -b1;
embPattern_addStitchRel(pattern, b1 / 10.0, b2 / 10.0, stitchType, 1);
}
embFile_close(file);
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
return 1; /*TODO: finish readSst */
}
void vp3PatchByteCount(EmbFile* file, int offset, int adjustment)
{
int currentPos = embFile_tell(file);
embFile_seek(file, offset, SEEK_SET);
embLog_print("Patching byte count: %d\n", currentPos - offset + adjustment);
binaryWriteIntBE(file, currentPos - offset + adjustment);
embFile_seek(file, currentPos, SEEK_SET);
}
void writePecStitches(EmbPattern* pattern, EmbFile* file, const char* fileName)
{
EmbStitchList* tempStitches = 0;
EmbRect bounds;
unsigned char image[38][48];
int i, flen, currentThreadCount, graphicsOffsetLocation, graphicsOffsetValue, height, width;
double xFactor, yFactor;
const char* forwardSlashPos = strrchr(fileName, '/');
const char* backSlashPos = strrchr(fileName, '\\');
const char* dotPos = strrchr(fileName, '.');
const char* start = 0;
if(!pattern) { embLog_error("format-pec.c writePecStitches(), pattern argument is null\n"); return; }
if(!file) { embLog_error("format-pec.c writePecStitches(), file argument is null\n"); return; }
if(!fileName) { embLog_error("format-pec.c writePecStitches(), fileName argument is null\n"); return; }
if(forwardSlashPos)
{
start = forwardSlashPos + 1;
}
if(backSlashPos && backSlashPos > start)
{
start = backSlashPos + 1;
}
if(!start)
{
start = fileName;
}
binaryWriteBytes(file, "LA:", 3);
flen = (int)(dotPos - start);
while(start < dotPos)
{
binaryWriteByte(file, (unsigned char)*start);
start++;
}
for(i = 0; i < (int)(16-flen); i++)
{
binaryWriteByte(file, (unsigned char)0x20);
}
binaryWriteByte(file, 0x0D);
for(i = 0; i < 12; i++)
{
binaryWriteByte(file, (unsigned char)0x20);
}
binaryWriteByte(file, (unsigned char)0xFF);
binaryWriteByte(file, (unsigned char)0x00);
binaryWriteByte(file, (unsigned char)0x06);
binaryWriteByte(file, (unsigned char)0x26);
for(i = 0; i < 12; i++)
{
binaryWriteByte(file, (unsigned char)0x20);
}
currentThreadCount = embThreadList_count(pattern->threadList);
binaryWriteByte(file, (unsigned char)(currentThreadCount-1));
for(i = 0; i < currentThreadCount; i++)
{
binaryWriteByte(file, (unsigned char)embThread_findNearestColorInArray(embThreadList_getAt(pattern->threadList, i).color, (EmbThread*)pecThreads, pecThreadCount));
}
for(i = 0; i < (int)(0x1CF - currentThreadCount); i++)
{
binaryWriteByte(file, (unsigned char)0x20);
}
binaryWriteShort(file, (short)0x0000);
graphicsOffsetLocation = embFile_tell(file);
/* placeholder bytes to be overwritten */
binaryWriteByte(file, (unsigned char)0x00);
binaryWriteByte(file, (unsigned char)0x00);
binaryWriteByte(file, (unsigned char)0x00);
binaryWriteByte(file, (unsigned char)0x31);
binaryWriteByte(file, (unsigned char)0xFF);
binaryWriteByte(file, (unsigned char)0xF0);
bounds = embPattern_calcBoundingBox(pattern);
height = roundDouble(embRect_height(bounds));
width = roundDouble(embRect_width(bounds));
/* write 2 byte x size */
binaryWriteShort(file, (short)width);
/* write 2 byte y size */
binaryWriteShort(file, (short)height);
/* Write 4 miscellaneous int16's */
binaryWriteShort(file, (short)0x1E0);
binaryWriteShort(file, (short)0x1B0);
binaryWriteUShortBE(file, (unsigned short)(0x9000 | -roundDouble(bounds.left)));
binaryWriteUShortBE(file, (unsigned short)(0x9000 | -roundDouble(bounds.top)));
pecEncode(file, pattern);
graphicsOffsetValue = embFile_tell(file) - graphicsOffsetLocation + 2;
embFile_seek(file, graphicsOffsetLocation, SEEK_SET);
binaryWriteByte(file, (unsigned char)(graphicsOffsetValue & 0xFF));
binaryWriteByte(file, (unsigned char)((graphicsOffsetValue >> 8) & 0xFF));
binaryWriteByte(file, (unsigned char)((graphicsOffsetValue >> 16) & 0xFF));
embFile_seek(file, 0x00, SEEK_END);
/* Writing all colors */
clearImage(image);
tempStitches = pattern->stitchList;
yFactor = 32.0 / height;
xFactor = 42.0 / width;
while(tempStitches->next)
{
int x = roundDouble((tempStitches->stitch.xx - bounds.left) * xFactor) + 3;
int y = roundDouble((tempStitches->stitch.yy - bounds.top) * yFactor) + 3;
image[y][x] = 1;
tempStitches = tempStitches->next;
}
writeImage(file, image);
/* Writing each individual color */
tempStitches = pattern->stitchList;
for(i = 0; i < currentThreadCount; i++)
{
clearImage(image);
while(tempStitches->next)
{
int x = roundDouble((tempStitches->stitch.xx - bounds.left) * xFactor) + 3;
int y = roundDouble((tempStitches->stitch.yy - bounds.top) * yFactor) + 3;
if(tempStitches->stitch.flags & STOP)
{
tempStitches = tempStitches->next;
break;
}
image[y][x] = 1;
tempStitches = tempStitches->next;
}
writeImage(file, image);
}
}
/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writeXxx(EmbPattern* pattern, const char* fileName)
{
EmbFile* file = 0;
int i;
EmbRect rect;
int endOfStitches;
EmbThreadList* colors = 0;
int curColor = 0;
if(!pattern) { embLog_error("format-xxx.c writeXxx(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-xxx.c writeXxx(), fileName argument is null\n"); return 0; }
if(!embStitchList_count(pattern->stitchList))
{
embLog_error("format-xxx.c writeXxx(), pattern contains no stitches\n");
return 0;
}
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch && pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
file = embFile_open(fileName, "wb");
if(!file)
{
embLog_error("format-xxx.c writeXxx(), cannot open %s for writing\n", fileName);
return 0;
}
embPattern_correctForMaxStitchLength(pattern, 124, 127);
for(i = 0; i < 0x17; i++)
{
binaryWriteByte(file, 0x00);
}
binaryWriteUInt(file, (unsigned int) embStitchList_count(pattern->stitchList));
for(i = 0; i < 0x0C; i++)
{
binaryWriteByte(file, 0x00);
}
binaryWriteUShort(file, (unsigned short)embThreadList_count(pattern->threadList));
binaryWriteShort(file, 0x0000);
rect = embPattern_calcBoundingBox(pattern);
binaryWriteShort(file, (short)(embRect_width(rect) * 10.0));
binaryWriteShort(file, (short)(embRect_height(rect) * 10.0));
binaryWriteShort(file, (short)(embRect_width(rect) / 2.0 * 10)); /*TODO: xEnd from start point x=0 */
binaryWriteShort(file, (short)(embRect_height(rect) / 2.0 * 10)); /*TODO: yEnd from start point y=0 */
binaryWriteShort(file, (short)(embRect_width(rect)/2.0 * 10)); /*TODO: left from start x = 0 */
binaryWriteShort(file, (short)(embRect_height(rect)/2.0 * 10)); /*TODO: bottom from start y = 0 */
for(i = 0; i < 0xC5; i++)
{
binaryWriteByte(file, 0x00);
}
binaryWriteInt(file, 0x0000); /* place holder for end of stitches */
xxxEncodeDesign(file, pattern);
endOfStitches = embFile_tell(file);
embFile_seek(file, 0xFC, SEEK_SET);
binaryWriteUInt(file, endOfStitches);
embFile_seek(file, 0, SEEK_END);
binaryWriteByte(file, 0x7F); /* is this really correct? */
binaryWriteByte(file, 0x7F);
binaryWriteByte(file, 0x03);
binaryWriteByte(file, 0x14);
binaryWriteByte(file, 0x00);
binaryWriteByte(file, 0x00);
colors = pattern->threadList;
while(colors)
{
binaryWriteByte(file, 0x00);
binaryWriteByte(file, colors->thread.color.r);
binaryWriteByte(file, colors->thread.color.g);
binaryWriteByte(file, colors->thread.color.b);
curColor++;
colors = colors->next;
}
for(i = 0; i < (22 - curColor); i++)
{
binaryWriteUInt(file, 0x01000000);
}
binaryWriteByte(file, 0x00);
binaryWriteByte(file, 0x01);
embFile_close(file);
return 1;
}
/*! Reads a file with the given \a fileName and loads the data into \a pattern.
* Returns \c true if successful, otherwise returns \c false. */
int readXxx(EmbPattern* pattern, const char* fileName)
{
EmbFile* file = 0;
unsigned char b0, b1;
int dx = 0, dy = 0;
int flags;
char endOfStream = 0;
int numberOfColors;
int paletteOffset;
int i;
char thisStitchJump = 0;
EmbStitchList* lastStitch = 0;
EmbStitchList* secondLast = 0;
if(!pattern) { embLog_error("format-xxx.c readXxx(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-xxx.c readXxx(), fileName argument is null\n"); return 0; }
file = embFile_open(fileName, "rb");
if(!file)
{
embLog_error("format-xxx.c readXxx(), cannot open %s for reading\n", fileName);
return 0;
}
embFile_seek(file, 0x27, SEEK_SET);
numberOfColors = binaryReadInt16(file);
embFile_seek(file, 0xFC, SEEK_SET);
paletteOffset = binaryReadInt32(file);
embFile_seek(file, paletteOffset + 6, SEEK_SET);
for(i = 0; i < numberOfColors; i++)
{
EmbThread thread;
binaryReadByte(file);
thread.color.r = binaryReadByte(file);
thread.color.g = binaryReadByte(file);
thread.color.b = binaryReadByte(file);
embPattern_addThread(pattern, thread);
}
embFile_seek(file, 0x100, SEEK_SET);
for(i = 0; !endOfStream && embFile_tell(file) < paletteOffset; i++)
{
flags = NORMAL;
if(thisStitchJump) flags = TRIM;
thisStitchJump = 0;
b0 = binaryReadByte(file);
b1 = binaryReadByte(file);
if(b0 == 0x7E || b0 == 0x7D) /* TODO: ARE THERE OTHER BIG JUMP CODES? */
{
dx = b1 + (binaryReadByte(file) << 8);
dx = ((short) dx);
dy = binaryReadInt16(file);
flags = TRIM;
}
else if(b0 == 0x7F)
{
if(b1 != 0x17 && b1 != 0x46 && b1 >= 8) /* TODO: LOOKS LIKE THESE CODES ARE IN THE HEADER */
{
b0 = 0;
b1 = 0;
thisStitchJump = 1;
flags = STOP;
}
else if(b1 == 1)
{
flags = TRIM;
b0 = binaryReadByte(file);
b1 = binaryReadByte(file);
}
else
{
continue;
}
dx = xxxDecodeByte(b0);
dy = xxxDecodeByte(b1);
}
else
{
dx = xxxDecodeByte(b0);
dy = xxxDecodeByte(b1);
}
embPattern_addStitchRel(pattern, dx / 10.0, dy / 10.0, flags, 1);
}
lastStitch = pattern->stitchList;
secondLast = 0;
if(lastStitch)
{
while(lastStitch->next)
{
secondLast = lastStitch;
lastStitch = lastStitch->next;
}
if((!pattern->stitchList) && lastStitch->stitch.flags == STOP && secondLast)
{
free(lastStitch);
lastStitch = 0;
secondLast->next = NULL;
embPattern_changeColor(pattern, pattern->currentColorIndex - 1);
}
}
embFile_close(file);
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch && pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
return 1;
}
/*! Writes the data from \a pattern to a file with the given \a fileName.
* Returns \c true if successful, otherwise returns \c false. */
int writeVp3(EmbPattern* pattern, const char* fileName)
{
EmbFile *file = 0;
EmbRect bounds;
int remainingBytesPos, remainingBytesPos2;
int colorSectionStitchBytes;
int first = 1;
int numberOfColors = 0;
EmbColor color;
EmbStitchList *mainPointer = 0, *pointer = 0;
if(!pattern) { embLog_error("format-vp3.c writeVp3(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-vp3.c writeVp3(), fileName argument is null\n"); return 0; }
if(!embStitchList_count(pattern->stitchList))
{
embLog_error("format-vp3.c writeVp3(), pattern contains no stitches\n");
return 0;
}
bounds = embPattern_calcBoundingBox(pattern);
file = embFile_open(fileName, "wb");
if(!file)
{
embLog_error("format-vp3.c writeVp3(), cannot open %s for writing\n", fileName);
return 0;
}
embPattern_correctForMaxStitchLength(pattern, 3200.0, 3200.0); /* VP3 can encode signed 16bit deltas */
embPattern_flipVertical(pattern);
binaryWriteBytes(file, "%vsm%", 5);
binaryWriteByte(file, 0);
vp3WriteString(file, "Embroidermodder");
binaryWriteByte(file, 0);
binaryWriteByte(file, 2);
binaryWriteByte(file, 0);
remainingBytesPos = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
vp3WriteString(file, "");
binaryWriteIntBE(file, bounds.right * 1000);
binaryWriteIntBE(file, bounds.bottom * 1000);
binaryWriteIntBE(file, bounds.left * 1000);
binaryWriteIntBE(file, bounds.top * 1000);
binaryWriteInt(file, 0); /* this would be some (unknown) function of thread length */
binaryWriteByte(file, 0);
numberOfColors = 0;
mainPointer = pattern->stitchList;
while(mainPointer)
{
int flag;
EmbColor newColor;
pointer = mainPointer;
flag = pointer->stitch.flags;
newColor = embThreadList_getAt(pattern->threadList, pointer->stitch.color).color;
if(newColor.r != color.r || newColor.g != color.g || newColor.b != color.b)
{
numberOfColors++;
color.r = newColor.r;
color.g = newColor.g;
color.b = newColor.b;
}
else if(flag & END || flag & STOP)
{
numberOfColors++;
}
while(pointer && (flag == pointer->stitch.flags))
{
pointer = pointer->next;
}
mainPointer = pointer;
}
binaryWriteByte(file, numberOfColors);
binaryWriteByte(file, 12);
binaryWriteByte(file, 0);
binaryWriteByte(file, 1);
binaryWriteByte(file, 0);
binaryWriteByte(file, 3);
binaryWriteByte(file, 0);
remainingBytesPos2 = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
binaryWriteIntBE(file, 0); /* origin X */
binaryWriteIntBE(file, 0); /* origin Y */
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteIntBE(file, bounds.right * 1000);
binaryWriteIntBE(file, bounds.bottom * 1000);
binaryWriteIntBE(file, bounds.left * 1000);
binaryWriteIntBE(file, bounds.top * 1000);
binaryWriteIntBE(file, (bounds.right - bounds.left) * 1000);
binaryWriteIntBE(file, (bounds.bottom - bounds.top) * 1000);
vp3WriteString(file, "");
binaryWriteShortBE(file, 25700);
binaryWriteIntBE(file, 4096);
binaryWriteIntBE(file, 0);
binaryWriteIntBE(file, 0);
binaryWriteIntBE(file, 4096);
binaryWriteBytes(file, "xxPP\x01\0", 6);
vp3WriteString(file, "");
binaryWriteShortBE(file, numberOfColors);
mainPointer = pattern->stitchList;
while(mainPointer)
{
char colorName[8] = { 0 };
double lastX, lastY;
int colorSectionLengthPos;
EmbStitch s;
int lastColor;
if(!first)
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 5);
binaryWriteByte(file, 0);
colorSectionLengthPos = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
pointer = mainPointer;
color = embThreadList_getAt(pattern->threadList, pointer->stitch.color).color;
if(first && pointer->stitch.flags & JUMP && pointer->next->stitch.flags & JUMP)
pointer = pointer->next;
s = pointer->stitch;
embLog_print("format-vp3.c DEBUG %d, %lf, %lf\n", s.flags, s.xx, s.yy);
binaryWriteIntBE(file, s.xx * 1000);
binaryWriteIntBE(file, -s.yy * 1000);
pointer = pointer->next;
first = 0;
lastX = s.xx;
lastY = s.yy;
lastColor = s.color;
binaryWriteByte(file, 1);
binaryWriteByte(file, 0);
embLog_print("format-vp3.c writeVp3(), switching to color (%d, %d, %d)\n", color.r, color.g, color.b);
binaryWriteByte(file, color.r);
binaryWriteByte(file, color.g);
binaryWriteByte(file, color.b);
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 0);
binaryWriteByte(file, 5);
binaryWriteByte(file, 40);
vp3WriteString(file, "");
sprintf(colorName, "#%02x%02x%02x", color.b, color.g, color.r);
vp3WriteString(file, colorName);
vp3WriteString(file, "");
binaryWriteIntBE(file, 0);
binaryWriteIntBE(file, 0);
vp3WriteStringLen(file, "\0", 1);
colorSectionStitchBytes = embFile_tell(file);
binaryWriteInt(file, 0); /* placeholder */
binaryWriteByte(file, 10);
binaryWriteByte(file, 246);
binaryWriteByte(file, 0);
while(pointer)
{
int dx, dy;
EmbStitch s = pointer->stitch;
if(s.color != lastColor)
break;
if(s.flags & END || s.flags & STOP)
break;
dx = (s.xx - lastX) * 10;
dy = (s.yy - lastY) * 10;
lastX = lastX + dx / 10.0; /* output is in ints, ensure rounding errors do not sum up */
lastY = lastY + dy / 10.0;
if(dx < -127 || dx > 127 || dy < -127 || dy > 127)
{
binaryWriteByte(file, 128);
binaryWriteByte(file, 1);
binaryWriteShortBE(file, dx);
binaryWriteShortBE(file, dy);
binaryWriteByte(file, 128);
binaryWriteByte(file, 2);
}
else
{
binaryWriteByte(file, dx);
binaryWriteByte(file, dy);
}
pointer = pointer->next;
}
vp3PatchByteCount(file, colorSectionStitchBytes, -4);
vp3PatchByteCount(file, colorSectionLengthPos, -3);
mainPointer = pointer;
}
vp3PatchByteCount(file, remainingBytesPos2, -4);
vp3PatchByteCount(file, remainingBytesPos, -4);
embFile_close(file);
embPattern_flipVertical(pattern);
return 1;
}
/*! Reads a file with the given \a fileName and loads the data into \a pattern.
* Returns \c true if successful, otherwise returns \c false. */
int readVp3(EmbPattern* pattern, const char* fileName)
{
unsigned char magicString[5];
unsigned char some;
unsigned char* softwareVendorString = 0;
unsigned char v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18;
unsigned char* anotherSoftwareVendorString = 0;
int numberOfColors;
long colorSectionOffset;
unsigned char magicCode[6];
short someShort;
unsigned char someByte;
int bytesRemainingInFile;
unsigned char* fileCommentString = 0; /* some software writes used settings here */
int hoopConfigurationOffset;
unsigned char* anotherCommentString = 0;
int i;
EmbFile* file = 0;
if(!pattern) { embLog_error("format-vp3.c readVp3(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-vp3.c readVp3(), fileName argument is null\n"); return 0; }
file = embFile_open(fileName, "rb");
if(!file)
{
embLog_error("format-vp3.c readVp3(), cannot open %s for reading\n", fileName);
return 0;
}
binaryReadBytes(file, magicString, 5); /* %vsm% */ /* TODO: check return value */
some = binaryReadByte(file); /* 0 */
softwareVendorString = vp3ReadString(file);
someShort = binaryReadInt16(file);
someByte = binaryReadByte(file);
bytesRemainingInFile = binaryReadInt32(file);
fileCommentString = vp3ReadString(file);
hoopConfigurationOffset = (int)embFile_tell(file);
vp3ReadHoopSection(file);
anotherCommentString = vp3ReadString(file);
/* TODO: review v1 thru v18 variables and use emb_unused() if needed */
v1 = binaryReadByte(file);
v2 = binaryReadByte(file);
v3 = binaryReadByte(file);
v4 = binaryReadByte(file);
v5 = binaryReadByte(file);
v6 = binaryReadByte(file);
v7 = binaryReadByte(file);
v8 = binaryReadByte(file);
v9 = binaryReadByte(file);
v10 = binaryReadByte(file);
v11 = binaryReadByte(file);
v12 = binaryReadByte(file);
v13 = binaryReadByte(file);
v14 = binaryReadByte(file);
v15 = binaryReadByte(file);
v16 = binaryReadByte(file);
v17 = binaryReadByte(file);
v18 = binaryReadByte(file);
binaryReadBytes(file, magicCode, 6); /* 0x78 0x78 0x55 0x55 0x01 0x00 */ /* TODO: check return value */
anotherSoftwareVendorString = vp3ReadString(file);
numberOfColors = binaryReadInt16BE(file);
embLog_error("format-vp3.c Number of Colors: %d\n", numberOfColors);
colorSectionOffset = (int)embFile_tell(file);
for(i = 0; i < numberOfColors; i++)
{
EmbThread t;
char tableSize;
int startX, startY, offsetToNextColorX, offsetToNextColorY;
unsigned char* threadColorNumber, *colorName, *threadVendor;
int unknownThreadString, numberOfBytesInColor;
embFile_seek(file, colorSectionOffset, SEEK_SET);
embLog_error("format-vp3.c Color Check Byte #1: 0 == %d\n", binaryReadByte(file));
embLog_error("format-vp3.c Color Check Byte #2: 5 == %d\n", binaryReadByte(file));
embLog_error("format-vp3.c Color Check Byte #3: 0 == %d\n", binaryReadByte(file));
colorSectionOffset = binaryReadInt32BE(file);
colorSectionOffset += embFile_tell(file);
startX = binaryReadInt32BE(file);
startY = binaryReadInt32BE(file);
embPattern_addStitchAbs(pattern, startX / 1000, -startY / 1000, JUMP, 0);
tableSize = binaryReadByte(file);
binaryReadByte(file);
t.color.r = binaryReadByte(file);
t.color.g = binaryReadByte(file);
t.color.b = binaryReadByte(file);
embPattern_addThread(pattern, t);
embFile_seek(file, 6*tableSize - 1, SEEK_CUR);
threadColorNumber = vp3ReadString(file);
colorName = vp3ReadString(file);
threadVendor = vp3ReadString(file);
offsetToNextColorX = binaryReadInt32BE(file);
offsetToNextColorY = binaryReadInt32BE(file);
unknownThreadString = binaryReadInt16BE(file);
embFile_seek(file, unknownThreadString, SEEK_CUR);
numberOfBytesInColor = binaryReadInt32BE(file);
embFile_seek(file, 0x3, SEEK_CUR);
while(embFile_tell(file) < colorSectionOffset - 1)
{
int lastFilePosition = embFile_tell(file);
int x = vp3Decode(binaryReadByte(file));
int y = vp3Decode(binaryReadByte(file));
if(x == 0x80)
{
switch (y)
{
case 0x00:
case 0x03:
break;
case 0x01:
x = vp3DecodeInt16(binaryReadInt16BE(file));
y = vp3DecodeInt16(binaryReadInt16BE(file));
binaryReadInt16BE(file);
embPattern_addStitchRel(pattern, x/ 10.0, y / 10.0, TRIM, 1);
break;
default:
break;
}
}
else
{
embPattern_addStitchRel(pattern, x / 10.0, y / 10.0, NORMAL, 1);
}
if(embFile_tell(file) == lastFilePosition)
{
embLog_error("format-vp3.c could not read stitch block in entirety\n");
return 0;
}
}
if(i + 1 < numberOfColors)
embPattern_addStitchRel(pattern, 0, 0, STOP, 1);
}
embFile_close(file);
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
embPattern_flipVertical(pattern);
return 1;
}
/*! Reads a file with the given \a fileName and loads the data into \a pattern.
* Returns \c true if successful, otherwise returns \c false. */
int readVip(EmbPattern* pattern, const char* fileName)
{
int fileLength;
int i;
unsigned char prevByte = 0;
unsigned char *attributeData = 0, *decodedColors = 0, *attributeDataDecompressed = 0;
unsigned char *xData = 0, *xDecompressed = 0, *yData = 0, *yDecompressed = 0;
VipHeader header;
EmbFile* file = 0;
if(!pattern) { embLog_error("format-vip.c readVip(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-vip.c readVip(), fileName argument is null\n"); return 0; }
file = embFile_open(fileName, "rb");
if(!file)
{
embLog_error("format-vip.c readVip(), cannot open %s for reading\n", fileName);
return 0;
}
embFile_seek(file, 0x0, SEEK_END);
fileLength = embFile_tell(file);
embFile_seek(file, 0x00, SEEK_SET);
header.magicCode = binaryReadInt32(file);
header.numberOfStitches = binaryReadInt32(file);
header.numberOfColors = binaryReadInt32(file);
header.postitiveXHoopSize = binaryReadInt16(file);
header.postitiveYHoopSize = binaryReadInt16(file);
header.negativeXHoopSize = binaryReadInt16(file);
header.negativeYHoopSize = binaryReadInt16(file);
header.attributeOffset = binaryReadInt32(file);
header.xOffset = binaryReadInt32(file);
header.yOffset = binaryReadInt32(file);
/*stringVal = (unsigned char*)malloc(sizeof(unsigned char)*8); TODO: review this and uncomment or remove
if(!stringVal) { embLog_error("format-vip.c readVip(), cannot allocate memory for stringVal\n"); return 0; }
*/
binaryReadBytes(file, header.stringVal, 8); /* TODO: check return value */
header.unknown = binaryReadInt16(file);
header.colorLength = binaryReadInt32(file);
decodedColors = (unsigned char*)malloc(header.numberOfColors*4);
if(!decodedColors) { embLog_error("format-vip.c readVip(), cannot allocate memory for decodedColors\n"); return 0; }
for(i = 0; i < header.numberOfColors*4; ++i)
{
unsigned char inputByte = binaryReadByte(file);
unsigned char tmpByte = (unsigned char) (inputByte ^ vipDecodingTable[i]);
decodedColors[i] = (unsigned char) (tmpByte ^ prevByte);
prevByte = inputByte;
}
for(i = 0; i < header.numberOfColors; i++)
{
EmbThread thread;
int startIndex = i << 2;
thread.color.r = decodedColors[startIndex];
thread.color.g = decodedColors[startIndex + 1];
thread.color.b = decodedColors[startIndex + 2];
/* printf("%d\n", decodedColors[startIndex + 3]); */
embPattern_addThread(pattern, thread);
}
embFile_seek(file, header.attributeOffset, SEEK_SET);
attributeData = (unsigned char*)malloc(header.xOffset - header.attributeOffset);
if(!attributeData) { embLog_error("format-vip.c readVip(), cannot allocate memory for attributeData\n"); return 0; }
binaryReadBytes(file, attributeData, header.xOffset - header.attributeOffset); /* TODO: check return value */
attributeDataDecompressed = vipDecompressData(attributeData, header.xOffset - header.attributeOffset, header.numberOfStitches);
embFile_seek(file, header.xOffset, SEEK_SET);
xData = (unsigned char*)malloc(header.yOffset - header.xOffset);
if(!xData) { embLog_error("format-vip.c readVip(), cannot allocate memory for xData\n"); return 0; }
binaryReadBytes(file, xData, header.yOffset - header.xOffset); /* TODO: check return value */
xDecompressed = vipDecompressData(xData, header.yOffset - header.xOffset, header.numberOfStitches);
embFile_seek(file, header.yOffset, SEEK_SET);
yData = (unsigned char*)malloc(fileLength - header.yOffset);
if(!yData) { embLog_error("format-vip.c readVip(), cannot allocate memory for yData\n"); return 0; }
binaryReadBytes(file, yData, fileLength - header.yOffset); /* TODO: check return value */
yDecompressed = vipDecompressData(yData, fileLength - header.yOffset, header.numberOfStitches);
for(i = 0; i < header.numberOfStitches; i++)
{
embPattern_addStitchRel(pattern,
vipDecodeByte(xDecompressed[i]) / 10.0,
vipDecodeByte(yDecompressed[i]) / 10.0,
vipDecodeStitchType(attributeDataDecompressed[i]), 1);
}
embPattern_addStitchRel(pattern, 0, 0, END, 1);
embFile_close(file);
free(attributeData); attributeData = 0;
free(xData); xData = 0;
free(yData); yData = 0;
free(attributeDataDecompressed); attributeDataDecompressed = 0;
free(xDecompressed); xDecompressed = 0;
free(yDecompressed); yDecompressed = 0;
return 1;
}
/*! Reads a file with the given \a fileName and loads the data into \a pattern.
* Returns \c true if successful, otherwise returns \c false. */
int readInb(EmbPattern* pattern, const char* fileName)
{
EmbFile* file = 0;
unsigned char fileDescription[8];
unsigned char nullVal;
int stitchCount;
short width;
short height;
short colorCount;
short unknown3;
short unknown2;
short imageWidth;
short imageHeight;
unsigned char bytesUnknown[300];
short nullbyte;
short left;
short right;
short top;
short bottom;
int x = 0;
int y = 0;
int i;
int fileLength;
if(!pattern) { embLog_error("format-inb.c readInb(), pattern argument is null\n"); return 0; }
if(!fileName) { embLog_error("format-inb.c readInb(), fileName argument is null\n"); return 0; }
file = embFile_open(fileName, "rb");
if(!file)
{
embLog_error("format-inb.c readInb(), cannot open %s for reading\n", fileName);
return 0;
}
embPattern_loadExternalColorFile(pattern, fileName);
embFile_seek(file, 0, SEEK_END);
fileLength = embFile_tell(file);
binaryReadBytes(file, fileDescription, 8);
nullVal = binaryReadByte(file);
binaryReadInt16(file);
stitchCount = binaryReadInt32(file);
width = binaryReadInt16(file);
height = binaryReadInt16(file);
colorCount = binaryReadInt16(file);
unknown3 = binaryReadInt16(file);
unknown2 = binaryReadInt16(file);
imageWidth = binaryReadInt16(file);
imageHeight = binaryReadInt16(file);
binaryReadBytes(file, bytesUnknown, 300);
nullbyte = binaryReadInt16(file);
left = binaryReadInt16(file);
right = binaryReadInt16(file);
top = binaryReadInt16(file);
bottom = binaryReadInt16(file);
embFile_seek(file, 0x2000, SEEK_SET);
/* Calculate stitch count since header has been seen to be blank */
stitchCount = (int)((fileLength - 0x2000) / 3);
for(i = 0; i < stitchCount; i++)
{
unsigned char type;
int stitch = NORMAL;
x = binaryReadByte(file);
y = binaryReadByte(file);
type = binaryReadByte(file);
if((type & 0x40) > 0)
x = -x;
if((type & 0x10) > 0)
y = -y;
if((type & 1) > 0)
stitch = STOP;
if((type & 2) > 0)
stitch = TRIM;
embPattern_addStitchRel(pattern, x / 10.0, y / 10.0, stitch, 1);
}
embFile_close(file);
/* Check for an END stitch and add one if it is not present */
if(pattern->lastStitch->stitch.flags != END)
embPattern_addStitchRel(pattern, 0, 0, END, 1);
embPattern_flipVertical(pattern);
return 1;
}
