X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fasdcp-test.cpp;h=df108c3974ce221cec0fe107ad7ee9102749d251;hb=1c26f274039b5ccb93ba138482e5328de0c7df2e;hp=1dfc33f781434bdd49096b23c8fcc0386753349b;hpb=6e23666cb6184999efc74577cfb1b524181ba5df;p=asdcplib.git

diff --git a/src/asdcp-test.cpp b/src/asdcp-test.cpp
index 1dfc33f..df108c3 100755
--- a/src/asdcp-test.cpp
+++ b/src/asdcp-test.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2003-2005, John Hurst
+Copyright (c) 2003-2014, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -47,26 +47,26 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   these features.
 */
 
-#include <iostream>
-#include <assert.h>
-
-#include <FileIO.h>
+#include <KM_fileio.h>
+#include <KM_prng.h>
 #include <PCMParserList.h>
 #include <WavFileWriter.h>
-#include <hex_utils.h>
-#include <AS_DCP_UUID.h>
 #include <MXF.h>
 #include <Metadata.h>
+#include <openssl/sha.h>
+
+#include <iostream>
+#include <assert.h>
 
 using namespace ASDCP;
 
-const ui32_t FRAME_BUFFER_SIZE = 4*1024*1024;
+const ui32_t FRAME_BUFFER_SIZE = 4 * Kumu::Megabyte;
 
 //------------------------------------------------------------------------------------------
 //
 // command line option parser class
 
-static const char* PACKAGE = "asdcp-test";  // program name for messages
+static const char* PROGRAM_NAME = "asdcp-test";  // program name for messages
 const ui32_t MAX_IN_FILES = 16;             // maximum number of input files handled by
                                             //   the command option parser
 
@@ -83,107 +83,169 @@ public:
       memcpy(ProductUUID, default_ProductUUID_Data, UUIDlen);
       CompanyName = "WidgetCo";
       ProductName = "asdcp-test";
-
-      char s_buf[128];
-      snprintf(s_buf, 128, "%lu.%lu.%lu", VERSION_MAJOR, VERSION_APIMINOR, VERSION_IMPMINOR);
-      ProductVersion = s_buf;
+      ProductVersion = ASDCP::Version();
   }
 } s_MyInfo;
 
 
-// Macros used to test command option data state.
-
-// True if a major mode has already been selected.
-#define TEST_MAJOR_MODE()     ( info_flag||create_flag||extract_flag||genkey_flag||genid_flag||gop_start_flag )
-
-// Causes the caller to return if a major mode has already been selected,
-// otherwise sets the given flag.
-#define TEST_SET_MAJOR_MODE(f) if ( TEST_MAJOR_MODE() ) \
-                                 { \
-                                   fputs("Conflicting major mode, choose one of -(gcixG)).\n", stderr); \
-                                   return; \
-                                 } \
-                                 (f) = true;
 
 // Increment the iterator, test for an additional non-option command line argument.
 // Causes the caller to return if there are no remaining arguments or if the next
 // argument begins with '-'.
 #define TEST_EXTRA_ARG(i,c)    if ( ++i >= argc || argv[(i)][0] == '-' ) \
                                  { \
-                                   fprintf(stderr, "Argument not found for option %c.\n", (c)); \
+                                   fprintf(stderr, "Argument not found for option -%c.\n", (c)); \
                                    return; \
                                  }
 //
 void
-banner(FILE* stream = stderr)
+banner(FILE* stream = stdout)
 {
   fprintf(stream, "\n\
 %s (asdcplib %s)\n\n\
-Copyright (c) 2003-2005 John Hurst\n\n\
+Copyright (c) 2003-2015 John Hurst\n\n\
 asdcplib may be copied only under the terms of the license found at\n\
 the top of every file in the asdcplib distribution kit.\n\n\
 Specify the -h (help) option for further information about %s\n\n",
-	  PACKAGE, ASDCP::Version(), PACKAGE);
+	  PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME);
 }
 
 //
 void
-usage(FILE* stream = stderr)
+usage(FILE* stream = stdout)
 {
   fprintf(stream, "\
-USAGE: %s [-i [-H, -n]|-c <filename> [-p <rate>, -e, -M, -R]|-x <root-name> [-m][-S]|-g|-u|-G|-V|-h]\n\
-       [-k <key-string>] [-j <key-id-string>] [-f <start-frame-num>] [-d <duration>]\n\
-       [-b <buf-size>] [-W] [-v [-s]] [<filename>, ...]\n\
-\n", PACKAGE);
+USAGE: %s -c <output-file> [-3] [-a <uuid>] [-b <buffer-size>]\n\
+       [-d <duration>] [-e|-E] [-f <start-frame>] [-j <key-id-string>]\n\
+       [-k <key-string>] [-l <label>] [-L] [-M] [-p <frame-rate>] [-R]\n\
+       [-s <num>] [-v] [-W] [-z|-Z] <input-file> [<input-file-2> ...]\n\
+\n\
+       %s [-h|-help] [-V]\n\
+\n\
+       %s -i [-H] [-n] [-v] <input-file>\n\
+\n\
+       %s -g | -u\n\
+\n\
+       %s -G [-v] <input-file>\n\
+\n\
+       %s -t <input-file>\n\
+\n\
+       %s -x <file-prefix> [-3] [-b <buffer-size>] [-d <duration>]\n\
+       [-f <starting-frame>] [-m] [-p <frame-rate>] [-R] [-s <num>] [-S|-1]\n\
+       [-v] [-W] [-w] <input-file>\n\n",
+	  PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME,
+	  PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
 
   fprintf(stream, "\
 Major modes:\n\
-  -i              - show file info\n\
-  -c <filename>   - create AS-DCP file from input(s)\n\
-  -x <root-name>  - extract essence from AS-DCP file to named file(s)\n\
-  -g              - generate a random 16 byte value to stdout\n\
-  -u              - generate a random UUID value to stdout\n\
-  -G              - Perform GOP start lookup test on MPEG file\n\
-  -V              - show version\n\
-  -h              - show help\n\
+  -3                - With -c, create a stereoscopic image file. Expects two\n\
+                      directories of JP2K codestreams (directories must have\n\
+                      an equal number of frames; left eye is first).\n\
+                    - With -x, force stereoscopic interpretation of a JP2K\n\
+                      track file.\n\
+  -c <output-file>  - Create an AS-DCP track file from input(s)\n\
+  -g                - Generate a random 16 byte value to stdout\n\
+  -G                - Perform GOP start lookup test on MXF+Interop MPEG file\n\
+  -h | -help        - Show help\n\
+  -i                - Show file info\n\
+  -t                - Calculate message digest of input file\n\
+  -U                - Dump UL catalog to stdout\n\
+  -u                - Generate a random UUID value to stdout\n\
+  -V                - Show version information\n\
+  -x <root-name>    - Extract essence from AS-DCP file to named file(s)\n\
 \n");
 
   fprintf(stream, "\
 Security Options:\n\
-  -j <key-id-str> - write key ID instead of creating a random value\n\
-  -k <key-string> - use key for ciphertext operations\n\
-  -e              - encrypt MPEG or JP2K headers (default)\n\
-  -E              - do not encrypt MPEG or JP2K headers\n\
-  -M              - do not create HMAC values when writing\n\
-  -m              - verify HMAC values when reading\n\
+  -e                - Encrypt MPEG or JP2K headers (default)\n\
+  -E                - Do not encrypt MPEG or JP2K headers\n\
+  -j <key-id-str>   - Write key ID instead of creating a random value\n\
+  -k <key-string>   - Use key for ciphertext operations\n\
+  -m                - verify HMAC values when reading\n\
+  -M                - Do not create HMAC values when writing\n\
 \n");
 
   fprintf(stream, "\
 Read/Write Options:\n\
-  -b <buf-size>   - Size (in bytes) of the picture frame buffer, default: 2097152 (2MB)\n\
-  -f <frame-num>  - starting frame number, default 0\n\
-  -d <duration>   - number of frames to process, default all\n\
-  -p <rate>       - fps of picture when wrapping PCM or JP2K:, use one of [23|24|48], 24 is default\n\
-  -R              - Repeat the first frame over the entire file (picture essence only, requires -c, -d)\n\
-  -S              - Split Wave essence to stereo WAV files during extract (default = multichannel WAV)\n\
-  -W              - read input file only, do not write source file\n\
+  -a <UUID>         - Specify the Asset ID of a file (with -c)\n\
+  -b <buffer-size>  - Specify size in bytes of picture frame buffer.\n\
+                      Defaults to 4,194,304 (4MB)\n\
+  -d <duration>     - Number of frames to process, default all\n\
+  -f <start-frame>  - Starting frame number, default 0\n\
+  -l <label>        - Use given channel format label when writing MXF sound\n\
+                      files. SMPTE 429-2 labels: '5.1', '6.1', '7.1', '7.1DS', 'WTF'.\n\
+                      Default is no label (valid for Interop only).\n\
+  -L                - Write SMPTE UL values instead of MXF Interop\n\
+  -p <rate>         - fps of picture when wrapping PCM or JP2K:\n\
+                      Use one of [23|24|25|30|48|50|60], 24 is default\n\
+  -R                - Repeat the first frame over the entire file (picture\n\
+                      essence only, requires -c, -d)\n\
+  -S                - Split Wave essence to stereo WAV files during extract.\n\
+                      Default is multichannel WAV\n\
+  -1                - Split Wave essence to mono WAV files during extract.\n\
+                      Default is multichannel WAV\n\
+  -W                - Read input file only, do not write source file\n\
+  -w <width>        - Width of numeric element in a series of frame file names\n\
+                      (use with -x, default 6).\n\
+  -z                - Fail if j2c inputs have unequal parameters (default)\n\
+  -Z                - Ignore unequal parameters in j2c inputs\n\
 \n");
 
   fprintf(stream, "\
 Info Options:\n\
-  -H              - show MXF header metadata, used with option -i\n\
-  -n              - show index, used with option -i\n\
+  -H                - Show MXF header metadata, used with option -i\n\
+  -n                - Show index, used with option -i\n\
 \n\
 Other Options:\n\
-  -s <number>     - number of bytes of frame buffer to be dumped as hex to stderr (use with -v)\n\
-  -v              - verbose, show extra detail during run\n\
+  -s <num>          - Number of bytes of frame buffer to be dumped as hex to\n\
+                      stderr, used with option -v\n\
+  -v                - Verbose, prints informative messages to stderr\n\
 \n\
   NOTES: o There is no option grouping, all options must be distinct arguments.\n\
          o All option arguments must be separated from the option by whitespace.\n\
-         o An argument of \"23\" to the -p option will be interpreted as 23000/1001 fps.\n\
+         o An argument of \"23\" to the -p option will be interpreted\n\
+           as 24000/1001 fps.\n\
 \n");
 }
 
+//
+enum MajorMode_t
+{
+  MMT_NONE,
+  MMT_INFO,
+  MMT_CREATE,
+  MMT_EXTRACT,
+  MMT_GEN_ID,
+  MMT_GEN_KEY,
+  MMT_GOP_START,
+  MMT_DIGEST,
+  MMT_UL_LIST,
+};
+
+//
+PCM::ChannelFormat_t
+decode_channel_fmt(const std::string& label_name)
+{
+  if ( label_name == "5.1" )
+    return PCM::CF_CFG_1;
+
+  else if ( label_name == "6.1" )
+    return PCM::CF_CFG_2;
+  
+  else if ( label_name == "7.1" )
+    return PCM::CF_CFG_3;
+
+  else if ( label_name == "WTF" )
+    return PCM::CF_CFG_4;
+
+  else if ( label_name == "7.1DS" )
+    return PCM::CF_CFG_5;
+
+  fprintf(stderr, "Error decoding channel format string: %s\n", label_name.c_str());
+  fprintf(stderr, "Expecting '5.1', '6.1', '7.1', '7.1DS' or 'WTF'\n");
+  return PCM::CF_NONE;
+}
+
 //
 //
 class CommandOptions
@@ -191,19 +253,16 @@ class CommandOptions
   CommandOptions();
 
 public:
+  MajorMode_t mode;
   bool   error_flag;     // true if the given options are in error or not complete
-  bool   info_flag;      // true if the file info mode was selected
-  bool   create_flag;    // true if the file create mode was selected
-  bool   extract_flag;   // true if the file extract mode was selected
-  bool   genkey_flag;    // true if we are to generate a new key value
-  bool   genid_flag;     // true if we are to generate a new UUID value
-  bool   gop_start_flag; // true if we are to perform a GOP start lookup test
   bool   key_flag;       // true if an encryption key was given
   bool   key_id_flag;    // true if a key ID was given
+  bool   asset_id_flag;  // true if an asset ID was given
   bool   encrypt_header_flag; // true if mpeg headers are to be encrypted
   bool   write_hmac;     // true if HMAC values are to be generated and written
   bool   read_hmac;      // true if HMAC values are to be validated
   bool   split_wav;      // true if PCM is to be extracted to stereo WAV files
+  bool   mono_wav;       // true if PCM is to be extracted to mono WAV files
   bool   verbose_flag;   // true if the verbose option was selected
   ui32_t fb_dump_size;   // number of bytes of frame buffer to dump
   bool   showindex_flag; // true if index is to be displayed
@@ -211,196 +270,268 @@ public:
   bool   no_write_flag;  // true if no output files are to be written
   bool   version_flag;   // true if the version display option was selected
   bool   help_flag;      // true if the help display option was selected
+  bool   stereo_image_flag; // if true, expect stereoscopic JP2K input (left eye first)
+  ui32_t number_width;   // number of digits in a serialized filename (for JPEG extract)
   ui32_t start_frame;    // frame number to begin processing
   ui32_t duration;       // number of frames to be processed
   bool   duration_flag;  // true if duration argument given
   bool   do_repeat;      // if true and -c -d, repeat first input frame
+  bool   use_smpte_labels; // if true, SMPTE UL values will be written instead of MXF Interop values
+  bool   j2c_pedantic;   // passed to JP2K::SequenceParser::OpenRead
   ui32_t picture_rate;   // fps of picture when wrapping PCM
   ui32_t fb_size;        // size of picture frame buffer
   ui32_t file_count;     // number of elements in filenames[]
   const char* file_root; // filename pre for files written by the extract mode
   const char* out_file;  // name of mxf file created by create mode
   byte_t key_value[KeyLen];  // value of given encryption key (when key_flag is true)
-  byte_t key_id_value[KeyIDlen];// value of given key ID (when key_id_flag is true)
+  byte_t key_id_value[UUIDlen];// value of given key ID (when key_id_flag is true)
+  byte_t asset_id_value[UUIDlen];// value of asset ID (when asset_id_flag is true)
   const char* filenames[MAX_IN_FILES]; // list of filenames to be processed
+  PCM::ChannelFormat_t channel_fmt; // audio channel arrangement
 
   //
   Rational PictureRate()
   {
+    if ( picture_rate == 16 ) return EditRate_16;
+    if ( picture_rate == 18 ) return EditRate_18;
+    if ( picture_rate == 20 ) return EditRate_20;
+    if ( picture_rate == 22 ) return EditRate_22;
     if ( picture_rate == 23 ) return EditRate_23_98;
+    if ( picture_rate == 24 ) return EditRate_24;
+    if ( picture_rate == 25 ) return EditRate_25;
+    if ( picture_rate == 30 ) return EditRate_30;
     if ( picture_rate == 48 ) return EditRate_48;
+    if ( picture_rate == 50 ) return EditRate_50;
+    if ( picture_rate == 60 ) return EditRate_60;
+    if ( picture_rate == 96 ) return EditRate_96;
+    if ( picture_rate == 100 ) return EditRate_100;
+    if ( picture_rate == 120 ) return EditRate_120;
+    if ( picture_rate == 192 ) return EditRate_192;
+    if ( picture_rate == 200 ) return EditRate_200;
+    if ( picture_rate == 240 ) return EditRate_240;
     return EditRate_24;
   }
 
   //
   const char* szPictureRate()
   {
+    if ( picture_rate == 16 ) return "16";
+    if ( picture_rate == 18 ) return "18.182";
+    if ( picture_rate == 20 ) return "20";
+    if ( picture_rate == 22 ) return "21.818";
     if ( picture_rate == 23 ) return "23.976";
+    if ( picture_rate == 24 ) return "24";
+    if ( picture_rate == 25 ) return "25";
+    if ( picture_rate == 30 ) return "30";
     if ( picture_rate == 48 ) return "48";
+    if ( picture_rate == 50 ) return "50";
+    if ( picture_rate == 60 ) return "60";
+    if ( picture_rate == 96 ) return "96";
+    if ( picture_rate == 100 ) return "100";
+    if ( picture_rate == 120 ) return "120";
+    if ( picture_rate == 192 ) return "192";
+    if ( picture_rate == 200 ) return "200";
+    if ( picture_rate == 240 ) return "240";
     return "24";
   }
 
   //
   CommandOptions(int argc, const char** argv) :
-    error_flag(true), info_flag(false), create_flag(false),
-    extract_flag(false), genkey_flag(false), genid_flag(false), gop_start_flag(false),
-    key_flag(false), encrypt_header_flag(true), write_hmac(true), read_hmac(false), split_wav(false),
+    mode(MMT_NONE), error_flag(true), key_flag(false), key_id_flag(false), asset_id_flag(false),
+    encrypt_header_flag(true), write_hmac(true), read_hmac(false), split_wav(false), mono_wav(false),
     verbose_flag(false), fb_dump_size(0), showindex_flag(false), showheader_flag(false),
-    no_write_flag(false), version_flag(false), help_flag(false), start_frame(0),
-    duration(0xffffffff), duration_flag(false), do_repeat(false), picture_rate(24),
-    fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0)
+    no_write_flag(false), version_flag(false), help_flag(false), stereo_image_flag(false),
+    number_width(6), start_frame(0),
+    duration(0xffffffff), duration_flag(false), do_repeat(false), use_smpte_labels(false), j2c_pedantic(true),
+    picture_rate(24), fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0),
+    channel_fmt(PCM::CF_NONE)
   {
     memset(key_value, 0, KeyLen);
-    memset(key_id_value, 0, KeyIDlen);
+    memset(key_id_value, 0, UUIDlen);
 
     for ( int i = 1; i < argc; i++ )
       {
-	if ( argv[i][0] == '-' && isalpha(argv[i][1]) && argv[i][2] == 0 )
+
+	if ( (strcmp( argv[i], "-help") == 0) )
+	  {
+	    help_flag = true;
+	    continue;
+	  }
+         
+	if ( argv[i][0] == '-'
+	     && ( isalpha(argv[i][1]) || isdigit(argv[i][1]) )
+	     && argv[i][2] == 0 )
 	  {
 	    switch ( argv[i][1] )
 	      {
-	      case 'i': TEST_SET_MAJOR_MODE(info_flag);	break;
-	      case 'G': TEST_SET_MAJOR_MODE(gop_start_flag); break;
-	      case 'W': no_write_flag = true; break;
-	      case 'n': showindex_flag = true; break;
-	      case 'H': showheader_flag = true; break;
-	      case 'R': do_repeat = true; break;
-	      case 'S': split_wav = true; break;
-	      case 'V': version_flag = true; break;
-	      case 'h': help_flag = true; break;
-	      case 'v': verbose_flag = true; break;
-	      case 'g':
-#ifdef ASDCP_WITHOUT_OPENSSL
-		fputs("Program compiled without encryption support.\n", stderr);
-		return;
-#else
-		genkey_flag = true;
-#endif
-		break;
+	      case '1': mono_wav = true; break;
+	      case '2': split_wav = true; break;
+	      case '3': stereo_image_flag = true; break;
 
-	      case 'u':
-#ifdef ASDCP_WITHOUT_OPENSSL
-		fputs("Program compiled without encryption support.\n", stderr);
-		return;
-#else
-		genid_flag = true;
-#endif
+	      case 'a':
+		asset_id_flag = true;
+		TEST_EXTRA_ARG(i, 'a');
+		{
+		  ui32_t length;
+		  Kumu::hex2bin(argv[i], asset_id_value, UUIDlen, &length);
+
+		  if ( length != UUIDlen )
+		    {
+		      fprintf(stderr, "Unexpected asset ID length: %u, expecting %u characters.\n", length, UUIDlen);
+		      return;
+		    }
+		}
 		break;
 
-	      case 'e': encrypt_header_flag = true; break;
-	      case 'E': encrypt_header_flag = false; break;
-	      case 'M': write_hmac = false; break;
-	      case 'm': read_hmac = true; break;
+	      case 'b':
+		TEST_EXTRA_ARG(i, 'b');
+		fb_size = Kumu::xabs(strtol(argv[i], 0, 10));
+
+		if ( verbose_flag )
+		  fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+
+		break;
 
 	      case 'c':
-		TEST_SET_MAJOR_MODE(create_flag);
 		TEST_EXTRA_ARG(i, 'c');
+		mode = MMT_CREATE;
 		out_file = argv[i];
 		break;
 
-	      case 'x':
-		TEST_SET_MAJOR_MODE(extract_flag);
-		TEST_EXTRA_ARG(i, 'x');
-		file_root = argv[i];
+	      case 'd':
+		TEST_EXTRA_ARG(i, 'd');
+		duration_flag = true;
+		duration = Kumu::xabs(strtol(argv[i], 0, 10));
 		break;
 
-	      case 'k': key_flag = true;
-#ifdef ASDCP_WITHOUT_OPENSSL
-		fputs("Program compiled without encryption support.\n", stderr);
-		return;
-#else
-		TEST_EXTRA_ARG(i, 'k');
+	      case 'E': encrypt_header_flag = false; break;
+	      case 'e': encrypt_header_flag = true; break;
+
+	      case 'f':
+		TEST_EXTRA_ARG(i, 'f');
+		start_frame = Kumu::xabs(strtol(argv[i], 0, 10));
+		break;
+
+	      case 'G': mode = MMT_GOP_START; break;
+	      case 'g': mode = MMT_GEN_KEY; break;
+	      case 'H': showheader_flag = true; break;
+	      case 'h': help_flag = true; break;
+	      case 'i': mode = MMT_INFO;	break;
+
+	      case 'j': key_id_flag = true;
+		TEST_EXTRA_ARG(i, 'j');
 		{
 		  ui32_t length;
-		  hex2bin(argv[i], key_value, KeyLen, &length);
+		  Kumu::hex2bin(argv[i], key_id_value, UUIDlen, &length);
 
-		  if ( length != KeyLen )
+		  if ( length != UUIDlen )
 		    {
-		      fprintf(stderr, "Unexpected key length: %lu, expecting %lu characters.\n", KeyLen, length);
+		      fprintf(stderr, "Unexpected key ID length: %u, expecting %u characters.\n", length, UUIDlen);
 		      return;
 		    }
 		}
-#endif
 		break;
 
-	      case 'j': key_id_flag = true;
-#ifdef ASDCP_WITHOUT_OPENSSL
-		fputs("Program compiled without encryption support.\n", stderr);
-		return;
-#else
-		TEST_EXTRA_ARG(i, 'j');
+	      case 'k': key_flag = true;
+		TEST_EXTRA_ARG(i, 'k');
 		{
 		  ui32_t length;
-		  hex2bin(argv[i], key_id_value, KeyIDlen, &length);
+		  Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
 
-		  if ( length != KeyIDlen )
+		  if ( length != KeyLen )
 		    {
-		      fprintf(stderr, "Unexpected key ID length: %lu, expecting %lu characters.\n", KeyIDlen, length);
+		      fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
 		      return;
 		    }
 		}
-#endif
 		break;
 
-	      case 'f':
-		TEST_EXTRA_ARG(i, 'f');
-		start_frame = atoi(argv[i]); // TODO: test for negative value, should use strtol()
+	      case 'l':
+		TEST_EXTRA_ARG(i, 'l');
+		channel_fmt = decode_channel_fmt(argv[i]);
 		break;
 
-	      case 'd':
-		TEST_EXTRA_ARG(i, 'd');
-		duration_flag = true;
-		duration = atoi(argv[i]); // TODO: test for negative value, should use strtol()
-		break;
+	      case 'L': use_smpte_labels = true; break;
+	      case 'M': write_hmac = false; break;
+	      case 'm': read_hmac = true; break;
+	      case 'n': showindex_flag = true; break;
 
 	      case 'p':
 		TEST_EXTRA_ARG(i, 'p');
-		picture_rate = atoi(argv[i]);
+		picture_rate = Kumu::xabs(strtol(argv[i], 0, 10));
 		break;
 
+	      case 'R': do_repeat = true; break;
+	      case 'S': split_wav = true; break;
+
 	      case 's':
 		TEST_EXTRA_ARG(i, 's');
-		fb_dump_size = atoi(argv[i]);
+		fb_dump_size = Kumu::xabs(strtol(argv[i], 0, 10));
 		break;
 
-	      case 'b':
-		TEST_EXTRA_ARG(i, 'b');
-		fb_size = atoi(argv[i]);
+	      case 't': mode = MMT_DIGEST; break;
+	      case 'U':	mode = MMT_UL_LIST; break;
+	      case 'u':	mode = MMT_GEN_ID; break;
+	      case 'V': version_flag = true; break;
+	      case 'v': verbose_flag = true; break;
+	      case 'W': no_write_flag = true; break;
 
-		if ( verbose_flag )
-		  fprintf(stderr, "Frame Buffer size: %lu bytes.\n", fb_size);
+	      case 'w':
+		TEST_EXTRA_ARG(i, 'w');
+		number_width = Kumu::xabs(strtol(argv[i], 0, 10));
+		break;
 
+	      case 'x':
+		TEST_EXTRA_ARG(i, 'x');
+		mode = MMT_EXTRACT;
+		file_root = argv[i];
 		break;
 
+	      case 'Z': j2c_pedantic = false; break;
+	      case 'z': j2c_pedantic = true; break;
+
 	      default:
-		fprintf(stderr, "Unrecognized option: %c\n", argv[i][1]);
+		fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
 		return;
 	      }
 	  }
 	else
 	  {
-	    filenames[file_count++] = argv[i];
+
+	    if ( argv[i][0] != '-' )
+	      {
+		filenames[file_count++] = argv[i];
+	      }
+	    else
+	      {
+		fprintf(stderr, "Unrecognized argument: %s\n", argv[i]);
+		return;
+	      }
 
 	    if ( file_count >= MAX_IN_FILES )
 	      {
-		fprintf(stderr, "Filename lists exceeds maximum list size: %lu\n", MAX_IN_FILES);
+		fprintf(stderr, "Filename lists exceeds maximum list size: %u\n", MAX_IN_FILES);
 		return;
 	      }
 	  }
       }
 
-    if ( TEST_MAJOR_MODE() )
+    if ( help_flag || version_flag )
+      return;
+    
+    if ( ( mode == MMT_INFO
+	   || mode == MMT_CREATE
+	   || mode == MMT_EXTRACT
+	   || mode == MMT_GOP_START
+	   || mode == MMT_DIGEST ) && file_count == 0 )
       {
-	if ( ! genkey_flag && ! genid_flag && file_count == 0 )
-	  {
-	    fputs("Option requires at least one filename argument.\n", stderr);
-	    return;
-	  }
+	fputs("Option requires at least one filename argument.\n", stderr);
+	return;
       }
 
-    if ( ! TEST_MAJOR_MODE() && ! help_flag && ! version_flag )
+    if ( mode == MMT_NONE && ! help_flag && ! version_flag )
       {
-	fputs("No operation selected (use one of -(gcixG) or -h for help).\n", stderr);
+	fputs("No operation selected (use one of -[gGcitux] or -h for help).\n", stderr);
 	return;
       }
 
@@ -410,7 +541,7 @@ public:
 
 //------------------------------------------------------------------------------------------
 // MPEG2 essence
-#if 0
+
 // Write a plaintext MPEG2 Video Elementary Stream to a plaintext ASDCP file
 // Write a plaintext MPEG2 Video Elementary Stream to a ciphertext ASDCP file
 //
@@ -423,11 +554,8 @@ write_MPEG2_file(CommandOptions& Options)
   MPEG2::Parser      Parser;
   MPEG2::MXFWriter   Writer;
   MPEG2::VideoDescriptor VDesc;
-
-#ifndef ASDCP_WITHOUT_OPENSSL
   byte_t             IV_buf[CBC_BLOCK_SIZE];
-  FortunaRNG         RNG;
-#endif
+  Kumu::FortunaRNG   RNG;
 
   // set up essence parser
   Result_t result = Parser.OpenRead(Options.filenames[0]);
@@ -441,7 +569,7 @@ write_MPEG2_file(CommandOptions& Options)
 	{
 	  fputs("MPEG-2 Pictures\n", stderr);
 	  fputs("VideoDescriptor:\n", stderr);
-	  fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
 	  MPEG2::VideoDescriptorDump(VDesc);
 	}
     }
@@ -449,19 +577,27 @@ write_MPEG2_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
-      GenRandomUUID(RNG, Info.AssetUUID);
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
 
       // configure encryption
       if( Options.key_flag )
 	{
-	  GenRandomUUID(RNG, Info.ContextID);
+	  Kumu::GenRandomUUID(Info.ContextID);
 	  Info.EncryptedEssence = true;
 
 	  if ( Options.key_id_flag )
-	    memcpy(Info.CryptographicKeyID, Options.key_id_value, KeyIDlen);
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
 	  else
-	    RNG.FillRandom(Info.CryptographicKeyID, KeyIDlen);
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
 
 	  Context = new AESEncContext;
 	  result = Context->InitKey(Options.key_value);
@@ -473,10 +609,9 @@ write_MPEG2_file(CommandOptions& Options)
 	    {
 	      Info.UsesHMAC = true;
 	      HMAC = new HMACContext;
-	      result = HMAC->InitKey(Options.key_value);
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
 	    }
 	}
-#endif // ASDCP_WITHOUT_OPENSSL
 
       if ( ASDCP_SUCCESS(result) )
 	result = Writer.OpenWrite(Options.out_file, Info, VDesc);
@@ -508,14 +643,12 @@ write_MPEG2_file(CommandOptions& Options)
 	    {
 	      result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
 
-#ifndef ASDCP_WITHOUT_OPENSSL
 	      // The Writer class will forward the last block of ciphertext
 	      // to the encryption context for use as the IV for the next
 	      // frame. If you want to use non-sequitur IV values, un-comment
 	      // the following  line of code.
 	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
 	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
 	    }
 	}
 
@@ -528,7 +661,6 @@ write_MPEG2_file(CommandOptions& Options)
 
   return result;
 }
-#endif
 
 // Read a plaintext MPEG2 Video Elementary Stream from a plaintext ASDCP file
 // Read a plaintext MPEG2 Video Elementary Stream from a ciphertext ASDCP file
@@ -541,7 +673,7 @@ read_MPEG2_file(CommandOptions& Options)
   HMACContext*       HMAC = 0;
   MPEG2::MXFReader   Reader;
   MPEG2::FrameBuffer FrameBuffer(Options.fb_size);
-  FileWriter         OutFile;
+  Kumu::FileWriter   OutFile;
   ui32_t             frame_count = 0;
 
   Result_t result = Reader.OpenRead(Options.filenames[0]);
@@ -554,7 +686,7 @@ read_MPEG2_file(CommandOptions& Options)
 
       if ( Options.verbose_flag )
 	{
-	  fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
 	  MPEG2::VideoDescriptorDump(VDesc);
 	}
     }
@@ -579,7 +711,7 @@ read_MPEG2_file(CommandOptions& Options)
 	  if ( Info.UsesHMAC )
 	    {
 	      HMAC = new HMACContext;
-	      result = HMAC->InitKey(Options.key_value);
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
 	    }
 	  else
 	    {
@@ -630,7 +762,7 @@ gop_start_test(CommandOptions& Options)
 
       if ( Options.verbose_flag )
 	{
-	  fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
 	  MPEG2::VideoDescriptorDump(VDesc);
 	}
     }
@@ -651,49 +783,53 @@ gop_start_test(CommandOptions& Options)
 	  if ( FrameBuffer.FrameType() != FRAME_I )
 	    fprintf(stderr, "Expecting an I frame, got %c\n", FrameTypeChar(FrameBuffer.FrameType()));
 
-	  fprintf(stderr, "Requested frame %lu, got %lu\n", i, FrameBuffer.FrameNumber());
+	  fprintf(stderr, "Requested frame %u, got %u\n", i, FrameBuffer.FrameNumber());
 	}
     }
 
   return result;
 }
 
-#if 0
 //------------------------------------------------------------------------------------------
 // JPEG 2000 essence
 
-// Write one or more plaintext JPEG 2000 codestreams to a plaintext ASDCP file
-// Write one or more plaintext JPEG 2000 codestreams to a ciphertext ASDCP file
+// Write one or more plaintext JPEG 2000 stereoscopic codestream pairs to a plaintext ASDCP file
+// Write one or more plaintext JPEG 2000 stereoscopic codestream pairs to a ciphertext ASDCP file
 //
 Result_t
-write_JP2K_file(CommandOptions& Options)
+write_JP2K_S_file(CommandOptions& Options)
 {
   AESEncContext*          Context = 0;
   HMACContext*            HMAC = 0;
-  JP2K::MXFWriter         Writer;
+  JP2K::MXFSWriter        Writer;
   JP2K::FrameBuffer       FrameBuffer(Options.fb_size);
   JP2K::PictureDescriptor PDesc;
-  JP2K::SequenceParser    Parser;
+  JP2K::SequenceParser    ParserLeft, ParserRight;
+  byte_t                  IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG        RNG;
 
-#ifndef ASDCP_WITHOUT_OPENSSL
-  byte_t           IV_buf[CBC_BLOCK_SIZE];
-  FortunaRNG       RNG;
-#endif
+  if ( Options.file_count != 2 )
+    {
+      fprintf(stderr, "Two inputs are required for stereoscopic option.\n");
+      return RESULT_FAIL;
+    }
 
   // set up essence parser
-  Result_t result = Parser.OpenRead(Options.filenames[0]);
+  Result_t result = ParserLeft.OpenRead(Options.filenames[0], Options.j2c_pedantic);
+
+  if ( ASDCP_SUCCESS(result) )
+    result = ParserRight.OpenRead(Options.filenames[1], Options.j2c_pedantic);
 
   // set up MXF writer
   if ( ASDCP_SUCCESS(result) )
     {
-      Parser.FillPictureDescriptor(PDesc);
+      ParserLeft.FillPictureDescriptor(PDesc);
       PDesc.EditRate = Options.PictureRate();
 
       if ( Options.verbose_flag )
 	{
-	  fprintf(stderr, "JPEG 2000 pictures\n");
-	  fputs("PictureDescriptor:\n", stderr);
-          fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+	  fputs("JPEG 2000 stereoscopic pictures\nPictureDescriptor:\n", stderr);
+          fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
 	  JP2K::PictureDescriptorDump(PDesc);
 	}
     }
@@ -701,19 +837,27 @@ write_JP2K_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
-      GenRandomUUID(RNG, Info.AssetUUID);
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
 
       // configure encryption
       if( Options.key_flag )
 	{
-	  GenRandomUUID(RNG, Info.ContextID);
+	  Kumu::GenRandomUUID(Info.ContextID);
 	  Info.EncryptedEssence = true;
 
 	  if ( Options.key_id_flag )
-	    memcpy(Info.CryptographicKeyID, Options.key_id_value, KeyIDlen);
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
 	  else
-	    RNG.FillRandom(Info.CryptographicKeyID, KeyIDlen);
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
 
 	  Context = new AESEncContext;
 	  result = Context->InitKey(Options.key_value);
@@ -725,10 +869,9 @@ write_JP2K_file(CommandOptions& Options)
 	    {
 	      Info.UsesHMAC = true;
 	      HMAC = new HMACContext;
-	      result = HMAC->InitKey(Options.key_value);
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
 	    }
 	}
-#endif // ASDCP_WITHOUT_OPENSSL
 
       if ( ASDCP_SUCCESS(result) )
 	result = Writer.OpenWrite(Options.out_file, Info, PDesc);
@@ -737,36 +880,39 @@ write_JP2K_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) )
     {
       ui32_t duration = 0;
-      result = Parser.Reset();
+      result = ParserLeft.Reset();
+      if ( ASDCP_SUCCESS(result) ) result = ParserRight.Reset();
 
       while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
 	{
-	  if ( ! Options.do_repeat || duration == 1 )
-	    {
-	      result = Parser.ReadFrame(FrameBuffer);
+	  result = ParserLeft.ReadFrame(FrameBuffer);
 
-	      if ( ASDCP_SUCCESS(result) )
-		{
-		  if ( Options.verbose_flag )
-		    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
 		  
-		  if ( Options.encrypt_header_flag )
-		    FrameBuffer.PlaintextOffset(0);
-		}
+	      if ( Options.encrypt_header_flag )
+		FrameBuffer.PlaintextOffset(0);
 	    }
 
 	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    result = Writer.WriteFrame(FrameBuffer, JP2K::SP_LEFT, Context, HMAC);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = ParserRight.ReadFrame(FrameBuffer);
+
+	  if ( ASDCP_SUCCESS(result) )
 	    {
-	      result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
-	      // The Writer class will forward the last block of ciphertext
-	      // to the encryption context for use as the IV for the next
-	      // frame. If you want to use non-sequitur IV values, un-comment
-	      // the following  line of code.
-	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
-	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+		  
+	      if ( Options.encrypt_header_flag )
+		FrameBuffer.PlaintextOffset(0);
 	    }
+
+	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    result = Writer.WriteFrame(FrameBuffer, JP2K::SP_RIGHT, Context, HMAC);
 	}
 
       if ( result == RESULT_ENDOFFILE )
@@ -778,18 +924,16 @@ write_JP2K_file(CommandOptions& Options)
 
   return result;
 }
-#endif
 
-// Read one or more plaintext JPEG 2000 codestreams from a plaintext ASDCP file
-// Read one or more plaintext JPEG 2000 codestreams from a ciphertext ASDCP file
-// Read one or more ciphertext JPEG 2000 codestreams from a ciphertext ASDCP file
-//
+// Read one or more plaintext JPEG 2000 stereoscopic codestream pairs from a plaintext ASDCP file
+// Read one or more plaintext JPEG 2000 stereoscopic codestream pairs from a ciphertext ASDCP file
+// Read one or more ciphertext JPEG 2000 stereoscopic codestream pairs from a ciphertext ASDCP file
 Result_t
-read_JP2K_file(CommandOptions& Options)
+read_JP2K_S_file(CommandOptions& Options)
 {
   AESDecContext*     Context = 0;
   HMACContext*       HMAC = 0;
-  JP2K::MXFReader    Reader;
+  JP2K::MXFSReader    Reader;
   JP2K::FrameBuffer  FrameBuffer(Options.fb_size);
   ui32_t             frame_count = 0;
 
@@ -804,7 +948,7 @@ read_JP2K_file(CommandOptions& Options)
 
       if ( Options.verbose_flag )
 	{
-	  fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
 	  JP2K::PictureDescriptorDump(PDesc);
 	}
     }
@@ -822,7 +966,7 @@ read_JP2K_file(CommandOptions& Options)
 	  if ( Info.UsesHMAC )
 	    {
 	      HMAC = new HMACContext;
-	      result = HMAC->InitKey(Options.key_value);
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
 	    }
 	  else
 	    {
@@ -831,20 +975,25 @@ read_JP2K_file(CommandOptions& Options)
 	}
     }
 
+  const int filename_max = 1024;
+  char filename[filename_max];
   ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
   if ( last_frame > frame_count )
     last_frame = frame_count;
 
+  char left_format[64];  char right_format[64];
+  snprintf(left_format,  64, "%%s%%0%duL.j2c", Options.number_width);
+  snprintf(right_format, 64, "%%s%%0%duR.j2c", Options.number_width);
+
   for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
     {
-      result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+      result = Reader.ReadFrame(i, JP2K::SP_LEFT, FrameBuffer, Context, HMAC);
 
       if ( ASDCP_SUCCESS(result) )
 	{
-	  FileWriter OutFile;
-	  char filename[256];
+	  Kumu::FileWriter OutFile;
 	  ui32_t write_count;
-	  snprintf(filename, 256, "%s%06lu.j2c", Options.file_root, i);
+	  snprintf(filename, filename_max, left_format, Options.file_root, i);
 	  result = OutFile.OpenWrite(filename);
 
 	  if ( ASDCP_SUCCESS(result) )
@@ -853,72 +1002,84 @@ read_JP2K_file(CommandOptions& Options)
 	  if ( Options.verbose_flag )
 	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
 	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Reader.ReadFrame(i, JP2K::SP_RIGHT, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter OutFile;
+	  ui32_t write_count;
+	  snprintf(filename, filename_max, right_format, Options.file_root, i);
+	  result = OutFile.OpenWrite(filename);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+	}
     }
 
   return result;
 }
 
-#if 0
-//------------------------------------------------------------------------------------------
-// PCM essence
 
 
-// Write one or more plaintext PCM audio streams to a plaintext ASDCP file
-// Write one or more plaintext PCM audio streams to a ciphertext ASDCP file
+// Write one or more plaintext JPEG 2000 codestreams to a plaintext ASDCP file
+// Write one or more plaintext JPEG 2000 codestreams to a ciphertext ASDCP file
 //
 Result_t
-write_PCM_file(CommandOptions& Options)
+write_JP2K_file(CommandOptions& Options)
 {
-  AESEncContext*   Context = 0;
-  HMACContext*     HMAC = 0;
-  PCMParserList    Parser;
-  PCM::MXFWriter   Writer;
-  PCM::FrameBuffer FrameBuffer;
-  PCM::AudioDescriptor ADesc;
-  Rational         PictureRate = Options.PictureRate();
-
-#ifndef ASDCP_WITHOUT_OPENSSL
-  byte_t           IV_buf[CBC_BLOCK_SIZE];
-  FortunaRNG       RNG;
-#endif
+  AESEncContext*          Context = 0;
+  HMACContext*            HMAC = 0;
+  JP2K::MXFWriter         Writer;
+  JP2K::FrameBuffer       FrameBuffer(Options.fb_size);
+  JP2K::PictureDescriptor PDesc;
+  JP2K::SequenceParser    Parser;
+  byte_t                  IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG        RNG;
 
   // set up essence parser
-  Result_t result = Parser.OpenRead(Options.file_count, Options.filenames, PictureRate);
+  Result_t result = Parser.OpenRead(Options.filenames[0], Options.j2c_pedantic);
 
   // set up MXF writer
   if ( ASDCP_SUCCESS(result) )
     {
-      Parser.FillAudioDescriptor(ADesc);
-
-      ADesc.SampleRate = PictureRate;
-      FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
+      Parser.FillPictureDescriptor(PDesc);
+      PDesc.EditRate = Options.PictureRate();
 
       if ( Options.verbose_flag )
 	{
-	  fprintf(stderr, "48Khz PCM Audio, %s fps (%lu spf)\n",
-		  Options.szPictureRate(),
-		  PCM::CalcSamplesPerFrame(ADesc));
-	  fputs("AudioDescriptor:\n", stderr);
-	  PCM::AudioDescriptorDump(ADesc);
+	  fprintf(stderr, "JPEG 2000 pictures\n");
+	  fputs("PictureDescriptor:\n", stderr);
+          fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  JP2K::PictureDescriptorDump(PDesc);
 	}
     }
 
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
-      GenRandomUUID(RNG, Info.AssetUUID);
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
 
       // configure encryption
       if( Options.key_flag )
 	{
-	  GenRandomUUID(RNG, Info.ContextID);
+	  Kumu::GenRandomUUID(Info.ContextID);
 	  Info.EncryptedEssence = true;
 
 	  if ( Options.key_id_flag )
-	    memcpy(Info.CryptographicKeyID, Options.key_id_value, KeyIDlen);
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
 	  else
-	    RNG.FillRandom(Info.CryptographicKeyID, KeyIDlen);
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
 
 	  Context = new AESEncContext;
 	  result = Context->InitKey(Options.key_value);
@@ -930,49 +1091,262 @@ write_PCM_file(CommandOptions& Options)
 	    {
 	      Info.UsesHMAC = true;
 	      HMAC = new HMACContext;
-	      result = HMAC->InitKey(Options.key_value);
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
 	    }
 	}
-#endif // ASDCP_WITHOUT_OPENSSL
 
       if ( ASDCP_SUCCESS(result) )
-	result = Writer.OpenWrite(Options.out_file, Info, ADesc);
+	result = Writer.OpenWrite(Options.out_file, Info, PDesc);
     }
 
   if ( ASDCP_SUCCESS(result) )
     {
-      result = Parser.Reset();
       ui32_t duration = 0;
+      result = Parser.Reset();
 
       while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
 	{
-	  result = Parser.ReadFrame(FrameBuffer);
-
-	  if ( ASDCP_SUCCESS(result) )
+	  if ( ! Options.do_repeat || duration == 1 )
 	    {
-	      if ( FrameBuffer.Size() != FrameBuffer.Capacity() )
+	      result = Parser.ReadFrame(FrameBuffer);
+
+	      if ( ASDCP_SUCCESS(result) )
 		{
-		  fprintf(stderr, "WARNING: Last frame read was short, PCM input is possibly not frame aligned.\n");
-		  fprintf(stderr, "Expecting %lu bytes, got %lu.\n", FrameBuffer.Capacity(), FrameBuffer.Size());
-		  result = RESULT_ENDOFFILE;
-		  continue;
+		  if ( Options.verbose_flag )
+		    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+		  
+		  if ( Options.encrypt_header_flag )
+		    FrameBuffer.PlaintextOffset(0);
 		}
+	    }
 
-	      if ( Options.verbose_flag )
-		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+	  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+	    {
+	      result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
 
-	      if ( ! Options.no_write_flag )
-		{
-		  result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
+	      // The Writer class will forward the last block of ciphertext
+	      // to the encryption context for use as the IV for the next
+	      // frame. If you want to use non-sequitur IV values, un-comment
+	      // the following  line of code.
+	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+	    }
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+// Read one or more plaintext JPEG 2000 codestreams from a plaintext ASDCP file
+// Read one or more plaintext JPEG 2000 codestreams from a ciphertext ASDCP file
+// Read one or more ciphertext JPEG 2000 codestreams from a ciphertext ASDCP file
+//
+Result_t
+read_JP2K_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  JP2K::MXFReader    Reader;
+  JP2K::FrameBuffer  FrameBuffer(Options.fb_size);
+  ui32_t             frame_count = 0;
+
+  Result_t result = Reader.OpenRead(Options.filenames[0]);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      JP2K::PictureDescriptor PDesc;
+      Reader.FillPictureDescriptor(PDesc);
+
+      frame_count = PDesc.ContainerDuration;
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	  JP2K::PictureDescriptorDump(PDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
+  if ( last_frame > frame_count )
+    last_frame = frame_count;
+
+  char name_format[64];
+  snprintf(name_format,  64, "%%s%%0%du.j2c", Options.number_width);
+
+  for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+    {
+      result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter OutFile;
+	  char filename[256];
+	  ui32_t write_count;
+	  snprintf(filename, 256, name_format, Options.file_root, i);
+	  result = OutFile.OpenWrite(filename);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+	}
+    }
+
+  return result;
+}
+
+//------------------------------------------------------------------------------------------
+// PCM essence
+
+
+// Write one or more plaintext PCM audio streams to a plaintext ASDCP file
+// Write one or more plaintext PCM audio streams to a ciphertext ASDCP file
+//
+Result_t
+write_PCM_file(CommandOptions& Options)
+{
+  AESEncContext*    Context = 0;
+  HMACContext*      HMAC = 0;
+  PCMParserList     Parser;
+  PCM::MXFWriter    Writer;
+  PCM::FrameBuffer  FrameBuffer;
+  PCM::AudioDescriptor ADesc;
+  Rational          PictureRate = Options.PictureRate();
+  byte_t            IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG  RNG;
+
+  // set up essence parser
+  Result_t result = Parser.OpenRead(Options.file_count, Options.filenames, PictureRate);
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Parser.FillAudioDescriptor(ADesc);
+
+      ADesc.EditRate = PictureRate;
+      FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
+      ADesc.ChannelFormat = Options.channel_fmt;
+
+      if ( Options.use_smpte_labels && ADesc.ChannelFormat == PCM::CF_NONE)
+	{
+	  fprintf(stderr, "ATTENTION! Writing SMPTE audio without ChannelAssignment property (see option -l)\n");
+	}
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "%.1fkHz PCM Audio, %s fps (%u spf)\n",
+		  ADesc.AudioSamplingRate.Quotient() / 1000.0,
+		  Options.szPictureRate(),
+		  PCM::CalcSamplesPerFrame(ADesc));
+	  fputs("AudioDescriptor:\n", stderr);
+	  PCM::AudioDescriptorDump(ADesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file, Info, ADesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      result = Parser.Reset();
+      ui32_t duration = 0;
+
+      while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
+	{
+	  result = Parser.ReadFrame(FrameBuffer);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( FrameBuffer.Size() != FrameBuffer.Capacity() )
+		{
+		  fprintf(stderr, "WARNING: Last frame read was short, PCM input is possibly not frame aligned.\n");
+		  fprintf(stderr, "Expecting %u bytes, got %u.\n", FrameBuffer.Capacity(), FrameBuffer.Size());
+		  result = RESULT_ENDOFFILE;
+		  continue;
+		}
+
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	      if ( ! Options.no_write_flag )
+		{
+		  result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
 
-#ifndef ASDCP_WITHOUT_OPENSSL
 		  // The Writer class will forward the last block of ciphertext
 		  // to the encryption context for use as the IV for the next
 		  // frame. If you want to use non-sequitur IV values, un-comment
 		  // the following  line of code.
 		  // if ( ASDCP_SUCCESS(result) && Options.key_flag )
 		  //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
 		}
 	    }
 	}
@@ -986,7 +1360,6 @@ write_PCM_file(CommandOptions& Options)
 
   return result;
 }
-#endif
 
 // Read one or more plaintext PCM audio streams from a plaintext ASDCP file
 // Read one or more plaintext PCM audio streams from a ciphertext ASDCP file
@@ -1009,10 +1382,14 @@ read_PCM_file(CommandOptions& Options)
     {
       Reader.FillAudioDescriptor(ADesc);
 
-      if ( ADesc.SampleRate != EditRate_23_98
-	   && ADesc.SampleRate != EditRate_24
-	   && ADesc.SampleRate != EditRate_48 )
-	ADesc.SampleRate = Options.PictureRate();
+      if ( ADesc.EditRate != EditRate_23_98
+	   && ADesc.EditRate != EditRate_24
+	   && ADesc.EditRate != EditRate_25
+	   && ADesc.EditRate != EditRate_30
+	   && ADesc.EditRate != EditRate_48
+	   && ADesc.EditRate != EditRate_50
+	   && ADesc.EditRate != EditRate_60 )
+	ADesc.EditRate = Options.PictureRate();
 
       FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
 
@@ -1035,11 +1412,13 @@ read_PCM_file(CommandOptions& Options)
 	      return RESULT_FAIL;
 	    }
 
-	  last_frame = xmin(Options.start_frame + last_frame, ADesc.ContainerDuration);
+	  last_frame = Kumu::xmin(Options.start_frame + last_frame, ADesc.ContainerDuration);
 	}
 
       ADesc.ContainerDuration = last_frame - Options.start_frame;
-      OutWave.OpenWrite(ADesc, Options.file_root, Options.split_wav);
+      OutWave.OpenWrite(ADesc, Options.file_root,
+			( Options.split_wav ? WavFileWriter::ST_STEREO : 
+			  ( Options.mono_wav ? WavFileWriter::ST_MONO : WavFileWriter::ST_NONE ) ));
     }
 
   if ( ASDCP_SUCCESS(result) && Options.key_flag )
@@ -1055,7 +1434,7 @@ read_PCM_file(CommandOptions& Options)
 	  if ( Info.UsesHMAC )
 	    {
 	      HMAC = new HMACContext;
-	      result = HMAC->InitKey(Options.key_value);
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
 	    }
 	  else
 	    {
@@ -1081,6 +1460,216 @@ read_PCM_file(CommandOptions& Options)
 }
 
 
+//------------------------------------------------------------------------------------------
+// TimedText essence
+
+
+// Write one or more plaintext timed text streams to a plaintext ASDCP file
+// Write one or more plaintext timed text streams to a ciphertext ASDCP file
+//
+Result_t
+write_timed_text_file(CommandOptions& Options)
+{
+  AESEncContext*    Context = 0;
+  HMACContext*      HMAC = 0;
+  TimedText::DCSubtitleParser  Parser;
+  TimedText::MXFWriter    Writer;
+  TimedText::FrameBuffer  FrameBuffer;
+  TimedText::TimedTextDescriptor TDesc;
+  byte_t            IV_buf[CBC_BLOCK_SIZE];
+  Kumu::FortunaRNG  RNG;
+
+  // set up essence parser
+  Result_t result = Parser.OpenRead(Options.filenames[0]);
+
+  // set up MXF writer
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Parser.FillTimedTextDescriptor(TDesc);
+      FrameBuffer.Capacity(Options.fb_size);
+
+      if ( Options.verbose_flag )
+	{
+	  fputs("D-Cinema Timed-Text Descriptor:\n", stderr);
+	  TimedText::DescriptorDump(TDesc);
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    {
+      WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
+      if ( Options.asset_id_flag )
+	memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+      else
+	Kumu::GenRandomUUID(Info.AssetUUID);
+
+      if ( Options.use_smpte_labels )
+	{
+	  Info.LabelSetType = LS_MXF_SMPTE;
+	  fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+	}
+
+      // configure encryption
+      if( Options.key_flag )
+	{
+	  Kumu::GenRandomUUID(Info.ContextID);
+	  Info.EncryptedEssence = true;
+
+	  if ( Options.key_id_flag )
+	    memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+	  else
+	    RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+	  Context = new AESEncContext;
+	  result = Context->InitKey(Options.key_value);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+	  if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+	    {
+	      Info.UsesHMAC = true;
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.OpenWrite(Options.out_file, Info, TDesc);
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    return result;
+
+  std::string XMLDoc;
+  TimedText::ResourceList_t::const_iterator ri;
+
+  result = Parser.ReadTimedTextResource(XMLDoc);
+
+  if ( ASDCP_SUCCESS(result) )
+    result = Writer.WriteTimedTextResource(XMLDoc, Context, HMAC);
+
+  for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
+    {
+      result = Parser.ReadAncillaryResource((*ri).ResourceID, FrameBuffer);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  if ( Options.verbose_flag )
+	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	  if ( ! Options.no_write_flag )
+	    {
+	      result = Writer.WriteAncillaryResource(FrameBuffer, Context, HMAC);
+	      
+	      // The Writer class will forward the last block of ciphertext
+	      // to the encryption context for use as the IV for the next
+	      // frame. If you want to use non-sequitur IV values, un-comment
+	      // the following  line of code.
+	      // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+	      //   Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+	    }
+	}
+
+      if ( result == RESULT_ENDOFFILE )
+	result = RESULT_OK;
+    }
+
+  if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+    result = Writer.Finalize();
+
+  return result;
+}
+
+
+// Read one or more timed text streams from a plaintext ASDCP file
+// Read one or more timed text streams from a ciphertext ASDCP file
+// Read one or more timed text streams from a ciphertext ASDCP file
+//
+Result_t
+read_timed_text_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  TimedText::MXFReader     Reader;
+  TimedText::FrameBuffer   FrameBuffer;
+  TimedText::TimedTextDescriptor TDesc;
+
+  Result_t result = Reader.OpenRead(Options.filenames[0]);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Reader.FillTimedTextDescriptor(TDesc);
+      FrameBuffer.Capacity(Options.fb_size);
+
+      if ( Options.verbose_flag )
+	TimedText::DescriptorDump(TDesc);
+    }
+
+  if ( ASDCP_SUCCESS(result) && Options.key_flag )
+    {
+      Context = new AESDecContext;
+      result = Context->InitKey(Options.key_value);
+
+      if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+	{
+	  WriterInfo Info;
+	  Reader.FillWriterInfo(Info);
+
+	  if ( Info.UsesHMAC )
+	    {
+	      HMAC = new HMACContext;
+	      result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+	    }
+	  else
+	    {
+	      fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+	    }
+	}
+    }
+
+  if ( ASDCP_FAILURE(result) )
+    return result;
+
+  std::string XMLDoc;
+  std::string out_path = Kumu::PathDirname(Options.file_root);
+  ui32_t write_count;
+  char buf[64];
+  TimedText::ResourceList_t::const_iterator ri;
+
+  result = Reader.ReadTimedTextResource(XMLDoc, Context, HMAC);
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      Kumu::FileWriter Writer;
+      result = Writer.OpenWrite(Options.file_root);
+
+      if ( ASDCP_SUCCESS(result) )
+	result = Writer.Write(reinterpret_cast<const byte_t*>(XMLDoc.c_str()), XMLDoc.size(), &write_count);
+    }
+
+  for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
+    {
+      result = Reader.ReadAncillaryResource(ri->ResourceID, FrameBuffer, Context, HMAC);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  Kumu::FileWriter Writer;
+	  result = Writer.OpenWrite(Kumu::PathJoin(out_path, Kumu::UUID(ri->ResourceID).EncodeHex(buf, 64)).c_str());
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	      result = Writer.Write(FrameBuffer.RoData(), FrameBuffer.Size(), &write_count);
+	    }
+	}
+    }
+
+  return result;
+}
+
 //------------------------------------------------------------------------------------------
 //
 
@@ -1113,6 +1702,18 @@ class MyPictureDescriptor : public JP2K::PictureDescriptor
   }
 };
 
+class MyStereoPictureDescriptor : public JP2K::PictureDescriptor
+{
+ public:
+  void FillDescriptor(JP2K::MXFSReader& Reader) {
+    Reader.FillPictureDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    JP2K::PictureDescriptorDump(*this, stream);
+  }
+};
+
 class MyAudioDescriptor : public PCM::AudioDescriptor
 {
  public:
@@ -1125,24 +1726,41 @@ class MyAudioDescriptor : public PCM::AudioDescriptor
   }
 };
 
+class MyTextDescriptor : public TimedText::TimedTextDescriptor
+{
+ public:
+  void FillDescriptor(TimedText::MXFReader& Reader) {
+    Reader.FillTimedTextDescriptor(*this);
+  }
+
+  void Dump(FILE* stream) {
+    TimedText::DescriptorDump(*this, stream);
+  }
+};
 
 // MSVC didn't like the function template, so now it's a static class method
 template<class ReaderT, class DescriptorT>
 class FileInfoWrapper
 {
 public:
-  static void file_info(CommandOptions& Options, FILE* stream = 0)
+  static Result_t
+  file_info(CommandOptions& Options, const char* type_string, FILE* stream = 0)
   {
+    assert(type_string);
     if ( stream == 0 )
       stream = stdout;
 
+    Result_t result = RESULT_OK;
+
     if ( Options.verbose_flag || Options.showheader_flag )
       {
 	ReaderT     Reader;
-	Result_t result = Reader.OpenRead(Options.filenames[0]);
+	result = Reader.OpenRead(Options.filenames[0]);
 
 	if ( ASDCP_SUCCESS(result) )
 	  {
+	    fprintf(stdout, "File essence type is %s.\n", type_string);
+
 	    if ( Options.showheader_flag )
 	      Reader.DumpHeaderMetadata(stream);
 
@@ -1162,6 +1780,8 @@ public:
 	    Reader.DumpHeaderMetadata(stream);
 	  }
       }
+
+    return result;
   }
 };
 
@@ -1178,24 +1798,59 @@ show_file_info(CommandOptions& Options)
 
   if ( EssenceType == ESS_MPEG2_VES )
     {
-      fputs("File essence type is MPEG2 video.\n", stdout);
-      FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options);
+      result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
     }
-  else if ( EssenceType == ESS_PCM_24b_48k )
+  else if ( EssenceType == ESS_PCM_24b_48k || EssenceType == ESS_PCM_24b_96k )
     {
-      fputs("File essence type is PCM audio.\n", stdout);
-      FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options);
+      result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  const Dictionary* Dict = &DefaultCompositeDict();
+	  PCM::MXFReader Reader;
+	  MXF::OP1aHeader Header(Dict);
+	  MXF::WaveAudioDescriptor *descriptor = 0;
+
+	  result = Reader.OpenRead(Options.filenames[0]);
+
+	  if ( ASDCP_SUCCESS(result) )
+	    result = Reader.OP1aHeader().GetMDObjectByType(Dict->ul(MDD_WaveAudioDescriptor), reinterpret_cast<MXF::InterchangeObject**>(&descriptor));
+
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      char buf[64];
+	      fprintf(stdout, " ChannelAssignment: %s\n", descriptor->ChannelAssignment.const_get().EncodeString(buf, 64));
+	    }
+	}
     }
   else if ( EssenceType == ESS_JPEG_2000 )
     {
-      fputs("File essence type is JPEG 2000 pictures.\n", stdout);
-      FileInfoWrapper<ASDCP::JP2K::MXFReader, MyPictureDescriptor>::file_info(Options);
+      if ( Options.stereo_image_flag )
+	{
+	  result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+				   MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+	}
+      else
+	{
+	  result = FileInfoWrapper<ASDCP::JP2K::MXFReader,
+				   MyPictureDescriptor>::file_info(Options, "JPEG 2000 pictures");
+	}
+    }
+  else if ( EssenceType == ESS_JPEG_2000_S )
+    {
+      result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+			       MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+    }
+  else if ( EssenceType == ESS_TIMED_TEXT )
+    {
+      result = FileInfoWrapper<ASDCP::TimedText::MXFReader, MyTextDescriptor>::file_info(Options, "Timed Text");
     }
   else
     {
       fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames[0]);
-      FileReader   Reader;
-      MXF::OPAtomHeader TestHeader;
+      Kumu::FileReader   Reader;
+      const Dictionary* Dict = &DefaultCompositeDict();
+      MXF::OP1aHeader TestHeader(Dict);
 
       result = Reader.OpenRead(Options.filenames[0]);
 
@@ -1204,15 +1859,15 @@ show_file_info(CommandOptions& Options)
 
       if ( ASDCP_SUCCESS(result) )
 	{
-	  TestHeader.Partition::Dump();
+	  TestHeader.Partition::Dump(stdout);
 
 	  if ( MXF::Identification* ID = TestHeader.GetIdentification() )
-	    ID->Dump();
+	    ID->Dump(stdout);
 	  else
 	    fputs("File contains no Identification object.\n", stdout);
 
 	  if ( MXF::SourcePackage* SP = TestHeader.GetSourcePackage() )
-	    SP->Dump();
+	    SP->Dump(stdout);
 	  else
 	    fputs("File contains no SourcePackage object.\n", stdout);
 	}
@@ -1226,61 +1881,116 @@ show_file_info(CommandOptions& Options)
 }
 
 
+//
+Result_t
+digest_file(const char* filename)
+{
+  using namespace Kumu;
+
+  ASDCP_TEST_NULL_STR(filename);
+  FileReader Reader;
+  SHA_CTX Ctx;
+  SHA1_Init(&Ctx);
+  ByteString Buf(8192);
+
+  Result_t result = Reader.OpenRead(filename);
+
+  while ( ASDCP_SUCCESS(result) )
+    {
+      ui32_t read_count = 0;
+      result = Reader.Read(Buf.Data(), Buf.Capacity(), &read_count);
+
+      if ( result == RESULT_ENDOFFILE )
+	{
+	  result = RESULT_OK;
+	  break;
+	}
+
+      if ( ASDCP_SUCCESS(result) )
+	SHA1_Update(&Ctx, Buf.Data(), read_count);
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      const ui32_t sha_len = 20;
+      byte_t bin_buf[sha_len];
+      char sha_buf[64];
+      SHA1_Final(bin_buf, &Ctx);
+
+      fprintf(stdout, "%s %s\n", base64encode(bin_buf, sha_len, sha_buf, 64), filename);
+    }
+
+  return result;
+}
+
 //
 int
 main(int argc, const char** argv)
 {
   Result_t result = RESULT_OK;
+  char     str_buf[64];
   CommandOptions Options(argc, argv);
 
+  if ( Options.version_flag )
+    banner();
+
   if ( Options.help_flag )
-    {
-      usage();
-      return 0;
-    }
+    usage();
 
-  if ( Options.error_flag )
-    return 3;
+  if ( Options.version_flag || Options.help_flag )
+    return 0;
 
-  if ( Options.version_flag )
-    banner();
+  if ( Options.error_flag )
+    {
+      fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
+      return 3;
+    }
 
-  if ( Options.info_flag )
+  if ( Options.mode == MMT_INFO )
     {
       result = show_file_info(Options);
+
+      for ( int i = 1; ASDCP_SUCCESS(result) && i < Options.file_count; ++i )
+	{
+	  Options.filenames[0] = Options.filenames[i]; // oh-so hackish
+	  result = show_file_info(Options);
+	}
     }
-  else if ( Options.gop_start_flag )
+  else if ( Options.mode == MMT_GOP_START )
     {
       result = gop_start_test(Options);
     }
-#ifndef ASDCP_WITHOUT_OPENSSL
-  else if ( Options.genkey_flag )
+  else if ( Options.mode == MMT_GEN_KEY )
     {
-      FortunaRNG RNG;
+      Kumu::FortunaRNG RNG;
       byte_t bin_buf[KeyLen];
-      char   str_buf[40];
 
       RNG.FillRandom(bin_buf, KeyLen);
-      printf("%s\n", bin2hex(bin_buf, KeyLen, str_buf, 40));
+      printf("%s\n", Kumu::bin2hex(bin_buf, KeyLen, str_buf, 64));
     }
-  else if ( Options.genid_flag )
+  else if ( Options.mode == MMT_GEN_ID )
     {
-      FortunaRNG RNG;
-      byte_t bin_buf[KeyLen];
-      char   str_buf[40];
-
-      GenRandomUUID(RNG, bin_buf);
-      bin2hex(bin_buf, KeyLen, str_buf, 40);
-      printf("%s\n", hyphenate_UUID(str_buf, 40));
+      UUID TmpID;
+      Kumu::GenRandomValue(TmpID);
+      printf("%s\n", TmpID.EncodeHex(str_buf, 64));
+    }
+  else if ( Options.mode == MMT_DIGEST )
+    {
+      for ( ui32_t i = 0; i < Options.file_count && ASDCP_SUCCESS(result); i++ )
+	result = digest_file(Options.filenames[i]);
     }
-#endif // ASDCP_WITHOUT_OPENSSL
-  else if ( Options.extract_flag )
+  else if ( Options.mode == MMT_UL_LIST )
+    {
+      if ( Options.use_smpte_labels )
+	DefaultSMPTEDict().Dump(stdout);
+      else
+	DefaultInteropDict().Dump(stdout);
+    }
+  else if ( Options.mode == MMT_EXTRACT )
     {
       EssenceType_t EssenceType;
       result = ASDCP::EssenceType(Options.filenames[0], EssenceType);
-#ifdef SMPTE_LABELS
-      fprintf(stderr, "ATTENTION! Expecting SMPTE Universal Labels\n");
-#endif
+
       if ( ASDCP_SUCCESS(result) )
 	{
 	  switch ( EssenceType )
@@ -1290,24 +2000,33 @@ main(int argc, const char** argv)
 	      break;
 
 	    case ESS_JPEG_2000:
-	      result = read_JP2K_file(Options);
+	      if ( Options.stereo_image_flag )
+		result = read_JP2K_S_file(Options);
+	      else
+		result = read_JP2K_file(Options);
+	      break;
+
+	    case ESS_JPEG_2000_S:
+	      result = read_JP2K_S_file(Options);
 	      break;
 
 	    case ESS_PCM_24b_48k:
+	    case ESS_PCM_24b_96k:
 	      result = read_PCM_file(Options);
 	      break;
 
+	    case ESS_TIMED_TEXT:
+	      result = read_timed_text_file(Options);
+	      break;
+
 	    default:
 	      fprintf(stderr, "%s: Unknown file type, not ASDCP essence.\n", Options.filenames[0]);
 	      return 5;
 	    }
 	}
     }
-  else if ( Options.create_flag )
+  else if ( Options.mode == MMT_CREATE )
     {
-      fprintf(stderr, "ATTENTION! This version of asdcplib does not support writing MXF files.\n");
-
-#if 0
       if ( Options.do_repeat && ! Options.duration_flag )
 	{
 	  fputs("Option -R requires -d <duration>\n", stderr);
@@ -1316,9 +2035,7 @@ main(int argc, const char** argv)
 
       EssenceType_t EssenceType;
       result = ASDCP::RawEssenceType(Options.filenames[0], EssenceType);
-#ifdef SMPTE_LABELS
-      fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
-#endif
+
       if ( ASDCP_SUCCESS(result) )
 	{
 	  switch ( EssenceType )
@@ -1328,29 +2045,47 @@ main(int argc, const char** argv)
 	      break;
 
 	    case ESS_JPEG_2000:
-	      result = write_JP2K_file(Options);
+	      if ( Options.stereo_image_flag )
+		result = write_JP2K_S_file(Options);
+
+	      else
+		result = write_JP2K_file(Options);
+
 	      break;
 
 	    case ESS_PCM_24b_48k:
+	    case ESS_PCM_24b_96k:
 	      result = write_PCM_file(Options);
 	      break;
 
+	    case ESS_TIMED_TEXT:
+	      result = write_timed_text_file(Options);
+	      break;
+
 	    default:
 	      fprintf(stderr, "%s: Unknown file type, not ASDCP-compatible essence.\n",
 		      Options.filenames[0]);
 	      return 5;
 	    }
 	}
-#endif
+    }
+  else
+    {
+      fprintf(stderr, "Unhandled mode: %d.\n", Options.mode);
+      return 6;
     }
 
-  if ( result != RESULT_OK )
+  if ( ASDCP_FAILURE(result) )
     {
       fputs("Program stopped on error.\n", stderr);
 
-      if ( result != RESULT_FAIL )
+      if ( result == RESULT_SFORMAT )
+	{
+	  fputs("Use option '-3' to force stereoscopic mode.\n", stderr);
+	}
+      else if ( result != RESULT_FAIL )
 	{
-	  fputs(GetResultString(result), stderr);
+	  fputs(result, stderr);
 	  fputc('\n', stderr);
 	}