Copy asdcplib 2.5.11 into the tree.

1 files changed, 308 insertions, 310 deletions

diff --git a/asdcplib/src/AS_DCP_JP2K.cpp b/asdcplib/src/AS_DCP_JP2K.cpp
index 05166d68..58781d61 100755
--- a/asdcplib/src/AS_DCP_JP2K.cpp
+++ b/asdcplib/src/AS_DCP_JP2K.cpp
@@ -1,7 +1,5 @@
-/* -*- c-basic-offset: 2; -*- */
-
 /*
-Copyright (c) 2004-2012, John Hurst
+Copyright (c) 2004-2014, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -27,7 +25,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 /*! \file    AS_DCP_JP2k.cpp
-    \version $Id: AS_DCP_JP2K.cpp,v 1.54 2012/02/07 18:54:24 jhurst Exp $
+    \version $Id: AS_DCP_JP2K.cpp,v 1.69 2015/10/07 16:41:23 jhurst Exp $
     \brief   AS-DCP library, JPEG 2000 essence reader and writer implementation
 */
 
@@ -35,7 +33,6 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <iostream>
 #include <iomanip>
 
-using std::cout;
 using namespace ASDCP::JP2K;
 using Kumu::GenRandomValue;
 
@@ -72,7 +69,7 @@ ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc)
   strm << "  bits  h-sep v-sep" << std::endl;
 
   ui32_t i;
-  for ( i = 0; i < PDesc.Csize; i++ )
+  for ( i = 0; i < PDesc.Csize && i < MaxComponents; ++i )
     {
       strm << "  " << std::setw(4) << PDesc.ImageComponents[i].Ssize + 1 /* See ISO 15444-1, Table A11, for the origin of '+1' */
 	   << "  " << std::setw(5) << PDesc.ImageComponents[i].XRsize
@@ -93,13 +90,13 @@ ASDCP::JP2K::operator << (std::ostream& strm, const PictureDescriptor& PDesc)
 
   ui32_t precinct_set_size = 0;
 
-  for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ )
+  for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; ++i )
     precinct_set_size++;
 
   strm << "          Precincts: " << (short) precinct_set_size << std::endl;
   strm << "precinct dimensions:" << std::endl;
 
-  for ( i = 0; i < precinct_set_size; i++ )
+  for ( i = 0; i < precinct_set_size && i < MaxPrecincts; ++i )
     strm << "    " << i + 1 << ": " << s_exp_lookup[PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]&0x0f] << " x "
 	 << s_exp_lookup[(PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]>>4)&0x0f] << std::endl;
 
@@ -157,7 +154,7 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream)
   fprintf(stream, "  bits  h-sep v-sep\n");
 
   ui32_t i;
-  for ( i = 0; i < PDesc.Csize; i++ )
+  for ( i = 0; i < PDesc.Csize && i < MaxComponents; i++ )
     {
       fprintf(stream, "  %4d  %5d %5d\n",
 	      PDesc.ImageComponents[i].Ssize + 1, // See ISO 15444-1, Table A11, for the origin of '+1'
@@ -166,34 +163,34 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream)
 	      );
     }
   
-  fprintf(stream, "               Scod: %hd\n", PDesc.CodingStyleDefault.Scod);
-  fprintf(stream, "   ProgressionOrder: %hd\n", PDesc.CodingStyleDefault.SGcod.ProgressionOrder);
+  fprintf(stream, "               Scod: %hhu\n", PDesc.CodingStyleDefault.Scod);
+  fprintf(stream, "   ProgressionOrder: %hhu\n", PDesc.CodingStyleDefault.SGcod.ProgressionOrder);
   fprintf(stream, "     NumberOfLayers: %hd\n",
 	  KM_i16_BE(Kumu::cp2i<ui16_t>(PDesc.CodingStyleDefault.SGcod.NumberOfLayers)));
 
-  fprintf(stream, " MultiCompTransform: %hd\n", PDesc.CodingStyleDefault.SGcod.MultiCompTransform);
-  fprintf(stream, "DecompositionLevels: %hd\n", PDesc.CodingStyleDefault.SPcod.DecompositionLevels);
-  fprintf(stream, "     CodeblockWidth: %hd\n", PDesc.CodingStyleDefault.SPcod.CodeblockWidth);
-  fprintf(stream, "    CodeblockHeight: %hd\n", PDesc.CodingStyleDefault.SPcod.CodeblockHeight);
-  fprintf(stream, "     CodeblockStyle: %hd\n", PDesc.CodingStyleDefault.SPcod.CodeblockStyle);
-  fprintf(stream, "     Transformation: %hd\n", PDesc.CodingStyleDefault.SPcod.Transformation);
+  fprintf(stream, " MultiCompTransform: %hhu\n", PDesc.CodingStyleDefault.SGcod.MultiCompTransform);
+  fprintf(stream, "DecompositionLevels: %hhu\n", PDesc.CodingStyleDefault.SPcod.DecompositionLevels);
+  fprintf(stream, "     CodeblockWidth: %hhu\n", PDesc.CodingStyleDefault.SPcod.CodeblockWidth);
+  fprintf(stream, "    CodeblockHeight: %hhu\n", PDesc.CodingStyleDefault.SPcod.CodeblockHeight);
+  fprintf(stream, "     CodeblockStyle: %hhu\n", PDesc.CodingStyleDefault.SPcod.CodeblockStyle);
+  fprintf(stream, "     Transformation: %hhu\n", PDesc.CodingStyleDefault.SPcod.Transformation);
 
 
   ui32_t precinct_set_size = 0;
 
-  for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ )
+  for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; ++i )
     precinct_set_size++;
 
-  fprintf(stream, "          Precincts: %hd\n", precinct_set_size);
+  fprintf(stream, "          Precincts: %u\n", precinct_set_size);
   fprintf(stream, "precinct dimensions:\n");
 
-  for ( i = 0; i < precinct_set_size; i++ )
+  for ( i = 0; i < precinct_set_size && i < MaxPrecincts; i++ )
     fprintf(stream, "    %d: %d x %d\n", i + 1,
 	    s_exp_lookup[PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]&0x0f],
 	    s_exp_lookup[(PDesc.CodingStyleDefault.SPcod.PrecinctSize[i]>>4)&0x0f]
 	    );
 
-  fprintf(stream, "               Sqcd: %hd\n", PDesc.QuantizationDefault.Sqcd);
+  fprintf(stream, "               Sqcd: %hhu\n", PDesc.QuantizationDefault.Sqcd);
 
   char tmp_buf[MaxDefaults*2];
   fprintf(stream, "              SPqcd: %s\n",
@@ -203,12 +200,128 @@ ASDCP::JP2K::PictureDescriptorDump(const PictureDescriptor& PDesc, FILE* stream)
 }
 
 
+const int VideoLineMapSize = 16; // See SMPTE 377M D.2.1
+const int PixelLayoutSize = 8*2; // See SMPTE 377M D.2.3
+static const byte_t s_PixelLayoutXYZ[PixelLayoutSize] = { 0xd8, 0x0c, 0xd9, 0x0c, 0xda, 0x0c, 0x00 };
+
+//
+ASDCP::Result_t
+ASDCP::JP2K_PDesc_to_MD(const JP2K::PictureDescriptor& PDesc,
+			const ASDCP::Dictionary& dict,
+			ASDCP::MXF::GenericPictureEssenceDescriptor& EssenceDescriptor,
+			ASDCP::MXF::JPEG2000PictureSubDescriptor& EssenceSubDescriptor)
+{
+  EssenceDescriptor.ContainerDuration = PDesc.ContainerDuration;
+  EssenceDescriptor.SampleRate = PDesc.EditRate;
+  EssenceDescriptor.FrameLayout = 0;
+  EssenceDescriptor.StoredWidth = PDesc.StoredWidth;
+  EssenceDescriptor.StoredHeight = PDesc.StoredHeight;
+  EssenceDescriptor.AspectRatio = PDesc.AspectRatio;
+
+  EssenceSubDescriptor.Rsize = PDesc.Rsize;
+  EssenceSubDescriptor.Xsize = PDesc.Xsize;
+  EssenceSubDescriptor.Ysize = PDesc.Ysize;
+  EssenceSubDescriptor.XOsize = PDesc.XOsize;
+  EssenceSubDescriptor.YOsize = PDesc.YOsize;
+  EssenceSubDescriptor.XTsize = PDesc.XTsize;
+  EssenceSubDescriptor.YTsize = PDesc.YTsize;
+  EssenceSubDescriptor.XTOsize = PDesc.XTOsize;
+  EssenceSubDescriptor.YTOsize = PDesc.YTOsize;
+  EssenceSubDescriptor.Csize = PDesc.Csize;
+
+  const ui32_t tmp_buffer_len = 1024;
+  byte_t tmp_buffer[tmp_buffer_len];
+
+  *(ui32_t*)tmp_buffer = KM_i32_BE(MaxComponents); // three components
+  *(ui32_t*)(tmp_buffer+4) = KM_i32_BE(sizeof(ASDCP::JP2K::ImageComponent_t));
+  memcpy(tmp_buffer + 8, &PDesc.ImageComponents, sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents);
+
+  const ui32_t pcomp_size = (sizeof(ui32_t) * 2) + (sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents);
+  memcpy(EssenceSubDescriptor.PictureComponentSizing.get().Data(), tmp_buffer, pcomp_size);
+  EssenceSubDescriptor.PictureComponentSizing.get().Length(pcomp_size);
+  EssenceSubDescriptor.PictureComponentSizing.set_has_value();
+
+  ui32_t precinct_set_size = 0;
+  for ( ui32_t i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; ++i )
+    precinct_set_size++;
+
+  ui32_t csd_size = sizeof(CodingStyleDefault_t) - MaxPrecincts + precinct_set_size;
+  memcpy(EssenceSubDescriptor.CodingStyleDefault.get().Data(), &PDesc.CodingStyleDefault, csd_size);
+  EssenceSubDescriptor.CodingStyleDefault.get().Length(csd_size);
+  EssenceSubDescriptor.CodingStyleDefault.set_has_value();
+
+  ui32_t qdflt_size = PDesc.QuantizationDefault.SPqcdLength + 1;
+  memcpy(EssenceSubDescriptor.QuantizationDefault.get().Data(), &PDesc.QuantizationDefault, qdflt_size);
+  EssenceSubDescriptor.QuantizationDefault.get().Length(qdflt_size);
+  EssenceSubDescriptor.QuantizationDefault.set_has_value();
+
+  return RESULT_OK;
+}
+
+
+//
+ASDCP::Result_t
+ASDCP::MD_to_JP2K_PDesc(const ASDCP::MXF::GenericPictureEssenceDescriptor&  EssenceDescriptor,
+			const ASDCP::MXF::JPEG2000PictureSubDescriptor& EssenceSubDescriptor,
+			const ASDCP::Rational& EditRate, const ASDCP::Rational& SampleRate,
+			ASDCP::JP2K::PictureDescriptor& PDesc)
+{
+  memset(&PDesc, 0, sizeof(PDesc));
+
+  PDesc.EditRate           = EditRate;
+  PDesc.SampleRate         = SampleRate;
+  assert(EssenceDescriptor.ContainerDuration.const_get() <= 0xFFFFFFFFL);
+  PDesc.ContainerDuration  = static_cast<ui32_t>(EssenceDescriptor.ContainerDuration.const_get());
+  PDesc.StoredWidth        = EssenceDescriptor.StoredWidth;
+  PDesc.StoredHeight       = EssenceDescriptor.StoredHeight;
+  PDesc.AspectRatio        = EssenceDescriptor.AspectRatio;
+
+  PDesc.Rsize   = EssenceSubDescriptor.Rsize;
+  PDesc.Xsize   = EssenceSubDescriptor.Xsize;
+  PDesc.Ysize   = EssenceSubDescriptor.Ysize;
+  PDesc.XOsize  = EssenceSubDescriptor.XOsize;
+  PDesc.YOsize  = EssenceSubDescriptor.YOsize;
+  PDesc.XTsize  = EssenceSubDescriptor.XTsize;
+  PDesc.YTsize  = EssenceSubDescriptor.YTsize;
+  PDesc.XTOsize = EssenceSubDescriptor.XTOsize;
+  PDesc.YTOsize = EssenceSubDescriptor.YTOsize;
+  PDesc.Csize   = EssenceSubDescriptor.Csize;
+
+  // PictureComponentSizing
+  ui32_t tmp_size = EssenceSubDescriptor.PictureComponentSizing.const_get().Length();
+
+  if ( tmp_size == 17 ) // ( 2 * sizeof(ui32_t) ) + 3 components * 3 byte each
+    {
+      memcpy(&PDesc.ImageComponents, EssenceSubDescriptor.PictureComponentSizing.const_get().RoData() + 8, tmp_size - 8);
+    }
+  else
+    {
+      DefaultLogSink().Warn("Unexpected PictureComponentSizing size: %u, should be 17\n", tmp_size);
+    }
+
+  // CodingStyleDefault
+  memset(&PDesc.CodingStyleDefault, 0, sizeof(CodingStyleDefault_t));
+  memcpy(&PDesc.CodingStyleDefault,
+	 EssenceSubDescriptor.CodingStyleDefault.const_get().RoData(),
+	 EssenceSubDescriptor.CodingStyleDefault.const_get().Length());
+
+  // QuantizationDefault
+  memset(&PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t));
+  memcpy(&PDesc.QuantizationDefault,
+	 EssenceSubDescriptor.QuantizationDefault.const_get().RoData(),
+	 EssenceSubDescriptor.QuantizationDefault.const_get().Length());
+  
+  PDesc.QuantizationDefault.SPqcdLength = EssenceSubDescriptor.QuantizationDefault.const_get().Length() - 1;
+  return RESULT_OK;
+}
+
+
 //------------------------------------------------------------------------------------------
 //
 // hidden, internal implementation of JPEG 2000 reader
 
 
-class lh__Reader : public ASDCP::h__Reader
+class lh__Reader : public ASDCP::h__ASDCPReader
 {
   RGBAEssenceDescriptor*        m_EssenceDescriptor;
   JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor;
@@ -222,71 +335,19 @@ public:
   PictureDescriptor m_PDesc;        // codestream parameter list
 
   lh__Reader(const Dictionary& d) :
-    ASDCP::h__Reader(d), m_EssenceDescriptor(0), m_EssenceSubDescriptor(0), m_Format(ESS_UNKNOWN) {}
-  Result_t    OpenRead(const char*, EssenceType_t);
-  Result_t    ReadFrame(ui32_t, JP2K::FrameBuffer&, AESDecContext*, HMACContext*);
-  Result_t    MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc);
-};
-
-//
-ASDCP::Result_t
-lh__Reader::MD_to_JP2K_PDesc(JP2K::PictureDescriptor& PDesc)
-{
-  memset(&PDesc, 0, sizeof(PDesc));
-  MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor;
-
-  PDesc.EditRate           = m_EditRate;
-  PDesc.SampleRate         = m_SampleRate;
-  assert(PDescObj->ContainerDuration <= 0xFFFFFFFFL);
-  PDesc.ContainerDuration  = (ui32_t) PDescObj->ContainerDuration;
-  PDesc.StoredWidth        = PDescObj->StoredWidth;
-  PDesc.StoredHeight       = PDescObj->StoredHeight;
-  PDesc.AspectRatio        = PDescObj->AspectRatio;
-
-  if ( m_EssenceSubDescriptor != 0 )
-    {
-      PDesc.Rsize   = m_EssenceSubDescriptor->Rsize;
-      PDesc.Xsize   = m_EssenceSubDescriptor->Xsize;
-      PDesc.Ysize   = m_EssenceSubDescriptor->Ysize;
-      PDesc.XOsize  = m_EssenceSubDescriptor->XOsize;
-      PDesc.YOsize  = m_EssenceSubDescriptor->YOsize;
-      PDesc.XTsize  = m_EssenceSubDescriptor->XTsize;
-      PDesc.YTsize  = m_EssenceSubDescriptor->YTsize;
-      PDesc.XTOsize = m_EssenceSubDescriptor->XTOsize;
-      PDesc.YTOsize = m_EssenceSubDescriptor->YTOsize;
-      PDesc.Csize   = m_EssenceSubDescriptor->Csize;
-
-      // PictureComponentSizing
-      ui32_t tmp_size = m_EssenceSubDescriptor->PictureComponentSizing.Length();
-
-      if ( tmp_size == 17 ) // ( 2 * sizeof(ui32_t) ) + 3 components * 3 byte each
-	memcpy(&PDesc.ImageComponents, m_EssenceSubDescriptor->PictureComponentSizing.RoData() + 8, tmp_size - 8);
-
-      else
-	DefaultLogSink().Error("Unexpected PictureComponentSizing size: %u, should be 17\n", tmp_size);
-
-      // CodingStyleDefault
-      memset(&PDesc.CodingStyleDefault, 0, sizeof(CodingStyleDefault_t));
-      memcpy(&PDesc.CodingStyleDefault,
-	     m_EssenceSubDescriptor->CodingStyleDefault.RoData(),
-	     m_EssenceSubDescriptor->CodingStyleDefault.Length());
+    ASDCP::h__ASDCPReader(d), m_EssenceDescriptor(0), m_EssenceSubDescriptor(0), m_Format(ESS_UNKNOWN) {}
 
-      // QuantizationDefault
-      memset(&PDesc.QuantizationDefault, 0, sizeof(QuantizationDefault_t));
-      memcpy(&PDesc.QuantizationDefault,
-	     m_EssenceSubDescriptor->QuantizationDefault.RoData(),
-	     m_EssenceSubDescriptor->QuantizationDefault.Length());
+  virtual ~lh__Reader() {}
 
-      PDesc.QuantizationDefault.SPqcdLength = m_EssenceSubDescriptor->QuantizationDefault.Length() - 1;
-    }
+  Result_t    OpenRead(const std::string&, EssenceType_t);
+  Result_t    ReadFrame(ui32_t, JP2K::FrameBuffer&, AESDecContext*, HMACContext*);
+};
 
-  return RESULT_OK;
-}
 
 //
 //
 ASDCP::Result_t
-lh__Reader::OpenRead(const char* filename, EssenceType_t type)
+lh__Reader::OpenRead(const std::string& filename, EssenceType_t type)
 {
   Result_t result = OpenMXFRead(filename);
 
@@ -296,9 +357,22 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type)
       m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), &tmp_iobj);
       m_EssenceDescriptor = static_cast<RGBAEssenceDescriptor*>(tmp_iobj);
 
+      if ( m_EssenceDescriptor == 0 )
+	{
+	  DefaultLogSink().Error("RGBAEssenceDescriptor object not found.\n");
+	  return RESULT_FORMAT;
+	}
+
       m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &tmp_iobj);
       m_EssenceSubDescriptor = static_cast<JPEG2000PictureSubDescriptor*>(tmp_iobj);
 
+      if ( m_EssenceSubDescriptor == 0 )
+	{
+	  m_EssenceDescriptor = 0;
+	  DefaultLogSink().Error("JPEG2000PictureSubDescriptor object not found.\n");
+	  return RESULT_FORMAT;
+	}
+
       std::list<InterchangeObject*> ObjectList;
       m_HeaderPart.GetMDObjectsByType(OBJ_TYPE_ARGS(Track), ObjectList);
 
@@ -318,12 +392,12 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type)
 	      DefaultLogSink().Warn("EditRate and SampleRate do not match (%.03f, %.03f).\n",
 				    m_EditRate.Quotient(), m_SampleRate.Quotient());
 	      
-	      if ( (m_EditRate == EditRate_24 && m_SampleRate == EditRate_48) ||
-		   (m_EditRate == EditRate_25 && m_SampleRate == EditRate_50) ||
-		   (m_EditRate == EditRate_30 && m_SampleRate == EditRate_60) ||
-		   (m_EditRate == EditRate_48 && m_SampleRate == EditRate_96) ||
-		   (m_EditRate == EditRate_50 && m_SampleRate == EditRate_100) ||
-		   (m_EditRate == EditRate_60 && m_SampleRate == EditRate_120) )
+	      if ( ( m_EditRate == EditRate_24 && m_SampleRate == EditRate_48 )
+		   || ( m_EditRate == EditRate_25 && m_SampleRate == EditRate_50 )
+		   || ( m_EditRate == EditRate_30 && m_SampleRate == EditRate_60 )
+		   || ( m_EditRate == EditRate_48 && m_SampleRate == EditRate_96 )
+		   || ( m_EditRate == EditRate_50 && m_SampleRate == EditRate_100 )
+		   || ( m_EditRate == EditRate_60 && m_SampleRate == EditRate_120 ) )
 		{
 		  DefaultLogSink().Debug("File may contain JPEG Interop stereoscopic images.\n");
 		  return RESULT_SFORMAT;
@@ -395,15 +469,9 @@ lh__Reader::OpenRead(const char* filename, EssenceType_t type)
 	  return RESULT_STATE;
 	}
 
-      result = MD_to_JP2K_PDesc(m_PDesc);
+      result = MD_to_JP2K_PDesc(*m_EssenceDescriptor, *m_EssenceSubDescriptor, m_EditRate, m_SampleRate, m_PDesc);
     }
 
-  if( ASDCP_SUCCESS(result) )
-    result = InitMXFIndex();
-
-  if( ASDCP_SUCCESS(result) )
-    result = InitInfo();
-
   return result;
 }
 
@@ -462,18 +530,20 @@ ASDCP::JP2K::MXFReader::MXFReader()
 
 ASDCP::JP2K::MXFReader::~MXFReader()
 {
+  if ( m_Reader && m_Reader->m_File.IsOpen() )
+    m_Reader->Close();
 }
 
 // Warning: direct manipulation of MXF structures can interfere
 // with the normal operation of the wrapper.  Caveat emptor!
 //
-ASDCP::MXF::OPAtomHeader&
-ASDCP::JP2K::MXFReader::OPAtomHeader()
+ASDCP::MXF::OP1aHeader&
+ASDCP::JP2K::MXFReader::OP1aHeader()
 {
   if ( m_Reader.empty() )
     {
-      assert(g_OPAtomHeader);
-      return *g_OPAtomHeader;
+      assert(g_OP1aHeader);
+      return *g_OP1aHeader;
     }
 
   return m_Reader->m_HeaderPart;
@@ -491,13 +561,28 @@ ASDCP::JP2K::MXFReader::OPAtomIndexFooter()
       return *g_OPAtomIndexFooter;
     }
 
-  return m_Reader->m_FooterPart;
+  return m_Reader->m_IndexAccess;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::RIP&
+ASDCP::JP2K::MXFReader::RIP()
+{
+  if ( m_Reader.empty() )
+    {
+      assert(g_RIP);
+      return *g_RIP;
+    }
+
+  return m_Reader->m_RIP;
 }
 
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
-ASDCP::JP2K::MXFReader::OpenRead(const char* filename) const
+ASDCP::JP2K::MXFReader::OpenRead(const std::string& filename) const
 {
   return m_Reader->OpenRead(filename, ASDCP::ESS_JPEG_2000);
 }
@@ -513,6 +598,12 @@ ASDCP::JP2K::MXFReader::ReadFrame(ui32_t FrameNum, FrameBuffer& FrameBuf,
   return RESULT_INIT;
 }
 
+ASDCP::Result_t
+ASDCP::JP2K::MXFReader::LocateFrame(ui32_t FrameNum, Kumu::fpos_t& streamOffset, i8_t& temporalOffset, i8_t& keyFrameOffset) const
+{
+    return m_Reader->LocateFrame(FrameNum, streamOffset, temporalOffset, keyFrameOffset);
+}
+
 
 // Fill the struct with the values from the file's header.
 // Returns RESULT_INIT if the file is not open.
@@ -557,7 +648,7 @@ void
 ASDCP::JP2K::MXFReader::DumpIndex(FILE* stream) const
 {
   if ( m_Reader->m_File.IsOpen() )
-    m_Reader->m_FooterPart.Dump(stream);
+    m_Reader->m_IndexAccess.Dump(stream);
 }
 
 //
@@ -591,14 +682,13 @@ public:
     // look up frame index node
     IndexTableSegment::IndexEntry TmpEntry;
 
-    if ( ASDCP_FAILURE(m_FooterPart.Lookup(FrameNum, TmpEntry)) )
+    if ( ASDCP_FAILURE(m_IndexAccess.Lookup(FrameNum, TmpEntry)) )
       {
-	DefaultLogSink().Error("Frame value out of range: %u\n", FrameNum);
 	return RESULT_RANGE;
       }
 
     // get frame position
-    Kumu::fpos_t FilePosition = m_EssenceStart + TmpEntry.StreamOffset;
+    Kumu::fpos_t FilePosition = m_HeaderPart.BodyOffset + TmpEntry.StreamOffset;
     Result_t result = RESULT_OK;
 
     if ( phase == SP_LEFT )
@@ -666,18 +756,20 @@ ASDCP::JP2K::MXFSReader::MXFSReader()
 
 ASDCP::JP2K::MXFSReader::~MXFSReader()
 {
+  if ( m_Reader && m_Reader->m_File.IsOpen() )
+    m_Reader->Close();
 }
 
 // Warning: direct manipulation of MXF structures can interfere
 // with the normal operation of the wrapper.  Caveat emptor!
 //
-ASDCP::MXF::OPAtomHeader&
-ASDCP::JP2K::MXFSReader::OPAtomHeader()
+ASDCP::MXF::OP1aHeader&
+ASDCP::JP2K::MXFSReader::OP1aHeader()
 {
   if ( m_Reader.empty() )
     {
-      assert(g_OPAtomHeader);
-      return *g_OPAtomHeader;
+      assert(g_OP1aHeader);
+      return *g_OP1aHeader;
     }
 
   return m_Reader->m_HeaderPart;
@@ -695,13 +787,28 @@ ASDCP::JP2K::MXFSReader::OPAtomIndexFooter()
       return *g_OPAtomIndexFooter;
     }
 
-  return m_Reader->m_FooterPart;
+  return m_Reader->m_IndexAccess;
+}
+
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::RIP&
+ASDCP::JP2K::MXFSReader::RIP()
+{
+  if ( m_Reader.empty() )
+    {
+      assert(g_RIP);
+      return *g_RIP;
+    }
+
+  return m_Reader->m_RIP;
 }
 
 // Open the file for reading. The file must exist. Returns error if the
 // operation cannot be completed.
 ASDCP::Result_t
-ASDCP::JP2K::MXFSReader::OpenRead(const char* filename) const
+ASDCP::JP2K::MXFSReader::OpenRead(const std::string& filename) const
 {
   return m_Reader->OpenRead(filename, ASDCP::ESS_JPEG_2000_S);
 }
@@ -734,6 +841,12 @@ ASDCP::JP2K::MXFSReader::ReadFrame(ui32_t FrameNum, StereoscopicPhase_t phase, F
   return RESULT_INIT;
 }
 
+ASDCP::Result_t
+ASDCP::JP2K::MXFSReader::LocateFrame(ui32_t FrameNum, Kumu::fpos_t& streamOffset, i8_t& temporalOffset, i8_t& keyFrameOffset) const
+{
+    return m_Reader->LocateFrame(FrameNum, streamOffset, temporalOffset, keyFrameOffset);
+}
+
 // Fill the struct with the values from the file's header.
 // Returns RESULT_INIT if the file is not open.
 ASDCP::Result_t
@@ -777,7 +890,7 @@ void
 ASDCP::JP2K::MXFSReader::DumpIndex(FILE* stream) const
 {
   if ( m_Reader->m_File.IsOpen() )
-    m_Reader->m_FooterPart.Dump(stream);
+    m_Reader->m_IndexAccess.Dump(stream);
 }
 
 //
@@ -798,7 +911,7 @@ ASDCP::JP2K::MXFSReader::Close() const
 
 
 //
-class lh__Writer : public ASDCP::h__Writer
+class lh__Writer : public ASDCP::h__ASDCPWriter
 {
   ASDCP_NO_COPY_CONSTRUCT(lh__Writer);
   lh__Writer();
@@ -809,116 +922,28 @@ public:
   PictureDescriptor m_PDesc;
   byte_t            m_EssenceUL[SMPTE_UL_LENGTH];
 
-  lh__Writer(const Dictionary& d) : ASDCP::h__Writer(d), m_EssenceSubDescriptor(0) {
+  lh__Writer(const Dictionary& d) : ASDCP::h__ASDCPWriter(d), m_EssenceSubDescriptor(0) {
     memset(m_EssenceUL, 0, SMPTE_UL_LENGTH);
   }
 
-  ~lh__Writer(){}
+  virtual ~lh__Writer(){}
 
-  Result_t OpenWrite(const char*, EssenceType_t type, ui32_t HeaderSize, bool);
+  Result_t OpenWrite(const std::string&, EssenceType_t type, ui32_t HeaderSize);
   Result_t SetSourceStream(const PictureDescriptor&, const std::string& label,
 			   ASDCP::Rational LocalEditRate = ASDCP::Rational(0,0));
-  Result_t WriteFrame(const JP2K::FrameBuffer&, bool add_index, AESEncContext*, HMACContext*, std::string* hash = 0);
-  Result_t FakeWriteFrame(int size, bool add_index);
+  Result_t WriteFrame(const JP2K::FrameBuffer&, bool add_index, AESEncContext*, HMACContext*);
   Result_t Finalize();
-  Result_t JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc);
 };
 
-const int VideoLineMapSize = 16; // See SMPTE 377M D.2.1
-const int PixelLayoutSize = 8*2; // See SMPTE 377M D.2.3
-static const byte_t s_PixelLayoutXYZ[PixelLayoutSize] = { 0xd8, 0x0c, 0xd9, 0x0c, 0xda, 0x0c, 0x00 };
-
-//
-ASDCP::Result_t
-lh__Writer::JP2K_PDesc_to_MD(JP2K::PictureDescriptor& PDesc)
-{
-  assert(m_EssenceDescriptor);
-  assert(m_EssenceSubDescriptor);
-  MXF::RGBAEssenceDescriptor* PDescObj = (MXF::RGBAEssenceDescriptor*)m_EssenceDescriptor;
-
-  PDescObj->ContainerDuration = PDesc.ContainerDuration;
-  PDescObj->SampleRate = PDesc.EditRate;
-  PDescObj->FrameLayout = 0;
-  PDescObj->StoredWidth = PDesc.StoredWidth;
-  PDescObj->StoredHeight = PDesc.StoredHeight;
-  PDescObj->AspectRatio = PDesc.AspectRatio;
-
-  //  if ( m_Info.LabelSetType == LS_MXF_SMPTE )
-  //    {
-  // PictureEssenceCoding UL = 
-  // Video Line Map       ui32_t[VideoLineMapSize] = { 2, 4, 0, 0 }
-  // CaptureGamma         UL = 
-  // ComponentMaxRef      ui32_t = 4095
-  // ComponentMinRef      ui32_t = 0
-  // PixelLayout          byte_t[PixelLayoutSize] = s_PixelLayoutXYZ
-  //    }
-
-  assert(m_Dict);
-  if ( PDesc.StoredWidth < 2049 )
-    {
-      PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_2K));
-      m_EssenceSubDescriptor->Rsize = 3;
-    }
-  else
-    {
-      PDescObj->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_4K));
-      m_EssenceSubDescriptor->Rsize = 4;
-    }
-
-  m_EssenceSubDescriptor->Xsize = PDesc.Xsize;
-  m_EssenceSubDescriptor->Ysize = PDesc.Ysize;
-  m_EssenceSubDescriptor->XOsize = PDesc.XOsize;
-  m_EssenceSubDescriptor->YOsize = PDesc.YOsize;
-  m_EssenceSubDescriptor->XTsize = PDesc.XTsize;
-  m_EssenceSubDescriptor->YTsize = PDesc.YTsize;
-  m_EssenceSubDescriptor->XTOsize = PDesc.XTOsize;
-  m_EssenceSubDescriptor->YTOsize = PDesc.YTOsize;
-  m_EssenceSubDescriptor->Csize = PDesc.Csize;
-
-  const ui32_t tmp_buffer_len = 1024;
-  byte_t tmp_buffer[tmp_buffer_len];
-
-  ui32_t* tmp_buffer_ui32 = (ui32_t*) tmp_buffer;
-  *tmp_buffer_ui32 = KM_i32_BE(MaxComponents); // three components
-  
-  *(ui32_t*)(tmp_buffer+4) = KM_i32_BE(sizeof(ASDCP::JP2K::ImageComponent_t));
-  memcpy(tmp_buffer + 8, &PDesc.ImageComponents, sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents);
-
-  const ui32_t pcomp_size = (sizeof(int) * 2) + (sizeof(ASDCP::JP2K::ImageComponent_t) * MaxComponents);
-  memcpy(m_EssenceSubDescriptor->PictureComponentSizing.Data(), tmp_buffer, pcomp_size);
-  m_EssenceSubDescriptor->PictureComponentSizing.Length(pcomp_size);
-
-  ui32_t precinct_set_size = 0, i;
-  for ( i = 0; PDesc.CodingStyleDefault.SPcod.PrecinctSize[i] != 0 && i < MaxPrecincts; i++ )
-    precinct_set_size++;
-
-  ui32_t csd_size = sizeof(CodingStyleDefault_t) - MaxPrecincts + precinct_set_size;
-  memcpy(m_EssenceSubDescriptor->CodingStyleDefault.Data(), &PDesc.CodingStyleDefault, csd_size);
-  m_EssenceSubDescriptor->CodingStyleDefault.Length(csd_size);
-
-  ui32_t qdflt_size = PDesc.QuantizationDefault.SPqcdLength + 1;
-  memcpy(m_EssenceSubDescriptor->QuantizationDefault.Data(), &PDesc.QuantizationDefault, qdflt_size);
-  m_EssenceSubDescriptor->QuantizationDefault.Length(qdflt_size);
-
-  return RESULT_OK;
-}
-
-
-// Open the file for writing. The file must not exist unless overwrite is true. Returns error if
+// Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
 ASDCP::Result_t
-lh__Writer::OpenWrite(const char* filename, EssenceType_t type, ui32_t HeaderSize, bool overwrite)
+lh__Writer::OpenWrite(const std::string& filename, EssenceType_t type, ui32_t HeaderSize)
 {
   if ( ! m_State.Test_BEGIN() )
     return RESULT_STATE;
 
-  Result_t result = RESULT_OK;
-  if (overwrite) {
-    result = m_File.OpenModify(filename);
-    m_File.Seek(0);
-  } else {
-    result = m_File.OpenWrite(filename);
-  }
+  Result_t result = m_File.OpenWrite(filename);
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -960,10 +985,26 @@ lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& l
     LocalEditRate = PDesc.EditRate;
 
   m_PDesc = PDesc;
-  Result_t result = JP2K_PDesc_to_MD(m_PDesc);
+  assert(m_Dict);
+  assert(m_EssenceDescriptor);
+  assert(m_EssenceSubDescriptor);
+  Result_t result = JP2K_PDesc_to_MD(m_PDesc, *m_Dict,
+				     *static_cast<ASDCP::MXF::GenericPictureEssenceDescriptor*>(m_EssenceDescriptor),
+				     *m_EssenceSubDescriptor);
 
   if ( ASDCP_SUCCESS(result) )
     {
+      if ( PDesc.StoredWidth < 2049 )
+	{
+	  static_cast<ASDCP::MXF::RGBAEssenceDescriptor*>(m_EssenceDescriptor)->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_2K));
+	  m_EssenceSubDescriptor->Rsize = 3;
+	}
+      else
+	{
+	  static_cast<ASDCP::MXF::RGBAEssenceDescriptor*>(m_EssenceDescriptor)->PictureEssenceCoding.Set(m_Dict->ul(MDD_JP2KEssenceCompression_4K));
+	  m_EssenceSubDescriptor->Rsize = 4;
+	}
+
       memcpy(m_EssenceUL, m_Dict->ul(MDD_JPEG2000Essence), SMPTE_UL_LENGTH);
       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
       result = m_State.Goto_READY();
@@ -971,11 +1012,9 @@ lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& l
 
   if ( ASDCP_SUCCESS(result) )
     {
-      ui32_t TCFrameRate = ( m_PDesc.EditRate == EditRate_23_98  ) ? 24 : m_PDesc.EditRate.Numerator;
-
-      result = WriteMXFHeader(label, UL(m_Dict->ul(MDD_JPEG_2000Wrapping)),
-			      PICT_DEF_LABEL, UL(m_EssenceUL), UL(m_Dict->ul(MDD_PictureDataDef)),
-			      LocalEditRate, TCFrameRate);
+      result = WriteASDCPHeader(label, UL(m_Dict->ul(MDD_JPEG_2000WrappingFrame)),
+				PICT_DEF_LABEL, UL(m_EssenceUL), UL(m_Dict->ul(MDD_PictureDataDef)),
+				LocalEditRate, derive_timecode_rate_from_edit_rate(m_PDesc.EditRate));
     }
 
   return result;
@@ -988,7 +1027,7 @@ lh__Writer::SetSourceStream(const PictureDescriptor& PDesc, const std::string& l
 //
 ASDCP::Result_t
 lh__Writer::WriteFrame(const JP2K::FrameBuffer& FrameBuf, bool add_index,
-		       AESEncContext* Ctx, HMACContext* HMAC, std::string* hash)
+		       AESEncContext* Ctx, HMACContext* HMAC)
 {
   Result_t result = RESULT_OK;
 
@@ -998,31 +1037,7 @@ lh__Writer::WriteFrame(const JP2K::FrameBuffer& FrameBuf, bool add_index,
   ui64_t StreamOffset = m_StreamOffset;
 
   if ( ASDCP_SUCCESS(result) )
-    result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC, hash);
-
-  if ( ASDCP_SUCCESS(result) && add_index )
-    {  
-      IndexTableSegment::IndexEntry Entry;
-      Entry.StreamOffset = StreamOffset;
-      m_FooterPart.PushIndexEntry(Entry);
-    }
-
-  m_FramesWritten++;
-  return result;
-}
-
-Result_t
-lh__Writer::FakeWriteFrame(int size, bool add_index)
-{
-  Result_t result = RESULT_OK;
-
-  if ( m_State.Test_READY() )
-    result = m_State.Goto_RUNNING();
-
-  ui64_t StreamOffset = m_StreamOffset;
-
-  if ( ASDCP_SUCCESS(result) )
-    result = FakeWriteEKLVPacket(size);
+    result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC);
 
   if ( ASDCP_SUCCESS(result) && add_index )
     {  
@@ -1046,7 +1061,7 @@ lh__Writer::Finalize()
 
   m_State.Goto_FINAL();
 
-  return WriteMXFFooter();
+  return WriteASDCPFooter();
 }
 
 
@@ -1076,13 +1091,13 @@ ASDCP::JP2K::MXFWriter::~MXFWriter()
 // Warning: direct manipulation of MXF structures can interfere
 // with the normal operation of the wrapper.  Caveat emptor!
 //
-ASDCP::MXF::OPAtomHeader&
-ASDCP::JP2K::MXFWriter::OPAtomHeader()
+ASDCP::MXF::OP1aHeader&
+ASDCP::JP2K::MXFWriter::OP1aHeader()
 {
   if ( m_Writer.empty() )
     {
-      assert(g_OPAtomHeader);
-      return *g_OPAtomHeader;
+      assert(g_OP1aHeader);
+      return *g_OP1aHeader;
     }
 
   return m_Writer->m_HeaderPart;
@@ -1103,11 +1118,26 @@ ASDCP::JP2K::MXFWriter::OPAtomIndexFooter()
   return m_Writer->m_FooterPart;
 }
 
-// Open the file for writing. The file must not exist unless overwrite is true. Returns error if
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::RIP&
+ASDCP::JP2K::MXFWriter::RIP()
+{
+  if ( m_Writer.empty() )
+    {
+      assert(g_RIP);
+      return *g_RIP;
+    }
+
+  return m_Writer->m_RIP;
+}
+
+// Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
 ASDCP::Result_t
-ASDCP::JP2K::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info,
-				  const PictureDescriptor& PDesc, ui32_t HeaderSize, bool overwrite)
+ASDCP::JP2K::MXFWriter::OpenWrite(const std::string& filename, const WriterInfo& Info,
+				  const PictureDescriptor& PDesc, ui32_t HeaderSize)
 {
   if ( Info.LabelSetType == LS_MXF_SMPTE )
     m_Writer = new h__Writer(DefaultSMPTEDict());
@@ -1116,7 +1146,7 @@ ASDCP::JP2K::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info,
 
   m_Writer->m_Info = Info;
 
-  Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000, HeaderSize, overwrite);
+  Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000, HeaderSize);
 
   if ( ASDCP_SUCCESS(result) )
     result = m_Writer->SetSourceStream(PDesc, JP2K_PACKAGE_LABEL);
@@ -1133,21 +1163,12 @@ ASDCP::JP2K::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info,
 // Fails if the file is not open, is finalized, or an operating system
 // error occurs.
 ASDCP::Result_t
-ASDCP::JP2K::MXFWriter::WriteFrame(const FrameBuffer& FrameBuf, AESEncContext* Ctx, HMACContext* HMAC, std::string* hash)
-{
-  if ( m_Writer.empty() )
-    return RESULT_INIT;
-
-  return m_Writer->WriteFrame(FrameBuf, true, Ctx, HMAC, hash);
-}
-
-ASDCP::Result_t
-ASDCP::JP2K::MXFWriter::FakeWriteFrame(int size)
+ASDCP::JP2K::MXFWriter::WriteFrame(const FrameBuffer& FrameBuf, AESEncContext* Ctx, HMACContext* HMAC)
 {
   if ( m_Writer.empty() )
     return RESULT_INIT;
 
-  return m_Writer->FakeWriteFrame(size, true);
+  return m_Writer->WriteFrame(FrameBuf, true, Ctx, HMAC);
 }
 
 // Closes the MXF file, writing the index and other closing information.
@@ -1160,12 +1181,6 @@ ASDCP::JP2K::MXFWriter::Finalize()
   return m_Writer->Finalize();
 }
 
-ui64_t
-ASDCP::JP2K::MXFWriter::Tell() const
-{
-	return m_Writer->m_File.Tell();
-}
-
 
 //------------------------------------------------------------------------------------------
 //
@@ -1182,7 +1197,7 @@ public:
 
   //
   Result_t WriteFrame(const FrameBuffer& FrameBuf, StereoscopicPhase_t phase,
-		      AESEncContext* Ctx, HMACContext* HMAC, std::string* hash)
+		      AESEncContext* Ctx, HMACContext* HMAC)
   {
     if ( m_NextPhase != phase )
       return RESULT_SPHASE;
@@ -1190,28 +1205,11 @@ public:
     if ( phase == SP_LEFT )
       {
 	m_NextPhase = SP_RIGHT;
-	return lh__Writer::WriteFrame(FrameBuf, true, Ctx, HMAC, hash);
+	return lh__Writer::WriteFrame(FrameBuf, true, Ctx, HMAC);
       }
 
     m_NextPhase = SP_LEFT;
-    return lh__Writer::WriteFrame(FrameBuf, false, Ctx, HMAC, hash);
-  }
-
-  Result_t FakeWriteFrame(int size, StereoscopicPhase_t phase)
-  {
-    if (m_NextPhase != phase)
-      {
-        return RESULT_SPHASE;
-      }
-
-    if (phase == SP_LEFT)
-      {
-        m_NextPhase = SP_RIGHT;
-	return lh__Writer::FakeWriteFrame(size, true);
-      }
-
-    m_NextPhase = SP_LEFT;
-    return lh__Writer::FakeWriteFrame(size, false);
+    return lh__Writer::WriteFrame(FrameBuf, false, Ctx, HMAC);
   }
 
   //
@@ -1239,13 +1237,13 @@ ASDCP::JP2K::MXFSWriter::~MXFSWriter()
 // Warning: direct manipulation of MXF structures can interfere
 // with the normal operation of the wrapper.  Caveat emptor!
 //
-ASDCP::MXF::OPAtomHeader&
-ASDCP::JP2K::MXFSWriter::OPAtomHeader()
+ASDCP::MXF::OP1aHeader&
+ASDCP::JP2K::MXFSWriter::OP1aHeader()
 {
   if ( m_Writer.empty() )
     {
-      assert(g_OPAtomHeader);
-      return *g_OPAtomHeader;
+      assert(g_OP1aHeader);
+      return *g_OP1aHeader;
     }
 
   return m_Writer->m_HeaderPart;
@@ -1266,11 +1264,26 @@ ASDCP::JP2K::MXFSWriter::OPAtomIndexFooter()
   return m_Writer->m_FooterPart;
 }
 
+// Warning: direct manipulation of MXF structures can interfere
+// with the normal operation of the wrapper.  Caveat emptor!
+//
+ASDCP::MXF::RIP&
+ASDCP::JP2K::MXFSWriter::RIP()
+{
+  if ( m_Writer.empty() )
+    {
+      assert(g_RIP);
+      return *g_RIP;
+    }
+
+  return m_Writer->m_RIP;
+}
+
 // Open the file for writing. The file must not exist. Returns error if
 // the operation cannot be completed.
 ASDCP::Result_t
-ASDCP::JP2K::MXFSWriter::OpenWrite(const char* filename, const WriterInfo& Info,
-				   const PictureDescriptor& PDesc, ui32_t HeaderSize, bool overwrite)
+ASDCP::JP2K::MXFSWriter::OpenWrite(const std::string& filename, const WriterInfo& Info,
+				   const PictureDescriptor& PDesc, ui32_t HeaderSize)
 {
   if ( Info.LabelSetType == LS_MXF_SMPTE )
     m_Writer = new h__SWriter(DefaultSMPTEDict());
@@ -1293,7 +1306,7 @@ ASDCP::JP2K::MXFSWriter::OpenWrite(const char* filename, const WriterInfo& Info,
 
   m_Writer->m_Info = Info;
 
-  Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000_S, HeaderSize, overwrite);
+  Result_t result = m_Writer->OpenWrite(filename, ASDCP::ESS_JPEG_2000_S, HeaderSize);
 
   if ( ASDCP_SUCCESS(result) )
     {
@@ -1332,10 +1345,10 @@ ASDCP::JP2K::MXFSWriter::WriteFrame(const SFrameBuffer& FrameBuf, AESEncContext*
   if ( m_Writer.empty() )
     return RESULT_INIT;
 
-  Result_t result = m_Writer->WriteFrame(FrameBuf.Left, SP_LEFT, Ctx, HMAC, 0);
+  Result_t result = m_Writer->WriteFrame(FrameBuf.Left, SP_LEFT, Ctx, HMAC);
 
   if ( ASDCP_SUCCESS(result) )
-    result = m_Writer->WriteFrame(FrameBuf.Right, SP_RIGHT, Ctx, HMAC, 0);
+    result = m_Writer->WriteFrame(FrameBuf.Right, SP_RIGHT, Ctx, HMAC);
 
   return result;
 }
@@ -1346,21 +1359,12 @@ ASDCP::JP2K::MXFSWriter::WriteFrame(const SFrameBuffer& FrameBuf, AESEncContext*
 // error occurs.
 ASDCP::Result_t
 ASDCP::JP2K::MXFSWriter::WriteFrame(const FrameBuffer& FrameBuf, StereoscopicPhase_t phase,
-				    AESEncContext* Ctx, HMACContext* HMAC, std::string* hash)
+				    AESEncContext* Ctx, HMACContext* HMAC)
 {
   if ( m_Writer.empty() )
     return RESULT_INIT;
 
-  return m_Writer->WriteFrame(FrameBuf, phase, Ctx, HMAC, hash);
-}
-
-ASDCP::Result_t
-ASDCP::JP2K::MXFSWriter::FakeWriteFrame(int size, StereoscopicPhase_t phase)
-{
-  if ( m_Writer.empty() )
-    return RESULT_INIT;
-
-  return m_Writer->FakeWriteFrame(size, phase);
+  return m_Writer->WriteFrame(FrameBuf, phase, Ctx, HMAC);
 }
 
 // Closes the MXF file, writing the index and other closing information.
@@ -1373,12 +1377,6 @@ ASDCP::JP2K::MXFSWriter::Finalize()
   return m_Writer->Finalize();
 }
 
-ui64_t
-ASDCP::JP2K::MXFSWriter::Tell() const
-{
-	return m_Writer->m_File.Tell();
-}
-
 //
 // end AS_DCP_JP2K.cpp
 //