/*
* Reads a read data block from an mFILE given a count of the number of
* flows and basecalls (from the common header and read headers).
*
* Returns the a pointer to sff_read_data on success
* NULL on failure
*/
sff_read_data *read_sff_read_data(mFILE *mf, int nflows, int nbases) {
sff_read_data *d;
int i;
if (NULL == (d = (sff_read_data *)xcalloc(1, sizeof(*d))))
return NULL;
if (NULL == (d->flowgram = (uint16_t *)xcalloc(nflows, 2)))
return free_sff_read_data(d), NULL;
if (nflows != mfread(d->flowgram, 2, nflows, mf))
return free_sff_read_data(d), NULL;
for (i = 0; i < nflows; i++)
d->flowgram[i] = be_int2(d->flowgram[i]);
if (NULL == (d->flow_index = (uint8_t *)xmalloc(nbases)))
return free_sff_read_data(d), NULL;
if (nbases != mfread(d->flow_index, 1, nbases, mf))
return free_sff_read_data(d), NULL;
if (NULL == (d->bases = (char *)xmalloc(nbases)))
return free_sff_read_data(d), NULL;
if (nbases != mfread(d->bases, 1, nbases, mf))
return free_sff_read_data(d), NULL;
if (NULL == (d->quality = (uint8_t *)xmalloc(nbases)))
return free_sff_read_data(d), NULL;
if (nbases != mfread(d->quality, 1, nbases, mf))
return free_sff_read_data(d), NULL;
/* Pad to 8 chars */
mfseek(mf, (mftell(mf) + 7)& ~7, SEEK_SET);
return d;
}
void pc_resetasm(void *handle)
{
assert(handle!=NULL);
#if defined __MSDOS__ || defined PAWN_LIGHT
fflush((FILE*)handle);
fseek((FILE*)handle,0,SEEK_SET);
#else
mfseek((MEMFILE*)handle,0,SEEK_SET);
#endif
}
/*
* Reads a read header (including variable length components) from an mFILE.
*
* Returns the a pointer to the header on success
* NULL on failure
*/
sff_read_header *read_sff_read_header(mFILE *mf) {
sff_read_header *h;
unsigned char rhdr[16];
if (16 != mfread(rhdr, 1, 16, mf))
return NULL;
h = decode_sff_read_header(rhdr);
if (h->name_len != mfread(h->name, 1, h->name_len, mf))
return free_sff_read_header(h), NULL;
/* Pad to 8 chars */
mfseek(mf, (mftell(mf) + 7)& ~7, SEEK_SET);
return h;
}
/*
* Reads a common header (including variable length components) from an mFILE.
*
* Returns the a pointer to the header on success
* NULL on failure
*/
sff_common_header *read_sff_common_header(mFILE *mf) {
sff_common_header *h;
unsigned char chdr[31];
if (31 != mfread(chdr, 1, 31, mf))
return NULL;
h = decode_sff_common_header(chdr);
if (h->flow_len != mfread(h->flow, 1, h->flow_len, mf))
return free_sff_common_header(h), NULL;
if (h->key_len != mfread(h->key , 1, h->key_len, mf))
return free_sff_common_header(h), NULL;
/* Pad to 8 chars */
mfseek(mf, (mftell(mf) + 7)& ~7, SEEK_SET);
return h;
}
char *mfgets(MEMFILE *mf,char *string,unsigned int size)
{
char *ptr;
unsigned int read;
long seek;
assert(mf!=NULL);
read=mfread(mf,(unsigned char *)string,size);
if (read==0)
return NULL;
seek=0L;
/* make sure that the string is zero-terminated */
assert(read<=size);
if (read<size) {
string[read]='\0';
} else {
string[size-1]='\0';
seek=-1; /* undo reading the character that gets overwritten */
} /* if */
/* find the first '\n' */
ptr=strchr(string,'\n');
if (ptr!=NULL) {
*(ptr+1)='\0';
seek=(long)(ptr-string)+1-(long)read;
} /* if */
/* undo over-read */
assert(seek<=0); /* should seek backward only */
if (seek!=0)
mfseek(mf,seek,SEEK_CUR);
return string;
}
void pc_resetasm(void *handle)
{
mfseek((MEMFILE*)handle,0,SEEK_SET);
}
int check_trace_body(Settings *opts, Trace_reader *trc, srf_t *srf) {
char name[512];
Spot_info spot = { NULL, 0, 0, 0, 0, 0, 0 };
ztr_t *ztr = NULL;
ztr_chunk_t *chunk;
int start_chunk = 0;
int i;
if (-1 == construct_trace_name(srf->th.id_prefix,
(unsigned char *)srf->tb.read_id,
srf->tb.read_id_length,
name, sizeof(name))) {
printf("Couldn't construct read name\n");
return -1;
}
if (0 != decode_name(name, &spot)) {
printf("Couldn't decode read name.\n");
return -1;
}
if (opts->verbosity > 0) {
printf("%s\n", name);
}
if (0 != read_trace_data(opts, trc, &spot)) {
printf("Couldn't get trace data for %s\n", name);
return -1;
}
mfseek(srf->mf, srf->mf_end, SEEK_SET);
if (srf->tb.trace_size) {
mfwrite(srf->tb.trace, 1, srf->tb.trace_size, srf->mf);
free(srf->tb.trace);
srf->tb.trace = NULL;
}
mftruncate(srf->mf, mftell(srf->mf));
mfseek(srf->mf, srf->mf_pos, SEEK_SET);
if (srf->ztr) {
start_chunk = srf->ztr->nchunks;
ztr = ztr_dup(srf->ztr);
}
if (NULL == partial_decode_ztr(srf, srf->mf, ztr)) {
printf("Couldn't decode ZTR data for %s\n", name);
return -1;
}
for (i = start_chunk; i < ztr->nchunks; i++) {
chunk = &ztr->chunk[i];
if (opts->verbosity > 1) {
printf(" Chunk %d type %.4s\n", i,
(char *) &chunk->type);
}
switch (chunk->type) {
case ZTR_TYPE_BASE:
if (0 != uncompress_chunk(ztr, chunk)) {
printf("Couldn't uncompress BASE chunk\n");
return -1;
}
if (trc->seq_len + 1 != chunk->dlength
|| 0 != memcmp(trc->seq, chunk->data + 1, trc->seq_len)) {
printf("Sequence differs for %s\n", name);
return -1;
}
break;
case ZTR_TYPE_CNF1:
if (0 != uncompress_chunk(ztr, chunk)) {
printf("Couldn't uncompress CNF1 chunk\n");
return -1;
}
if (trc->seq_len + 1 != chunk->dlength
|| 0 != memcmp(trc->qual, chunk->data + 1, trc->seq_len)) {
printf("CNF1 confidence values differ for %s\n", name);
return -1;
}
break;
case ZTR_TYPE_CNF4:
if (0 != uncompress_chunk(ztr, chunk)) {
printf("Couldn't uncompress CNF4 chunk\n");
return -1;
}
if (0 != check_cnf4(ztr, chunk, trc)) {
printf("CNF4 confidence values differ for %s\n", name);
return -1;
}
break;
case ZTR_TYPE_SMP4:
if (0 != uncompress_chunk(ztr, chunk)) {
printf("Couldn't uncompress SMP4 chunk\n");
return -1;
}
if (0 != check_trace(ztr, chunk, trc)) {
printf("Trace doesn't match for %s\n", name);
return -1;
}
break;
default:
printf("Found unexpected chunk type in trace body for %s\n",
name);
return -1;
}
}
delete_ztr(ztr);
return 0;
}
int check_trace_header(Settings *opts, srf_t *srf, Previous_data *seen) {
int i;
int j;
int n;
uint8_t *data;
uint32_t val;
ztr_chunk_t *chunk;
if (NULL != srf->mf) {
mfrecreate(srf->mf, NULL, 0);
} else {
srf->mf = mfcreate(NULL, 0);
}
if (NULL == srf->mf) die("%s\n", strerror(errno));
if (srf->th.trace_hdr_size) {
if (1 != mfwrite(srf->th.trace_hdr, srf->th.trace_hdr_size, 1, srf->mf)) {
die("mfwrite failed: %s\n", strerror(errno));
}
}
if (srf->ztr) delete_ztr(srf->ztr);
mrewind(srf->mf);
if (NULL != (srf->ztr = partial_decode_ztr(srf, srf->mf, NULL))) {
srf->mf_pos = mftell(srf->mf);
} else {
/* We expect this to work for srfs made by illumina2srf */
printf("partial_decode_ztr failed for trace header\n");
srf->mf_pos = 0;
return -1;
}
mfseek(srf->mf, 0, SEEK_END);
srf->mf_end = mftell(srf->mf);
/* Go through chunks */
for (i = 0; i < srf->ztr->nchunks; i++) {
chunk = &srf->ztr->chunk[i];
if (opts->verbosity > 1) {
printf(" Chunk %d type %.4s\n", i,
(char *) &chunk->type);
}
switch (chunk->type) {
case ZTR_TYPE_HUFF:
break;
case ZTR_TYPE_BPOS:
if (0 != uncompress_chunk(srf->ztr, chunk)) {
printf("Couldn't uncompress BPOS chunk\n");
return -1;
}
n = (chunk->dlength - 4) / 4;
for (j = 0; j < n; j++) {
data = (uint8_t *) &chunk->data[j * 4 + 4];
val = ( ((uint32_t) data[0]) << 24
| ((uint32_t) data[1]) << 16
| ((uint32_t) data[2]) << 8
| ((uint32_t) data[3]));
if (val != j) {
printf("BPOS data misses cycles\n");
return -1;
}
}
break;
case ZTR_TYPE_REGN:
if (0 != uncompress_chunk(srf->ztr, chunk)) {
printf("Couldn't uncompress REGN chunk\n");
return -1;
}
if (NULL == seen->regn) {
/* Copy REGN chunk */
seen->regn_meta_sz = chunk->mdlength;
seen->regn_meta = smalloc(seen->regn_meta_sz);
memcpy(seen->regn_meta, chunk->mdata, seen->regn_meta_sz);
seen->regn_sz = chunk->dlength;
seen->regn = smalloc(seen->regn_sz);
memcpy(seen->regn, chunk->data, seen->regn_sz);
} else {
/* Compare with last copy */
if (seen->regn_meta_sz != chunk->mdlength
|| seen->regn_sz != chunk->dlength
|| 0 != memcmp(seen->regn_meta, chunk->mdata, seen->regn_meta_sz)
|| 0 != memcmp(seen->regn, chunk->data, seen->regn_sz)) {
printf("REGN chunk changed between header blocks\n");
return -1;
}
}
break;
case ZTR_TYPE_TEXT:
if (0 != uncompress_chunk(srf->ztr, chunk)) {
printf("Couldn't uncompress REGN chunk\n");
return -1;
}
if (NULL == seen->text) {
seen->text_sz = chunk->dlength;
seen->text = smalloc(seen->text_sz);
memcpy(seen->text, chunk->data, seen->text_sz);
if (0 != check_text(opts, seen)) return -1;
} else {
if (seen->text_sz != chunk->dlength
|| 0 != memcmp(seen->text, chunk->data, seen->text_sz)) {
printf("New TEXT chunk found\n");
seen->text_sz = chunk->dlength;
seen->text = srealloc(seen->text, seen->text_sz);
memcpy(seen->text, chunk->data, seen->text_sz);
if (0 != check_text(opts, seen)) return -1;
}
}
break;
default:
printf("Found unexpected chunk type in header block\n");
return -1;
}
}
return 0;
}
static int do_it(char *file, int argc, char **argv) {
mFILE *fp;
Header h;
char *c, *p, *p2;
int all = 0;
int found = 0;
if (NULL == (fp = fopen_compressed(file, NULL))) {
if (!silent)
perror(file);
return 2;
}
/* Read the SCF header */
if (-1 == read_scf_header(fp, &h)) {
if (!silent)
fprintf(stderr, "Failed to read header\n");
return 2;
}
/* Read our comments */
if (NULL == (c = (char *)xmalloc(h.comments_size + 1)))
return 2;
if (-1 == mfseek(fp, h.comments_offset, SEEK_SET)) {
if (!silent)
perror("seek()");
return 2;
}
if (-1 == read_scf_comment(fp, c, h.comments_size)) {
if (!silent)
perror("read() of comments");
return 2;
}
if (argc == 0)
all = 1;
p = c;
for (; p2 = strstr(p, "\n"); p = p2+1) {
char *q;
*p2 = '\0';
if (NULL == (q = strchr(p, '=')))
continue;
*q = '\0';
if (!all) {
int i;
for (i=0; i<argc; i++)
if (strcmp(argv[i], p) == 0)
break;
if (i == argc)
continue;
}
if (suppress)
printf("%s\n", q+1);
else
printf("%s=%s\n", p, q+1);
found = 1;
}
return found ? 0 : 3;
}
int main(void)
{
MEMFILE *file, *file2, *file3;
char test[] = "This is a very long string that just goes on and on, but it can surely tell us a few things about how this code is working.";
char test2[] = "This is the second string, and should get cat'd right up behind the first string.";
char buffer[512];
printf("\n--------- open should fail (file doesn't exist)\n");
file = mfopen( "dummy", "r+b" );
printf("fopen(\"dummy\",\"r+b\") -> 0x%x\n", file );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- open should succeed (truncated on open)\n");
file = mfopen( "dummy", "w+b" );
printf("fopen(\"dummy\",\"w+b\") -> 0x%x\n", file );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("growth increment was %d\n", _mfsetgrowincrement( file, 64 ) );
printf("growth increment is now %d\n", _mfsetgrowincrement( file, 0 ) );
printf("\n--------- should be zero offset, and eof == false\n");
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- should write %d bytes\n", strlen(test));
printf( "fwrite( [], %d, %d, file ) -> %d\n", strlen(test), sizeof(char),
mfwrite( test, strlen(test), sizeof(char), file ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- should read the string back in\n");
printf( "rewind(file) \n" ); mrewind(file);
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
memset( buffer, 0, sizeof( buffer ));
printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char),
mfread( buffer, sizeof(buffer), sizeof(char), file ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- should cat the second string to the first\n");
printf( "fwrite( [], %d, %d, file ) -> %d\n", sizeof(char), strlen(test2),
mfwrite( test2, strlen(test2), sizeof(char), file ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- should read zero (fp is at eof)\n");
memset( buffer, 0, sizeof( buffer ));
printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char),
mfread( buffer, sizeof(buffer), sizeof(char), file ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- seek test\n");
printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) );
printf( "seek(file,64,0)-> %d\n", mfseek( file, 64, SEEK_SET ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- read after seek test, should read filelen-64 bytes\n");
memset( buffer, 0, sizeof( buffer ));
printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char),
mfread( buffer, sizeof(buffer), sizeof(char), file ) );
printf( "-> \"%s\"\n", buffer );
printf("\n--------- change size test\n");
printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf( "ftruncate(fileno(file),10) -> %d\n", mftruncate( mfileno( file ), 10 ) );
printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- negative seek test\n");
printf( "fseek(file,-5,2)->%d\n", mfseek( file, -5, SEEK_END ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("\n--------- read after seek test, should read 5 bytes\n");
memset( buffer, 0, sizeof( buffer ));
printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char),
mfread( buffer, sizeof(buffer), sizeof(char), file ) );
printf( "-> \"%s\"\n", buffer );
printf("\n--------- open and write a second file\n");
file2 = mfopen( "dummy2", "w+b" );
printf("fopen(\"dummy2\",\"w+b\") -> 0x%x\n", file2 );
printf( "fwrite( [], %d, %d, file2 ) -> %d\n", strlen("TEST"), sizeof(char),
mfwrite( "TEST", strlen("TEST"), sizeof(char), file2 ) );
printf( "filelength( fileno( file2 ) )-> %ld\n", mfilelength( mfileno( file2 ) ) );
printf( "ftell(file2) -> %ld feof(file2)-> %d\n", mftell( file2 ), mfeof( file2 ) );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- open and write a third file\n");
file3 = mfopen( "dummy3", "w+b" );
printf("fopen(\"dummy3\",\"w+b\") -> 0x%x\n", file3 );
printf( "fwrite( [], %d, %d, file3 ) -> %d\n", strlen("BLAHBLAH"), sizeof(char),
mfwrite( "BLAHBLAH", strlen("BLAHBLAH"), sizeof(char), file3 ) );
printf( "filelength( fileno( file3 ) )-> %ld\n", mfilelength( mfileno( file3 ) ) );
printf( "ftell(file3) -> %ld feof(file3)-> %d\n", mftell( file3 ), mfeof( file3 ) );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- close second\n");
printf( "fclose(file2) -> %d\n", mfclose( file2 ) );
printf( "filelength( fileno( file2 ) )-> %ld\n", mfilelength( mfileno( file2 ) ) );
printf( "ftell(file2) -> %ld feof(file2)-> %d\n", mftell( file2 ), mfeof( file2 ) );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- check first\n");
printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- truncate to zero test\n");
printf( "ftruncate(fileno(file),0) -> %d\n", mftruncate( mfileno( file ), 0 ) );
printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- close first\n");
printf( "fclose(file) -> %d\n", mfclose( file ) );
printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) );
printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) );
printf("#of open memstreams: %d\n", count_open_streams() );
printf("\n--------- close third\n");
printf( "fclose(file3) -> %d\n", mfclose( file3 ) );
printf( "filelength( fileno( file3 ) )-> %ld\n", mfilelength( mfileno( file3 ) ) );
printf( "ftell(file3) -> %ld feof(file3)-> %d\n", mftell( file3 ), mfeof( file3 ) );
printf("#of open memstreams: %d\n", count_open_streams() );
return 0;
}
void mrewind( MEMFILE *mp ) {
mfseek( mp, 0, SEEK_SET );
}
/*
* Given the archive name and the level_mode
* generate information about the archive
*
* Note the generated srf file is NOT indexed
*
* Returns 0 on success.
*/
int srf_info(char *input, int level_mode, long *read_count, long *chunk_count,
uint64_t *chunk_size, long key_count[NCHUNKS][NKEYS],
long type_count[NCHUNKS][NTYPES], HashTable *regn_hash,
uint64_t *base_count) {
srf_t *srf;
off_t pos;
int type;
int count = 0;
long trace_body_count = 0;
char name[1024];
if (NULL == (srf = srf_open(input, "rb"))) {
perror(input);
return 1;
}
while ((type = srf_next_block_type(srf)) >= 0) {
switch (type) {
case SRFB_CONTAINER:
if( trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
trace_body_count = 0;
}
if (0 != srf_read_cont_hdr(srf, &srf->ch)) {
fprintf(stderr, "Error reading container header.\nExiting.\n");
exit(1);
}
break;
case SRFB_XML:
if( trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
trace_body_count = 0;
}
if (0 != srf_read_xml(srf, &srf->xml)) {
fprintf(stderr, "Error reading XML.\nExiting.\n");
exit(1);
}
break;
case SRFB_TRACE_HEADER:
if( trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
trace_body_count = 0;
}
if (0 != srf_read_trace_hdr(srf, &srf->th)) {
fprintf(stderr, "Error reading trace header.\nExiting.\n");
exit(1);
}
if( 0 == (level_mode & (LEVEL_CHUNK | LEVEL_BASE)) )
break;
/* Decode ZTR chunks in the header */
if (srf->mf)
mfdestroy(srf->mf);
srf->mf = mfcreate(NULL, 0);
if (srf->th.trace_hdr_size)
mfwrite(srf->th.trace_hdr, 1, srf->th.trace_hdr_size, srf->mf);
if (srf->ztr)
delete_ztr(srf->ztr);
mrewind(srf->mf);
if (NULL != (srf->ztr = partial_decode_ztr(srf, srf->mf, NULL))) {
srf->mf_pos = mftell(srf->mf);
} else {
/* Maybe not enough to decode or no headerBlob. */
/* So delay until decoding the body. */
srf->mf_pos = 0;
}
mfseek(srf->mf, 0, SEEK_END);
srf->mf_end = mftell(srf->mf);
break;
case SRFB_TRACE_BODY: {
srf_trace_body_t old_tb;
ztr_t *ztr_tmp;
int no_trace = (level_mode & (LEVEL_CHUNK | LEVEL_BASE) ? 0 : 1);
if (0 != srf_read_trace_body(srf, &old_tb, no_trace)) {
fprintf(stderr, "Error reading trace body.\nExiting.\n");
exit(1);
}
if (-1 == construct_trace_name(srf->th.id_prefix,
(unsigned char *)old_tb.read_id,
old_tb.read_id_length,
name, 512)) {
fprintf(stderr, "Error constructing trace name.\nExiting.\n");
exit(1);
}
trace_body_count++;
if( 1 == trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( "trace_name: %s + %s", srf->th.id_prefix, name+strlen(srf->th.id_prefix));
}
read_count[READ_TOTAL]++;
if (old_tb.flags & SRF_READ_FLAG_BAD_MASK ){
read_count[READ_BAD]++;
} else {
read_count[READ_GOOD]++;
}
if( 0 == (level_mode & (LEVEL_CHUNK | LEVEL_BASE)) )
break;
if (!srf->mf) {
fprintf(stderr, "Error reading trace body.\nExiting.\n");
exit(1);
}
mfseek(srf->mf, srf->mf_end, SEEK_SET);
if (old_tb.trace_size) {
mfwrite(old_tb.trace, 1, old_tb.trace_size, srf->mf);
free(old_tb.trace);
old_tb.trace = NULL;
}
mftruncate(srf->mf, mftell(srf->mf));
mfseek(srf->mf, srf->mf_pos, SEEK_SET);
if (srf->ztr)
ztr_tmp = ztr_dup(srf->ztr); /* inefficient, but simple */
else
ztr_tmp = NULL;
if ((ztr_tmp = partial_decode_ztr(srf, srf->mf, ztr_tmp))) {
int i;
for (i=0; i<ztr_tmp->nchunks; i++) {
int ichunk = -1;
switch (ztr_tmp->chunk[i].type) {
case ZTR_TYPE_BASE:
ichunk = CHUNK_BASE;
chunk_size[ichunk] += ztr_tmp->chunk[i].dlength;
if( parse_base(ztr_tmp, &ztr_tmp->chunk[i], base_count) ){
delete_ztr(ztr_tmp);
return 1;
}
break;
case ZTR_TYPE_CNF1:
ichunk = CHUNK_CNF1;
chunk_size[ichunk] += ztr_tmp->chunk[i].dlength;
break;
case ZTR_TYPE_CNF4:
ichunk = CHUNK_CNF4;
chunk_size[ichunk] += ztr_tmp->chunk[i].dlength;
break;
case ZTR_TYPE_SAMP:
ichunk = CHUNK_SAMP;
chunk_size[ichunk] += ztr_tmp->chunk[i].dlength;
break;
case ZTR_TYPE_SMP4:
ichunk = CHUNK_SMP4;
chunk_size[ichunk] += ztr_tmp->chunk[i].dlength;
break;
case ZTR_TYPE_REGN:
ichunk = CHUNK_REGN;
chunk_size[ichunk] += ztr_tmp->chunk[i].dlength;
if( NULL == parse_regn(ztr_tmp, &ztr_tmp->chunk[i], regn_hash) ){
delete_ztr(ztr_tmp);
return 1;
}
break;
default:
break;
}
if( ichunk > -1 ) {
chunk_count[ichunk]++;
count_mdata_keys(ztr_tmp, &ztr_tmp->chunk[i], ichunk, key_count, type_count);
}
}
}
if( ztr_tmp )
delete_ztr(ztr_tmp);
count++;
if( (level_mode == LEVEL_CHECK) && (count == 10) ){
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
srf_destroy(srf, 1);
return 0;
}
break;
}
case SRFB_INDEX: {
off_t pos = ftell(srf->fp);
if( trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
trace_body_count = 0;
}
printf( "Reading srf index block\n");
if (0 != srf_read_index_hdr(srf, &srf->hdr, 1)) {
srf_destroy(srf, 1);
fprintf(stderr, "Error reading srf index block header.\nExiting.\n");
exit(1);
}
/* Skip the index body */
fseeko(srf->fp, pos + srf->hdr.size, SEEK_SET);
break;
}
case SRFB_NULL_INDEX: {
uint64_t ilen;
if( trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
trace_body_count = 0;
}
printf( "Reading srf null index block\n");
/*
* Maybe the last 8 bytes of a the file (or previously was
* last 8 bytes prior to concatenating SRF files together).
* If so it's the index length and should always be 8 zeros.
*/
if (1 != fread(&ilen, 8, 1, srf->fp)) {
srf_destroy(srf, 1);
fprintf(stderr, "Error reading srf null index block.\nExiting.\n");
exit(1);
}
if (ilen != 0) {
srf_destroy(srf, 1);
fprintf(stderr, "Invalid srf null index block.\nExiting.\n");
exit(1);
}
break;
}
default:
srf_destroy(srf, 1);
fprintf(stderr, "Block of unknown type '%c'\nExiting.\n", type);
exit(1);
}
}
if( trace_body_count ){
if( level_mode & LEVEL_NAME )
printf( " ... %s x%ld\n", name+strlen(srf->th.id_prefix), trace_body_count);
trace_body_count = 0;
}
/* the type should be -1 (EOF) */
if( type != -1 ) {
fprintf(stderr, "Block of unknown type '%c'\nExiting.\n", type);
exit(1);
}
/* are we really at the end of the srf file */
pos = ftell(srf->fp);
fseek(srf->fp, 0, SEEK_END);
if( pos != ftell(srf->fp) ){
fprintf(stderr, "srf file is corrupt\n");
exit(1);
}
srf_destroy(srf, 1);
return 0;
}
/*
* As per partial_decode_ztr in srf.c, but without uncompress_ztr.
*/
ztr_t *partial_decode_ztr2(srf_t *srf, mFILE *mf, ztr_t *z) {
ztr_t *ztr;
ztr_chunk_t *chunk;
long pos = 0;
if (z) {
/* Use existing ZTR object => already loaded header */
ztr = z;
} else {
/* Allocate or use existing ztr */
if (NULL == (ztr = new_ztr()))
return NULL;
/* Read the header */
if (-1 == ztr_read_header(mf, &ztr->header)) {
if (!z)
delete_ztr(ztr);
mrewind(mf);
return NULL;
}
/* Check magic number and version */
if (memcmp(ztr->header.magic, ZTR_MAGIC, 8) != 0) {
if (!z)
delete_ztr(ztr);
mrewind(mf);
return NULL;
}
if (ztr->header.version_major != ZTR_VERSION_MAJOR) {
if (!z)
delete_ztr(ztr);
mrewind(mf);
return NULL;
}
}
/* Load chunks */
pos = mftell(mf);
while ((chunk = ztr_read_chunk_hdr(mf))) {
chunk->data = (char *)xmalloc(chunk->dlength);
if (chunk->dlength != mfread(chunk->data, 1, chunk->dlength, mf))
break;
ztr->nchunks++;
ztr->chunk = (ztr_chunk_t *)xrealloc(ztr->chunk, ztr->nchunks *
sizeof(ztr_chunk_t));
memcpy(&ztr->chunk[ztr->nchunks-1], chunk, sizeof(*chunk));
xfree(chunk);
pos = mftell(mf);
}
/*
* At this stage we're 'pos' into the mFILE mf with any remainder being
* a partial block.
*/
if (0 == ztr->nchunks) {
if (!z)
delete_ztr(ztr);
mrewind(mf);
return NULL;
}
/* Ensure we exit at the start of a ztr CHUNK */
mfseek(mf, pos, SEEK_SET);
/* If this is the header part, ensure we uncompress and init. data */
if (!z) {
/* Force caching of huffman code_sets */
ztr_find_hcode(ztr, CODE_USER);
/* And uncompress the rest */
uncompress_ztr(ztr);
}
return ztr;
}
