1 files changed, 1 insertions, 1 deletions

diff --git a/src/iii-extract-riff-chunk.cc b/src/iii-extract-riff-chunk.cc
index 3a06db2..d53170d 100644
--- a/src/iii-extract-riff-chunk.cc
+++ b/src/iii-extract-riff-chunk.cc
@@ -1,114 +1,114 @@
 /* vim:set sw=8 nosi noai cin cino=:0,l1,g0: */
 #include <stdint.h>
 #include <stdlib.h>
 #include <getopt.h>
 #include <cstring>
 #include <iostream>
 #include <fstream>
 #include <stdexcept>
 #include <cassert>
 #include <list>
 #include <string>
 #include <iterator>
 
 #include "config.h"
 
 #define PHEADER \
 	PACKAGE " Version " VERSION "\n" \
-	"Copyright (c) 2009-2010 Klever Group"
+	"Copyright (c) 2009-2011 Klever Group"
 
 typedef uint32_t fourcc_type;
 enum fourcc_value {
 	fourcc_RIFF = 0x46464952, fourcc_AVI  = 0x20495641, fourcc_LIST = 0x5453494c,
 	fourcc_hdrl = 0x6c726468, fourcc_strl = 0x6c727473,
 	fourcc_ncdt = 0x7464636e, fourcc_ncvr = 0x7276636e, fourcc_nctg = 0x6774636e, fourcc_ncth = 0x6874636e
 };
 
 fourcc_type str2fourcc(const char *str) {
 	fourcc_type rv = 0;
 	return *(fourcc_type*)strncpy((char*)&rv,str,sizeof(rv));
 }
 const std::string fourcc2str(fourcc_type fcc) {
 	char rv[sizeof(fcc)+1];
 	*(fourcc_type*)rv = fcc;
 	rv[sizeof(fcc)]=0;
 	return rv;
 }
 
 #pragma pack(1)
 struct riff_sized_head {
 	fourcc_type fourcc;
 	uint32_t size;
 };
 #pragma pack()
 
 class exceptional_success : public std::exception { };
 
 struct riff {
 	struct chunk_type {
 		riff_sized_head head;
 		uint32_t left;
 
 		chunk_type(riff& r) {
 			r.read(&head);
 			left = head.size;
 		}
 	};
 
 	std::istream *in;
 	typedef std::list<chunk_type> chunks_type;
 	chunks_type chunks;
 
 	riff(std::istream& i) : in(&i) { }
 
 	protected:
 
 	int begin_chunk() {
 		chunks.push_back( chunk_type(*this) );
 		return chunks.size();
 	}
 	void end_chunk(int level) {
 		assert(in); assert(chunks.size()==level);
 		std::streamsize o = chunks.back().left;
 		chunks.pop_back();
 		if(!o) return;
 		in->seekg(o,std::ios::cur);
 		for(chunks_type::iterator i=chunks.begin(),ie=chunks.end() ;i!=ie; (i++)->left -= o) ;
 	}
 
 	void read(void *p,size_t n) {
 		assert(in);
 		if( (!chunks.empty()) && chunks.back().left < n)
 			throw std::runtime_error("attempt to read beyond the end of chunk");
 		if(!in->read((char*)p,n))
 			throw std::runtime_error("failed to read()");
 		std::streamsize gc = in->gcount();
 		for(chunks_type::iterator i=chunks.begin(),ie=chunks.end();i!=ie;++i) {
 			i->left -= gc; assert(i->left >= 0);
 		}
 		if(gc!=n) throw std::runtime_error("incomplete read()");
 	}
 
 	template<typename T> void read(T* v) { read(v,sizeof(*v)); }
 
 	friend class scoped_chunk;
 
 };
 
 struct scoped_chunk {
 	riff& rs;
 	int level;
 	riff::chunks_type::reverse_iterator chunk_iterator;
 
 	scoped_chunk(riff& rs_) : rs(rs_), level(rs.begin_chunk()), chunk_iterator(rs.chunks.rbegin()) { }
 	~scoped_chunk() { rs.end_chunk(level); }
 
 	riff::chunk_type& chunk() { return *chunk_iterator; }
 
 	fourcc_type get_chunk_id() { return chunk().head.fourcc; }
 	bool has(uint32_t bytes=1) { return chunk().left >= bytes; }
 
 	template<typename T> T read() { T rv; rs.read(&rv); return rv; }
 	template<typename T> void read(T& t) { rs.read(&t); }
 	void read(void *p,size_t n) { rs.read(p,n); }