ERR_VALUE read_set_generate_from_sequence(const char *Seq, const size_t SeqLen, const uint32_t ReadLength, const size_t ReadCount, PONE_READ *ReadSet) { PONE_READ r = NULL; PONE_READ tmpReadSet = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(ReadCount, sizeof(ONE_READ), &tmpReadSet); if (ret == ERR_SUCCESS) { r = tmpReadSet; for (size_t i = 0; i < ReadCount; ++i) { memset(r, 0, sizeof(ONE_READ)); r->Pos = utils_ranged_rand(0, SeqLen - ReadLength + 1); r->PosQuality = 254; r->ReadSequenceLen = ReadLength; ret = utils_calloc(r->ReadSequenceLen + 1, sizeof(char), &r->ReadSequence); if (ret == ERR_SUCCESS) { memcpy(r->ReadSequence, Seq + r->Pos, r->ReadSequenceLen*sizeof(char)); r->ReadSequence[r->ReadSequenceLen] = '\0'; r->QualityLen = r->ReadSequenceLen; ret = utils_calloc(r->QualityLen, sizeof(uint8_t), &r->Quality); if (ret == ERR_SUCCESS) memset(r->Quality, 254, r->QualityLen); if (ret != ERR_SUCCESS) utils_free(r->ReadSequence); } if (ret != ERR_SUCCESS) { --r; for (size_t j = 0; j < i; ++j) { _read_destroy_structure(r); --r; } break; } ++r; } if (ret == ERR_SUCCESS) *ReadSet = tmpReadSet; if (ret != ERR_SUCCESS) utils_free(tmpReadSet); } return ret; }
static ERR_VALUE _examine_read_coverage(const ONE_READ *Reads, const size_t ReadCount, const char *RefSeq, const size_t RefSeqLen, const char *Alternate) { uint32_t *c = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(RefSeqLen, sizeof(uint32_t), &c); if (ret == ERR_SUCCESS) { memset(c, 0, RefSeqLen*sizeof(uint32_t)); for (size_t i = 0; i < ReadCount; ++i) { for (size_t j = 0; j < Reads[i].ReadSequenceLen; ++j) c[Reads[i].Pos + j]++; } printf("Not covered: "); for (size_t i = 0; i < RefSeqLen; ++i) { if (c[i] == 0) { printf("%u ", i); if (RefSeq[i] != Alternate[i]) { printf("%u: The position has SNPs but is not covered in any read (%c %c)\n", i, RefSeq[i], Alternate[i]); ret = ERR_BAD_READ_COVERAGE; } } } printf("\n"); utils_free(c); } return ret; }
ERR_VALUE read_set_load(FILE *Stream, PONE_READ *ReadSet, size_t *Count) { uint32_t count32 = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; PONE_READ tmpReadSet = NULL; ret = utils_fread(&count32, sizeof(count32), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_calloc(count32, sizeof(ONE_READ), &tmpReadSet); if (ret == ERR_SUCCESS) { for (uint32_t i = 0; i < count32; ++i) { ret = read_load(Stream, tmpReadSet + i); if (ret != ERR_SUCCESS) { for (uint32_t j = 0; j < i; ++j) _read_destroy_structure(tmpReadSet + j); break; } } if (ret == ERR_SUCCESS) { *ReadSet = tmpReadSet; *Count = count32; } if (ret != ERR_SUCCESS) utils_free(tmpReadSet); } } return ret; }
ERR_VALUE read_load(FILE *Stream, PONE_READ Read) { uint32_t rsLen32 = 0; uint32_t qLen32 = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; memset(Read, 0, sizeof(ONE_READ)); ret = utils_fread(&rsLen32, sizeof(rsLen32), 1, Stream); if (ret == ERR_SUCCESS) { Read->ReadSequenceLen = rsLen32; ret = utils_calloc(Read->ReadSequenceLen + 1, sizeof(char), &Read->ReadSequence); if (ret == ERR_SUCCESS) { Read->ReadSequence[Read->ReadSequenceLen] = '\0'; ret = utils_fread(Read->ReadSequence, sizeof(char), Read->ReadSequenceLen, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&qLen32, sizeof(qLen32), 1, Stream); if (ret == ERR_SUCCESS) { Read->QualityLen = qLen32; ret = utils_calloc(Read->QualityLen, sizeof(uint8_t), &Read->Quality); if (ret == ERR_SUCCESS) { ret = utils_fread(Read->Quality, sizeof(uint8_t), Read->QualityLen, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&Read->Pos, sizeof(Read->Pos), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&Read->PosQuality, sizeof(Read->PosQuality), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_fread(&Read->Flags, sizeof(Read->Flags), 1, Stream); if (ret == ERR_SUCCESS) read_split(Read); } } } if (ret != ERR_SUCCESS) utils_free(Read->Quality); } } } if (ret != ERR_SUCCESS) utils_free(Read->ReadSequence); } } return ret; }
ERR_VALUE read_copy(PONE_READ Dest, const ONE_READ *Source) { ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = ERR_SUCCESS; *Dest = *Source; if (Dest->CIGARLen > 0) ret = utils_copy_string(Source->CIGAR, &Dest->CIGAR); if (ret == ERR_SUCCESS) { if (Dest->TemplateNameLen > 0) ret = utils_copy_string(Source->TemplateName, &Dest->TemplateName); if (ret == ERR_SUCCESS) { if (Dest->ReadSequenceLen > 0) ret = utils_copy_string(Source->ReadSequence, &Dest->ReadSequence); if (ret == ERR_SUCCESS) { if (Dest->QualityLen > 0) { ret = utils_calloc(Dest->QualityLen + 1, sizeof(uint8_t), &Dest->Quality); if (ret == ERR_SUCCESS) { memcpy(Dest->Quality, Source->Quality, Dest->QualityLen);; Dest->Quality[Dest->QualityLen] = 0; } } if (ret == ERR_SUCCESS && Source->RNameLen > 0) ret = utils_copy_string(Source->RName, &Dest->RName); if (ret == ERR_SUCCESS && Source->RNextLen > 0) ret = utils_copy_string(Source->RNext, &Dest->RNext); if (ret != ERR_SUCCESS) { if (Dest->ReadSequenceLen > 0) utils_free(Dest->ReadSequence); } } if (ret != ERR_SUCCESS) { if (Dest->TemplateNameLen > 0) utils_free(Dest->TemplateName); } } if (ret != ERR_SUCCESS) { if (Dest->CIGARLen > 0) utils_free(Dest->CIGAR); } } return ret; }
ERR_VALUE read_create_from_test_line(const char *Line, const size_t Length, PONE_READ *Read) { PONE_READ tmpRead = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(1, sizeof(ONE_READ), &tmpRead); if (ret == ERR_SUCCESS) { memset(tmpRead, 0, sizeof(ONE_READ)); tmpRead->Pos = (uint64_t)-1; tmpRead->ReadSequenceLen = Length; ret = utils_calloc(Length + 1, sizeof(char), &tmpRead->ReadSequence); if (ret == ERR_SUCCESS) { memcpy(tmpRead->ReadSequence, Line, Length*sizeof(char)); tmpRead->ReadSequence[Length] = '\0'; *Read = tmpRead; } if (ret != ERR_SUCCESS) utils_free(tmpRead); } return ret; }
ERR_VALUE read_set_merge(PONE_READ *Target, const size_t TargetCount, struct _ONE_READ *Source, const size_t SourceCount) { PONE_READ tmp = NULL; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(TargetCount + SourceCount, sizeof(ONE_READ), &tmp); if (ret == ERR_SUCCESS) { memcpy(tmp, *Target, TargetCount*sizeof(ONE_READ)); memcpy(tmp + TargetCount, Source, SourceCount*sizeof(ONE_READ)); utils_free(Source); utils_free(*Target); *Target = tmp; } return ret; }
struct packet_buffer *init_packet_buffer_v2 (const int number_of_buffer) { int i; struct packet_buffer_t *ptr; fprintf (stderr, "Allocate %d packet buffer ... ", number_of_buffer); if ((pktlink = utils_calloc (number_of_buffer, sizeof (struct packet_buffer_t))) == NULL) { fprintf (stderr, "error\n"); return NULL; } else { packet_buffer_count = number_of_buffer; } for (i = 0, ptr = NULL; i < packet_buffer_count; i++) { // full_packet[i].buffer_ready = 0; // pktlink[i].buffer_ready = 0; pktlink[i].prev = NULL; pktlink[i].next = ptr; ptr = &pktlink[i]; } pkt_freelist = ptr; pkt_use_front = NULL; pkt_use_rear = NULL; fprintf (stderr, "ok\n"); bufuse = 0; pktbuf.request = &request; pktbuf.retrieve = &retrieve; pktbuf.dequeue = &dequeue; pktbuf.ready = &bufready; pktbuf.close = &pktbuf_close; pktbuf.count = &pktbuf_count; pktbuf.num_of_buffers = &pktbuf_num_of_buffers; pktbuf.num_of_freebuf = &pktbuf_num_of_freebuf; return &pktbuf; }
ERR_VALUE seq_load(FILE *Stream, char **RefSeq, size_t *Length) { char *tmpSeq = NULL; uint32_t length32 = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_fread(&length32, sizeof(length32), 1, Stream); if (ret == ERR_SUCCESS) { ret = utils_calloc(length32 + 1, sizeof(char), &tmpSeq); if (ret == ERR_SUCCESS) { tmpSeq[length32] = '\0'; ret = utils_fread(tmpSeq, sizeof(char), length32, Stream); if (ret == ERR_SUCCESS) { *RefSeq = tmpSeq; *Length = length32; } if (ret != ERR_SUCCESS) utils_free(tmpSeq); } } return ret; }
ERR_VALUE kmer_freq_distribution(const PROGRAM_OPTIONS *Options, const uint32_t KMerSize, const ONE_READ *Reads, const size_t ReadCount) { int err; size_t maxValue = 0; khiter_t it; size_t kmerCount = 0; char *kmerString = NULL; khash_t(kc) *table = kh_init(kc); ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(KMerSize + 1, sizeof(char), &kmerString); if (ret == ERR_SUCCESS) { const ONE_READ *r = Reads; kmerString[KMerSize] = '\0'; for (size_t i = 0; i < ReadCount; ++i) { const READ_PART *p = &r->Part; read_split(r); if (p->ReadSequenceLength >= KMerSize) { for (size_t j = 0; j < p->ReadSequenceLength - KMerSize + 1; ++j) { char *s = NULL; memcpy(kmerString, p->ReadSequence + j, KMerSize*sizeof(char)); ret = utils_copy_string(kmerString, &s); if (ret == ERR_SUCCESS) { it = kh_put(kc, table, s, &err); switch (err) { case 0: kh_value(table, it) += 1; if (kh_value(table, it) > maxValue) maxValue = kh_value(table, it); utils_free(s); break; case 1: case 2: kh_value(table, it) = 1; break; default: ret = ERR_OUT_OF_MEMORY; break; } ++kmerCount; if (ret != ERR_SUCCESS) utils_free(s); } if (ret != ERR_SUCCESS) break; } } if (ret != ERR_SUCCESS) break; ++r; } if (ret == ERR_SUCCESS) { size_t *freqArray = NULL; ++maxValue; ret = utils_calloc(maxValue, sizeof(size_t), &freqArray); if (ret == ERR_SUCCESS) { memset(freqArray, 0, maxValue*sizeof(size_t)); for (it = kh_begin(table); it != kh_end(table); ++it) { if (kh_exist(table, it)) ++freqArray[kh_value(table, it)]; } for (size_t i = 0; i < maxValue; ++i) { if (freqArray[i] > 0) fprintf(stdout, "%Iu, %Iu, %lf\n", i, freqArray[i], (double)freqArray[i]*100/ (double)kmerCount); } utils_free(freqArray); } } utils_free(kmerString); } for (size_t i = kh_begin(table); i < kh_end(table); ++i) { if (kh_exist(table, i)) utils_free(kh_key(table, i)); } kh_destroy(kc, table); return ret; }
static ERR_VALUE _process_variant_call(const ASSEMBLY_TASK *Task, const size_t RefSeqStart, const size_t RefSeqEnd, const char *AltSeq, const size_t AltSeqLen, const size_t RSWeight, const size_t ReadWeight, PGEN_ARRAY_VARIANT_CALL VCArray) { VARIANT_CALL vc; char *altSeqStart = NULL; size_t rsPos = Task->RegionStart + RefSeqStart + 1; size_t rsLen = RefSeqEnd - RefSeqStart; size_t altLen = AltSeqLen; char *altSeq = NULL; const char *refSeq = Task->Reference + RefSeqStart; ERR_VALUE ret = ERR_INTERNAL_ERROR; ret = utils_calloc(altLen + 2, sizeof(char), &altSeq); if (ret == ERR_SUCCESS) { altSeqStart = altSeq; memcpy(altSeq + 1, AltSeq, altLen*sizeof(char)); *altSeq = *(refSeq - 1); ++altSeq; altSeq[altLen] = '\0'; char *opString = NULL; size_t opStringLen = 0; ret = ssw_clever(refSeq, rsLen, altSeq, altLen, 2, -1, -1, &opString, &opStringLen);; if (ret == ERR_SUCCESS) { const char *opIt = opString; const char *tmpRS = refSeq; const char *tmpAltS = altSeq; size_t pos = rsPos; boolean nothing = TRUE; while (ret == ERR_SUCCESS) { switch (*opIt) { case '\0': case 'M': if (!nothing) { if (altSeq == tmpAltS || refSeq == tmpRS) { --rsPos; --refSeq; --altSeq; } ret = variant_call_init("1", rsPos, ".", refSeq, tmpRS - refSeq, altSeq, tmpAltS - altSeq, 60, &vc); if (ret == ERR_SUCCESS) { vc.RefWeight = RSWeight; vc.AltWeight = ReadWeight; ret = vc_array_add(VCArray, &vc); if (ret == ERR_SUCCESS) { } if (ret != ERR_SUCCESS) { variant_call_finit(&vc); if (ret == ERR_ALREADY_EXISTS) ret = ERR_SUCCESS; } rsPos += (tmpRS - refSeq); refSeq = tmpRS; altSeq = tmpAltS; } nothing = TRUE; } else { rsPos++; refSeq++; altSeq++; } ++tmpRS; ++tmpAltS; break; case 'X': ++tmpRS; ++tmpAltS; nothing = FALSE; break; case 'I': ++tmpAltS; nothing = FALSE; break; case 'D': ++tmpRS; nothing = FALSE; break; } if (*opIt == '\0') break; ++opIt; } utils_free(opString); } utils_free(altSeqStart); } return ret; }
int main(int argc, char *argv[]) { ERR_VALUE ret = ERR_INTERNAL_ERROR; utils_allocator_init(omp_get_num_procs()); omp_init_lock(&_readCoverageLock); #ifdef _MSC_VER uint64_t startTime = GetTickCount64(); #endif ret = options_module_init(37); if (ret == ERR_SUCCESS) { ret = _init_default_values(); if (ret == ERR_SUCCESS) { ret = options_parse_command_line(argc - 2, argv + 2); if (ret == ERR_SUCCESS) { PROGRAM_OPTIONS po; PROGRAM_STATISTICS st; memset(&st, 0, sizeof(st)); ret = _capture_program_options(&po); if (ret == ERR_SUCCESS) { omp_set_num_threads(po.OMPThreads); const char *cmd = argv[1]; if (strncmp(cmd, "help", sizeof("help")) == 0) { options_print_help(); } else if (strncmp(cmd, "repair", sizeof("repair")) == 0) { size_t refSeqLen = 0; FASTA_FILE seqFile; char *rsFasta = NULL; ret = fasta_load(po.RefSeqFile, &seqFile); if (ret == ERR_SUCCESS) { ret = fasta_read_seq(&seqFile, &rsFasta, &refSeqLen); po.ReferenceSequence = rsFasta; if (ret != ERR_SUCCESS) fasta_free(&seqFile); } if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_vertexLAs); if (ret == ERR_SUCCESS) ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_edgeLAs); if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_ONE_READ), &po.ReadSubArrays); if (ret == ERR_SUCCESS) { const size_t numThreads = omp_get_num_procs(); for (size_t i = 0; i < numThreads; ++i) { dym_array_init_ONE_READ(po.ReadSubArrays + i, 140); _vertexLAs[i] = NULL; _edgeLAs[i] = NULL; } size_t regionCount = 0; PACTIVE_REGION regions = NULL; ret = input_refseq_to_regions(po.ReferenceSequence, refSeqLen, ®ions, ®ionCount); if (ret == ERR_SUCCESS) { const ACTIVE_REGION *pa = NULL; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) _activeRegionCount += (pa->Length / po.TestStep); ++pa; } _activeRegionProcessed = 0; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) repair_reads_in_parallel(pa, &po); ++pa; } input_free_regions(regions, regionCount); } PONE_READ r = po.Reads; for (size_t i = 0; i < po.ReadCount; ++i) { if (r->NumberOfFixes * 100 / r->ReadSequenceLen <= po.ParseOptions.ReadMaxErrorRate) { read_quality_encode(r); read_write_sam(stdout, r); read_quality_decode(r); } ++r; } utils_free(rsFasta); int i = 0; #pragma omp parallel for shared (po) for (i = 0; i < numThreads; ++i) dym_array_finit_ONE_READ(po.ReadSubArrays + i); utils_free(po.ReadSubArrays); } } utils_free(_edgeLAs); utils_free(_vertexLAs); fasta_free(&seqFile); } } else if (strncmp(cmd, "rfreq", sizeof("rfreq")) == 0) { kmer_freq_distribution(&po, po.KMerSize, po.Reads, po.ReadCount); } else if (strncmp(cmd, "call", sizeof("call")) == 0) { fprintf(stderr, "K-mer size: %u\n", po.KMerSize); fprintf(stderr, "Active region length: %u\n", po.RegionLength); fprintf(stderr, "Reference: %s\n", po.RefSeqFile); fprintf(stderr, "Reads: %u\n", po.ReadCount); fprintf(stderr, "Read coverage threshold: %u\n", po.Threshold); fprintf(stderr, "Min. read position quality: %u\n", po.ReadPosQuality); fprintf(stderr, "OpenMP thread count: %i\n", po.OMPThreads); fprintf(stderr, "Output VCF file: %s\n", po.VCFFile); ret = paired_reads_init(); if (ret == ERR_SUCCESS) { if (ret == ERR_SUCCESS) { size_t refSeqLen = 0; FASTA_FILE seqFile; char *rsFasta = NULL; ret = fasta_load(po.RefSeqFile, &seqFile); if (ret == ERR_SUCCESS) { ret = fasta_read_seq(&seqFile, &rsFasta, &refSeqLen); po.ReferenceSequence = rsFasta; if (ret != ERR_SUCCESS) fasta_free(&seqFile); } if (ret == ERR_SUCCESS) { po.VCFFileHandle = NULL; if (*po.VCFFile != '\0') { ret = utils_fopen(po.VCFFile, FOPEN_MODE_WRITE, &po.VCFFileHandle); if (ret == ERR_SUCCESS) dym_array_init_VARIANT_CALL(&po.VCArray, 140); } if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_vertexLAs); if (ret == ERR_SUCCESS) ret = utils_calloc(omp_get_num_procs(), sizeof(PUTILS_LOOKASIDE), &_edgeLAs); ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_VARIANT_CALL), &po.VCSubArrays); if (ret == ERR_SUCCESS) { ret = utils_calloc(omp_get_num_procs(), sizeof(GEN_ARRAY_ONE_READ), &po.ReadSubArrays); if (ret == ERR_SUCCESS) { const size_t numThreads = omp_get_num_procs(); for (size_t i = 0; i < numThreads; ++i) { dym_array_init_VARIANT_CALL(po.VCSubArrays + i, 140); dym_array_init_ONE_READ(po.ReadSubArrays + i, 140); _vertexLAs[i] = NULL; _edgeLAs[i] = NULL; } size_t regionCount = 0; PACTIVE_REGION regions = NULL; ret = input_refseq_to_regions(po.ReferenceSequence, refSeqLen, ®ions, ®ionCount); if (ret == ERR_SUCCESS) { const ACTIVE_REGION *pa = NULL; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) _activeRegionCount += (pa->Length / po.TestStep); ++pa; } _activeRegionProcessed = 0; pa = regions; for (size_t i = 0; i < regionCount; ++i) { if (pa->Type == artValid && pa->Length >= po.RegionLength) process_active_region_in_parallel(pa, &po); ++pa; } input_free_regions(regions, regionCount); } utils_free(rsFasta); ret = vc_array_merge(&po.VCArray, po.VCSubArrays, numThreads); int i = 0; #pragma omp parallel for shared(po) for (i = 0; i <(int) numThreads; ++i) { dym_array_finit_ONE_READ(po.ReadSubArrays + i); vc_array_finit(po.VCSubArrays + i); } utils_free(po.ReadSubArrays); } utils_free(po.VCSubArrays); } utils_free(_edgeLAs); utils_free(_vertexLAs); if (po.VCFFileHandle != NULL) { if (ret == ERR_SUCCESS) vc_array_print(po.VCFFileHandle, &po.VCArray); vc_array_finit(&po.VCArray); utils_fclose(po.VCFFileHandle); } } fasta_free(&seqFile); } } else printf("fix_reads(): %u\n", ret); printf("Read coverage: %lf\n", _readBaseCount / _totalRegionLength ); paired_reads_finit(); } } } } } options_module_finit(); } #ifdef _MSC_VER uint64_t endTime = GetTickCount64(); fprintf(stderr, "Time: %I64u s\n", (endTime - startTime) / 1000); #endif omp_destroy_lock(&_readCoverageLock); return ret; }
int main(int argc, char **argv) { fml_opt_t options; bseq1_t *seqs = NULL; PONE_READ reads = NULL; size_t readCount = 0; ERR_VALUE ret = ERR_INTERNAL_ERROR; fml_opt_init(&options); options.n_threads = omp_get_num_procs(); options.ec_k = 31; utils_allocator_init(options.n_threads); fprintf(stderr, "Loading reads from %s...\n", argv[1]); ret = input_get_reads(argv[1], "sam", &reads, &readCount); if (ret == ERR_SUCCESS) { fprintf(stderr, "Converting to fermi-lite format...\n"); ret = utils_calloc(readCount, sizeof(bseq1_t), &seqs); if (ret == ERR_SUCCESS) { for (size_t i = 0; i < readCount; ++i) { memset(seqs + i, 0, sizeof(seqs[i])); seqs[i].l_seq = reads[i].ReadSequenceLen; read_quality_encode(reads + i); seqs[i].seq = _copy_string(reads[i].ReadSequence, reads[i].ReadSequenceLen); if (reads[i].Quality != NULL) seqs[i].qual = _copy_string(reads[i].Quality, reads[i].QualityLen); read_quality_decode(reads + i); } fml_opt_adjust(&options, readCount, seqs); fprintf(stderr, "Correcting...\n"); fml_correct(&options, readCount, seqs); fprintf(stderr, "Fitting unique k-mers...\n"); fml_fltuniq(&options, readCount, seqs); fprintf(stderr, "Converting back to our format...\n"); for (size_t i = 0; i < readCount; ++i) { if (reads[i].ReadSequenceLen != seqs[i].l_seq) { utils_copy_string("*", &reads[i].CIGAR); reads[i].CIGARLen = 1; } reads[i].ReadSequenceLen = seqs[i].l_seq; reads[i].QualityLen = seqs[i].l_seq; ret = utils_copy_string(seqs[i].seq, &reads[i].ReadSequence); if (ret == ERR_SUCCESS) ret = utils_copy_string(seqs[i].qual, &reads[i].Quality); for (size_t j = 0; j < reads[i].ReadSequenceLen; ++j) reads[i].ReadSequence[j] = toupper(reads[i].ReadSequence[j]); if (reads[i].ReadSequenceLen > 0 && reads[i].QualityLen > 0) read_write_sam(stdout, reads + i); read_quality_decode(reads + i); } fprintf(stderr, "Freeing fermi-lite resources...\n"); utils_free(seqs); } fprintf(stderr, "Freeing our reads...\n"); read_set_destroy(reads, readCount); } return 0; }