
#ifndef __VIDEOMGRUTIL_RIFF_H
#define __VIDEOMGRUTIL_RIFF_H

#include <stdint.h>
#include <string.h>
#include <stdio.h>

#include "informational.h"

typedef uint32_t riff_fourcc_t;
#define riff_fourcc_const(a,b,c,d)	( (((uint32_t)(a)) << 0U) | (((uint32_t)(b)) << 8U) | (((uint32_t)(c)) << 16U) | (((uint32_t)(d)) << 24U) )

#define riff_LIST		riff_fourcc_const('L','I','S','T')
#define riff_RIFF		riff_fourcc_const('R','I','F','F')

#define riff_wav_fmt		riff_fourcc_const('f','m','t',' ')
#define riff_wav_data		riff_fourcc_const('d','a','t','a')

typedef struct {
	int64_t			absolute_header_offset;
	int64_t			absolute_data_offset;
	int64_t			absolute_offset_next_chunk;
	riff_fourcc_t		fourcc;
	uint32_t		data_length;
	uint32_t		absolute_data_length;
	riff_fourcc_t		list_fourcc;
	int64_t			read_offset;
	int64_t			write_offset;
	int			wmode;
	unsigned char		disable_sync;		/* 1=riff_stack_pop() will NOT rewrite the header.
							   caller would use this if using riff_stack_streamwrite()
							   to blast the data to disk as fast as possible */
	unsigned char		placeholder;		/* 1=write 0xFFFFFFFF as a placeholder for the actual size
							   until the header is actually updated. you should really
							   only set this flag for LIST chunks that are unlikely to
							   be zero bytes in length. flag is cleared automatically
							   by riff_stack_pop(). do NOT set if disable_sync is set. */
} riff_chunk;

static const riff_chunk RIFF_CHUNK_INIT = {
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0
};

typedef struct {
	int			current,depth;
	riff_chunk		*stack,*top;

	int			fd;
	int			eof;
	void*			user;
	int			wmode;
	int64_t			next_read;
	int64_t			next_write;
	void*			buffer;
	size_t			buflen;
	size_t			bufofs;
	int			(*read)(void *a,void *b,size_t c);
	int64_t			(*seek)(void *a,int64_t offset);
	int			(*write)(void *a,const void *b,size_t c);

	/* flags for controlling some of the optimizations used in this code */
	unsigned char		always_lseek;		/* 1=always lseek()
							   0=ignore lseek() if file pointer should be at that point anyway
							   EXPLANATION: Linux disk I/O caching is more likely to provide better
							                throughput if we avoid lseek() and write structures and
								        data using only a continuous series of read() or write()
									calls. */

	/* variables provided for the file I/O code */
	int64_t			trk_file_pointer;

	/* more flags */
	unsigned int		fd_owner:1;		/* if set, we take ownership of the file descriptor */
} riff_stack;

int riff_std_read(void *a,void *b,size_t c);
int riff_std_write(void *a,const void *b,size_t c);
int64_t riff_std_seek(void *a,int64_t offset);

riff_stack *riff_stack_create(int depth);
riff_stack *riff_stack_destroy(riff_stack *s);
int riff_stack_is_empty(riff_stack *s);
int riff_stack_empty(riff_stack *s);
riff_chunk *riff_stack_top(riff_stack *s);
riff_chunk *riff_stack_pop(riff_stack *s);
int riff_stack_push(riff_stack *s,riff_chunk *c);
int64_t riff_stack_seek(riff_stack *s,riff_chunk *c,int64_t of);
int riff_stack_read(riff_stack *s,riff_chunk *c,void *buf,size_t len);
int riff_stack_write(riff_stack *s,riff_chunk *c,const void *buf,size_t len);
int riff_stack_streamwrite(riff_stack *s,riff_chunk *c,const void *buf,size_t len);
int64_t riff_stack_current_chunk_offset(riff_stack *s);
int riff_stack_assign_fd(riff_stack *s,int fd);
int riff_stack_assign_fd_ownership(riff_stack *s);
int riff_stack_assign_buffer(riff_stack *s,void *buffer,size_t len);
int riff_stack_chunk_contains_subchunks(riff_chunk *c);
int riff_stack_readchunk(riff_stack *s,riff_chunk *pc,riff_chunk *c);
int riff_stack_set_chunk_data_type(riff_chunk *c,riff_fourcc_t fcc);
int riff_stack_set_chunk_list_type(riff_chunk *c,riff_fourcc_t list,riff_fourcc_t fcc);
void riff_stack_debug_chunk_dump(FILE *fp,riff_stack *riff,riff_chunk *chunk);
void riff_stack_debug_print(FILE *fp,int level,riff_chunk *chunk);
void riff_chunk_improvise(riff_chunk *c,uint64_t ofs,uint32_t size);
void riff_stack_fourcc_to_str(riff_fourcc_t t,char *tmp);
void riff_stack_debug_print_indent(FILE *fp,int level);
int riff_stack_eof(riff_stack *r);
int riff_stack_prepare_for_writing(riff_stack *r,int wmode);
int riff_stack_begin_new_chunk_here(riff_stack *s,riff_chunk *c);
int riff_stack_header_sync(riff_stack *s,riff_chunk *c);
int riff_stack_header_sync_all(riff_stack *s);
int riff_stack_chunk_limit(riff_stack *s,int len);
int riff_stack_enable_placeholder(riff_stack *s,riff_chunk *c);
void riff_stack_writing_sync(riff_stack *s);

#define RIFF_CHUNK_HEADER_LENGTH		8
#define RIFF_LIST_CHUNK_HEADER_LENGTH		12

#endif

