introducing iii-extract-riff-chunk utility

for getting the timestamp out of Nikon AVIs

Signed-off-by: Michael Krelin <hacker@klever.net>

3 files changed, 251 insertions, 0 deletions

diff --git a/src/.gitignore b/src/.gitignore
index 425033a..f1c5466 100644
--- a/src/.gitignore
+++ b/src/.gitignore
@@ -1,10 +1,11 @@
 /.deps
 eyefi.nsmap
 soapC.cpp
 soapH.h
 soapStub.h
 soapeyefiService.cpp
 soapeyefiService.h
 *.o
 /iiid
 /COPYING.cc
+/iii-extract-riff-chunk
diff --git a/src/Makefile.am b/src/Makefile.am
index b5b7d5c..b31bed5 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,31 +1,35 @@
+bin_PROGRAMS=iii-extract-riff-chunk
 sbin_PROGRAMS=iiid
 noinst_HEADERS = \
 	eyefi.h \
 	eyekinfig.h eyetil.h \
 	eyefiworker.h
 
 AM_CPPFLAGS = ${CPPFLAGS_DEBUG} \
 	      -DEYEKIN_CONF_DIR=\"${sysconfdir}/${PACKAGE}\"
 DEFAULT_INCLUDES = -I${top_builddir} -I${builddir} -I${srcdir}
 INCLUDES = ${MODULES_CFLAGS} ${UUID_CFLAGS}
 
 iiid_SOURCES = iiid.cc \
 	eyekinfig.cc eyetil.cc \
 	eyefiservice.cc eyefiworker.cc
 nodist_iiid_SOURCES = \
 	${builddir}/soapC.cpp ${builddir}/soapeyefiService.cpp \
 	COPYING.cc
 iiid_LDADD = ${MODULES_LIBS} ${UUID_LIBS}
 
+iii_extract_riff_chunk_SOURCES = iii-extract-riff-chunk.cc
+nodist_iii_extract_riff_chunk_SOURCES = COPYING.cc
+
 COPYING.cc: ${top_srcdir}/COPYING
 	echo "const char * COPYING = " >$@ || (rm $@;exit 1)
 	sed -e 's/"/\\"/g' -e 's/^/\"/' -e 's/$$/\\n\"/' $< >>$@ || (rm $@;exit 1)
 	echo ';' >>$@ || (rm $@;exit 1)
 
 ${srcdir}/eyefiservice.cc: ${builddir}/soapeyefiService.h
 ${srcdir}/iiid.cc: ${builddir}/eyefi.nsmap
 
 ${builddir}soapC.cpp ${builddir}/soapeyefiService.cpp ${builddir}/eyefi.nsmap ${builddir}/soapeyefiService.h: ${srcdir}/eyefi.h
 	${SOAPCPP2} -d${builddir} -S -L -a -i -w -x $<
 
 clean-local:
diff --git a/src/iii-extract-riff-chunk.cc b/src/iii-extract-riff-chunk.cc
new file mode 100644
index 0000000..3a06db2
--- a/dev/null
+++ b/src/iii-extract-riff-chunk.cc
@@ -0,0 +1,246 @@
+/* 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"
+
+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); }
+
+};
+
+struct chunk_path_type : public std::list<std::string> {
+
+	chunk_path_type() { }
+	chunk_path_type(const char *str) {
+	for(const char *p0=str,*p1=strchr(p0,'/');p0;p1=p1?strchr(p0=++p1,'/'):(p0=0))
+		if(p0!=p1)
+			push_back( p1? std::string(p0,p1-p0) : std::string(p0) );
+	}
+
+};
+
+struct chunk_walker {
+	riff& r;
+	chunk_path_type path;
+
+	chunk_walker(riff& r_) : r(r_) { }
+
+	void shoot(scoped_chunk& chunk) {
+		riff::chunk_type& c = chunk.chunk();
+		while(c.left) {
+			static char tmp[512];
+			int r = (c.left<sizeof(tmp)) ? c.left : sizeof(tmp) ;
+			chunk.read(tmp,r); std::cout.write(tmp,r);
+		}
+		if(first) throw exceptional_success();
+	}
+
+	void walk_chunks() {
+		scoped_chunk chunk(r);
+		std::string pc = fourcc2str(chunk.get_chunk_id());
+		bool list = false;
+		switch(chunk.get_chunk_id()) {
+		case fourcc_RIFF: case fourcc_LIST:
+			list = true;
+			pc += '.'; pc += fourcc2str(chunk.read<fourcc_type>());
+			break;
+		}
+		path.push_back(pc);
+		std::pair<chunk_path_type::const_iterator,chunk_path_type::const_iterator>
+			mm = std::mismatch(path.begin(),path.end(),target.begin());
+		bool dive = list;
+		if(mm.first==path.end()) {
+			if(mm.second==target.end()) {
+				shoot(chunk);
+				dive = false;
+			}
+		}else{
+			assert(mm.second!=target.end());
+			dive = false;
+		}
+
+		if(dive) while(chunk.has()) walk_chunks();
+		path.pop_back();
+	}
+
+
+	chunk_path_type target;
+	chunk_walker& set_target(chunk_path_type t) { target = t; return *this; }
+	bool first;
+	chunk_walker& set_oneshot(bool os) { first = true; return *this; }
+};
+
+void usage(char **argv) {
+	std::cerr << PHEADER << std::endl << std::endl
+		<< ' ' << argv[0] << " [options] <avi-file> <chunk-path>" << std::endl
+		<< std::endl <<
+		" -h, --help,\n"
+		" --usage        display this text\n"
+		" -V, --version  display version information\n"
+		" -L, --license  show license\n"
+		"\n"
+		"Example: " << argv[0] << " DSC_0001.AVI '/RIFF.AVI /LIST.ncdt/nctg' \\\n"
+		"\t\t| dd bs=1 skip=82 count=19 2>/dev/null\n"
+		"Output:  YYYY:MM:DD HH:MM:SS (for Nikon-recorded AVI)"
+		<< std::endl << std::endl;
+	exit(0);
+}
+
+int main(int argc,char **argv) try {
+
+	bool first = false;
+
+	for(;;) {
+		static struct option opts[] = {
+			{ "first", no_argument, 0, '1' },
+			{ "help", no_argument, 0, 'h' },
+			{ "usage", no_argument, 0, 'h' },
+			{ "version", no_argument, 0, 'V' },
+			{ "license", no_argument, 0, 'L' },
+			{ NULL, 0, 0, 0 }
+		};
+		int c = getopt_long(argc,argv,"1hVL",opts,NULL);
+		if(c==-1) break;
+		switch(c) {
+		case 'h':
+			usage(argv); break;
+		case 'V':
+			std::cerr << VERSION << std::endl;
+			exit(0); break;
+		case 'L':
+			extern const char *COPYING;
+			std::cerr << COPYING << std::endl;
+			exit(0); break;
+		case '1':
+			first = true; break;
+		default:
+			std::cerr << "Huh?" << std::endl;
+			exit(1); break;
+		}
+	}
+
+	if(optind!=(argc-2)) usage(argv);
+
+	std::ifstream i(argv[optind],std::ios::in);
+	if(!i) {
+		std::cerr << "Failed to open file '" << argv[optind] << "'" << std::endl;
+		exit(1);
+	}
+	riff rs(i);
+	chunk_walker(rs)
+		.set_target(chunk_path_type(argv[++optind]))
+		.set_oneshot(first)
+		.walk_chunks();
+	return 0;
+}catch(exceptional_success&) {
+	return 0;
+}catch(std::exception &e) {
+	std::cerr << "oops: " << e.what() << std::endl;
+	return 1;
+}