// Marth Lab, Department of Biology, Boston College\r
// All rights reserved.\r
// ---------------------------------------------------------------------------\r
-// Last modified: 29 March 2010 (DB)\r
+// Last modified: 14 April 2010 (DB)\r
// ---------------------------------------------------------------------------\r
// Uses BGZF routines were adapted from the bgzf.c code developed at the Broad\r
// Institute.\r
using namespace BamTools;\r
using namespace std;\r
\r
+namespace BamTools {\r
+ struct BamAlignmentSupportData {\r
+ string AllCharData;\r
+ uint32_t BlockLength;\r
+ uint32_t NumCigarOperations;\r
+ uint32_t QueryNameLength;\r
+ uint32_t QuerySequenceLength;\r
+ };\r
+} // namespace BamTools\r
+\r
struct BamReader::BamReaderPrivate {\r
\r
// -------------------------------\r
// data members\r
// -------------------------------\r
\r
- // general data\r
+ // general file data\r
BgzfData mBGZF;\r
string HeaderText;\r
BamIndex Index;\r
string Filename;\r
string IndexFilename;\r
\r
+ // system data\r
bool IsBigEndian;\r
\r
// user-specified region values\r
// "public" interface\r
// -------------------------------\r
\r
- // flie operations\r
+ // file operations\r
void Close(void);\r
bool Jump(int refID, int position = 0);\r
void Open(const string& filename, const string& indexFilename = "");\r
bool GetNextAlignment(BamAlignment& bAlignment);\r
\r
// access auxiliary data\r
- const string GetHeaderText(void) const;\r
- const int GetReferenceCount(void) const;\r
- const RefVector GetReferenceData(void) const;\r
- const int GetReferenceID(const string& refName) const;\r
+ int GetReferenceID(const string& refName) const;\r
\r
// index operations\r
bool CreateIndex(void);\r
\r
// calculate bins that overlap region ( left to reference end for now )\r
int BinsFromRegion(int refID, int left, uint16_t[MAX_BIN]);\r
- // calculates alignment end position based on starting position and provided CIGAR operations\r
- int CalculateAlignmentEnd(const int& position, const std::vector<CigarOp>& cigarData);\r
+ // fills out character data for BamAlignment data\r
+ bool BuildCharData(BamAlignment& bAlignment, const BamAlignmentSupportData& supportData);\r
// calculate file offset for first alignment chunk overlapping 'left'\r
int64_t GetOffset(int refID, int left);\r
// checks to see if alignment overlaps current region\r
// retrieves header text from BAM file\r
void LoadHeaderData(void);\r
// retrieves BAM alignment under file pointer\r
- bool LoadNextAlignment(BamAlignment& bAlignment);\r
+ bool LoadNextAlignment(BamAlignment& bAlignment, BamAlignmentSupportData& supportData);\r
// builds reference data structure from BAM file\r
void LoadReferenceData(void);\r
\r
bool LoadIndex(void);\r
// simplifies index by merging 'chunks'\r
void MergeChunks(void);\r
- // round-up 32-bit integer to next power-of-2\r
- void Roundup32(int& value);\r
// saves index to BAM index file\r
bool WriteIndex(void);\r
};\r
bool BamReader::GetNextAlignment(BamAlignment& bAlignment) { return d->GetNextAlignment(bAlignment); }\r
\r
// access auxiliary data\r
-const string BamReader::GetHeaderText(void) const { return d->HeaderText; }\r
-const int BamReader::GetReferenceCount(void) const { return d->References.size(); }\r
+const string BamReader::GetHeaderText(void) const { return d->HeaderText; }\r
+int BamReader::GetReferenceCount(void) const { return d->References.size(); }\r
const RefVector BamReader::GetReferenceData(void) const { return d->References; }\r
-const int BamReader::GetReferenceID(const string& refName) const { return d->GetReferenceID(refName); }\r
+int BamReader::GetReferenceID(const string& refName) const { return d->GetReferenceID(refName); }\r
+const std::string BamReader::GetFilename(void) const { return d->Filename; }\r
\r
// index operations\r
bool BamReader::CreateIndex(void) { return d->CreateIndex(); }\r
return i;\r
}\r
\r
+bool BamReader::BamReaderPrivate::BuildCharData(BamAlignment& bAlignment, const BamAlignmentSupportData& supportData) {\r
+ \r
+ // calculate character lengths/offsets\r
+ const unsigned int dataLength = supportData.BlockLength - BAM_CORE_SIZE;\r
+ const unsigned int seqDataOffset = supportData.QueryNameLength + (supportData.NumCigarOperations * 4);\r
+ const unsigned int qualDataOffset = seqDataOffset + (supportData.QuerySequenceLength+1)/2;\r
+ const unsigned int tagDataOffset = qualDataOffset + supportData.QuerySequenceLength;\r
+ const unsigned int tagDataLength = dataLength - tagDataOffset;\r
+ \r
+ // set up char buffers\r
+ const char* allCharData = supportData.AllCharData.data();\r
+ const char* seqData = ((const char*)allCharData) + seqDataOffset;\r
+ const char* qualData = ((const char*)allCharData) + qualDataOffset;\r
+ char* tagData = ((char*)allCharData) + tagDataOffset;\r
+ \r
+ // save query sequence\r
+ bAlignment.QueryBases.clear();\r
+ bAlignment.QueryBases.reserve(supportData.QuerySequenceLength);\r
+ for (unsigned int i = 0; i < supportData.QuerySequenceLength; ++i) {\r
+ char singleBase = DNA_LOOKUP[ ( ( seqData[(i/2)] >> (4*(1-(i%2)))) & 0xf ) ];\r
+ bAlignment.QueryBases.append(1, singleBase);\r
+ }\r
+ \r
+ // save qualities, converting from numeric QV to 'FASTQ-style' ASCII character\r
+ bAlignment.Qualities.clear();\r
+ bAlignment.Qualities.reserve(supportData.QuerySequenceLength);\r
+ for (unsigned int i = 0; i < supportData.QuerySequenceLength; ++i) {\r
+ char singleQuality = (char)(qualData[i]+33);\r
+ bAlignment.Qualities.append(1, singleQuality);\r
+ }\r
+ \r
+ // parse CIGAR to build 'AlignedBases'\r
+ bAlignment.AlignedBases.clear();\r
+ bAlignment.AlignedBases.reserve(supportData.QuerySequenceLength);\r
+ \r
+ int k = 0;\r
+ vector<CigarOp>::const_iterator cigarIter = bAlignment.CigarData.begin();\r
+ vector<CigarOp>::const_iterator cigarEnd = bAlignment.CigarData.end();\r
+ for ( ; cigarIter != cigarEnd; ++cigarIter ) {\r
+ \r
+ const CigarOp& op = (*cigarIter);\r
+ switch(op.Type) {\r
+ \r
+ case ('M') :\r
+ case ('I') :\r
+ bAlignment.AlignedBases.append(bAlignment.QueryBases.substr(k, op.Length)); // for 'M', 'I' - write bases\r
+ // fall through\r
+ \r
+ case ('S') :\r
+ k += op.Length; // for 'S' - soft clip, skip over query bases\r
+ break;\r
+ \r
+ case ('D') :\r
+ bAlignment.AlignedBases.append(op.Length, '-'); // for 'D' - write gap character\r
+ break;\r
+ \r
+ case ('P') :\r
+ bAlignment.AlignedBases.append( op.Length, '*' ); // for 'P' - write padding character\r
+ break;\r
+ \r
+ case ('N') :\r
+ bAlignment.AlignedBases.append( op.Length, 'N' ); // for 'N' - write N's, skip bases in original query sequence\r
+ // k+=op.Length; \r
+ break;\r
+ \r
+ case ('H') :\r
+ break; // for 'H' - hard clip, do nothing to AlignedBases, move to next op\r
+ \r
+ default:\r
+ printf("ERROR: Invalid Cigar op type\n"); // shouldn't get here\r
+ exit(1);\r
+ }\r
+ }\r
+ \r
+ // -----------------------\r
+ // Added: 3-25-2010 DWB\r
+ // Fixed: endian-correctness for tag data\r
+ // -----------------------\r
+ if ( IsBigEndian ) {\r
+ int i = 0;\r
+ while ( (unsigned int)i < tagDataLength ) {\r
+ \r
+ i += 2; // skip tag type (e.g. "RG", "NM", etc)\r
+ uint8_t type = toupper(tagData[i]); // lower & upper case letters have same meaning \r
+ ++i; // skip value type\r
+ \r
+ switch (type) {\r
+ \r
+ case('A') :\r
+ case('C') : \r
+ ++i;\r
+ break;\r
+\r
+ case('S') : \r
+ SwapEndian_16p(&tagData[i]); \r
+ i+=2; // sizeof(uint16_t)\r
+ break;\r
+ \r
+ case('F') :\r
+ case('I') : \r
+ SwapEndian_32p(&tagData[i]);\r
+ i+=4; // sizeof(uint32_t)\r
+ break;\r
+ \r
+ case('D') : \r
+ SwapEndian_64p(&tagData[i]);\r
+ i+=8; // sizeof(uint64_t) \r
+ break;\r
+ \r
+ case('H') :\r
+ case('Z') : \r
+ while (tagData[i]) { ++i; }\r
+ ++i; // increment one more for null terminator\r
+ break;\r
+ \r
+ default : \r
+ printf("ERROR: Invalid tag value type\n"); // shouldn't get here\r
+ exit(1);\r
+ }\r
+ }\r
+ }\r
+ \r
+ // store TagData\r
+ bAlignment.TagData.clear();\r
+ bAlignment.TagData.resize(tagDataLength);\r
+ memcpy((char*)bAlignment.TagData.data(), tagData, tagDataLength);\r
+ \r
+ // return success\r
+ return true;\r
+}\r
+\r
// populates BAM index data structure from BAM file data\r
bool BamReader::BamReaderPrivate::BuildIndex(void) {\r
\r
return Rewind();\r
}\r
\r
-// calculates alignment end position based on starting position and provided CIGAR operations\r
-int BamReader::BamReaderPrivate::CalculateAlignmentEnd(const int& position, const vector<CigarOp>& cigarData) {\r
-\r
- // initialize alignment end to starting position\r
- int alignEnd = position;\r
-\r
- // iterate over cigar operations\r
- vector<CigarOp>::const_iterator cigarIter = cigarData.begin();\r
- vector<CigarOp>::const_iterator cigarEnd = cigarData.end();\r
- for ( ; cigarIter != cigarEnd; ++cigarIter) {\r
- char cigarType = (*cigarIter).Type;\r
- if ( cigarType == 'M' || cigarType == 'D' || cigarType == 'N' ) {\r
- alignEnd += (*cigarIter).Length;\r
- }\r
- }\r
- return alignEnd;\r
-}\r
-\r
\r
// clear index data structure\r
void BamReader::BamReaderPrivate::ClearIndex(void) {\r
}\r
\r
// returns RefID for given RefName (returns References.size() if not found)\r
-const int BamReader::BamReaderPrivate::GetReferenceID(const string& refName) const {\r
+int BamReader::BamReaderPrivate::GetReferenceID(const string& refName) const {\r
\r
// retrieve names from reference data\r
vector<string> refNames;\r
// get next alignment (from specified region, if given)\r
bool BamReader::BamReaderPrivate::GetNextAlignment(BamAlignment& bAlignment) {\r
\r
+ BamAlignmentSupportData supportData;\r
+ \r
// if valid alignment available\r
- if ( LoadNextAlignment(bAlignment) ) {\r
+ if ( LoadNextAlignment(bAlignment, supportData) ) {\r
\r
// if region not specified, return success\r
- if ( !IsRegionSpecified ) { return true; }\r
+ if ( !IsRegionSpecified ) { \r
+ bool ok = BuildCharData(bAlignment, supportData);\r
+ return ok; \r
+ }\r
\r
// load next alignment until region overlap is found\r
while ( !IsOverlap(bAlignment) ) {\r
// if no valid alignment available (likely EOF) return failure\r
- if ( !LoadNextAlignment(bAlignment) ) { return false; }\r
+ if ( !LoadNextAlignment(bAlignment, supportData) ) { return false; }\r
}\r
\r
// return success (alignment found that overlaps region)\r
- return true;\r
+ bool ok = BuildCharData(bAlignment, supportData);\r
+ return ok;\r
}\r
\r
// no valid alignment\r
{\r
// get converted offsets\r
int beginOffset = bAlignment.Position >> BAM_LIDX_SHIFT;\r
- int endOffset = ( CalculateAlignmentEnd(bAlignment.Position, bAlignment.CigarData) - 1) >> BAM_LIDX_SHIFT;\r
+ int endOffset = (bAlignment.GetEndPosition() - 1) >> BAM_LIDX_SHIFT;\r
\r
// resize vector if necessary\r
int oldSize = offsets.size();\r
int newSize = endOffset + 1;\r
- if ( oldSize < newSize ) { \r
- Roundup32(newSize);\r
- offsets.resize(newSize, 0);\r
- }\r
+ if ( oldSize < newSize ) { offsets.resize(newSize, 0); }\r
\r
// store offset\r
for(int i = beginOffset + 1; i <= endOffset ; ++i) {\r
if ( bAlignment.Position >= CurrentLeft) { return true; }\r
\r
// return whether alignment end overlaps left boundary\r
- return ( CalculateAlignmentEnd(bAlignment.Position, bAlignment.CigarData) >= CurrentLeft );\r
+ return ( bAlignment.GetEndPosition() >= CurrentLeft );\r
}\r
\r
// jumps to specified region(refID, leftBound) in BAM file, returns success/fail\r
}\r
\r
size_t elementsRead = 0;\r
- \r
+ \r
// see if index is valid BAM index\r
char magic[4];\r
elementsRead = fread(magic, 1, 4, indexStream);\r
}\r
\r
// populates BamAlignment with alignment data under file pointer, returns success/fail\r
-bool BamReader::BamReaderPrivate::LoadNextAlignment(BamAlignment& bAlignment) {\r
+bool BamReader::BamReaderPrivate::LoadNextAlignment(BamAlignment& bAlignment, BamAlignmentSupportData& supportData) {\r
\r
// read in the 'block length' value, make sure it's not zero\r
char buffer[4];\r
mBGZF.Read(buffer, 4);\r
- unsigned int blockLength = BgzfData::UnpackUnsignedInt(buffer);\r
- if ( IsBigEndian ) { SwapEndian_32(blockLength); }\r
- if ( blockLength == 0 ) { return false; }\r
-\r
- // keep track of bytes read as method progresses\r
- int bytesRead = 4;\r
+ supportData.BlockLength = BgzfData::UnpackUnsignedInt(buffer);\r
+ if ( IsBigEndian ) { SwapEndian_32(supportData.BlockLength); }\r
+ if ( supportData.BlockLength == 0 ) { return false; }\r
\r
// read in core alignment data, make sure the right size of data was read\r
- uint32_t x[8];\r
+ char x[BAM_CORE_SIZE];\r
if ( mBGZF.Read(x, BAM_CORE_SIZE) != BAM_CORE_SIZE ) { return false; }\r
- bytesRead += BAM_CORE_SIZE;\r
\r
if ( IsBigEndian ) {\r
- for ( int i = 0; i < 8; ++i ) { \r
- SwapEndian_32(x[i]); \r
+ for ( int i = 0; i < BAM_CORE_SIZE; i+=sizeof(uint32_t) ) { \r
+ SwapEndian_32p(&x[i]); \r
}\r
}\r
\r
- // set BamAlignment 'core' data and character data lengths\r
- unsigned int tempValue;\r
- unsigned int queryNameLength;\r
- unsigned int numCigarOperations;\r
- unsigned int querySequenceLength;\r
-\r
+ // set BamAlignment 'core' and 'support' data\r
bAlignment.RefID = BgzfData::UnpackSignedInt(&x[0]); \r
- bAlignment.Position = BgzfData::UnpackSignedInt(&x[1]);\r
+ bAlignment.Position = BgzfData::UnpackSignedInt(&x[4]);\r
\r
- tempValue = BgzfData::UnpackUnsignedInt(&x[2]);\r
+ unsigned int tempValue = BgzfData::UnpackUnsignedInt(&x[8]);\r
bAlignment.Bin = tempValue >> 16;\r
bAlignment.MapQuality = tempValue >> 8 & 0xff;\r
- queryNameLength = tempValue & 0xff;\r
+ supportData.QueryNameLength = tempValue & 0xff;\r
\r
- tempValue = BgzfData::UnpackUnsignedInt(&x[3]);\r
+ tempValue = BgzfData::UnpackUnsignedInt(&x[12]);\r
bAlignment.AlignmentFlag = tempValue >> 16;\r
- numCigarOperations = tempValue & 0xffff;\r
+ supportData.NumCigarOperations = tempValue & 0xffff;\r
\r
- querySequenceLength = BgzfData::UnpackUnsignedInt(&x[4]);\r
- bAlignment.MateRefID = BgzfData::UnpackSignedInt(&x[5]);\r
- bAlignment.MatePosition = BgzfData::UnpackSignedInt(&x[6]);\r
- bAlignment.InsertSize = BgzfData::UnpackSignedInt(&x[7]);\r
+ supportData.QuerySequenceLength = BgzfData::UnpackUnsignedInt(&x[16]);\r
+ bAlignment.MateRefID = BgzfData::UnpackSignedInt(&x[20]);\r
+ bAlignment.MatePosition = BgzfData::UnpackSignedInt(&x[24]);\r
+ bAlignment.InsertSize = BgzfData::UnpackSignedInt(&x[28]);\r
+ \r
+ // store 'all char data' and cigar ops\r
+ const unsigned int dataLength = supportData.BlockLength - BAM_CORE_SIZE;\r
+ const unsigned int cigarDataOffset = supportData.QueryNameLength;\r
\r
- // calculate lengths/offsets\r
- const unsigned int dataLength = blockLength - BAM_CORE_SIZE;\r
- const unsigned int cigarDataOffset = queryNameLength;\r
- const unsigned int seqDataOffset = cigarDataOffset + (numCigarOperations * 4);\r
- const unsigned int qualDataOffset = seqDataOffset + (querySequenceLength+1)/2;\r
- const unsigned int tagDataOffset = qualDataOffset + querySequenceLength;\r
- const unsigned int tagDataLen = dataLength - tagDataOffset;\r
-\r
- // set up destination buffers for character data\r
- char* allCharData = (char*)calloc(sizeof(char), dataLength);\r
- uint32_t* cigarData = (uint32_t*)(allCharData + cigarDataOffset);\r
- char* seqData = ((char*)allCharData) + seqDataOffset;\r
- char* qualData = ((char*)allCharData) + qualDataOffset;\r
- char* tagData = ((char*)allCharData) + tagDataOffset;\r
-\r
- // get character data - make sure proper data size was read\r
+ char* allCharData = (char*)calloc(sizeof(char), dataLength);\r
+ uint32_t* cigarData = (uint32_t*)(allCharData + cigarDataOffset);\r
+ \r
+ // read in character data - make sure proper data size was read\r
if ( mBGZF.Read(allCharData, dataLength) != (signed int)dataLength) { return false; }\r
else {\r
-\r
- bytesRead += dataLength;\r
-\r
- // clear out any previous string data\r
- bAlignment.Name.clear(;)\r
- bAlignment.QueryBases.clear();\r
- bAlignment.Qualities.clear();\r
- bAlignment.AlignedBases.clear();\r
+ \r
+ // store alignment name and length\r
+ bAlignment.Name.assign((const char*)(allCharData));\r
+ bAlignment.Length = supportData.QuerySequenceLength;\r
+ \r
+ // store remaining 'allCharData' in supportData structure\r
+ supportData.AllCharData.assign((const char*)allCharData, dataLength);\r
+ \r
+ // save CigarOps for BamAlignment\r
bAlignment.CigarData.clear();\r
- bAlignment.TagData.clear();\r
-\r
- // save name\r
- bAlignment.Name = (string)((const char*)(allCharData));\r
-\r
- // save query sequence\r
- // -----------------------\r
- // Added: 3-25-2010 DWB\r
- // Improved: reduced repeated memory allocations as string grows\r
- bAlignment.QueryBases.reserve(querySequenceLength);\r
- // -----------------------\r
- \r
- for (unsigned int i = 0; i < querySequenceLength; ++i) {\r
- char singleBase = DNA_LOOKUP[ ( ( seqData[(i/2)] >> (4*(1-(i%2)))) & 0xf ) ];\r
- bAlignment.QueryBases.append( 1, singleBase );\r
- }\r
-\r
- // save sequence length\r
- bAlignment.Length = bAlignment.QueryBases.length();\r
-\r
- // save qualities, convert from numeric QV to FASTQ character\r
- // -----------------------\r
- // Added: 3-25-2010 DWB\r
- // Improved: reduced repeated memory allocations as string grows\r
- bAlignment.Qualities.reserve(querySequenceLength);\r
- // -----------------------\r
- \r
- for (unsigned int i = 0; i < querySequenceLength; ++i) {\r
- char singleQuality = (char)(qualData[i]+33);\r
- bAlignment.Qualities.append( 1, singleQuality );\r
- }\r
-\r
- // save CIGAR-related data;\r
- // -----------------------\r
- // Added: 3-25-2010 DWB\r
- // Improved: reduced repeated memory allocations as string grows\r
- bAlignment.AlignedBases.reserve(querySequenceLength);\r
- // -----------------------\r
- \r
- int k = 0;\r
- for (unsigned int i = 0; i < numCigarOperations; ++i) {\r
+ for (unsigned int i = 0; i < supportData.NumCigarOperations; ++i) {\r
\r
+ // swap if necessary\r
if ( IsBigEndian ) { SwapEndian_32(cigarData[i]); }\r
\r
- // build CigarOp struct\r
+ // build CigarOp structure\r
CigarOp op;\r
op.Length = (cigarData[i] >> BAM_CIGAR_SHIFT);\r
op.Type = CIGAR_LOOKUP[ (cigarData[i] & BAM_CIGAR_MASK) ];\r
\r
// save CigarOp\r
bAlignment.CigarData.push_back(op);\r
-\r
- // build AlignedBases string\r
- switch (op.Type) {\r
-\r
- case ('M') :\r
- case ('I') : \r
- bAlignment.AlignedBases.append( bAlignment.QueryBases.substr(k, op.Length) ); // for 'M', 'I' - write bases\r
- // fall through\r
- \r
- case ('S') : \r
- k += op.Length; // for 'S' - skip over query bases\r
- break;\r
-\r
- case ('D') : \r
- bAlignment.AlignedBases.append( op.Length, '-' ); // for 'D' - write gap character\r
- break;\r
-\r
- case ('P') : \r
- bAlignment.AlignedBases.append( op.Length, '*' ); // for 'P' - write padding character;\r
- break;\r
-\r
- case ('N') : \r
- bAlignment.AlignedBases.append( op.Length, 'N' ); // for 'N' - write N's, skip bases in query sequence\r
- // -----------------------\r
- // Removed: 3-25-2010 DWB\r
- // Contributed: ARQ\r
- // Fixed: compliance with actual 'N' definition in BAM spec\r
- // k += op.Length;\r
- // -----------------------\r
- break;\r
-\r
- case ('H') : \r
- break; // for 'H' - do nothing, move to next op\r
-\r
- default : \r
- printf("ERROR: Invalid Cigar op type\n"); // shouldn't get here\r
- free(allCharData);\r
- exit(1);\r
- }\r
}\r
-\r
- // -----------------------\r
- // Added: 3-25-2010 DWB\r
- // Fixed: endian-correctness for tag data\r
- // -----------------------\r
- if ( IsBigEndian ) {\r
- int i = 0;\r
- while ( i < tagDataLen ) {\r
- \r
- i += 2; // skip tag type (e.g. "RG", "NM", etc)\r
- uint8_t type = toupper(tagData[i]); // lower & upper case letters have same meaning \r
- ++i; // skip value type\r
- \r
- switch (type) {\r
- \r
- case('A') :\r
- case('C') : \r
- ++i;\r
- break;\r
- \r
- case('S') : \r
- SwapEndian_16p(&tagData[i]); \r
- i+=2; // sizeof(uint16_t)\r
- break;\r
- \r
- case('F') :\r
- case('I') : \r
- SwapEndian_32p(&tagData[i]);\r
- i+=4; // sizeof(uint32_t)\r
- break;\r
- \r
- case('D') : \r
- SwapEndian_64p(&tagData[i]);\r
- i+=8; // sizeof(uint64_t)\r
- break;\r
- \r
- case('H') :\r
- case('Z') : \r
- while (tagData[i]) { ++i; }\r
- ++i; // increment one more for null terminator\r
- break;\r
- \r
- default : \r
- printf("ERROR: Invalid tag value type\n"); // shouldn't get here\r
- free(allCharData);\r
- exit(1); \r
- }\r
- }\r
- }\r
- \r
- // store tag data\r
- bAlignment.TagData.resize(tagDataLen);\r
- memcpy((char*)bAlignment.TagData.data(), tagData, tagDataLen);\r
}\r
\r
free(allCharData);\r
return mBGZF.Seek(AlignmentsBeginOffset);\r
}\r
\r
-// rounds value up to next power-of-2 (used in index building)\r
-void BamReader::BamReaderPrivate::Roundup32(int& value) { \r
- --value;\r
- value |= value >> 1;\r
- value |= value >> 2;\r
- value |= value >> 4;\r
- value |= value >> 8;\r
- value |= value >> 16;\r
- ++value;\r
-}\r
-\r
// saves index data to BAM index file (".bai"), returns success/fail\r
bool BamReader::BamReaderPrivate::WriteIndex(void) {\r
\r
projects / bamtools.git / blobdiff