X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fasdcp-test.cpp;h=a35770a3e7bc1b76bcac3dd0805c248066d07668;hb=620722efa3a2df7857074e36abd751826a61d0e0;hp=daa8b4fdf973f88dc0760ac1ca2f481e94f3377b;hpb=8bf17481fbd360094c04d25023986b38e57205bc;p=asdcplib.git

diff --git a/src/asdcp-test.cpp b/src/asdcp-test.cpp
index daa8b4f..a35770a 100755
--- a/src/asdcp-test.cpp
+++ b/src/asdcp-test.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2003-2008, John Hurst
+Copyright (c) 2003-2012, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -103,7 +103,7 @@ banner(FILE* stream = stdout)
 {
   fprintf(stream, "\n\
 %s (asdcplib %s)\n\n\
-Copyright (c) 2003-2008 John Hurst\n\n\
+Copyright (c) 2003-2012 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",
@@ -115,10 +115,10 @@ void
 usage(FILE* stream = stdout)
 {
   fprintf(stream, "\
-USAGE: %s -c <output-file> [-3] [-b <buffer-size>] [-d <duration>] [-e|-E]\n\
-       [-f <start-frame>] [-j <key-id-string>] [-k <key-string>] [-L] [-M]\n\
-       [-p <frame-rate>] [-R] [-s <num>] [-v] [-W]\n\
-       <input-file> [<input-file-2> ...]\n\
+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\
@@ -132,8 +132,9 @@ USAGE: %s -c <output-file> [-3] [-b <buffer-size>] [-d <duration>] [-e|-E]\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] <input-file>\n\
-\n", PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
+       [-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\
@@ -166,13 +167,17 @@ Security Options:\n\
 
   fprintf(stream, "\
 Read/Write Options:\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|48], 24 is default\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\
@@ -180,6 +185,10 @@ Read/Write Options:\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, "\
@@ -195,7 +204,7 @@ Other Options:\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\n\
-           as 23000/1001 fps.\n\
+           as 24000/1001 fps.\n\
 \n");
 }
 
@@ -213,6 +222,32 @@ enum MajorMode_t
   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;
+
+  else if ( label_name == "MCA" )
+    return PCM::CF_CFG_6;
+
+  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;
+}
 
 //
 //
@@ -225,6 +260,7 @@ public:
   bool   error_flag;     // true if the given options are in error or not complete
   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
@@ -238,11 +274,13 @@ public:
   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[]
@@ -250,32 +288,60 @@ public:
   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[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;
     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";
     return "24";
   }
 
   //
   CommandOptions(int argc, const char** argv) :
-    mode(MMT_NONE), error_flag(true), key_flag(false), key_id_flag(false), encrypt_header_flag(true),
-    write_hmac(true), read_hmac(false), split_wav(false), mono_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), stereo_image_flag(false), start_frame(0),
-    duration(0xffffffff), duration_flag(false), do_repeat(false), use_smpte_labels(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, UUIDlen);
@@ -298,24 +364,30 @@ public:
 	      case '1': mono_wav = true; break;
 	      case '2': split_wav = true; break;
 	      case '3': stereo_image_flag = true; break;
-	      case 'i': mode = MMT_INFO;	break;
-	      case 'G': mode = MMT_GOP_START; 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': mode = MMT_GEN_KEY; break;
-	      case 'U':	mode = MMT_UL_LIST; break;
-	      case 'u':	mode = MMT_GEN_ID; 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 'L': use_smpte_labels = true; break;
+
+	      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 'b':
+		TEST_EXTRA_ARG(i, 'b');
+		fb_size = abs(atoi(argv[i]));
+
+		if ( verbose_flag )
+		  fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+
+		break;
 
 	      case 'c':
 		TEST_EXTRA_ARG(i, 'c');
@@ -323,26 +395,26 @@ public:
 		out_file = argv[i];
 		break;
 
-	      case 'x':
-		TEST_EXTRA_ARG(i, 'x');
-		mode = MMT_EXTRACT;
-		file_root = argv[i];
+	      case 'd':
+		TEST_EXTRA_ARG(i, 'd');
+		duration_flag = true;
+		duration = abs(atoi(argv[i]));
 		break;
 
-	      case 'k': key_flag = true;
-		TEST_EXTRA_ARG(i, 'k');
-		{
-		  ui32_t length;
-		  Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
+	      case 'E': encrypt_header_flag = false; break;
+	      case 'e': encrypt_header_flag = true; break;
 
-		  if ( length != KeyLen )
-		    {
-		      fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
-		      return;
-		    }
-		}
+	      case 'f':
+		TEST_EXTRA_ARG(i, 'f');
+		start_frame = abs(atoi(argv[i]));
 		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');
 		{
@@ -357,38 +429,64 @@ public:
 		}
 		break;
 
-	      case 'f':
-		TEST_EXTRA_ARG(i, 'f');
-		start_frame = abs(atoi(argv[i]));
+	      case 'k': key_flag = true;
+		TEST_EXTRA_ARG(i, 'k');
+		{
+		  ui32_t length;
+		  Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
+
+		  if ( length != KeyLen )
+		    {
+		      fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
+		      return;
+		    }
+		}
 		break;
 
-	      case 'd':
-		TEST_EXTRA_ARG(i, 'd');
-		duration_flag = true;
-		duration = abs(atoi(argv[i]));
+	      case 'l':
+		TEST_EXTRA_ARG(i, 'l');
+		channel_fmt = decode_channel_fmt(argv[i]);
 		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 = abs(atoi(argv[i]));
 		break;
 
+	      case 'R': do_repeat = true; break;
+	      case 'S': split_wav = true; break;
+
 	      case 's':
 		TEST_EXTRA_ARG(i, 's');
 		fb_dump_size = abs(atoi(argv[i]));
 		break;
 
 	      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;
 
-	      case 'b':
-		TEST_EXTRA_ARG(i, 'b');
-		fb_size = abs(atoi(argv[i]));
-
-		if ( verbose_flag )
-		  fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+	      case 'w':
+		TEST_EXTRA_ARG(i, 'w');
+		number_width = abs(atoi(argv[i]));
+		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: %s\n", argv[i]);
 		return;
@@ -476,7 +574,10 @@ write_MPEG2_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-      Kumu::GenRandomUUID(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 )
 	{
@@ -711,10 +812,10 @@ write_JP2K_S_file(CommandOptions& Options)
     }
 
   // set up essence parser
-  Result_t result = ParserLeft.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]);
+    result = ParserRight.OpenRead(Options.filenames[1], Options.j2c_pedantic);
 
   // set up MXF writer
   if ( ASDCP_SUCCESS(result) )
@@ -733,7 +834,10 @@ write_JP2K_S_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-      Kumu::GenRandomUUID(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 )
 	{
@@ -874,6 +978,10 @@ read_JP2K_S_file(CommandOptions& Options)
   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, JP2K::SP_LEFT, FrameBuffer, Context, HMAC);
@@ -882,7 +990,7 @@ read_JP2K_S_file(CommandOptions& Options)
 	{
 	  Kumu::FileWriter OutFile;
 	  ui32_t write_count;
-	  snprintf(filename, filename_max, "%s%06uL.j2c", Options.file_root, i);
+	  snprintf(filename, filename_max, left_format, Options.file_root, i);
 	  result = OutFile.OpenWrite(filename);
 
 	  if ( ASDCP_SUCCESS(result) )
@@ -899,7 +1007,7 @@ read_JP2K_S_file(CommandOptions& Options)
 	{
 	  Kumu::FileWriter OutFile;
 	  ui32_t write_count;
-	  snprintf(filename, filename_max, "%s%06uR.j2c", Options.file_root, i);
+	  snprintf(filename, filename_max, right_format, Options.file_root, i);
 	  result = OutFile.OpenWrite(filename);
 
 	  if ( ASDCP_SUCCESS(result) )
@@ -928,7 +1036,7 @@ write_JP2K_file(CommandOptions& Options)
   Kumu::FortunaRNG        RNG;
 
   // set up essence parser
-  Result_t result = Parser.OpenRead(Options.filenames[0]);
+  Result_t result = Parser.OpenRead(Options.filenames[0], Options.j2c_pedantic);
 
   // set up MXF writer
   if ( ASDCP_SUCCESS(result) )
@@ -948,7 +1056,10 @@ write_JP2K_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-      Kumu::GenRandomUUID(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 )
 	{
@@ -1084,6 +1195,9 @@ read_JP2K_file(CommandOptions& Options)
   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);
@@ -1093,7 +1207,7 @@ read_JP2K_file(CommandOptions& Options)
 	  Kumu::FileWriter OutFile;
 	  char filename[256];
 	  ui32_t write_count;
-	  snprintf(filename, 256, "%s%06u.j2c", Options.file_root, i);
+	  snprintf(filename, 256, name_format, Options.file_root, i);
 	  result = OutFile.OpenWrite(filename);
 
 	  if ( ASDCP_SUCCESS(result) )
@@ -1135,12 +1249,19 @@ write_PCM_file(CommandOptions& Options)
     {
       Parser.FillAudioDescriptor(ADesc);
 
-      ADesc.SampleRate = PictureRate;
+      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, "48Khz PCM Audio, %s fps (%u spf)\n",
+	  fprintf(stderr, "%.1fkHz PCM Audio, %s fps (%u spf)\n",
+		  ADesc.AudioSamplingRate.Quotient() / 1000.0,
 		  Options.szPictureRate(),
 		  PCM::CalcSamplesPerFrame(ADesc));
 	  fputs("AudioDescriptor:\n", stderr);
@@ -1151,7 +1272,10 @@ write_PCM_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-      Kumu::GenRandomUUID(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 )
 	{
@@ -1255,10 +1379,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));
 
@@ -1354,8 +1482,8 @@ write_timed_text_file(CommandOptions& Options)
   // set up MXF writer
   if ( ASDCP_SUCCESS(result) )
     {
-      Parser.FillDescriptor(TDesc);
-      FrameBuffer.Capacity(2*Kumu::Megabyte);
+      Parser.FillTimedTextDescriptor(TDesc);
+      FrameBuffer.Capacity(Options.fb_size);
 
       if ( Options.verbose_flag )
 	{
@@ -1367,7 +1495,10 @@ write_timed_text_file(CommandOptions& Options)
   if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
     {
       WriterInfo Info = s_MyInfo;  // fill in your favorite identifiers here
-      Kumu::GenRandomUUID(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 )
 	{
@@ -1465,8 +1596,8 @@ read_timed_text_file(CommandOptions& Options)
 
   if ( ASDCP_SUCCESS(result) )
     {
-      Reader.FillDescriptor(TDesc);
-      FrameBuffer.Capacity(2*Kumu::Megabyte);
+      Reader.FillTimedTextDescriptor(TDesc);
+      FrameBuffer.Capacity(Options.fb_size);
 
       if ( Options.verbose_flag )
 	TimedText::DescriptorDump(TDesc);
@@ -1498,23 +1629,38 @@ read_timed_text_file(CommandOptions& Options)
     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);
 
-  // do something with the XML here
-  fprintf(stderr, "XMLDoc size: %lu\n", XMLDoc.size());
+  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);
+      result = Reader.ReadAncillaryResource(ri->ResourceID, FrameBuffer, Context, HMAC);
 
       if ( ASDCP_SUCCESS(result) )
 	{
-	  //	  if ( Options.verbose_flag )
-	    FrameBuffer.Dump(stderr, Options.fb_dump_size);
+	  Kumu::FileWriter Writer;
+	  result = Writer.OpenWrite(Kumu::PathJoin(out_path, Kumu::UUID(ri->ResourceID).EncodeHex(buf, 64)).c_str());
 
-	  // do something with the resource data here
+	  if ( ASDCP_SUCCESS(result) )
+	    {
+	      if ( Options.verbose_flag )
+		FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+	      result = Writer.Write(FrameBuffer.RoData(), FrameBuffer.Size(), &write_count);
+	    }
 	}
     }
 
@@ -1581,7 +1727,7 @@ class MyTextDescriptor : public TimedText::TimedTextDescriptor
 {
  public:
   void FillDescriptor(TimedText::MXFReader& Reader) {
-    Reader.FillDescriptor(*this);
+    Reader.FillTimedTextDescriptor(*this);
   }
 
   void Dump(FILE* stream) {
@@ -1648,33 +1794,60 @@ show_file_info(CommandOptions& Options)
     return result;
 
   if ( EssenceType == ESS_MPEG2_VES )
-    result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
+    {
+      result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
+    }
+  else if ( EssenceType == ESS_PCM_24b_48k || EssenceType == ESS_PCM_24b_96k )
+    {
+      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;
 
-  else if ( EssenceType == ESS_PCM_24b_48k )
-    result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
+	  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 )
     {
       if ( Options.stereo_image_flag )
-	result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
-	MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
-
+	{
+	  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");
+	{
+	  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");
-
+    {
+      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");
-
+    {
+      result = FileInfoWrapper<ASDCP::TimedText::MXFReader, MyTextDescriptor>::file_info(Options, "Timed Text");
+    }
   else
     {
       fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames[0]);
       Kumu::FileReader   Reader;
-      MXF::OPAtomHeader TestHeader;
+      const Dictionary* Dict = &DefaultCompositeDict();
+      MXF::OP1aHeader TestHeader(Dict);
 
       result = Reader.OpenRead(Options.filenames[0]);
 
@@ -1683,15 +1856,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);
 	}
@@ -1773,6 +1946,12 @@ main(int argc, const char** argv)
   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.mode == MMT_GOP_START )
     {
@@ -1799,15 +1978,10 @@ main(int argc, const char** argv)
     }
   else if ( Options.mode == MMT_UL_LIST )
     {
-      MDD_t di = (MDD_t)0;
-
-      while ( di < MDD_Max )
-	{
-	  MDDEntry TmpType = Dict::Type(di);
-	  UL TmpUL(TmpType.ul);
-	  fprintf(stdout, "%s: %s\n", TmpUL.EncodeString(str_buf, 64), TmpType.name);
-	  di = (MDD_t)(di + 1);
-	}
+      if ( Options.use_smpte_labels )
+	DefaultSMPTEDict().Dump(stdout);
+      else
+	DefaultInteropDict().Dump(stdout);
     }
   else if ( Options.mode == MMT_EXTRACT )
     {
@@ -1834,6 +2008,7 @@ main(int argc, const char** argv)
 	      break;
 
 	    case ESS_PCM_24b_48k:
+	    case ESS_PCM_24b_96k:
 	      result = read_PCM_file(Options);
 	      break;
 
@@ -1876,6 +2051,7 @@ main(int argc, const char** argv)
 	      break;
 
 	    case ESS_PCM_24b_48k:
+	    case ESS_PCM_24b_96k:
 	      result = write_PCM_file(Options);
 	      break;