usbloadergx/source/libs/libwbfs/libwbfs.c
dimok321 0f4eb6b209 *several code optimizations
*added saving of game browser position (on all modes)
*several cleanups and small fixes
*added a "Block Category Menu" setting
*fixed bug with parental block and game settings (thanks NJ7 for finding it)
*fixed "All" not being translated in category menu
2011-06-24 19:11:36 +00:00

806 lines
24 KiB
C

// Copyright 2009 Kwiirk
// Licensed under the terms of the GNU GPL, version 2
// http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
// Modified by oggzee
#include "libwbfs.h"
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#define ERROR(x) do {wbfs_error(x);goto error;}while(0)
#define ALIGN_LBA(x) (((x)+p->hd_sec_sz-1)&(~(p->hd_sec_sz-1)))
wbfs_t wbfs_iso_file;
static int force_mode = 0;
void wbfs_set_force_mode(int force)
{
force_mode = force;
}
static u8 size_to_shift(u32 size)
{
u8 ret = 0;
while (size)
{
ret++;
size >>= 1;
}
return ret - 1;
}
#define read_le32_unaligned(x) ((x)[0]|((x)[1]<<8)|((x)[2]<<16)|((x)[3]<<24))
wbfs_t*wbfs_open_hd(rw_sector_callback_t read_hdsector, rw_sector_callback_t write_hdsector, void *callback_data,
int hd_sector_size, int num_hd_sector __attribute( ( unused ) ), int reset)
{
int i = num_hd_sector, ret;
u8 *ptr, *tmp_buffer = wbfs_ioalloc( hd_sector_size );
u8 part_table[16 * 4];
ret = read_hdsector(callback_data, 0, 1, tmp_buffer);
if (ret) return 0;
//find wbfs partition
wbfs_memcpy( part_table, tmp_buffer + 0x1be, 16*4 );
ptr = part_table;
for (i = 0; i < 4; i++, ptr += 16)
{
u32 part_lba = read_le32_unaligned( ptr + 0x8 );
wbfs_head_t *head = (wbfs_head_t *) tmp_buffer;
ret = read_hdsector(callback_data, part_lba, 1, tmp_buffer);
// verify there is the magic.
if (head->magic == wbfs_htonl( WBFS_MAGIC ))
{
wbfs_t*p = wbfs_open_partition(read_hdsector, write_hdsector, callback_data, hd_sector_size, 0, part_lba,
reset);
wbfs_iofree( tmp_buffer );
return p;
}
}
wbfs_iofree( tmp_buffer );
if (reset)// XXX make a empty hd partition..
{
}
return 0;
}
wbfs_t*wbfs_open_partition(rw_sector_callback_t read_hdsector, rw_sector_callback_t write_hdsector,
void *callback_data, int hd_sector_size, int num_hd_sector, u32 part_lba, int reset)
{
wbfs_t *p = wbfs_malloc( sizeof( wbfs_t ) );
wbfs_head_t *head = wbfs_ioalloc( hd_sector_size ? hd_sector_size : 512 );
//constants, but put here for consistancy
p->wii_sec_sz = 0x8000;
p->wii_sec_sz_s = size_to_shift(0x8000);
p->n_wii_sec = (num_hd_sector / 0x8000) * hd_sector_size;
p->n_wii_sec_per_disc = 143432 * 2;//support for double layers discs..
p->head = head;
p->part_lba = part_lba;
// init the partition
if (reset)
{
u8 sz_s;
wbfs_memset( head, 0, hd_sector_size );
head->magic = wbfs_htonl( WBFS_MAGIC );
head->hd_sec_sz_s = size_to_shift(hd_sector_size);
head->n_hd_sec = wbfs_htonl( num_hd_sector );
// choose minimum wblk_sz that fits this partition size
for (sz_s = 6; sz_s < 11; sz_s++)
{
// ensure that wbfs_sec_sz is big enough to address every blocks using 16 bits
if (p->n_wii_sec < ((1U << 16) * (1 << sz_s))) break;
}
head->wbfs_sec_sz_s = sz_s + p->wii_sec_sz_s;
}
else read_hdsector(callback_data, p->part_lba, 1, head);
if (head->magic != wbfs_htonl( WBFS_MAGIC ))
ERROR( "bad magic" );
if (!force_mode && hd_sector_size && head->hd_sec_sz_s != size_to_shift(hd_sector_size))
ERROR( "hd sector size doesn't match" );
if (!force_mode && num_hd_sector && head->n_hd_sec != (u32) wbfs_htonl( num_hd_sector ))
ERROR( "hd num sector doesn't match" );
p->hd_sec_sz = 1 << head->hd_sec_sz_s;
p->hd_sec_sz_s = head->hd_sec_sz_s;
p->n_hd_sec = wbfs_ntohl( head->n_hd_sec );
p->n_wii_sec = (p->n_hd_sec / p->wii_sec_sz) * (p->hd_sec_sz);
p->wbfs_sec_sz_s = head->wbfs_sec_sz_s;
p->wbfs_sec_sz = 1 << p->wbfs_sec_sz_s;
p->n_wbfs_sec = p->n_wii_sec >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
p->n_wbfs_sec_per_disc = p->n_wii_sec_per_disc >> (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
p->disc_info_sz = ALIGN_LBA( sizeof( wbfs_disc_info_t ) + p->n_wbfs_sec_per_disc * 2 );
//printf("hd_sector_size %X wii_sector size %X wbfs sector_size %X\n",p->hd_sec_sz,p->wii_sec_sz,p->wbfs_sec_sz);
p->read_hdsector = read_hdsector;
p->write_hdsector = write_hdsector;
p->callback_data = callback_data;
p->freeblks_lba = (p->wbfs_sec_sz - p->n_wbfs_sec / 8) >> p->hd_sec_sz_s;
if (!reset)
p->freeblks = 0; // will alloc and read only if needed
else
{
// init with all free blocks
p->freeblks = wbfs_ioalloc( ALIGN_LBA( p->n_wbfs_sec / 8 ) );
wbfs_memset( p->freeblks, 0xff, p->n_wbfs_sec / 8 );
}
p->max_disc = (p->freeblks_lba - 1) / (p->disc_info_sz >> p->hd_sec_sz_s);
if (p->max_disc > p->hd_sec_sz - sizeof(wbfs_head_t)) p->max_disc = p->hd_sec_sz - sizeof(wbfs_head_t);
p->tmp_buffer = wbfs_ioalloc( p->hd_sec_sz );
p->n_disc_open = 0;
return p;
error: wbfs_free( p );
wbfs_iofree( head );
return 0;
}
void wbfs_sync(wbfs_t*p)
{
// copy back descriptors
if (p->write_hdsector)
{
p->write_hdsector(p->callback_data, p->part_lba + 0, 1, p->head);
if (p->freeblks) p->write_hdsector(p->callback_data, p->part_lba + p->freeblks_lba,
ALIGN_LBA( p->n_wbfs_sec / 8 ) >> p->hd_sec_sz_s, p->freeblks);
}
}
void wbfs_close(wbfs_t*p)
{
wbfs_sync(p);
if (p->n_disc_open)
ERROR( "trying to close wbfs while discs still open" );
wbfs_iofree( p->head );
wbfs_iofree( p->tmp_buffer );
if (p->freeblks) wbfs_iofree( p->freeblks );
wbfs_free( p );
error: return;
}
wbfs_disc_t *wbfs_open_disc(wbfs_t* p, u8 *discid)
{
u32 i;
int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
wbfs_disc_t *d = 0;
for (i = 0; i < p->max_disc; i++)
{
if (p->head->disc_table[i])
{
p->read_hdsector(p->callback_data, p->part_lba + 1 + i * disc_info_sz_lba, 1, p->tmp_buffer);
if (wbfs_memcmp( discid, p->tmp_buffer, 6 ) == 0)
{
d = wbfs_malloc( sizeof( *d ) );
if (!d)
ERROR( "allocating memory" );
d->p = p;
d->i = i;
d->header = wbfs_ioalloc( p->disc_info_sz );
if (!d->header)
ERROR( "allocating memory" );
p->read_hdsector(p->callback_data, p->part_lba + 1 + i * disc_info_sz_lba, disc_info_sz_lba, d->header);
p->n_disc_open++;
// for(i=0;i<p->n_wbfs_sec_per_disc;i++)
// printf("%d,",wbfs_ntohs(d->header->wlba_table[i]));
return d;
}
}
}
return 0;
error: if (d) wbfs_iofree( d );
return 0;
}
void wbfs_close_disc(wbfs_disc_t*d)
{
d->p->n_disc_open--;
wbfs_iofree( d->header );
wbfs_free( d );
}
// offset is pointing 32bit words to address the whole dvd, although len is in bytes
int wbfs_disc_read(wbfs_disc_t*d, u32 offset, u32 len, u8 *data)
{
if (d->p == &wbfs_iso_file)
{
return wbfs_iso_file_read(d, offset, data, len);
}
wbfs_t *p = d->p;
u16 wlba = offset >> (p->wbfs_sec_sz_s - 2);
u32 iwlba_shift = p->wbfs_sec_sz_s - p->hd_sec_sz_s;
u32 lba_mask = (p->wbfs_sec_sz - 1) >> (p->hd_sec_sz_s);
u32 lba = (offset >> (p->hd_sec_sz_s - 2)) & lba_mask;
u32 off = offset & ((p->hd_sec_sz >> 2) - 1);
u16 iwlba = wbfs_ntohs( d->header->wlba_table[wlba] );
u32 len_copied;
int err = 0;
u8 *ptr = data;
if (unlikely( iwlba == 0 )) return 1;
if (unlikely( off ))
{
off *= 4;
err = p->read_hdsector(p->callback_data, p->part_lba + (iwlba << iwlba_shift) + lba, 1, p->tmp_buffer);
if (err) return err;
len_copied = p->hd_sec_sz - off;
if (likely( len < len_copied )) len_copied = len;
wbfs_memcpy( ptr, p->tmp_buffer + off, len_copied );
len -= len_copied;
ptr += len_copied;
lba++;
if (unlikely( lba > lba_mask && len ))
{
lba = 0;
iwlba = wbfs_ntohs( d->header->wlba_table[++wlba] );
if (unlikely( iwlba == 0 )) return 1;
}
}
while (likely( len >= p->hd_sec_sz ))
{
u32 nlb = len >> (p->hd_sec_sz_s);
if (unlikely( lba + nlb > p->wbfs_sec_sz )) // dont cross wbfs sectors..
nlb = p->wbfs_sec_sz - lba;
err = p->read_hdsector(p->callback_data, p->part_lba + (iwlba << iwlba_shift) + lba, nlb, ptr);
if (err) return err;
len -= nlb << p->hd_sec_sz_s;
ptr += nlb << p->hd_sec_sz_s;
lba += nlb;
if (unlikely( lba > lba_mask && len ))
{
lba = 0;
iwlba = wbfs_ntohs( d->header->wlba_table[++wlba] );
if (unlikely( iwlba == 0 )) return 1;
}
}
if (unlikely( len ))
{
err = p->read_hdsector(p->callback_data, p->part_lba + (iwlba << iwlba_shift) + lba, 1, p->tmp_buffer);
if (err) return err;
wbfs_memcpy( ptr, p->tmp_buffer, len );
}
return 0;
}
// disc listing
u32 wbfs_count_discs(wbfs_t*p)
{
u32 i, count = 0;
for (i = 0; i < p->max_disc; i++)
if (p->head->disc_table[i]) count++;
return count;
}
u32 wbfs_sector_used(wbfs_t *p, wbfs_disc_info_t *di)
{
u32 tot_blk = 0, j;
for (j = 0; j < p->n_wbfs_sec_per_disc; j++)
if (wbfs_ntohs( di->wlba_table[j] )) tot_blk++;
return tot_blk;
}
u32 wbfs_get_disc_info(wbfs_t*p, u32 index, u8 *header, int header_size, u32 *size)//size in 32 bit
{
u32 i, count = 0;
if (!p) return 1;
int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
for (i = 0; i < p->max_disc; i++)
if (p->head->disc_table[i])
{
if (count++ == index)
{
p->read_hdsector(p->callback_data, p->part_lba + 1 + i * disc_info_sz_lba, 1, p->tmp_buffer);
if (header_size > (int) p->hd_sec_sz) header_size = p->hd_sec_sz;
u32 magic = wbfs_ntohl( *( u32* )( p->tmp_buffer + 24 ) );
if (magic != 0x5D1C9EA3)
{
p->head->disc_table[i] = 0;
return 1;
}
memcpy(header, p->tmp_buffer, header_size);
if (size)
{
u8 *header = wbfs_ioalloc( p->disc_info_sz );
p->read_hdsector(p->callback_data, p->part_lba + 1 + i * disc_info_sz_lba, disc_info_sz_lba, header);
u32 sec_used = wbfs_sector_used(p, (wbfs_disc_info_t *) header);
wbfs_iofree( header );
*size = sec_used << (p->wbfs_sec_sz_s - 2);
}
return 0;
}
}
return 1;
}
static void load_freeblocks(wbfs_t*p)
{
if (p->freeblks) return;
// XXX should handle malloc error..
p->freeblks = wbfs_ioalloc( ALIGN_LBA( p->n_wbfs_sec / 8 ) );
p->read_hdsector(p->callback_data, p->part_lba + p->freeblks_lba, ALIGN_LBA( p->n_wbfs_sec / 8 ) >> p->hd_sec_sz_s,
p->freeblks);
}
u32 wbfs_count_usedblocks(wbfs_t*p)
{
u32 i, j, count = 0;
load_freeblocks(p);
for (i = 0; i < p->n_wbfs_sec / (8 * 4); i++)
{
u32 v = wbfs_ntohl( p->freeblks[i] );
if (v == ~0U)
count += 32;
else if (v != 0) for (j = 0; j < 32; j++)
if (v & (1 << j)) count++;
}
return count;
}
// write access
//static
int block_used(u8 *used, u32 i, u32 wblk_sz)
{
u32 k;
i *= wblk_sz;
for (k = 0; k < wblk_sz; k++)
if (i + k < 143432 * 2 && used[i + k]) return 1;
return 0;
}
static u32 alloc_block(wbfs_t*p)
{
u32 i, j;
for (i = 0; i < p->n_wbfs_sec / (8 * 4); i++)
{
u32 v = wbfs_ntohl( p->freeblks[i] );
if (v != 0)
{
for (j = 0; j < 32; j++)
if (v & (1 << j))
{
p->freeblks[i] = wbfs_htonl( v & ~( 1 << j ) );
return (i * 32) + j + 1;
}
}
}
return ~0;
}
static void free_block(wbfs_t *p, int bl)
{
int i = (bl - 1) / (32);
int j = (bl - 1) & 31;
u32 v = wbfs_ntohl( p->freeblks[i] );
p->freeblks[i] = wbfs_htonl( v | 1 << j );
}
s32 wbfs_add_disc(wbfs_t*p, read_wiidisc_callback_t read_src_wii_disc, void *callback_data,
progress_callback_t spinner, partition_selector_t sel, int copy_1_1)
{
int i, discn;
u32 tot, cur;
u32 wii_sec_per_wbfs_sect = 1 << (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
wiidisc_t *d = 0;
u8 *used = 0;
wbfs_disc_info_t *info = 0;
u8* copy_buffer = 0;
int retval = -1;
int num_wbfs_sect_to_copy;
u32 last_used;
used = wbfs_malloc( p->n_wii_sec_per_disc );
if (!used)
ERROR( "unable to alloc memory" );
// copy_1_1 needs disk usage for layers detection
//if(!copy_1_1)
{
d = wd_open_disc(read_src_wii_disc, callback_data);
if (!d)
ERROR( "unable to open wii disc" );
wd_build_disc_usage(d, sel, used);
wd_close_disc(d);
d = 0;
}
for (i = 0; i < p->max_disc; i++)// find a free slot.
if (p->head->disc_table[i] == 0) break;
if (i == p->max_disc)
ERROR( "no space left on device (table full)" );
p->head->disc_table[i] = 1;
discn = i;
load_freeblocks(p);
// build disc info
info = wbfs_ioalloc( p->disc_info_sz );
read_src_wii_disc(callback_data, 0, 0x100, info->disc_header_copy);
copy_buffer = wbfs_ioalloc( p->wii_sec_sz );
if (!copy_buffer)
ERROR( "alloc memory" );
tot = 0;
cur = 0;
num_wbfs_sect_to_copy = p->n_wbfs_sec_per_disc;
// count total number of sectors to write
last_used = 0;
for (i = 0; i < num_wbfs_sect_to_copy; i++)
{
if (block_used(used, i, wii_sec_per_wbfs_sect))
{
tot += wii_sec_per_wbfs_sect;
last_used = i;
}
}
if (copy_1_1)
{
// detect single or dual layer
if ((last_used + 1) > (p->n_wbfs_sec_per_disc / 2))
{
// dual layer
num_wbfs_sect_to_copy = p->n_wbfs_sec_per_disc;
}
else
{
// single layer
num_wbfs_sect_to_copy = p->n_wbfs_sec_per_disc / 2;
}
tot = num_wbfs_sect_to_copy * wii_sec_per_wbfs_sect;
}
/*
// num of hd sectors to copy could be specified directly
if (copy_1_1 > 1) {
u32 hd_sec_per_wii_sec = p->wii_sec_sz / p->hd_sec_sz;
num_wbfs_sect_to_copy = copy_1_1 / hd_sec_per_wii_sec / wii_sec_per_wbfs_sect;
tot = num_wbfs_sect_to_copy * wii_sec_per_wbfs_sect;
}*/
int ret = 0;
if (spinner) spinner(0, tot);
for (i = 0; i < num_wbfs_sect_to_copy; i++)
{
u16 bl = 0;
if (copy_1_1 || block_used(used, i, wii_sec_per_wbfs_sect))
{
u16 j;
bl = alloc_block(p);
if (bl == 0xffff)
ERROR( "no space left on device (disc full)" );
for (j = 0; j < wii_sec_per_wbfs_sect; j++)
{
u32 offset = (i * (p->wbfs_sec_sz >> 2)) + (j * (p->wii_sec_sz >> 2));
ret = read_src_wii_disc(callback_data, offset, p->wii_sec_sz, copy_buffer);
if (ret)
{
if (copy_1_1 && i > p->n_wbfs_sec_per_disc / 2)
{
// end of dual layer data
if (j > 0)
{
info->wlba_table[i] = wbfs_htons( bl );
}
spinner(tot, tot);
break;
}
//ERROR("read error");
printf("\rWARNING: read (%u) error (%d)\n", offset, ret);
}
//fix the partition table
if (offset == (0x40000 >> 2)) wd_fix_partition_table(d, sel, copy_buffer);
p->write_hdsector(p->callback_data, p->part_lba + bl * (p->wbfs_sec_sz / p->hd_sec_sz) + j
* (p->wii_sec_sz / p->hd_sec_sz), p->wii_sec_sz / p->hd_sec_sz, copy_buffer);
cur++;
if (spinner) spinner(cur, tot);
}
}
if (ret) break;
info->wlba_table[i] = wbfs_htons( bl );
wbfs_sync(p);
}
// write disc info
int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
p->write_hdsector(p->callback_data, p->part_lba + 1 + discn * disc_info_sz_lba, disc_info_sz_lba, info);
wbfs_sync(p);
retval = 0;
error: if (d) wd_close_disc(d);
if (used) wbfs_free( used );
if (info) wbfs_iofree( info );
if (copy_buffer) wbfs_iofree( copy_buffer );
// init with all free blocks
return retval;
}
u32 wbfs_rm_disc(wbfs_t*p, u8* discid)
{
wbfs_disc_t *d = wbfs_open_disc(p, discid);
int i;
int discn = 0;
int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
if (!d) return 1;
load_freeblocks(p);
discn = d->i;
for (i = 0; i < p->n_wbfs_sec_per_disc; i++)
{
u32 iwlba = wbfs_ntohs( d->header->wlba_table[i] );
if (iwlba) free_block(p, iwlba);
}
memset(d->header, 0, p->disc_info_sz);
p->write_hdsector(p->callback_data, p->part_lba + 1 + discn * disc_info_sz_lba, disc_info_sz_lba, d->header);
p->head->disc_table[discn] = 0;
wbfs_close_disc(d);
wbfs_sync(p);
return 0;
}
u32 wbfs_ren_disc(wbfs_t*p, u8* discid, u8* newname)
{
wbfs_disc_t *d = wbfs_open_disc(p, discid);
int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
if (!d) return 1;
memset(d->header->disc_header_copy + 0x20, 0, 0x40);
strncpy((char *) d->header->disc_header_copy + 0x20, (char *) newname, 0x39);
p->write_hdsector(p->callback_data, p->part_lba + 1 + d->i * disc_info_sz_lba, disc_info_sz_lba, d->header);
wbfs_close_disc(d);
return 0;
}
u32 wbfs_rID_disc(wbfs_t*p, u8* discid, u8* newID)
{
wbfs_disc_t *d = wbfs_open_disc(p, discid);
int disc_info_sz_lba = p->disc_info_sz >> p->hd_sec_sz_s;
if (!d) return 1;
memset(d->header->disc_header_copy, 0, 0x10);
strncpy((char *) d->header->disc_header_copy, (char *) newID, 0x9);
p->write_hdsector(p->callback_data, p->part_lba + 1 + d->i * disc_info_sz_lba, disc_info_sz_lba, d->header);
wbfs_close_disc(d);
return 0;
}
// trim the file-system to its minimum size
u32 wbfs_trim(wbfs_t*p)
{
u32 maxbl;
load_freeblocks(p);
maxbl = alloc_block(p);
p->n_hd_sec = maxbl << (p->wbfs_sec_sz_s - p->hd_sec_sz_s);
p->head->n_hd_sec = wbfs_htonl( p->n_hd_sec );
// make all block full
memset(p->freeblks, 0, p->n_wbfs_sec / 8);
wbfs_sync(p);
// os layer will truncate the file.
return maxbl;
}
// data extraction
u32 wbfs_extract_disc(wbfs_disc_t*d, rw_sector_callback_t write_dst_wii_sector, void *callback_data,
progress_callback_t spinner)
{
wbfs_t *p = d->p;
u8* copy_buffer = 0;
int i;
int src_wbs_nlb = p->wbfs_sec_sz / p->hd_sec_sz;
int dst_wbs_nlb = p->wbfs_sec_sz / p->wii_sec_sz;
copy_buffer = wbfs_ioalloc( p->wbfs_sec_sz );
if (!copy_buffer)
{
wbfs_error( "alloc memory" );
return 1;
}
for (i = 0; i < p->n_wbfs_sec_per_disc; i++)
{
u32 iwlba = wbfs_ntohs( d->header->wlba_table[i] );
if (iwlba)
{
if (spinner) spinner(i, p->n_wbfs_sec_per_disc);
p->read_hdsector(p->callback_data, p->part_lba + iwlba * src_wbs_nlb, src_wbs_nlb, copy_buffer);
write_dst_wii_sector(callback_data, i * dst_wbs_nlb, dst_wbs_nlb, copy_buffer);
}
}
wbfs_iofree( copy_buffer );
return 0;
}
u64 wbfs_estimate_disc(wbfs_t *p, read_wiidisc_callback_t read_src_wii_disc, void *callback_data, partition_selector_t sel)
{
int i;
u32 tot;
u32 wii_sec_per_wbfs_sect = 1 << (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
wiidisc_t *d = 0;
u8 *used = 0;
wbfs_disc_info_t *info = 0;
tot = 0;
used = wbfs_malloc( p->n_wii_sec_per_disc );
if (!used)
{
ERROR( "unable to alloc memory" );
}
d = wd_open_disc(read_src_wii_disc, callback_data);
if (!d)
{
ERROR( "unable to open wii disc" );
}
wd_build_disc_usage(d, sel, used);
wd_close_disc(d);
d = 0;
info = wbfs_ioalloc( p->disc_info_sz );
read_src_wii_disc(callback_data, 0, 0x100, info->disc_header_copy);
for (i = 0; i < p->n_wbfs_sec_per_disc; i++)
{
if (block_used(used, i, wii_sec_per_wbfs_sect))
{
tot++;
}
}
error:
if (d) wd_close_disc(d);
if (used) wbfs_free( used );
if (info) wbfs_iofree( info );
return (u64) tot * (u64) p->wbfs_sec_sz;
}
u32 wbfs_size_disc(wbfs_t*p, read_wiidisc_callback_t read_src_wii_disc, void *callback_data, partition_selector_t sel,
u32 *comp_size, u32 *real_size)
{
int i;
u32 tot = 0, last = 0;
u32 wii_sec_per_wbfs_sect = 1 << (p->wbfs_sec_sz_s - p->wii_sec_sz_s);
wiidisc_t *d = 0;
u8 *used = 0;
used = wbfs_malloc( p->n_wii_sec_per_disc );
if (!used)
ERROR( "unable to alloc memory" );
d = wd_open_disc(read_src_wii_disc, callback_data);
if (!d)
ERROR( "unable to open wii disc" );
wd_build_disc_usage(d, sel, used);
wd_close_disc(d);
d = 0;
// count total number to write for spinner
for (i = 0; i < p->n_wbfs_sec_per_disc; i++)
{
if (block_used(used, i, wii_sec_per_wbfs_sect))
{
tot += wii_sec_per_wbfs_sect;
last = i * wii_sec_per_wbfs_sect;
}
}
error: if (d) wd_close_disc(d);
if (used) wbfs_free( used );
*comp_size = tot;
*real_size = last;
return 0;
}
// offset is pointing 32bit words to address the whole dvd, although len is in bytes
//int wbfs_disc_read(wbfs_disc_t*d,u32 offset, u8 *data, u32 len)
// offset points 32bit words, count counts bytes
//int (*read_wiidisc_callback_t)(void*fp,u32 offset,u32 count,void*iobuf);
// connect wiidisc to wbfs_disc
int read_wiidisc_wbfsdisc(void*fp, u32 offset, u32 count, void*iobuf)
{
return wbfs_disc_read((wbfs_disc_t*) fp, offset, count, iobuf);
}
int wbfs_extract_file(wbfs_disc_t*d, char *path, void **data)
{
wiidisc_t *wd = 0;
int ret = 0;
wd = wd_open_disc(read_wiidisc_wbfsdisc, d);
if (!wd)
{
wbfs_error( "opening wbfs disc" );
return -1;
}
wd->extracted_size = 0;
*data = wd_extract_file(wd, ONLY_GAME_PARTITION, path);
ret = wd->extracted_size;
if (!*data)
{
//ERROR("file not found");
ret = -1;
}
wd_close_disc(wd);
return ret;
}
int wbfs_get_fragments(wbfs_disc_t *d, _frag_append_t append_fragment, void *callback_data, u32 hdd_sector_size)
{
if (!d) return -1;
wbfs_t *p = d->p;
int src_wbs_nlb = p->wbfs_sec_sz / hdd_sector_size;
int i, ret, last = 0;
for (i = 0; i < p->n_wbfs_sec_per_disc; i++)
{
u32 iwlba = wbfs_ntohs( d->header->wlba_table[i] );
if (iwlba)
{
ret = append_fragment(callback_data, i * src_wbs_nlb, // offset
p->part_lba + iwlba * src_wbs_nlb, // sector
src_wbs_nlb); // count
if (ret) return ret; // error
last = i;
}
}
if (last < p->n_wbfs_sec_per_disc / 2)
{
last = p->n_wbfs_sec_per_disc / 2;
}
u32 size = last * src_wbs_nlb;
append_fragment(callback_data, size, 0, 0); // set size
return 0;
}
// wrapper for reading .iso files using wbfs apis
#include <unistd.h>
#include <sys/stat.h>
// offset is pointing 32bit words to address the whole dvd, although len is in bytes
int wbfs_iso_file_read(wbfs_disc_t*d, u32 offset, u8 *data, u32 len)
{
if (!d || d->p != &wbfs_iso_file) return -1;
int fd = d->i;
off_t off = ((u64) offset) << 2;
off_t ret_off;
int ret;
ret_off = lseek(fd, off, SEEK_SET);
if (ret_off != off) return -1;
ret = read(fd, data, len);
if (ret != (int) len) return -2;
return 0;
}
u32 wbfs_disc_sector_used(wbfs_disc_t *d)
{
if(!d) return 0;
if (d->p == &wbfs_iso_file)
{
int fd = d->i;
struct stat st;
if (fstat(fd, &st) == -1) return 0;
return (st.st_size >> 9);
}
return wbfs_sector_used(d->p, d->header);
}