This commit of samblaster 0.1.21 includes the following:

1) Fixed bug that resulted in intermittent incorrect detection of
   split-read mappings when using --acceptDupMarks option.
2) Merged in pull request from Aakrosh Ratan for OSX support,
   with additional minor mods to make Linux support more portable.
3) Updated SAMBLASTER_Supplemental.pdf to include final samblaster
   citation, and fixed recently broken link to the file in README.

Author: GregoryFaust

README.md

@@ -6,14 +6,14 @@
 **Please cite:**  
 [Faust, G.G. and Hall, I.M., “*SAMBLASTER*: fast duplicate marking and structural variant read extraction,” *Bioinformatics* Sept. 2014; **30**(17): 2503-2505.](http://bioinformatics.oxfordjournals.org/content/30/17/2503)
 
-**Also see:** [SAMBLASTER_Supplemental.pdf] (http://faculty.virginia.edu/irahall/support/samblaster/SAMBLASTER_Supplemental.pdf) for additonal discussion and statistics about the duplicates marked by *samblaster* vs. *Picard* using the NA12878 sample dataset.  
+**Also see:** [SAMBLASTER_Supplemental.pdf] (https://www.dropbox.com/s/s7vvdtf2gmytvay/SAMBLASTER_Supplemental.pdf?dl=0) for additonal discussion and statistics about the duplicates marked by *samblaster* vs. *Picard* using the NA12878 sample dataset.  
 Click the preceeding link or download the file from this repository.
 
 ---
 
-**Current version:** 0.1.20
+**Current version:** 0.1.21
 
-Current support for Linux only.
+Support for Linux and OSX.
 
 ##Summary
 *samblaster* is a fast and flexible program for marking duplicates in __read-id grouped<sup>1</sup>__ paired-end SAM files.

SAMBLASTER_Supplemental.pdf

@@ -18,29 +18,32 @@
 
 */
 
+// This define is needed for portable definition of PRIu64
+#define __STDC_FORMAT_MACROS
+
 #include <stdlib.h>
-#include <stdint.h>
+#include <inttypes.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
-#include <inttypes.h> // support for printing UINT64
 #include <map>
 #include "sbhash.h"
 
-#ifndef _GNU_SOURCE
-// mempcpy is a GNU extension and not available everywhere.
-void *mempcpy(void *dest, const void *src, size_t n)
-{
-    return (char*) memcpy(dest, src, n) + n;
-}
-#endif
-
 // Rename common integer types.
 // I like having these shorter name.
 typedef uint64_t UINT64;
 typedef uint32_t UINT32;
 
 // Some helper routines.
+
+// mempcpy is a GNU extension and not available everywhere.
+#ifndef _GNU_SOURCE
+inline void *mempcpy(void *dest, const void *src, size_t n)
+{
+    return (char*) memcpy(dest, src, n) + n;
+}
+#endif
+
 inline bool streq(char * s1, const char * s2) __attribute__((always_inline));
 inline bool streq(char * s1, const char * s2)
 {
@@ -87,7 +90,7 @@ void fprintTimeSeconds (FILE * out, double seconds, int precision)
         seconds -= minutes * 60;
         fprintf(out, "%dM", minutes);
     }
-    if (hours + minutes > 0) 
+    if (hours + minutes > 0)
     {
         fprintf(out, "%.0fS", seconds);
         fprintf(out, "(%.*fS)", precision, totalseconds);
@@ -107,7 +110,7 @@ inline UINT64 diffTVs (struct timeval * startTV, struct timeval * endTV)
 #include <sys/times.h>
 #include <sys/resource.h>
 #include <time.h>
-#endif // TIMING 
+#endif // TIMING
 
 ///////////////////////////////////////////////////////////////////////////////
 // Split Lines
@@ -333,7 +336,7 @@ splitLine_t * readLine(FILE * input)
 inline void outputString(char * str, FILE * output)
 {
     // Do the error checking here so we don't have to do it elsewhere.
-    if (fputs(str, output) < 0) 
+    if (fputs(str, output) < 0)
     {
         fatalError("samblaster: Unable to write to output file.\n");
     }
@@ -395,7 +398,7 @@ inline bool isFirstRead(splitLine_t * line) { return checkFlag(line, FIRST_SEG);
 
 inline bool isSecondRead(splitLine_t * line) { return checkFlag(line, SECOND_SEG); }
 
-inline bool isSecondaryAlignment(splitLine_t * line) 
+inline bool isSecondaryAlignment(splitLine_t * line)
 { return (checkFlag(line, 0x100) || checkFlag(line, 0x800)); }
 
 inline bool isDuplicate(splitLine_t * line) { return checkFlag(line, 0x400); }
@@ -474,7 +477,7 @@ struct state_struct
     char *         outputFileName;
     FILE *         outputFile;
     FILE *         discordantFile;
-    char *         discordantFileName; 
+    char *         discordantFileName;
     FILE *         splitterFile;
     char *         splitterFileName;
     FILE *         unmappedClippedFile;
@@ -535,7 +538,7 @@ void deleteState(state_t * s)
 {
     free(s->splitterArray);
     if (s->sigs != NULL) delete[] s->sigs;
-    for (seqMap_t::iterator iter = s->seqs.begin(); iter != s->seqs.end(); ++iter) 
+    for (seqMap_t::iterator iter = s->seqs.begin(); iter != s->seqs.end(); ++iter)
     {
         free((char *)(iter->first));
     }
@@ -562,7 +565,7 @@ inline int calcSigArrOff(splitLine_t * first, splitLine_t * second, seqMap_t & s
     int s2 = (second->seqNum * 2) + (isReverseStrand(second) ? 1 : 0);
     int retval = (s1 * seqs.size() * 2) + s2;
 #ifdef DEBUG
-    fprintf(stderr, "1st %d %d -> %d 2nd %d %d -> %d count %lu result %d\n", 
+    fprintf(stderr, "1st %d %d -> %d 2nd %d %d -> %d count %lu result %d\n",
             first->seqNum, isReverseStrand(first), s1, second->seqNum, isReverseStrand(second), s2, seqs.size(), retval);
 #endif
     return retval;
@@ -632,7 +635,7 @@ void calcOffsets(splitLine_t * line)
         int opLen = parseNextInt(&cigar);
         char opCode = parseNextOpCode(&cigar);
         if      (opCode == 'M' || opCode == '=' || opCode == 'X')
-        { 
+        {
             line->raLen += opLen;
             line->qaLen += opLen;
         }
@@ -744,7 +747,7 @@ int fillSplitterArray(splitLine_t * block, state_t * state, int mask, bool flagV
 void markDupsDiscordants(splitLine_t * block, state_t * state)
 {
     splitLine_t * first = NULL;
-    splitLine_t * second = NULL;    
+    splitLine_t * second = NULL;
     int count = 0;
     for (splitLine_t * line = block; line != NULL; line = line->next)
     {
@@ -905,7 +908,7 @@ int fillSplitterArray(splitLine_t * block, state_t * state, int mask, bool flagV
             if (count >= state->splitterArrayMaxSize)
             {
                 state->splitterArrayMaxSize *= 2;
-                state->splitterArray = (splitLine_t **)(realloc(state->splitterArray, 
+                state->splitterArray = (splitLine_t **)(realloc(state->splitterArray,
                                                                 state->splitterArrayMaxSize * sizeof(splitLine_t *)));
             }
             state->splitterArray[count] = line;
@@ -957,11 +960,6 @@ void markSplitterUnmappedClipped(splitLine_t * block, state_t * state, int mask,
             // Make sure the primary is mapped!
             if (isUnmapped(line)) return;
         }
-        else
-        {
-            // We have a secondary, which needs a sequence number.
-            line->seqNum = getSeqNum(line, RNAME, state);
-        }
         calcOffsets(line);
     }
 
@@ -985,7 +983,9 @@ void markSplitterUnmappedClipped(splitLine_t * block, state_t * state, int mask,
 
         // Now check for the deserts and diagonal difference.
         // If they are on different chroms or strands, they pass without the other checks.
-        if ((left->seqNum == right->seqNum) && (isReverseStrand(left) == isReverseStrand(right)))
+        // Since we only care if the sequences are the same, we don't need seqNums.
+        // Instead just compare the strings!
+        if (streq(left->fields[RNAME], right->fields[RNAME]) && (isReverseStrand(left) == isReverseStrand(right)))
         {
             // The start and end diags might be different if there is an indel in the alignments.
             // So, we use the end on the left, and the start on the right.
@@ -1025,9 +1025,9 @@ void markSplitterUnmappedClipped(splitLine_t * block, state_t * state, int mask,
 void writeUnmappedClipped(splitLine_t * line, state_t * state)
 {
     // Check if we are outputting fasta or fastq.
-    if (state->unmappedFastq == -1) 
+    if (state->unmappedFastq == -1)
         state->unmappedFastq = (streq(line->fields[QUAL], "*") ? 0 : 1);
-    
+
     // Print the first line.
     char firstChar = (state->unmappedFastq) ? '@' : '>';
     if (isPaired(line)) fprintf(state->unmappedClippedFile, "%c%s_%d\n", firstChar, line->fields[QNAME], (isFirstRead(line) ? 1 : 2));
@@ -1099,7 +1099,7 @@ void printVersionString()
 
 void printUsageString()
 {
-    const char* useString = 
+    const char* useString =
         "Author: Greg Faust ([email protected])\n"
         "Tool to mark duplicates and optionally output split reads and/or discordant pairs.\n"
         "Input sam file must contain paired end data, contain sequence header and be sorted by read ids.\n"
@@ -1130,7 +1130,7 @@ void printUsageString()
         "   --minNonOverlap    INT Minimum non-overlaping base pairs between two alignments for a read to be included in splitter file. [20]\n"
         "   --minClipSize      INT Minumum number of bases a mapped read must be clipped to be included in unmapped file. [20]\n"
         "-q --quiet                Output fewer statistics.\n";
-    
+
         printVersionString();
         fprintf(stderr, "%s", useString);
 }
@@ -1322,7 +1322,8 @@ int main (int argc, char *argv[])
             {
                 if (strncmp(line->fields[i], "SN:", 3) == 0)
                 {
-                    state->seqs[strdup(line->fields[i]+3)] = count;
+                    // Unless we are marking dups, we don't need to use sequence numbers.
+                    if (!state->acceptDups) state->seqs[strdup(line->fields[i]+3)] = count;
                     count += 1;
                 }
             }
@@ -1335,7 +1336,7 @@ int main (int argc, char *argv[])
             writeLine(line, state->splitterFile);
         disposeSplitLines(line);
     }
-    
+
     // Make sure we have a header.
     if (count == 1 && !state->acceptDups)
     {
@@ -1393,16 +1394,16 @@ int main (int argc, char *argv[])
         if (state->unmappedClippedFile != NULL)
             fprintf(stderr, "samblaster: Output %"PRIu64" unmapped/clipped reads to %s\n", unmapClipCount, state->unmappedClippedFileName);
     }
-    
+
     // Output stats.
     if (state->removeDups)
     {
-        fprintf(stderr, "samblaster: Removed %"PRIu64" of %"PRIu64" (%4.2f%%) read ids as duplicates", 
+        fprintf(stderr, "samblaster: Removed %"PRIu64" of %"PRIu64" (%4.2f%%) read ids as duplicates",
                 dupCount, idCount, ((double)100)*dupCount/idCount);
     }
     else
     {
-        fprintf(stderr, "samblaster: Marked %"PRIu64" of %"PRIu64" (%4.2f%%) read ids as duplicates", 
+        fprintf(stderr, "samblaster: Marked %"PRIu64" of %"PRIu64" (%4.2f%%) read ids as duplicates",
                 dupCount, idCount, ((double)100)*dupCount/idCount);
     }
     if ((TIMING == 0) || state->quiet)
@@ -1414,7 +1415,7 @@ int main (int argc, char *argv[])
 #if TIMING
         getrusage(RUSAGE_SELF, &usagebuf);
         time_t endTime = time(NULL);
-        struct timeval endRUTime = usagebuf.ru_utime;    
+        struct timeval endRUTime = usagebuf.ru_utime;
         fprintf(stderr, " using %luk memory in ", usagebuf.ru_maxrss);
         fprintTimeMicroSeconds(stderr, diffTVs(&startRUTime, &endRUTime), 3);
         fprintf(stderr, " CPU seconds and ");