extern void
cfuopt_destroy(cfuopt_t *context) {
if (!context) return;
cfulist_destroy_with_free_fn(context->option_list, _opt_list_free_fn);
cfuhash_destroy(context->option_map);
cfulist_destroy(context->extra);
free(context->progname);
free(context);
}
void FuseSDKTerminate_platform()
{
// Add any platform-specific termination code here
if( gameConfig != NULL )
{
cfuhash_destroy(gameConfig);
gameConfig = NULL;
}
FuseSDKTerminateSession_platform();
}
int32 FusePause(void* systemData, void* userData)
{
if( gameConfig != NULL )
{
cfuhash_destroy(gameConfig);
gameConfig = NULL;
}
s3eTimerSetTimer(100, &DelayedPause, NULL);
return 1;
}
BM_mappedRead * extractReads(char * bamFile,
char ** contigs,
int numContigs,
uint16_t * groups,
char * prettyName,
int headersOnly,
int minMapQual,
int maxMisMatches,
int ignoreSuppAlignments,
int ignoreSecondaryAlignments) {
//-----
// code uses the pattern outlined in samtools view (sam_view.c)
// thanks lh3!
//
int i = 0;
int result = -1;
int hh = 0;
int supp_check = 0x0; // include supp mappings
if (ignoreSuppAlignments) {
supp_check |= BAM_FSUPPLEMENTARY;
}
if (ignoreSecondaryAlignments) {
supp_check |= BAM_FSECONDARY;
}
// we need to let the users know if their pairings
// will be corrupted
int p_corrupt = 0;
// helper variables
samFile *in = 0;
bam_hdr_t *header = NULL;
bam1_t *b = bam_init1();
BM_mappedRead * root = 0;
BM_mappedRead * prev = 0;
// open file handlers
if ((in = sam_open(bamFile, "r")) == 0) {
fprintf(stderr,
"ERROR: Failed to open \"%s\" for reading.\n",
bamFile);
}
else {
// retrieve the header
if ((header = sam_hdr_read(in)) == 0) {
fprintf(stderr,
"ERROR: Failed to read the header from \"%s\".\n",
bamFile);
}
else {
// check the index is intact
hts_idx_t *idx = sam_index_load(in, bamFile); // load index
if (idx == 0) { // index is unavailable
fprintf(stderr,
"ERROR: Random retrieval only works "\
"for indexed files.\n");
}
else {
cfuhash_table_t *pair_buffer = \
cfuhash_new_with_initial_size(1000000);
cfuhash_set_flag(pair_buffer, CFUHASH_FROZEN_UNTIL_GROWS);
for (hh = 0; hh < numContigs; ++hh) {
// parse a region in the format like `chr2:100-200'
hts_itr_t *iter = sam_itr_querys(idx, header, contigs[hh]);
if (iter == NULL) { // reference name is not found
fprintf(stderr,
"WARNING: Could not find contig: "\
"[%s] in BAM: [%s].\n",
contigs[hh],
bamFile);
}
// fetch alignments
int line = 0;
while ((result = sam_itr_next(in, iter, b)) >= 0) {
bam1_core_t core = b->core;
line += 1;
// only high quality?, primary? mappings
if ( core.qual < minMapQual)
continue;
if ((core.flag & supp_check) != 0)
continue;
if(bam_aux2i(bam_aux_get(b, "NM")) > maxMisMatches) {
continue;
}
char * seqId = bam_get_qname(b);
char * seq = 0;
char * qual = 0;
int qual_len = 0;
int seq_len = 0;
// get sequence and quality
if(0 == headersOnly) {
// no point allocating unused space
seq = calloc(core.l_qseq+1, sizeof(char));
qual = calloc(core.l_qseq+1, sizeof(char));
uint8_t *s = bam_get_seq(b);
if (core.flag&BAM_FREVERSE) {
// reverse the read
int r = 0;
for (i = core.l_qseq-1; i >=0 ; --i) {
seq[r]="=TGKCYSBAWRDMHVN"[bam_seqi(s,
i)];
++r;
}
}
else {
for (i = 0; i < core.l_qseq; ++i) {
seq[i]="=ACMGRSVTWYHKDBN"[bam_seqi(s,
i)];
}
}
seq_len = core.l_qseq;
s = bam_get_qual(b);
if (s[0] != 0xff) {
qual_len = core.l_qseq;
for (i = 0; i < core.l_qseq; ++i) {
qual[i] = (char)(s[i] + 33);
}
}
else if (qual != 0) {
free(qual);
qual = 0;
}
}
// work out pairing information
uint8_t rpi = RPI_ERROR;
if (core.flag&BAM_FPAIRED) {
if(core.flag&BAM_FMUNMAP) {
if (core.flag&BAM_FREAD1) {
rpi = RPI_SNGL_FIR;
}
else if (core.flag&BAM_FREAD2) {
rpi = RPI_SNGL_SEC;
}
}
else {
if (core.flag&BAM_FREAD1) {
rpi = RPI_FIR;
}
else if (core.flag&BAM_FREAD2) {
rpi = RPI_SEC;
}
}
}
else {
rpi = RPI_SNGL;
}
// make the funky Id
#define MAX_SEQ_ID_LEN 80
char * seq_id = calloc(MAX_SEQ_ID_LEN,
sizeof(char));
// allocate the string to the buffer but check to
// ensure we're not cutting anything off
int id_len = snprintf(seq_id,
MAX_SEQ_ID_LEN,
"b_%s;c_%s;r_%s",
prettyName,
contigs[hh],
seqId);
if(id_len >= MAX_SEQ_ID_LEN) {
seq_id = calloc(id_len+1, sizeof(char));
snprintf(seq_id,
id_len+1, // don't forget the NULL!
"b_%s;c_%s;r_%s",
prettyName,
contigs[hh],
seqId);
}
// make the mapped read struct
prev = makeMappedRead(seq_id,
seq,
qual,
id_len,
seq_len,
qual_len,
rpi,
groups[hh],
prev);
if (0 == root) { root = prev; }
if(rpi == RPI_SNGL || \
rpi == RPI_SNGL_FIR || \
rpi == RPI_SNGL_SEC) {
// we can just add away
// indicate singleton reads by pointing the
// partner pointer to itself
prev->partnerRead = prev;
}
else {
// RPI_FIR or RPI_SEC
// work out pairing information using the hash
// we append a 1 or 2 to the end so that
// we don't accidentally pair 1's with 1's etc.
char * stripped_result;
if(rpi == RPI_FIR) {
stripped_result = \
pairStripper(seqId,
core.l_qname-1,
'2');
}
else {
stripped_result = \
pairStripper(seqId,
core.l_qname-1,
'1');
}
char * stripped = seqId;
if(stripped_result)
stripped = stripped_result;
//fprintf(stdout, "SEARCH %s\n", stripped);
// now stripped always holds a stripped value
// see if it is in the hash already
BM_mappedRead * stored_MR = \
cfuhash_get(pair_buffer,
stripped);
if (0 != stored_MR) {
// exists in the hash -> Add the pair info
if(rpi == RPI_FIR) {
prev->partnerRead = stored_MR;
}
else {
stored_MR->partnerRead = prev;
}
// delete the entry from the hash
cfuhash_delete(pair_buffer,
stripped);
}
else {
// we should put it in the hash
// make sure to change it into something
// we will find next time
if(rpi == RPI_FIR)
stripped[strlen(stripped)-1] = '1';
else
stripped[strlen(stripped)-1] = '2';
// check to make sure we're not overwriting
// anything important. cfuhash overwrites
// duplicate entries, so we need to grab
// it and put it to "SNGL_XXX" before we
// lose the pointer
BM_mappedRead * OWMMR = \
cfuhash_put(pair_buffer,
stripped, prev);
if(OWMMR) {
if(OWMMR->rpi == RPI_FIR)
OWMMR->rpi = RPI_SNGL_FIR;
else
OWMMR->rpi = RPI_SNGL_SEC;
OWMMR->partnerRead = OWMMR;
printPairCorruptionWarning(p_corrupt);
p_corrupt = 1;
}
}
if(stripped_result != 0) { // free this!
free(stripped_result);
stripped_result = 0;
}
}
}
hts_itr_destroy(iter);
if (result < -1) {
fprintf(stderr, "ERROR: retrieval of reads from "\
"contig: \"%s\" failed due to "\
"truncated file or corrupt BAM index "\
"file\n", header->target_name[hh]);
break;
}
}
// any entries left in the hash are pairs whose mates did
// not meet quality standards
size_t key_size = 0;
char * key;
BM_mappedRead * LOMMR;
size_t pr_size = 1;
if(cfuhash_each_data(pair_buffer,
(void**)&key,
&key_size,
(void**)&LOMMR,
&pr_size)) {
do {
// get the mapped read
// update it's pairing so we know it's really single
if (LOMMR->rpi == RPI_FIR)
LOMMR->rpi = RPI_SNGL_FIR;
else if (LOMMR->rpi == RPI_SEC)
LOMMR->rpi = RPI_SNGL_SEC;
// indicate singleton reads by pointing the
// partner pointer to itself
LOMMR->partnerRead = LOMMR;
} while(cfuhash_next_data(pair_buffer,
(void**)&key,
&key_size,
(void**)&LOMMR,
&pr_size));
}
cfuhash_clear(pair_buffer);
cfuhash_destroy(pair_buffer);
}
hts_idx_destroy(idx); // destroy the BAM index
}
}
// always do this
if (in) sam_close(in);
bam_destroy1(b);
if ( header ) bam_hdr_destroy(header);
return root;
}