#include <stdint.h>
#include <cram/misc.h>

Macros
#define	ITF8_MACROS

Functions

int	cram_load_reference (cram_fd fd, char fn)

int	refs2id (refs_t r, SAM_hdr bfd)

void	refs_free (refs_t *r)

char *	cram_get_ref (cram_fd *fd, int id, int start, int end)

void	cram_ref_incr (refs_t *r, int id)

void	cram_ref_decr (refs_t *r, int id)


cram_container *	cram_new_container (int nrec, int nslice)

void	cram_free_container (cram_container *c)

cram_container *	cram_read_container (cram_fd *fd)

int	cram_write_container (cram_fd fd, cram_container h)

int	cram_flush_container (cram_fd fd, cram_container c)

int	cram_flush_container_mt (cram_fd fd, cram_container c)


cram_block_compression_hdr *	cram_new_compression_header (void)

void	cram_free_compression_header (cram_block_compression_hdr *hdr)


void	cram_free_slice_header (cram_block_slice_hdr *hdr)

void	cram_free_slice (cram_slice *s)

cram_slice *	cram_new_slice (enum cram_content_type type, int nrecs)

cram_slice *	cram_read_slice (cram_fd *fd)


cram_file_def *	cram_read_file_def (cram_fd *fd)

int	cram_write_file_def (cram_fd fd, cram_file_def def)

void	cram_free_file_def (cram_file_def *def)


SAM_hdr *	cram_read_SAM_hdr (cram_fd *fd)

int	cram_write_SAM_hdr (cram_fd fd, SAM_hdr hdr)


cram_fd *	cram_open (const char filename, const char mode)

cram_fd *	cram_dopen (struct hFILE fp, const char filename, const char *mode)

int	cram_close (cram_fd *fd)

int	cram_seek (cram_fd *fd, off_t offset, int whence)

int	cram_flush (cram_fd *fd)

int	cram_eof (cram_fd *fd)

int	cram_set_option (cram_fd *fd, enum cram_option opt,...)

int	cram_set_voption (cram_fd *fd, enum cram_option opt, va_list args)

int	cram_set_header (cram_fd fd, SAM_hdr hdr)

#define	CRAM_KEY(a, b) (((a)<<8)\|((b)))

#define	itf8_get(c, v) (((uc)(c)[0]<0x80)?((v)=(uc)(c)[0],1):(((uc)(c)[0]<0xc0)?((v)=(((uc)(c)[0]<<8)\|(uc)(c)[1])&0x3fff,2):(((uc)(c)[0]<0xe0)?((v)=(((uc)(c)[0]<<16)\|((uc)(c)[1]<<8)\|(uc)(c)[2])&0x1fffff,3):(((uc)(c)[0]<0xf0)?((v)=(((uc)(c)[0]<<24)\|((uc)(c)[1]<<16)\|((uc)(c)[2]<<8)\|(uc)(c)[3])&0x0fffffff,4):(*(v)=(((uc)(c)[0]&0x0f)<<28)\|((uc)(c)[1]<<20)\|((uc)(c)[2]<<12)\|((uc)(c)[3]<<4)\|((uc)(c)[4]&0x0f),5)))))

#define	itf8_put(c, v) ((!((v)&~0x7f))?((c)[0]=(v),1):(!((v)&~0x3fff))?((c)[0]=((v)>>8)\|0x80,(c)[1]=(v)&0xff,2):(!((v)&~0x1fffff))?((c)[0]=((v)>>16)\|0xc0,(c)[1]=((v)>>8)&0xff,(c)[2]=(v)&0xff,3):(!((v)&~0xfffffff))?((c)[0]=((v)>>24)\|0xe0,(c)[1]=((v)>>16)&0xff,(c)[2]=((v)>>8)&0xff,(c)[3]=(v)&0xff,4):((c)[0]=0xf0\|(((v)>>28)&0xff),(c)[1]=((v)>>20)&0xff,(c)[2]=((v)>>12)&0xff,(c)[3]=((v)>>4)&0xff,(c)[4]=(v)&0xf,5))

#define	itf8_size(v) ((!((v)&~0x7f))?1:(!((v)&~0x3fff))?2:(!((v)&~0x1fffff))?3:(!((v)&~0xfffffff))?4:5)

int	itf8_decode (cram_fd fd, int32_t val)

int	itf8_put_blk (cram_block *blk, int val)

#define	BLOCK_SIZE(b) ((b)->byte)

#define	BLOCK_DATA(b) ((b)->data)

#define	BLOCK_END(b) (&(b)->data[(b)->byte])

#define	BLOCK_RESIZE(b, l)

#define	BLOCK_GROW(b, l) BLOCK_RESIZE((b), BLOCK_SIZE((b)) + (l))

#define	BLOCK_APPEND(b, s, l)

#define	BLOCK_APPEND_CHAR(b, c)

#define	BLOCK_APPEND_UINT(b, i)

#define	BLOCK_UPLEN(b) (b)->comp_size = (b)->uncomp_size = BLOCK_SIZE((b))

cram_block *	cram_new_block (enum cram_content_type content_type, int content_id)

cram_block *	cram_read_block (cram_fd *fd)

int	cram_write_block (cram_fd fd, cram_block b)

void	cram_free_block (cram_block *b)

char *	zlib_mem_inflate (char cdata, size_t csize, size_t size)

int	cram_uncompress_block (cram_block *b)

int	cram_compress_block (cram_fd fd, cram_block b, cram_metrics *metrics, int method, int level)

cram_metrics *	cram_new_metrics (void)

char *	cram_block_method2str (enum cram_block_method m)

char *	cram_content_type2str (enum cram_content_type t)

Detailed Description

Include cram.h instead.

This is an internal part of the CRAM system and is automatically included when you #include cram.h.

Implements the low level CRAM I/O primitives. This includes basic data types such as byte, int, ITF-8, maps, bitwise I/O, etc.

Macro Definition Documentation

#define BLOCK_APPEND	(	b,
		s,
		l
	)

Value:

do {          \
        BLOCK_GROW((b),(l));      \
        memcpy(BLOCK_END((b)), (s), (l)); \
	BLOCK_SIZE((b)) += (l);      \
    } while (0)

#define BLOCK_APPEND_CHAR	(	b,
		c
	)

Value:

do {          \
        BLOCK_GROW((b),1);      \
  (b)->data[(b)->byte++] = (c);   \
    } while (0)

#define BLOCK_APPEND_UINT	(	b,
		i
	)

Value:

do {               \
        unsigned char *cp;           \
        BLOCK_GROW((b),11);          \
  cp = &(b)->data[(b)->byte];        \
        (b)->byte += append_uint(cp, (i)) - cp; \
    } while (0)

#define BLOCK_DATA ( b ) ((b)->data)

#define BLOCK_END ( b ) (&(b)->data[(b)->byte])

#define BLOCK_GROW	(	b,
		l
	)	BLOCK_RESIZE((b), BLOCK_SIZE((b)) + (l))

#define BLOCK_RESIZE	(	b,
		l
	)

Value:

do {              \
  while((b)->alloc <= (l)) {        \
      (b)->alloc = (b)->alloc ? (b)->alloc*1.5 : 1024;  \
      (b)->data = realloc((b)->data, (b)->alloc);   \
  }             \
     } while(0)

#define BLOCK_SIZE ( b ) ((b)->byte)

#define BLOCK_UPLEN ( b ) (b)->comp_size = (b)->uncomp_size = BLOCK_SIZE((b))

#define CRAM_KEY	(	a,
		b
	)	(((a)<<8)\|((b)))

ITF8 encoding and decoding.

Also see the itf8_get and itf8_put macros.

INTERNAL: Converts two characters into an integer for use in switch{}

#define itf8_get	(	c,
		v
	)	(((uc)(c)[0]<0x80)?((v)=(uc)(c)[0],1):(((uc)(c)[0]<0xc0)?((v)=(((uc)(c)[0]<<8)\|(uc)(c)[1])&0x3fff,2):(((uc)(c)[0]<0xe0)?((v)=(((uc)(c)[0]<<16)\|((uc)(c)[1]<<8)\|(uc)(c)[2])&0x1fffff,3):(((uc)(c)[0]<0xf0)?((v)=(((uc)(c)[0]<<24)\|((uc)(c)[1]<<16)\|((uc)(c)[2]<<8)\|(uc)(c)[3])&0x0fffffff,4):(*(v)=(((uc)(c)[0]&0x0f)<<28)\|((uc)(c)[1]<<20)\|((uc)(c)[2]<<12)\|((uc)(c)[3]<<4)\|((uc)(c)[4]&0x0f),5)))))

#define ITF8_MACROS

#define itf8_put	(	c,
		v
	)	((!((v)&~0x7f))?((c)[0]=(v),1):(!((v)&~0x3fff))?((c)[0]=((v)>>8)\|0x80,(c)[1]=(v)&0xff,2):(!((v)&~0x1fffff))?((c)[0]=((v)>>16)\|0xc0,(c)[1]=((v)>>8)&0xff,(c)[2]=(v)&0xff,3):(!((v)&~0xfffffff))?((c)[0]=((v)>>24)\|0xe0,(c)[1]=((v)>>16)&0xff,(c)[2]=((v)>>8)&0xff,(c)[3]=(v)&0xff,4):((c)[0]=0xf0\|(((v)>>28)&0xff),(c)[1]=((v)>>20)&0xff,(c)[2]=((v)>>12)&0xff,(c)[3]=((v)>>4)&0xff,(c)[4]=(v)&0xf,5))

#define itf8_size ( v ) ((!((v)&~0x7f))?1:(!((v)&~0x3fff))?2:(!((v)&~0x1fffff))?3:(!((v)&~0xfffffff))?4:5)

Function Documentation

char* cram_block_method2str ( enum cram_block_method m )

int cram_close ( cram_fd * fd )

Closes a CRAM file.

Returns: Returns 0 on success; -1 on failure

int cram_compress_block	(	cram_fd *	fd,
		cram_block *	b,
		cram_metrics *	metrics,
		int	method,
		int	level
	)

Compresses a block.

Compresses a block using one of two different zlib strategies. If we only want one choice set strat2 to be -1.

The logic here is that sometimes Z_RLE does a better job than Z_FILTERED or Z_DEFAULT_STRATEGY on quality data. If so, we'd rather use it as it is significantly faster.

Returns: Returns 0 on success; -1 on failure

char* cram_content_type2str ( enum cram_content_type t )

cram_fd* cram_dopen	(	struct hFILE *	fp,
		const char *	filename,
		const char *	mode
	)

Opens an existing stream for reading or writing.

Returns: Returns file handle on success; NULL on failure.

int cram_eof ( cram_fd * fd )

Checks for end of file on a cram_fd stream.

Returns: Returns 0 if not at end of file 1 if we hit an expected EOF (end of range or EOF block) 2 for other EOF (end of stream without EOF block)

int cram_flush ( cram_fd * fd )

int cram_flush_container	(	cram_fd *	fd,
		cram_container *	c
	)

Flushes a container to disk.

Flushes a completely or partially full container to disk, writing container structure, header and blocks. This also calls the encoder functions.

Returns: Returns 0 on success; -1 on failure

int cram_flush_container_mt	(	cram_fd *	fd,
		cram_container *	c
	)

void cram_free_block ( cram_block * b )

Frees a CRAM block, deallocating internal data too.

void cram_free_compression_header ( cram_block_compression_hdr * hdr )

Frees a cram_block_compression_hdr

void cram_free_container ( cram_container * c )

void cram_free_file_def ( cram_file_def * def )

Frees a cram_file_def structure.

void cram_free_slice ( cram_slice * s )

Frees a slice

void cram_free_slice_header ( cram_block_slice_hdr * hdr )

Slices and slice headers

Frees a slice header

char* cram_get_ref	(	cram_fd *	fd,
		int	id,
		int	start,
		int	end
	)

Returns a portion of a reference sequence from start to end inclusive.

The returned pointer is owned by the cram_file fd and should not be freed by the caller. It is valid only until the next cram_get_ref is called with the same fd parameter (so is thread-safe if given multiple files).

To return the entire reference sequence, specify start as 1 and end as 0.

Returns: Returns reference on success; NULL on failure

int cram_load_reference	(	cram_fd *	fd,
		char *	fn
	)

Reference sequence handling

Loads a reference set from fn and stores in the cram_fd.

Returns: Returns 0 on success; -1 on failure

cram_block* cram_new_block	(	enum cram_content_type	content_type,
		int	content_id
	)

CRAM blocks - the dynamically growable data block. We have code to create, update, (un)compress and read/write.

These are derived from the deflate_interlaced.c blocks, but with the CRAM extension of content types and IDs.

Allocates a new cram_block structure with a specified content_type and id.

Returns: Returns block pointer on success; NULL on failure

cram_block_compression_hdr* cram_new_compression_header ( void )

Compression headers; the first part of the container

Creates a new blank container compression header

Returns: Returns header ptr on success; NULL on failure

cram_container* cram_new_container	(	int	nrec,
		int	nslice
	)

Containers

Creates a new container, specifying the maximum number of slices and records permitted.

Returns: Returns cram_container ptr on success; NULL on failure

cram_metrics* cram_new_metrics ( void )

cram_slice* cram_new_slice	(	enum cram_content_type	type,
		int	nrecs
	)

Creates a new empty slice in memory, for subsequent writing to disk.

Returns: Returns cram_slice ptr on success; NULL on failure

cram_fd* cram_open	(	const char *	filename,
		const char *	mode
	)

The top-level cram opening, closing and option handling

Opens a CRAM file for read (mode "rb") or write ("wb").

The filename may be "-" to indicate stdin or stdout.

Returns: Returns file handle on success; NULL on failure.

cram_block* cram_read_block ( cram_fd * fd )

Reads a block from a cram file.

Returns: Returns cram_block pointer on success; NULL on failure

cram_container* cram_read_container ( cram_fd * fd )

Reads a container header.

Returns: Returns cram_container on success; NULL on failure or no container left (fd->err == 0).

cram_file_def* cram_read_file_def ( cram_fd * fd )

CRAM file definition (header)

Reads a CRAM file definition structure.

Returns: Returns file_def ptr on success; NULL on failure

SAM_hdr* cram_read_SAM_hdr ( cram_fd * fd )

SAM header I/O

Reads the SAM header from the first CRAM data block.

Also performs minimal parsing to extract read-group and sample information.

Returns: Returns SAM hdr ptr on success; NULL on failure

cram_slice* cram_read_slice ( cram_fd * fd )

Loads an entire slice.

FIXME: In 1.0 the native unit of slices within CRAM is broken as slices contain references to objects in other slices. To work around this while keeping the slice oriented outer loop we read all slices and stitch them together into a fake large slice instead.

Returns: Returns cram_slice ptr on success; NULL on failure

void cram_ref_decr	(	refs_t *	r,
		int	id
	)

void cram_ref_incr	(	refs_t *	r,
		int	id
	)

int cram_seek	(	cram_fd *	fd,
		off_t	offset,
		int	whence
	)

int cram_set_header	(	cram_fd *	fd,
		SAM_hdr *	hdr
	)

Attaches a header to a cram_fd.

This should be used when creating a new cram_fd for writing where we have an SAM_hdr already constructed (eg from a file we've read in).

Returns: Returns 0 on success; -1 on failure

int cram_set_option	(	cram_fd *	fd,
		enum cram_option	opt,
			...
	)

Sets options on the cram_fd.

See CRAM_OPT_* definitions in cram_structs.h. Use this immediately after opening.

Returns: Returns 0 on success; -1 on failure

int cram_set_voption	(	cram_fd *	fd,
		enum cram_option	opt,
		va_list	args
	)

Sets options on the cram_fd.

See CRAM_OPT_* definitions in cram_structs.h. Use this immediately after opening.

Returns: Returns 0 on success; -1 on failure

int cram_uncompress_block ( cram_block * b )

Uncompresses a CRAM block, if compressed.

Returns: Returns 0 on success; -1 on failure

int cram_write_block	(	cram_fd *	fd,
		cram_block *	b
	)

Writes a CRAM block.

Returns: Returns 0 on success; -1 on failure

int cram_write_container	(	cram_fd *	fd,
		cram_container *	h
	)

Writes a container structure.

Returns: Returns 0 on success; -1 on failure

int cram_write_file_def	(	cram_fd *	fd,
		cram_file_def *	def
	)

Writes a cram_file_def structure to cram_fd.

Returns: Returns 0 on success; -1 on failure

int cram_write_SAM_hdr	(	cram_fd *	fd,
		SAM_hdr *	hdr
	)

Writes a CRAM SAM header.

Returns: Returns 0 on success; -1 on failure

int itf8_decode	(	cram_fd *	fd,
		int32_t *	val
	)

Reads an integer in ITF-8 encoding from 'fd' and stores it in *val.

Returns: Returns the number of bytes read on success; -1 on failure

int itf8_put_blk	(	cram_block *	blk,
		int	val
	)

Pushes a value in ITF8 format onto the end of a block.

This shouldn't be used for high-volume data as it is not the fastest method.

Returns: Returns the number of bytes written

int refs2id	(	refs_t *	r,
		SAM_hdr *	bfd
	)

Generates a lookup table in refs based on the SQ headers in SAM_hdr.

Indexes references by the order they appear in a BAM file. This may not necessarily be the same order they appear in the fasta reference file.

Returns: Returns 0 on success; -1 on failure

void refs_free ( refs_t * r )

char* zlib_mem_inflate	(	char *	cdata,
		size_t	csize,
		size_t *	size
	)

Uncompress a memory block using Zlib.

Returns: Returns 0 on success; -1 on failure

Macros

Functions

Detailed Description

Macro Definition Documentation

Function Documentation