X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2FAS_DCP_TimedText.cpp;h=f7d64bda3a004c2207a7200ea5983b737575874d;hb=062846490c38e32ec1f9822565476f28b64fcbd7;hp=bab3a6a1e616e338700fdad95ef282497f7d0d5e;hpb=c5e3e4e83032b790c62bd55795a20dd912010c9f;p=asdcplib.git

diff --git a/src/AS_DCP_TimedText.cpp b/src/AS_DCP_TimedText.cpp
index bab3a6a..f7d64bd 100644
--- a/src/AS_DCP_TimedText.cpp
+++ b/src/AS_DCP_TimedText.cpp
@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2007, John Hurst
+Copyright (c) 2008-2011, John Hurst
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -32,8 +32,12 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "AS_DCP_internal.h"
 #include "KM_xml.h"
+#include <iostream>
+#include <iomanip>
 
-static std::string TIMED_TEXT_PACKAGE_LABEL = "File Package: SMPTE 429-5 frame wrapping of D-Cinema Timed Text data";
+using Kumu::GenRandomValue;
+
+static std::string TIMED_TEXT_PACKAGE_LABEL = "File Package: SMPTE 429-5 clip wrapping of D-Cinema Timed Text data";
 static std::string TIMED_TEXT_DEF_LABEL = "Timed Text Track";
 
 
@@ -46,11 +50,34 @@ MIME2str(TimedText::MIMEType_t m)
     return "image/png";
 
   else if ( m == TimedText::MT_OPENTYPE )
-    return "application/x-opentype";
+    return "application/x-font-opentype";
 
   return "application/octet-stream";
 }
 
+//
+std::ostream&
+ASDCP::TimedText::operator << (std::ostream& strm, const TimedTextDescriptor& TDesc)
+{
+  UUID TmpID(TDesc.AssetID);
+  char buf[64];
+
+  strm << "         EditRate: " << (unsigned) TDesc.EditRate.Numerator << "/" << (unsigned) TDesc.EditRate.Denominator << std::endl;
+  strm << "ContainerDuration: " << (unsigned) TDesc.ContainerDuration << std::endl;
+  strm << "          AssetID: " << TmpID.EncodeHex(buf, 64) << std::endl;
+  strm << "    NamespaceName: " << TDesc.NamespaceName << std::endl;
+  strm << "    ResourceCount: " << (unsigned long) TDesc.ResourceList.size() << std::endl;
+
+  TimedText::ResourceList_t::const_iterator ri;
+  for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end(); ri++ )
+    {
+      TmpID.Set((*ri).ResourceID);
+      strm << "    " << TmpID.EncodeHex(buf, 64) << ": " << MIME2str((*ri).Type) << std::endl;
+    }
+
+  return strm;
+}
+
 //
 void
 ASDCP::TimedText::DescriptorDump(ASDCP::TimedText::TimedTextDescriptor const& TDesc, FILE* stream)
@@ -64,8 +91,8 @@ ASDCP::TimedText::DescriptorDump(ASDCP::TimedText::TimedTextDescriptor const& TD
   fprintf(stream, "         EditRate: %u/%u\n", TDesc.EditRate.Numerator, TDesc.EditRate.Denominator);
   fprintf(stream, "ContainerDuration: %u\n",    TDesc.ContainerDuration);
   fprintf(stream, "          AssetID: %s\n",    TmpID.EncodeHex(buf, 64));
-  fprintf(stream, "    NamespaceName: %s\n", TDesc.NamespaceName.c_str());
-  fprintf(stream, "    ResourceCount: %lu\n", TDesc.ResourceList.size());
+  fprintf(stream, "    NamespaceName: %s\n",    TDesc.NamespaceName.c_str());
+  fprintf(stream, "    ResourceCount: %d\n",   TDesc.ResourceList.size());
 
   TimedText::ResourceList_t::const_iterator ri;
   for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end(); ri++ )
@@ -98,15 +125,15 @@ typedef std::map<UUID, UUID> ResourceMap_t;
 
 class ASDCP::TimedText::MXFReader::h__Reader : public ASDCP::h__Reader
 {
-  TimedTextDescriptor*  m_EssenceDescriptor;
-  ResourceMap_t         m_ResourceMap;
+  MXF::TimedTextDescriptor* m_EssenceDescriptor;
+  ResourceMap_t             m_ResourceMap;
 
   ASDCP_NO_COPY_CONSTRUCT(h__Reader);
 
 public:
   TimedTextDescriptor m_TDesc;    
 
-  h__Reader() : m_EssenceDescriptor(0) {
+  h__Reader(const Dictionary& d) : ASDCP::h__Reader(d), m_EssenceDescriptor(0) {
     memset(&m_TDesc.AssetID, 0, UUIDlen);
   }
 
@@ -122,38 +149,43 @@ ASDCP::TimedText::MXFReader::h__Reader::MD_to_TimedText_TDesc(TimedText::TimedTe
 {
   assert(m_EssenceDescriptor);
   memset(&m_TDesc.AssetID, 0, UUIDlen);
-  MXF::DCTimedTextDescriptor* TDescObj = (MXF::DCTimedTextDescriptor*)m_EssenceDescriptor;
+  MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
 
   TDesc.EditRate = TDescObj->SampleRate;
-  TDesc.ContainerDuration = TDescObj->ContainerDuration;
+  assert(TDescObj->ContainerDuration <= 0xFFFFFFFFL);
+  TDesc.ContainerDuration = (ui32_t) TDescObj->ContainerDuration;
   memcpy(TDesc.AssetID, TDescObj->ResourceID.Value(), UUIDlen);
-  TDesc.NamespaceName = TDescObj->RootNamespaceName;
-  TDesc.EncodingName = TDescObj->UTFEncoding;
+  TDesc.NamespaceName = TDescObj->NamespaceURI;
+  TDesc.EncodingName = TDescObj->UCSEncoding;
 
   Batch<UUID>::const_iterator sdi = TDescObj->SubDescriptors.begin();
-  DCTimedTextResourceDescriptor* DescObject = 0;
+  TimedTextResourceSubDescriptor* DescObject = 0;
   Result_t result = RESULT_OK;
 
   for ( ; sdi != TDescObj->SubDescriptors.end() && KM_SUCCESS(result); sdi++ )
     {
-      result = m_HeaderPart.GetMDObjectByID(*sdi, (InterchangeObject**)&DescObject);
+      InterchangeObject* tmp_iobj = 0;
+      result = m_HeaderPart.GetMDObjectByID(*sdi, &tmp_iobj);
+      DescObject = static_cast<TimedTextResourceSubDescriptor*>(tmp_iobj);
 
       if ( KM_SUCCESS(result) )
 	{
 	  TimedTextResourceDescriptor TmpResource;
-	  memcpy(TmpResource.ResourceID, DescObject->ResourceID.Value(), UUIDlen);
+	  memcpy(TmpResource.ResourceID, DescObject->AncillaryResourceID.Value(), UUIDlen);
 
-	  if ( DescObject->ResourceMIMEType.find("font/") != std::string::npos )
+	  if ( DescObject->MIMEMediaType.find("application/x-font-opentype") != std::string::npos
+	       || DescObject->MIMEMediaType.find("application/x-opentype") != std::string::npos
+	       || DescObject->MIMEMediaType.find("font/opentype") != std::string::npos )
 	    TmpResource.Type = MT_OPENTYPE;
 
-	  else if ( DescObject->ResourceMIMEType.find("image/png") != std::string::npos )
+	  else if ( DescObject->MIMEMediaType.find("image/png") != std::string::npos )
 	    TmpResource.Type = MT_PNG;
 
 	  else
 	    TmpResource.Type = MT_BIN;
 
 	  TDesc.ResourceList.push_back(TmpResource);
-	  m_ResourceMap.insert(ResourceMap_t::value_type(DescObject->ResourceID, *sdi));
+	  m_ResourceMap.insert(ResourceMap_t::value_type(DescObject->AncillaryResourceID, *sdi));
 	}
       else
 	{
@@ -174,9 +206,14 @@ ASDCP::TimedText::MXFReader::h__Reader::OpenRead(char const* filename)
   if( ASDCP_SUCCESS(result) )
     {
       if ( m_EssenceDescriptor == 0 )
-	  m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(DCTimedTextDescriptor), (InterchangeObject**)&m_EssenceDescriptor);
+	{
+	  InterchangeObject* tmp_iobj = 0;
+	  result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(TimedTextDescriptor), &tmp_iobj);
+	  m_EssenceDescriptor = static_cast<MXF::TimedTextDescriptor*>(tmp_iobj);
+	}
 
-      result = MD_to_TimedText_TDesc(m_TDesc);
+      if( ASDCP_SUCCESS(result) )
+	result = MD_to_TimedText_TDesc(m_TDesc);
     }
 
   if( ASDCP_SUCCESS(result) )
@@ -196,7 +233,8 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadTimedTextResource(FrameBuffer& Frame
   if ( ! m_File.IsOpen() )
     return RESULT_INIT;
 
-  Result_t result = ReadEKLVFrame(0, FrameBuf, Dict::ul(MDD_DCTimedTextEssence), Ctx, HMAC);
+  assert(m_Dict);
+  Result_t result = ReadEKLVFrame(0, FrameBuf, m_Dict->ul(MDD_TimedTextEssence), Ctx, HMAC);
 
  if( ASDCP_SUCCESS(result) )
    {
@@ -223,9 +261,11 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
       return RESULT_RANGE;
     }
 
-  DCTimedTextResourceDescriptor* DescObject = 0;
+  TimedTextResourceSubDescriptor* DescObject = 0;
   // get the subdescriptor
-  Result_t result = m_HeaderPart.GetMDObjectByID((*ri).second, (InterchangeObject**)&DescObject);
+  InterchangeObject* tmp_iobj = 0;
+  Result_t result = m_HeaderPart.GetMDObjectByID((*ri).second, &tmp_iobj);
+  DescObject = static_cast<TimedTextResourceSubDescriptor*>(tmp_iobj);
 
   if ( KM_SUCCESS(result) )
     {
@@ -238,7 +278,7 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
       // value needed to  complete the HMAC.
       for ( pi = m_HeaderPart.m_RIP.PairArray.begin(); pi != m_HeaderPart.m_RIP.PairArray.end(); pi++, sequence++ )
 	{
-	  if ( (*pi).BodySID == DescObject->ResourceSID )
+	  if ( (*pi).BodySID == DescObject->EssenceStreamID )
 	    {
 	      TmpPair = *pi;
 	      break;
@@ -247,14 +287,14 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
 
       if ( TmpPair.ByteOffset == 0 )
 	{
-	  DefaultLogSink().Error("Body SID not found in RIP set: %d\n", DescObject->ResourceSID);
+	  DefaultLogSink().Error("Body SID not found in RIP set: %d\n", DescObject->EssenceStreamID);
 	  return RESULT_FORMAT;
 	}
 
       if ( KM_SUCCESS(result) )
 	{
 	  FrameBuf.AssetID(uuid);
-	  FrameBuf.MIMEType(DescObject->ResourceMIMEType);
+	  FrameBuf.MIMEType(DescObject->MIMEMediaType);
 
 	  // seek tp the start of the partition
 	  if ( (Kumu::fpos_t)TmpPair.ByteOffset != m_LastPosition )
@@ -264,13 +304,13 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
 	    }
 
 	  // read the partition header
-	  MXF::Partition GSPart;
+	  MXF::Partition GSPart(m_Dict);
 	  result = GSPart.InitFromFile(m_File);
 
 	  if( ASDCP_SUCCESS(result) )
 	    {
 	      // check the SID
-	      if ( DescObject->ResourceSID != GSPart.BodySID )
+	      if ( DescObject->EssenceStreamID != GSPart.BodySID )
 		{
 		  char buf[64];
 		  DefaultLogSink().Error("Generic stream partition body differs: %s\n", RID.EncodeHex(buf, 64));
@@ -278,8 +318,9 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
 		}
 
 	      // read the essence packet
+	      assert(m_Dict);
 	      if( ASDCP_SUCCESS(result) )
-		result = ReadEKLVPacket(0, FrameBuf, Dict::ul(MDD_DCTimedTextDescriptor), Ctx, HMAC);
+		result = ReadEKLVPacket(0, 1, FrameBuf, m_Dict->ul(MDD_GenericStream_DataElement), Ctx, HMAC);
 	    }
 	}
     }
@@ -292,7 +333,7 @@ ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid
 
 ASDCP::TimedText::MXFReader::MXFReader()
 {
-  m_Reader = new h__Reader;
+  m_Reader = new h__Reader(DefaultSMPTEDict());
 }
 
 
@@ -311,7 +352,7 @@ ASDCP::TimedText::MXFReader::OpenRead(const char* filename) const
 // Fill the struct with the values from the file's header.
 // Returns RESULT_INIT if the file is not open.
 ASDCP::Result_t
-ASDCP::TimedText::MXFReader::FillDescriptor(TimedText::TimedTextDescriptor& TDesc) const
+ASDCP::TimedText::MXFReader::FillTimedTextDescriptor(TimedText::TimedTextDescriptor& TDesc) const
 {
   if ( m_Reader && m_Reader->m_File.IsOpen() )
     {
@@ -390,20 +431,35 @@ ASDCP::TimedText::MXFReader::DumpIndex(FILE* stream) const
     m_Reader->m_FooterPart.Dump(stream);
 }
 
+//
+ASDCP::Result_t
+ASDCP::TimedText::MXFReader::Close() const
+{
+  if ( m_Reader && m_Reader->m_File.IsOpen() )
+    {
+      m_Reader->Close();
+      return RESULT_OK;
+    }
+
+  return RESULT_INIT;
+}
+
+
 //------------------------------------------------------------------------------------------
 
 
 //
 class ASDCP::TimedText::MXFWriter::h__Writer : public ASDCP::h__Writer
 {
+  ASDCP_NO_COPY_CONSTRUCT(h__Writer);
+  h__Writer();
+
 public:
   TimedTextDescriptor m_TDesc;
   byte_t              m_EssenceUL[SMPTE_UL_LENGTH];
-  ui32_t              m_ResourceSID;
+  ui32_t              m_EssenceStreamID;
 
-  ASDCP_NO_COPY_CONSTRUCT(h__Writer);
-
-  h__Writer() : m_ResourceSID(10) {
+  h__Writer(const Dictionary& d) : ASDCP::h__Writer(d), m_EssenceStreamID(10) {
     memset(m_EssenceUL, 0, SMPTE_UL_LENGTH);
   }
 
@@ -422,13 +478,13 @@ ASDCP::Result_t
 ASDCP::TimedText::MXFWriter::h__Writer::TimedText_TDesc_to_MD(TimedText::TimedTextDescriptor& TDesc)
 {
   assert(m_EssenceDescriptor);
-  MXF::DCTimedTextDescriptor* TDescObj = (MXF::DCTimedTextDescriptor*)m_EssenceDescriptor;
+  MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
 
   TDescObj->SampleRate = TDesc.EditRate;
   TDescObj->ContainerDuration = TDesc.ContainerDuration;
   TDescObj->ResourceID.Set(TDesc.AssetID);
-  TDescObj->RootNamespaceName = TDesc.NamespaceName;
-  TDescObj->UTFEncoding = TDesc.EncodingName;
+  TDescObj->NamespaceURI = TDesc.NamespaceName;
+  TDescObj->UCSEncoding = TDesc.EncodingName;
 
   return RESULT_OK;
 }
@@ -445,7 +501,7 @@ ASDCP::TimedText::MXFWriter::h__Writer::OpenWrite(char const* filename, ui32_t H
   if ( ASDCP_SUCCESS(result) )
     {
       m_HeaderSize = HeaderSize;
-      m_EssenceDescriptor = new DCTimedTextDescriptor();
+      m_EssenceDescriptor = new MXF::TimedTextDescriptor(m_Dict);
       result = m_State.Goto_INIT();
     }
 
@@ -465,24 +521,25 @@ ASDCP::TimedText::MXFWriter::h__Writer::SetSourceStream(ASDCP::TimedText::TimedT
 
   for ( ri = m_TDesc.ResourceList.begin() ; ri != m_TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
     {
-      DCTimedTextResourceDescriptor* resourceSubdescriptor = new DCTimedTextResourceDescriptor;
+      TimedTextResourceSubDescriptor* resourceSubdescriptor = new TimedTextResourceSubDescriptor(m_Dict);
       GenRandomValue(resourceSubdescriptor->InstanceUID);
-      resourceSubdescriptor->ResourceID.Set((*ri).ResourceID);
-      resourceSubdescriptor->ResourceMIMEType = MIME2str((*ri).Type);
-      resourceSubdescriptor->ResourceSID = m_ResourceSID++;
+      resourceSubdescriptor->AncillaryResourceID.Set((*ri).ResourceID);
+      resourceSubdescriptor->MIMEMediaType = MIME2str((*ri).Type);
+      resourceSubdescriptor->EssenceStreamID = m_EssenceStreamID++;
       m_EssenceSubDescriptorList.push_back((FileDescriptor*)resourceSubdescriptor);
       m_EssenceDescriptor->SubDescriptors.push_back(resourceSubdescriptor->InstanceUID);
     }
 
-  m_ResourceSID = 10;
+  m_EssenceStreamID = 10;
+  assert(m_Dict);
 
   if ( ASDCP_SUCCESS(result) )
     {
       InitHeader();
       AddDMSegment(m_TDesc.EditRate, 24, TIMED_TEXT_DEF_LABEL,
-		   UL(Dict::ul(MDD_PictureDataDef)), TIMED_TEXT_PACKAGE_LABEL);
+		   UL(m_Dict->ul(MDD_PictureDataDef)), TIMED_TEXT_PACKAGE_LABEL);
 
-      AddEssenceDescriptor(UL(Dict::ul(MDD_DCTimedTextWrapping)));
+      AddEssenceDescriptor(UL(m_Dict->ul(MDD_TimedTextWrapping)));
 
       result = m_HeaderPart.WriteToFile(m_File, m_HeaderSize);
       
@@ -492,7 +549,7 @@ ASDCP::TimedText::MXFWriter::h__Writer::SetSourceStream(ASDCP::TimedText::TimedT
 
   if ( ASDCP_SUCCESS(result) )
     {
-      memcpy(m_EssenceUL, Dict::ul(MDD_DCTimedTextEssence), SMPTE_UL_LENGTH);
+      memcpy(m_EssenceUL, m_Dict->ul(MDD_TimedTextEssence), SMPTE_UL_LENGTH);
       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
       result = m_State.Goto_READY();
     }
@@ -543,24 +600,26 @@ ASDCP::TimedText::MXFWriter::h__Writer::WriteAncillaryResource(const ASDCP::Time
     return RESULT_STATE;
 
   Kumu::fpos_t here = m_File.Tell();
+  assert(m_Dict);
 
   // create generic stream partition header
-  MXF::Partition GSPart;
+  static UL GenericStream_DataElement(m_Dict->ul(MDD_GenericStream_DataElement));
+  MXF::Partition GSPart(m_Dict);
 
   GSPart.ThisPartition = here;
   GSPart.PreviousPartition = m_HeaderPart.m_RIP.PairArray.back().ByteOffset;
-  GSPart.BodySID = m_ResourceSID;
+  GSPart.BodySID = m_EssenceStreamID;
   GSPart.OperationalPattern = m_HeaderPart.OperationalPattern;
 
-  m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(m_ResourceSID++, here));
-  GSPart.EssenceContainers.push_back(UL(Dict::ul(MDD_DCTimedTextEssence)));
-  UL TmpUL(Dict::ul(MDD_GenericStreamPartition));
+  m_HeaderPart.m_RIP.PairArray.push_back(RIP::Pair(m_EssenceStreamID++, here));
+  GSPart.EssenceContainers.push_back(UL(m_Dict->ul(MDD_TimedTextEssence)));
+  UL TmpUL(m_Dict->ul(MDD_GenericStreamPartition));
   Result_t result = GSPart.WriteToFile(m_File, TmpUL);
 
   if ( ASDCP_SUCCESS(result) )
-    result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC);
+    result = WriteEKLVPacket(FrameBuf, GenericStream_DataElement.Value(), Ctx, HMAC);
 
- m_FramesWritten++;
+  m_FramesWritten++;
   return result;
 }
 
@@ -601,15 +660,13 @@ ASDCP::TimedText::MXFWriter::OpenWrite(const char* filename, const WriterInfo& I
       return RESULT_FORMAT;
     }
 
-  m_Writer = new h__Writer;
+  m_Writer = new h__Writer(DefaultSMPTEDict());
+  m_Writer->m_Info = Info;
   
   Result_t result = m_Writer->OpenWrite(filename, HeaderSize);
 
   if ( ASDCP_SUCCESS(result) )
-    {
-      m_Writer->m_Info = Info;
-      result = m_Writer->SetSourceStream(TDesc);
-    }
+    result = m_Writer->SetSourceStream(TDesc);
 
   if ( ASDCP_FAILURE(result) )
     m_Writer.release();