o Cleared up MXFGCP1FrameWrappedPictureElement / MXFGCP1FrameWrappedPictureElement

   ambiguity. PHDR continues to use MXFGCP1FrameWrappedPictureElement.
   MXFGCI1FrameWrappedPictureElement is supported for interlace.
 o Added prototype PIDM dynamic metadata wrapping, config with --enable-phdr

1 files changed, 117 insertions, 2 deletions

diff --git a/src/phdr-unwrap.cpp b/src/phdr-unwrap.cpp
index c6669e9..cb0e177 100755
--- a/src/phdr-unwrap.cpp
+++ b/src/phdr-unwrap.cpp
@@ -84,7 +84,9 @@ Options:\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\
+  -e <extension>    - Extension to use for aux data files. default \"bin\"\n\
   -f <start-frame>  - Starting frame number, default 0\n\
+  -g <filename>     - Extract global metadata to the named file.\n\
   -h | -help        - Show help\n\
   -k <key-string>   - Use key for ciphertext operations\n\
   -m                - verify HMAC values when reading\n\
@@ -123,7 +125,8 @@ public:
   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)
   const char* input_filename;
-  std::string prefix_buffer;
+  const char* extension;
+  std::string global_metadata_filename, prefix_buffer;
 
   //
   CommandOptions(int argc, const char** argv) :
@@ -132,7 +135,7 @@ public:
     version_flag(false), help_flag(false), number_width(6),
     start_frame(0), duration(0xffffffff), duration_flag(false),
     fb_size(FRAME_BUFFER_SIZE), file_prefix(0),
-    input_filename(0)
+    input_filename(0), extension("bin")
   {
     memset(key_value, 0, KeyLen);
     memset(key_id_value, 0, UUIDlen);
@@ -172,6 +175,11 @@ public:
 		start_frame = Kumu::xabs(strtol(argv[i], 0, 10));
 		break;
 
+	      case 'g':
+		TEST_EXTRA_ARG(i, 'g');
+		global_metadata_filename = argv[i];
+		break;
+
 	      case 'h': help_flag = true; break;
 	      case 'm': read_hmac = true; break;
 
@@ -381,6 +389,109 @@ read_JP2K_file(CommandOptions& Options)
   return result;
 }
 
+
+// Read one or more plaintext DCData bytestreams from a plaintext ASDCP file
+// Read one or more plaintext DCData bytestreams from a ciphertext ASDCP file
+// Read one or more ciphertext DCData byestreams from a ciphertext ASDCP file
+//
+Result_t
+read_aux_data_file(CommandOptions& Options)
+{
+  AESDecContext*     Context = 0;
+  HMACContext*       HMAC = 0;
+  AS_02::PIDM::MXFReader Reader;
+  DCData::FrameBuffer FrameBuffer(Options.fb_size);
+  ui32_t             frame_count = 0;
+
+  ASDCP::FrameBuffer global_metadata;
+  Result_t result = Reader.OpenRead(Options.input_filename, global_metadata);
+
+  if ( ASDCP_SUCCESS(result)
+       && global_metadata.Size()
+       && ! Options.global_metadata_filename.empty() )
+    {
+      ui32_t write_count = 0;
+      Kumu::FileWriter Writer;
+
+      result = Writer.OpenWrite(Options.global_metadata_filename);
+
+      if ( ASDCP_SUCCESS(result) )
+	{
+	  result = Writer.Write(global_metadata.RoData(), global_metadata.Size(), &write_count);
+	}
+
+      if ( ASDCP_SUCCESS(result) && global_metadata.Size() != write_count) 
+	{
+	  return RESULT_WRITEFAIL;
+	}
+    }
+
+  if ( ASDCP_SUCCESS(result) )
+    {
+      frame_count = Reader.AS02IndexReader().GetDuration();
+
+      if ( Options.verbose_flag )
+	{
+	  fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+	}
+    }
+
+  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.%s", Options.number_width, Options.extension);
+
+  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) )
+	{
+	  if ( ! Options.no_write_flag )
+	    {
+	  Kumu::FileWriter OutFile;
+	  char filename[256];
+	  ui32_t write_count;
+	  snprintf(filename, 256, name_format, Options.file_prefix, 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;
+}
+
+
 //
 int
 main(int argc, const char** argv)
@@ -414,6 +525,10 @@ main(int argc, const char** argv)
 	  result = read_JP2K_file(Options);
 	  break;
 
+        case ESS_DCDATA_UNKNOWN:
+          result = read_aux_data_file(Options);
+          break;
+
 	default:
 	  fprintf(stderr, "%s: Unknown file type, not P-HDR essence.\n", Options.input_filename);
 	  return 5;