summaryrefslogtreecommitdiffabout
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--src/.gitignore1
-rw-r--r--src/Makefile.am4
-rw-r--r--src/iii-extract-riff-chunk.cc246
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
@@ -10 +10,2 @@ soapeyefiService.h
/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 +1,2 @@
+bin_PROGRAMS=iii-extract-riff-chunk
sbin_PROGRAMS=iiid
@@ -19,2 +20,5 @@ 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
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;
+}