utils/jz4740_tools/HXF2IHFS.c - rockbox - Gitiles

 /***************************************************************************
  *             __________               __   ___.
  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
  *                     \/            \/     \/    \/            \/
  * $Id$
  *
  * Copyright (C) 2008 by William Poetra Yoga Hadisoeseno
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  * KIND, either express or implied.
  *
  ****************************************************************************/
 #include <stdio.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>

 void usage()
 {
     fprintf(stderr, "Usage: HXF2IHFS <hxf_img> <ihfs_img> [ihfs_size]\n");
     exit(1);
 }

 typedef struct {
     uint32_t signature;
     char unknown1[4];
     char timestamp[12];
     uint32_t length;
     uint32_t unknown2;
     uint32_t unknown3;
     char id[32];
 } hxf_header_t;

 int hxf_sanity(const int hxf_img)
 {
     struct stat statbuf;
     hxf_header_t hxf_hdr;
     int r, len_name, len_file, pos;

     printf("Starting sanity check for HXF image...\n");

     lseek(hxf_img, 0, SEEK_SET);
     read(hxf_img, &hxf_hdr, sizeof (hxf_hdr));

     printf("  Checking for HXF signature...\n");
     if (hxf_hdr.signature != 0x46444157)
         return 1;

     printf("  Checking for unknown value 1...\n");
     if (strncmp(hxf_hdr.unknown1, "0100", 4))
         return 1;

     printf("  Checking for length...\n");
     fstat(hxf_img, &statbuf);
     if (hxf_hdr.length != statbuf.st_size)
         return 1;

     printf("  Checking for unknown value 3...\n");
     if (hxf_hdr.unknown3 != 0x00000000)
         return 1;

     printf("  Checking for id...\n");
     if (memcmp(hxf_hdr.id, "Chinachip PMP firmware V1.0\0\0\0\0\0", 32))
         return 1;

     printf("  Checking for file completeness...\n");
     while (1) {
         r = read(hxf_img, &len_name, 4);
         if (r != 4)
             return 1;
         if (len_name == 0)
             break;

         r = lseek(hxf_img, len_name + 1, SEEK_CUR);
         if (r < 0)
             return 1;

         r = read(hxf_img, &len_file, 4);
         if (r != 4)
             return 1;
         if (len_file <= 0)
             return 1;

         r = lseek(hxf_img, len_file, SEEK_CUR);
         if (r < 0)
             return 1;
     }
     pos = lseek(hxf_img, 0, SEEK_CUR);
     if (pos != statbuf.st_size)
         return 1;

     return 0;
 }

 typedef struct {
     uint32_t signature;
     uint32_t fslen;
     uint32_t unknown1;
     uint32_t unknown2;
     char timestamp[12];
     uint32_t numfiles;
     char zeros[476];
     uint32_t marker;
 } ihfs_header_t;

 #define MAX_FILES 2048
 #define MAX_IHFS_PATH 56

 typedef struct {
     struct {
         char fullpath[MAX_IHFS_PATH];
         uint32_t sector;
         uint32_t length;
     } files[MAX_FILES];
 } ihfs_file_table_t;

 #define SECTOR_SIZE 512

 #define DEFAULT_IHFS_SIZE 65273856
 #define DEADFACE_START 0x02140000


 int hxf_ihfs_compatible(int hxf_img)
 {
     int n, len_name, len_file;

     lseek(hxf_img, sizeof (hxf_header_t), SEEK_SET);

     n = 0;
     while (1) {
         read(hxf_img, &len_name, 4);
         if (len_name == 0)
             break;
         if (len_name > MAX_IHFS_PATH)
             return 1;
         lseek(hxf_img, len_name + 1, SEEK_CUR);
         read(hxf_img, &len_file, 4);
         lseek(hxf_img, len_file, SEEK_CUR);
         ++n;
     }

     if (n > MAX_FILES)
         return 1;

     return 0;
 }

 void hxf_to_ihfs(int hxf_img, int ihfs_img, int filesize)
 {
     char buf[SECTOR_SIZE];
     char ff[SECTOR_SIZE];
     int i, n, rem;

     n = filesize / SECTOR_SIZE;
     rem = filesize % SECTOR_SIZE;

     for (i = 0; i < n; ++i) {
         read(hxf_img, buf, SECTOR_SIZE);
         write(ihfs_img, buf, SECTOR_SIZE);
     }

     if (rem > 0) {
         read(hxf_img, buf, rem);
         write(ihfs_img, buf, rem);
         /* pad with 0xff */
         memset(ff, 0xff, SECTOR_SIZE-rem);
         write(ihfs_img, ff, SECTOR_SIZE-rem);
     }
 }

 int main(int argc, char **argv)
 {
     struct stat statbuf;
     int hxf_img;
     hxf_header_t hxf_hdr;
     char s[32];
     int i, n;

     int ihfs_img;
     ihfs_header_t ihfs_hdr;
     ihfs_file_table_t ihfs_ftbl;
     int ihfs_len;
     unsigned char deadface[SECTOR_SIZE];
     char ff[SECTOR_SIZE];

     int pathlen;
     char *path;
     char filetype;
     int filesize;
     int pos;

     /* check the arguments */
     if (argc != 3 && argc != 4)
         usage();

     stat(argv[1], &statbuf);
     if (!S_ISREG(statbuf.st_mode))
         usage();

     if (argc == 3) {
         ihfs_len = DEFAULT_IHFS_SIZE;
     } else {
         errno = 0;
         ihfs_len = strtol(argv[3], NULL, 10);
         if (errno != 0 || ihfs_len < 0 || (ihfs_len % SECTOR_SIZE) != 0)
             usage();
     }

     /* check the file */

     hxf_img = open(argv[1], O_RDONLY);

     if (hxf_sanity(hxf_img)) {
         printf("Non-HXF format!\n");
         return 1;
     } else {
         printf("Sanity check OK\n");
     }

     lseek(hxf_img, 0, SEEK_SET);
     read(hxf_img, &hxf_hdr, sizeof (hxf_hdr));

     printf("HXF info:\n");

     printf("  Signature: 0x%08x\n", hxf_hdr.signature);

     strncpy(s, hxf_hdr.unknown1, 4);
     s[4] = '\0';
     printf("  Unknown1: %s\n", s);

     strncpy(s, hxf_hdr.timestamp, 12);
     s[12] = '\0';
     printf("  Timestamp: %s\n", s);

     printf("  File size: %d bytes\n", hxf_hdr.length);
     printf("  Unknown2: 0x%08x\n", hxf_hdr.unknown2);
     printf("  Unknown3: 0x%08x\n", hxf_hdr.unknown3);
     printf("  Identifier: %s\n", hxf_hdr.id);

     if (hxf_ihfs_compatible(hxf_img)) {
         printf("This HXF image can't be converted into IHFS\n");
         return 1;
     } else {
         printf("HXF can be converted into IHFS\n");
     }

     /* initialize IHFS structures */
     ihfs_hdr.signature = 0x49484653;
     ihfs_hdr.fslen = ihfs_len / SECTOR_SIZE;
     ihfs_hdr.unknown1 = 0x00000004;
     ihfs_hdr.unknown2 = 0xfffff000;
     memcpy(ihfs_hdr.timestamp, hxf_hdr.timestamp, 12);
     ihfs_hdr.numfiles = 0;
     memset(ihfs_hdr.zeros, 0, 476);
     ihfs_hdr.marker = 0x55aa55aa;

     memset(&ihfs_ftbl, 0, sizeof (ihfs_ftbl));

     /* start converting */
     lseek(hxf_img, sizeof (hxf_header_t), SEEK_SET);

     ihfs_img = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0644);
     lseek(ihfs_img, sizeof (ihfs_header_t) + 3 * SECTOR_SIZE + sizeof (ihfs_file_table_t), SEEK_SET);

     i = 0;
     while (lseek(hxf_img, 0, SEEK_CUR) < hxf_hdr.length) {
         read(hxf_img, &pathlen, 4);
         if (pathlen == 0)
             break;

         path = malloc(pathlen + 1);
         read(hxf_img, path, pathlen);
         path[pathlen] = '\0';
         read(hxf_img, &filetype, 1);
         read(hxf_img, &filesize, 4);

         /* update the file table and copy the data */
         strncpy(ihfs_ftbl.files[i].fullpath, path, MAX_IHFS_PATH);
         ihfs_ftbl.files[i].sector = lseek(ihfs_img, 0, SEEK_CUR) / 512;
         ihfs_ftbl.files[i].length = filesize;

         hxf_to_ihfs(hxf_img, ihfs_img, filesize);

         free(path);
         ++i;
     }
     ihfs_hdr.numfiles = i;

     /* finalize the ihfs image */

     pos = lseek(ihfs_img, 0, SEEK_CUR);
     if ((pos % SECTOR_SIZE) != 0) {
         printf("Something wrong happened during IHFS image creation at %d\n", pos);
         return 1;
     }
     if (pos < ihfs_len && pos < DEADFACE_START) {
         memset(ff, 0xff, SECTOR_SIZE);
         n = (DEADFACE_START - pos) / SECTOR_SIZE;
         for (i = 0; i < n; ++i)
             write(ihfs_img, ff, SECTOR_SIZE);
         pos = DEADFACE_START;
     }
     if (pos < ihfs_len) {
         for (i = 0; i < SECTOR_SIZE; i += 4) {
             deadface[i] = 0xde;
             deadface[i+1] = 0xad;
             deadface[i+2] = 0xfa;
             deadface[i+3] = 0xce;
         }
         n = (ihfs_len - pos) / SECTOR_SIZE;
         for (i = 0; i < n; ++i)
             write(ihfs_img, deadface, SECTOR_SIZE);
     }

     lseek(ihfs_img, 0, SEEK_SET);
     write(ihfs_img, &ihfs_hdr, sizeof (ihfs_hdr));
     memset(ff, 0xff, SECTOR_SIZE);
     write(ihfs_img, ff, SECTOR_SIZE);
     write(ihfs_img, ff, SECTOR_SIZE);
     write(ihfs_img, ff, SECTOR_SIZE);
     write(ihfs_img, &ihfs_ftbl, sizeof (ihfs_ftbl));

     /* cleanup */
     close(hxf_img);
     close(ihfs_img);

     printf("Done!\n");

     return 0;
 }
	/***************************************************************************
	* __________ __ ___.
	* Open \______ \ ____ ____ \| \| _\_ \|__ _______ ___
	* Source \| _// _ \_/ ___\\| \|/ /\| __ \ / _ \ \/ /
	* Jukebox \| \| ( <_> ) \___\| < \| \_\ ( <_> > < <
	* Firmware \|____\|_ /\____/ \___ >__\|_ \\|___ /\____/__/\_ \
	* \/ \/ \/ \/ \/
	* $Id$
	*
	* Copyright (C) 2008 by William Poetra Yoga Hadisoeseno
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version 2
	* of the License, or (at your option) any later version.
	*
	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
	* KIND, either express or implied.
	*
	****************************************************************************/
	#include <stdio.h>
	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <stdint.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <errno.h>

	void usage()
	{
	fprintf(stderr, "Usage: HXF2IHFS <hxf_img> <ihfs_img> [ihfs_size]\n");
	exit(1);
	}

	typedef struct {
	uint32_t signature;
	char unknown1[4];
	char timestamp[12];
	uint32_t length;
	uint32_t unknown2;
	uint32_t unknown3;
	char id[32];
	} hxf_header_t;

	int hxf_sanity(const int hxf_img)
	{
	struct stat statbuf;
	hxf_header_t hxf_hdr;
	int r, len_name, len_file, pos;

	printf("Starting sanity check for HXF image...\n");

	lseek(hxf_img, 0, SEEK_SET);
	read(hxf_img, &hxf_hdr, sizeof (hxf_hdr));

	printf(" Checking for HXF signature...\n");
	if (hxf_hdr.signature != 0x46444157)
	return 1;

	printf(" Checking for unknown value 1...\n");
	if (strncmp(hxf_hdr.unknown1, "0100", 4))
	return 1;

	printf(" Checking for length...\n");
	fstat(hxf_img, &statbuf);
	if (hxf_hdr.length != statbuf.st_size)
	return 1;

	printf(" Checking for unknown value 3...\n");
	if (hxf_hdr.unknown3 != 0x00000000)
	return 1;

	printf(" Checking for id...\n");
	if (memcmp(hxf_hdr.id, "Chinachip PMP firmware V1.0\0\0\0\0\0", 32))
	return 1;

	printf(" Checking for file completeness...\n");
	while (1) {
	r = read(hxf_img, &len_name, 4);
	if (r != 4)
	return 1;
	if (len_name == 0)
	break;

	r = lseek(hxf_img, len_name + 1, SEEK_CUR);
	if (r < 0)
	return 1;

	r = read(hxf_img, &len_file, 4);
	if (r != 4)
	return 1;
	if (len_file <= 0)
	return 1;

	r = lseek(hxf_img, len_file, SEEK_CUR);
	if (r < 0)
	return 1;
	}
	pos = lseek(hxf_img, 0, SEEK_CUR);
	if (pos != statbuf.st_size)
	return 1;

	return 0;
	}

	typedef struct {
	uint32_t signature;
	uint32_t fslen;
	uint32_t unknown1;
	uint32_t unknown2;
	char timestamp[12];
	uint32_t numfiles;
	char zeros[476];
	uint32_t marker;
	} ihfs_header_t;

	#define MAX_FILES 2048
	#define MAX_IHFS_PATH 56

	typedef struct {
	struct {
	char fullpath[MAX_IHFS_PATH];
	uint32_t sector;
	uint32_t length;
	} files[MAX_FILES];
	} ihfs_file_table_t;

	#define SECTOR_SIZE 512

	#define DEFAULT_IHFS_SIZE 65273856
	#define DEADFACE_START 0x02140000


	int hxf_ihfs_compatible(int hxf_img)
	{
	int n, len_name, len_file;

	lseek(hxf_img, sizeof (hxf_header_t), SEEK_SET);

	n = 0;
	while (1) {
	read(hxf_img, &len_name, 4);
	if (len_name == 0)
	break;
	if (len_name > MAX_IHFS_PATH)
	return 1;
	lseek(hxf_img, len_name + 1, SEEK_CUR);
	read(hxf_img, &len_file, 4);
	lseek(hxf_img, len_file, SEEK_CUR);
	++n;
	}

	if (n > MAX_FILES)
	return 1;

	return 0;
	}

	void hxf_to_ihfs(int hxf_img, int ihfs_img, int filesize)
	{
	char buf[SECTOR_SIZE];
	char ff[SECTOR_SIZE];
	int i, n, rem;

	n = filesize / SECTOR_SIZE;
	rem = filesize % SECTOR_SIZE;

	for (i = 0; i < n; ++i) {
	read(hxf_img, buf, SECTOR_SIZE);
	write(ihfs_img, buf, SECTOR_SIZE);
	}

	if (rem > 0) {
	read(hxf_img, buf, rem);
	write(ihfs_img, buf, rem);
	/* pad with 0xff */
	memset(ff, 0xff, SECTOR_SIZE-rem);
	write(ihfs_img, ff, SECTOR_SIZE-rem);
	}
	}

	int main(int argc, char **argv)
	{
	struct stat statbuf;
	int hxf_img;
	hxf_header_t hxf_hdr;
	char s[32];
	int i, n;

	int ihfs_img;
	ihfs_header_t ihfs_hdr;
	ihfs_file_table_t ihfs_ftbl;
	int ihfs_len;
	unsigned char deadface[SECTOR_SIZE];
	char ff[SECTOR_SIZE];

	int pathlen;
	char *path;
	char filetype;
	int filesize;
	int pos;

	/* check the arguments */
	if (argc != 3 && argc != 4)
	usage();

	stat(argv[1], &statbuf);
	if (!S_ISREG(statbuf.st_mode))
	usage();

	if (argc == 3) {
	ihfs_len = DEFAULT_IHFS_SIZE;
	} else {
	errno = 0;
	ihfs_len = strtol(argv[3], NULL, 10);
	if (errno != 0 \|\| ihfs_len < 0 \|\| (ihfs_len % SECTOR_SIZE) != 0)
	usage();
	}

	/* check the file */

	hxf_img = open(argv[1], O_RDONLY);

	if (hxf_sanity(hxf_img)) {
	printf("Non-HXF format!\n");
	return 1;
	} else {
	printf("Sanity check OK\n");
	}

	lseek(hxf_img, 0, SEEK_SET);
	read(hxf_img, &hxf_hdr, sizeof (hxf_hdr));

	printf("HXF info:\n");

	printf(" Signature: 0x%08x\n", hxf_hdr.signature);

	strncpy(s, hxf_hdr.unknown1, 4);
	s[4] = '\0';
	printf(" Unknown1: %s\n", s);

	strncpy(s, hxf_hdr.timestamp, 12);
	s[12] = '\0';
	printf(" Timestamp: %s\n", s);

	printf(" File size: %d bytes\n", hxf_hdr.length);
	printf(" Unknown2: 0x%08x\n", hxf_hdr.unknown2);
	printf(" Unknown3: 0x%08x\n", hxf_hdr.unknown3);
	printf(" Identifier: %s\n", hxf_hdr.id);

	if (hxf_ihfs_compatible(hxf_img)) {
	printf("This HXF image can't be converted into IHFS\n");
	return 1;
	} else {
	printf("HXF can be converted into IHFS\n");
	}

	/* initialize IHFS structures */
	ihfs_hdr.signature = 0x49484653;
	ihfs_hdr.fslen = ihfs_len / SECTOR_SIZE;
	ihfs_hdr.unknown1 = 0x00000004;
	ihfs_hdr.unknown2 = 0xfffff000;
	memcpy(ihfs_hdr.timestamp, hxf_hdr.timestamp, 12);
	ihfs_hdr.numfiles = 0;
	memset(ihfs_hdr.zeros, 0, 476);
	ihfs_hdr.marker = 0x55aa55aa;

	memset(&ihfs_ftbl, 0, sizeof (ihfs_ftbl));

	/* start converting */
	lseek(hxf_img, sizeof (hxf_header_t), SEEK_SET);

	ihfs_img = open(argv[2], O_WRONLY\|O_CREAT\|O_TRUNC, 0644);
	lseek(ihfs_img, sizeof (ihfs_header_t) + 3 * SECTOR_SIZE + sizeof (ihfs_file_table_t), SEEK_SET);

	i = 0;
	while (lseek(hxf_img, 0, SEEK_CUR) < hxf_hdr.length) {
	read(hxf_img, &pathlen, 4);
	if (pathlen == 0)
	break;

	path = malloc(pathlen + 1);
	read(hxf_img, path, pathlen);
	path[pathlen] = '\0';
	read(hxf_img, &filetype, 1);
	read(hxf_img, &filesize, 4);

	/* update the file table and copy the data */
	strncpy(ihfs_ftbl.files[i].fullpath, path, MAX_IHFS_PATH);
	ihfs_ftbl.files[i].sector = lseek(ihfs_img, 0, SEEK_CUR) / 512;
	ihfs_ftbl.files[i].length = filesize;

	hxf_to_ihfs(hxf_img, ihfs_img, filesize);

	free(path);
	++i;
	}
	ihfs_hdr.numfiles = i;

	/* finalize the ihfs image */

	pos = lseek(ihfs_img, 0, SEEK_CUR);
	if ((pos % SECTOR_SIZE) != 0) {
	printf("Something wrong happened during IHFS image creation at %d\n", pos);
	return 1;
	}
	if (pos < ihfs_len && pos < DEADFACE_START) {
	memset(ff, 0xff, SECTOR_SIZE);
	n = (DEADFACE_START - pos) / SECTOR_SIZE;
	for (i = 0; i < n; ++i)
	write(ihfs_img, ff, SECTOR_SIZE);
	pos = DEADFACE_START;
	}
	if (pos < ihfs_len) {
	for (i = 0; i < SECTOR_SIZE; i += 4) {
	deadface[i] = 0xde;
	deadface[i+1] = 0xad;
	deadface[i+2] = 0xfa;
	deadface[i+3] = 0xce;
	}
	n = (ihfs_len - pos) / SECTOR_SIZE;
	for (i = 0; i < n; ++i)
	write(ihfs_img, deadface, SECTOR_SIZE);
	}

	lseek(ihfs_img, 0, SEEK_SET);
	write(ihfs_img, &ihfs_hdr, sizeof (ihfs_hdr));
	memset(ff, 0xff, SECTOR_SIZE);
	write(ihfs_img, ff, SECTOR_SIZE);
	write(ihfs_img, ff, SECTOR_SIZE);
	write(ihfs_img, ff, SECTOR_SIZE);
	write(ihfs_img, &ihfs_ftbl, sizeof (ihfs_ftbl));

	/* cleanup */
	close(hxf_img);
	close(ihfs_img);

	printf("Done!\n");

	return 0;
	}