/*! 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; }