src/AS_DCP_TimedText.cpp

   1 /*
   2 Copyright (c) 2008-2013, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27 /*! \file    AS_DCP_TimedText.cpp
  28     \version $Id$
  29     \brief   AS-DCP library, PCM essence reader and writer implementation
  30 */
  31
  32
  33 #include "AS_DCP_internal.h"
  34 #include "KM_xml.h"
  35 #include <iostream>
  36 #include <iomanip>
  37
  38 using Kumu::GenRandomValue;
  39
  40 static std::string TIMED_TEXT_PACKAGE_LABEL = "File Package: SMPTE 429-5 clip wrapping of D-Cinema Timed Text data";
  41 static std::string TIMED_TEXT_DEF_LABEL = "Timed Text Track";
  42
  43
  44 //------------------------------------------------------------------------------------------
  45
  46 const char*
  47 MIME2str(TimedText::MIMEType_t m)
  48 {
  49   if ( m == TimedText::MT_PNG )
  50     return "image/png";
  51
  52   else if ( m == TimedText::MT_OPENTYPE )
  53     return "application/x-font-opentype";
  54
  55   return "application/octet-stream";
  56 }
  57
  58 //
  59 std::ostream&
  60 ASDCP::TimedText::operator << (std::ostream& strm, const TimedTextDescriptor& TDesc)
  61 {
  62   UUID TmpID(TDesc.AssetID);
  63   char buf[64];
  64
  65   strm << "         EditRate: " << (unsigned) TDesc.EditRate.Numerator << "/" << (unsigned) TDesc.EditRate.Denominator << std::endl;
  66   strm << "ContainerDuration: " << (unsigned) TDesc.ContainerDuration << std::endl;
  67   strm << "          AssetID: " << TmpID.EncodeHex(buf, 64) << std::endl;
  68   strm << "    NamespaceName: " << TDesc.NamespaceName << std::endl;
  69   strm << "    ResourceCount: " << (unsigned long) TDesc.ResourceList.size() << std::endl;
  70
  71   TimedText::ResourceList_t::const_iterator ri;
  72   for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end(); ri++ )
  73     {
  74       TmpID.Set((*ri).ResourceID);
  75       strm << "    " << TmpID.EncodeHex(buf, 64) << ": " << MIME2str((*ri).Type) << std::endl;
  76     }
  77
  78   return strm;
  79 }
  80
  81 //
  82 void
  83 ASDCP::TimedText::DescriptorDump(ASDCP::TimedText::TimedTextDescriptor const& TDesc, FILE* stream)
  84 {
  85   if ( stream == 0 )
  86     stream = stderr;
  87
  88   UUID TmpID(TDesc.AssetID);
  89   char buf[64];
  90
  91   fprintf(stream, "         EditRate: %u/%u\n", TDesc.EditRate.Numerator, TDesc.EditRate.Denominator);
  92   fprintf(stream, "ContainerDuration: %u\n",    TDesc.ContainerDuration);
  93   fprintf(stream, "          AssetID: %s\n",    TmpID.EncodeHex(buf, 64));
  94   fprintf(stream, "    NamespaceName: %s\n",    TDesc.NamespaceName.c_str());
  95   fprintf(stream, "    ResourceCount: %zu\n",   TDesc.ResourceList.size());
  96
  97   TimedText::ResourceList_t::const_iterator ri;
  98   for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end(); ri++ )
  99     {
 100       TmpID.Set((*ri).ResourceID);
 101       fprintf(stream, "    %s: %s\n",
 102               TmpID.EncodeHex(buf, 64),
 103               MIME2str((*ri).Type));
 104     }
 105 }
 106
 107 //
 108 void
 109 ASDCP::TimedText::FrameBuffer::Dump(FILE* stream, ui32_t dump_len) const
 110 {
 111   if ( stream == 0 )
 112     stream = stderr;
 113
 114   UUID TmpID(m_AssetID);
 115   char buf[64];
 116   fprintf(stream, "%s | %s | %u\n", TmpID.EncodeHex(buf, 64), m_MIMEType.c_str(), Size());
 117
 118   if ( dump_len > 0 )
 119     Kumu::hexdump(m_Data, dump_len, stream);
 120 }
 121
 122 //------------------------------------------------------------------------------------------
 123
 124 typedef std::map<UUID, UUID> ResourceMap_t;
 125
 126 class ASDCP::TimedText::MXFReader::h__Reader : public ASDCP::h__ASDCPReader
 127 {
 128   MXF::TimedTextDescriptor* m_EssenceDescriptor;
 129   ResourceMap_t             m_ResourceMap;
 130
 131   ASDCP_NO_COPY_CONSTRUCT(h__Reader);
 132
 133 public:
 134   TimedTextDescriptor m_TDesc;
 135
 136   h__Reader(const Dictionary& d) : ASDCP::h__ASDCPReader(d), m_EssenceDescriptor(0) {
 137     memset(&m_TDesc.AssetID, 0, UUIDlen);
 138   }
 139
 140   virtual ~h__Reader() {}
 141
 142   Result_t    OpenRead(const char*);
 143   Result_t    MD_to_TimedText_TDesc(TimedText::TimedTextDescriptor& TDesc);
 144   Result_t    ReadTimedTextResource(FrameBuffer& FrameBuf, AESDecContext* Ctx, HMACContext* HMAC);
 145   Result_t    ReadAncillaryResource(const byte_t*, FrameBuffer& FrameBuf, AESDecContext* Ctx, HMACContext* HMAC);
 146 };
 147
 148 //
 149 ASDCP::Result_t
 150 ASDCP::TimedText::MXFReader::h__Reader::MD_to_TimedText_TDesc(TimedText::TimedTextDescriptor& TDesc)
 151 {
 152   assert(m_EssenceDescriptor);
 153   memset(&m_TDesc.AssetID, 0, UUIDlen);
 154   MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
 155
 156   TDesc.EditRate = TDescObj->SampleRate;
 157   assert(TDescObj->ContainerDuration <= 0xFFFFFFFFL);
 158   TDesc.ContainerDuration = (ui32_t) TDescObj->ContainerDuration;
 159   memcpy(TDesc.AssetID, TDescObj->ResourceID.Value(), UUIDlen);
 160   TDesc.NamespaceName = TDescObj->NamespaceURI;
 161   TDesc.EncodingName = TDescObj->UCSEncoding;
 162
 163   Batch<UUID>::const_iterator sdi = TDescObj->SubDescriptors.begin();
 164   TimedTextResourceSubDescriptor* DescObject = 0;
 165   Result_t result = RESULT_OK;
 166
 167   for ( ; sdi != TDescObj->SubDescriptors.end() && KM_SUCCESS(result); sdi++ )
 168     {
 169       InterchangeObject* tmp_iobj = 0;
 170       result = m_HeaderPart.GetMDObjectByID(*sdi, &tmp_iobj);
 171       DescObject = static_cast<TimedTextResourceSubDescriptor*>(tmp_iobj);
 172
 173       if ( KM_SUCCESS(result) )
 174         {
 175           TimedTextResourceDescriptor TmpResource;
 176           memcpy(TmpResource.ResourceID, DescObject->AncillaryResourceID.Value(), UUIDlen);
 177
 178           if ( DescObject->MIMEMediaType.find("application/x-font-opentype") != std::string::npos
 179                || DescObject->MIMEMediaType.find("application/x-opentype") != std::string::npos
 180                || DescObject->MIMEMediaType.find("font/opentype") != std::string::npos )
 181             TmpResource.Type = MT_OPENTYPE;
 182
 183           else if ( DescObject->MIMEMediaType.find("image/png") != std::string::npos )
 184             TmpResource.Type = MT_PNG;
 185
 186           else
 187             TmpResource.Type = MT_BIN;
 188
 189           TDesc.ResourceList.push_back(TmpResource);
 190           m_ResourceMap.insert(ResourceMap_t::value_type(DescObject->AncillaryResourceID, *sdi));
 191         }
 192       else
 193         {
 194           DefaultLogSink().Error("Broken sub-descriptor link\n");
 195           return RESULT_FORMAT;
 196         }
 197     }
 198
 199   return result;
 200 }
 201
 202 //
 203 ASDCP::Result_t
 204 ASDCP::TimedText::MXFReader::h__Reader::OpenRead(char const* filename)
 205 {
 206   Result_t result = OpenMXFRead(filename);
 207
 208   if( ASDCP_SUCCESS(result) )
 209     {
 210       if ( m_EssenceDescriptor == 0 )
 211         {
 212           InterchangeObject* tmp_iobj = 0;
 213           result = m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(TimedTextDescriptor), &tmp_iobj);
 214           m_EssenceDescriptor = static_cast<MXF::TimedTextDescriptor*>(tmp_iobj);
 215         }
 216
 217       if( ASDCP_SUCCESS(result) )
 218         result = MD_to_TimedText_TDesc(m_TDesc);
 219     }
 220
 221   return result;
 222 }
 223
 224 //
 225 ASDCP::Result_t
 226 ASDCP::TimedText::MXFReader::h__Reader::ReadTimedTextResource(FrameBuffer& FrameBuf,
 227                                                               AESDecContext* Ctx, HMACContext* HMAC)
 228 {
 229   if ( ! m_File.IsOpen() )
 230     return RESULT_INIT;
 231
 232   assert(m_Dict);
 233   Result_t result = ReadEKLVFrame(0, FrameBuf, m_Dict->ul(MDD_TimedTextEssence), Ctx, HMAC);
 234
 235  if( ASDCP_SUCCESS(result) )
 236    {
 237      FrameBuf.AssetID(m_TDesc.AssetID);
 238      FrameBuf.MIMEType("text/xml");
 239    }
 240
 241  return result;
 242 }
 243
 244 //
 245 ASDCP::Result_t
 246 ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid, FrameBuffer& FrameBuf,
 247                                                               AESDecContext* Ctx, HMACContext* HMAC)
 248 {
 249   KM_TEST_NULL_L(uuid);
 250   UUID RID(uuid);
 251
 252   ResourceMap_t::const_iterator ri = m_ResourceMap.find(RID);
 253   if ( ri == m_ResourceMap.end() )
 254     {
 255       char buf[64];
 256       DefaultLogSink().Error("No such resource: %s\n", RID.EncodeHex(buf, 64));
 257       return RESULT_RANGE;
 258     }
 259
 260   TimedTextResourceSubDescriptor* DescObject = 0;
 261   // get the subdescriptor
 262   InterchangeObject* tmp_iobj = 0;
 263   Result_t result = m_HeaderPart.GetMDObjectByID((*ri).second, &tmp_iobj);
 264   DescObject = static_cast<TimedTextResourceSubDescriptor*>(tmp_iobj);
 265
 266   if ( KM_SUCCESS(result) )
 267     {
 268       Array<RIP::Pair>::const_iterator pi;
 269       RIP::Pair TmpPair;
 270       ui32_t sequence = 0;
 271
 272       // Look up the partition start in the RIP using the SID.
 273       // Count the sequence length in because this is the sequence
 274       // value needed to  complete the HMAC.
 275       for ( pi = m_RIP.PairArray.begin(); pi != m_RIP.PairArray.end(); ++pi, ++sequence )
 276         {
 277           if ( (*pi).BodySID == DescObject->EssenceStreamID )
 278             {
 279               TmpPair = *pi;
 280               break;
 281             }
 282         }
 283
 284       if ( TmpPair.ByteOffset == 0 )
 285         {
 286           DefaultLogSink().Error("Body SID not found in RIP set: %d\n", DescObject->EssenceStreamID);
 287           return RESULT_FORMAT;
 288         }
 289
 290       if ( KM_SUCCESS(result) )
 291         {
 292           FrameBuf.AssetID(uuid);
 293           FrameBuf.MIMEType(DescObject->MIMEMediaType);
 294
 295           // seek tp the start of the partition
 296           if ( (Kumu::fpos_t)TmpPair.ByteOffset != m_LastPosition )
 297             {
 298               m_LastPosition = TmpPair.ByteOffset;
 299               result = m_File.Seek(TmpPair.ByteOffset);
 300             }
 301
 302           // read the partition header
 303           MXF::Partition GSPart(m_Dict);
 304           result = GSPart.InitFromFile(m_File);
 305
 306           if( ASDCP_SUCCESS(result) )
 307             {
 308               // check the SID
 309               if ( DescObject->EssenceStreamID != GSPart.BodySID )
 310                 {
 311                   char buf[64];
 312                   DefaultLogSink().Error("Generic stream partition body differs: %s\n", RID.EncodeHex(buf, 64));
 313                   return RESULT_FORMAT;
 314                 }
 315
 316               // read the essence packet
 317               assert(m_Dict);
 318               if( ASDCP_SUCCESS(result) )
 319                 result = ReadEKLVPacket(0, sequence, FrameBuf, m_Dict->ul(MDD_GenericStream_DataElement), Ctx, HMAC);
 320             }
 321         }
 322     }
 323
 324   return result;
 325 }
 326
 327
 328 //------------------------------------------------------------------------------------------
 329
 330 ASDCP::TimedText::MXFReader::MXFReader()
 331 {
 332   m_Reader = new h__Reader(DefaultSMPTEDict());
 333 }
 334
 335
 336 ASDCP::TimedText::MXFReader::~MXFReader()
 337 {
 338 }
 339
 340 // Warning: direct manipulation of MXF structures can interfere
 341 // with the normal operation of the wrapper.  Caveat emptor!
 342 //
 343 ASDCP::MXF::OP1aHeader&
 344 ASDCP::TimedText::MXFReader::OP1aHeader()
 345 {
 346   if ( m_Reader.empty() )
 347     {
 348       assert(g_OP1aHeader);
 349       return *g_OP1aHeader;
 350     }
 351
 352   return m_Reader->m_HeaderPart;
 353 }
 354
 355 // Warning: direct manipulation of MXF structures can interfere
 356 // with the normal operation of the wrapper.  Caveat emptor!
 357 //
 358 ASDCP::MXF::OPAtomIndexFooter&
 359 ASDCP::TimedText::MXFReader::OPAtomIndexFooter()
 360 {
 361   if ( m_Reader.empty() )
 362     {
 363       assert(g_OPAtomIndexFooter);
 364       return *g_OPAtomIndexFooter;
 365     }
 366
 367   return m_Reader->m_IndexAccess;
 368 }
 369
 370 // Warning: direct manipulation of MXF structures can interfere
 371 // with the normal operation of the wrapper.  Caveat emptor!
 372 //
 373 ASDCP::MXF::RIP&
 374 ASDCP::TimedText::MXFReader::RIP()
 375 {
 376   if ( m_Reader.empty() )
 377     {
 378       assert(g_RIP);
 379       return *g_RIP;
 380     }
 381
 382   return m_Reader->m_RIP;
 383 }
 384
 385 // Open the file for reading. The file must exist. Returns error if the
 386 // operation cannot be completed.
 387 ASDCP::Result_t
 388 ASDCP::TimedText::MXFReader::OpenRead(const char* filename) const
 389 {
 390   return m_Reader->OpenRead(filename);
 391 }
 392
 393 // Fill the struct with the values from the file's header.
 394 // Returns RESULT_INIT if the file is not open.
 395 ASDCP::Result_t
 396 ASDCP::TimedText::MXFReader::FillTimedTextDescriptor(TimedText::TimedTextDescriptor& TDesc) const
 397 {
 398   if ( m_Reader && m_Reader->m_File.IsOpen() )
 399     {
 400       TDesc = m_Reader->m_TDesc;
 401       return RESULT_OK;
 402     }
 403
 404   return RESULT_INIT;
 405 }
 406
 407 // Fill the struct with the values from the file's header.
 408 // Returns RESULT_INIT if the file is not open.
 409 ASDCP::Result_t
 410 ASDCP::TimedText::MXFReader::FillWriterInfo(WriterInfo& Info) const
 411 {
 412   if ( m_Reader && m_Reader->m_File.IsOpen() )
 413     {
 414       Info = m_Reader->m_Info;
 415       return RESULT_OK;
 416     }
 417
 418   return RESULT_INIT;
 419 }
 420
 421 //
 422 ASDCP::Result_t
 423 ASDCP::TimedText::MXFReader::ReadTimedTextResource(std::string& s, AESDecContext* Ctx, HMACContext* HMAC) const
 424 {
 425   FrameBuffer FrameBuf(2*Kumu::Megabyte);
 426
 427   Result_t result = ReadTimedTextResource(FrameBuf, Ctx, HMAC);
 428
 429   if ( ASDCP_SUCCESS(result) )
 430     s.assign((char*)FrameBuf.Data(), FrameBuf.Size());
 431
 432   return result;
 433 }
 434
 435 //
 436 ASDCP::Result_t
 437 ASDCP::TimedText::MXFReader::ReadTimedTextResource(FrameBuffer& FrameBuf,
 438                                                    AESDecContext* Ctx, HMACContext* HMAC) const
 439 {
 440   if ( m_Reader && m_Reader->m_File.IsOpen() )
 441     return m_Reader->ReadTimedTextResource(FrameBuf, Ctx, HMAC);
 442
 443   return RESULT_INIT;
 444 }
 445
 446 //
 447 ASDCP::Result_t
 448 ASDCP::TimedText::MXFReader::ReadAncillaryResource(const byte_t* uuid, FrameBuffer& FrameBuf,
 449                                                    AESDecContext* Ctx, HMACContext* HMAC) const
 450 {
 451   if ( m_Reader && m_Reader->m_File.IsOpen() )
 452     return m_Reader->ReadAncillaryResource(uuid, FrameBuf, Ctx, HMAC);
 453
 454   return RESULT_INIT;
 455 }
 456
 457
 458 //
 459 void
 460 ASDCP::TimedText::MXFReader::DumpHeaderMetadata(FILE* stream) const
 461 {
 462   if ( m_Reader->m_File.IsOpen() )
 463     m_Reader->m_HeaderPart.Dump(stream);
 464 }
 465
 466
 467 //
 468 void
 469 ASDCP::TimedText::MXFReader::DumpIndex(FILE* stream) const
 470 {
 471   if ( m_Reader->m_File.IsOpen() )
 472     m_Reader->m_IndexAccess.Dump(stream);
 473 }
 474
 475 //
 476 ASDCP::Result_t
 477 ASDCP::TimedText::MXFReader::Close() const
 478 {
 479   if ( m_Reader && m_Reader->m_File.IsOpen() )
 480     {
 481       m_Reader->Close();
 482       return RESULT_OK;
 483     }
 484
 485   return RESULT_INIT;
 486 }
 487
 488
 489 //------------------------------------------------------------------------------------------
 490
 491
 492 //
 493 class ASDCP::TimedText::MXFWriter::h__Writer : public ASDCP::h__ASDCPWriter
 494 {
 495   ASDCP_NO_COPY_CONSTRUCT(h__Writer);
 496   h__Writer();
 497
 498 public:
 499   TimedTextDescriptor m_TDesc;
 500   byte_t              m_EssenceUL[SMPTE_UL_LENGTH];
 501   ui32_t              m_EssenceStreamID;
 502
 503   h__Writer(const Dictionary& d) : ASDCP::h__ASDCPWriter(d), m_EssenceStreamID(10) {
 504     memset(m_EssenceUL, 0, SMPTE_UL_LENGTH);
 505   }
 506
 507   virtual ~h__Writer() {}
 508
 509   Result_t OpenWrite(const char*, ui32_t HeaderSize);
 510   Result_t SetSourceStream(const TimedTextDescriptor&);
 511   Result_t WriteTimedTextResource(const std::string& XMLDoc, AESEncContext* = 0, HMACContext* = 0);
 512   Result_t WriteAncillaryResource(const FrameBuffer&, AESEncContext* = 0, HMACContext* = 0);
 513   Result_t Finalize();
 514   Result_t TimedText_TDesc_to_MD(TimedText::TimedTextDescriptor& TDesc);
 515 };
 516
 517 //
 518 ASDCP::Result_t
 519 ASDCP::TimedText::MXFWriter::h__Writer::TimedText_TDesc_to_MD(TimedText::TimedTextDescriptor& TDesc)
 520 {
 521   assert(m_EssenceDescriptor);
 522   MXF::TimedTextDescriptor* TDescObj = (MXF::TimedTextDescriptor*)m_EssenceDescriptor;
 523
 524   TDescObj->SampleRate = TDesc.EditRate;
 525   TDescObj->ContainerDuration = TDesc.ContainerDuration;
 526   TDescObj->ResourceID.Set(TDesc.AssetID);
 527   TDescObj->NamespaceURI = TDesc.NamespaceName;
 528   TDescObj->UCSEncoding = TDesc.EncodingName;
 529
 530   return RESULT_OK;
 531 }
 532
 533 //
 534 ASDCP::Result_t
 535 ASDCP::TimedText::MXFWriter::h__Writer::OpenWrite(char const* filename, ui32_t HeaderSize)
 536 {
 537   if ( ! m_State.Test_BEGIN() )
 538     return RESULT_STATE;
 539
 540   Result_t result = m_File.OpenWrite(filename);
 541
 542   if ( ASDCP_SUCCESS(result) )
 543     {
 544       m_HeaderSize = HeaderSize;
 545       m_EssenceDescriptor = new MXF::TimedTextDescriptor(m_Dict);
 546       result = m_State.Goto_INIT();
 547     }
 548
 549   return result;
 550 }
 551
 552 //
 553 ASDCP::Result_t
 554 ASDCP::TimedText::MXFWriter::h__Writer::SetSourceStream(ASDCP::TimedText::TimedTextDescriptor const& TDesc)
 555 {
 556   if ( ! m_State.Test_INIT() )
 557     return RESULT_STATE;
 558
 559   m_TDesc = TDesc;
 560   ResourceList_t::const_iterator ri;
 561   Result_t result = TimedText_TDesc_to_MD(m_TDesc);
 562
 563   for ( ri = m_TDesc.ResourceList.begin() ; ri != m_TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
 564     {
 565       TimedTextResourceSubDescriptor* resourceSubdescriptor = new TimedTextResourceSubDescriptor(m_Dict);
 566       GenRandomValue(resourceSubdescriptor->InstanceUID);
 567       resourceSubdescriptor->AncillaryResourceID.Set((*ri).ResourceID);
 568       resourceSubdescriptor->MIMEMediaType = MIME2str((*ri).Type);
 569       resourceSubdescriptor->EssenceStreamID = m_EssenceStreamID++;
 570       m_EssenceSubDescriptorList.push_back((FileDescriptor*)resourceSubdescriptor);
 571       m_EssenceDescriptor->SubDescriptors.push_back(resourceSubdescriptor->InstanceUID);
 572     }
 573
 574   m_EssenceStreamID = 10;
 575   assert(m_Dict);
 576
 577   if ( ASDCP_SUCCESS(result) )
 578     {
 579       InitHeader();
 580       AddDMSegment(m_TDesc.EditRate, 24, TIMED_TEXT_DEF_LABEL,
 581                    UL(m_Dict->ul(MDD_DataDataDef)), TIMED_TEXT_PACKAGE_LABEL);
 582
 583       AddEssenceDescriptor(UL(m_Dict->ul(MDD_TimedTextWrapping)));
 584
 585       result = m_HeaderPart.WriteToFile(m_File, m_HeaderSize);
 586
 587       if ( KM_SUCCESS(result) )
 588         result = CreateBodyPart(m_TDesc.EditRate);
 589     }
 590
 591   if ( ASDCP_SUCCESS(result) )
 592     {
 593       memcpy(m_EssenceUL, m_Dict->ul(MDD_TimedTextEssence), SMPTE_UL_LENGTH);
 594       m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
 595       result = m_State.Goto_READY();
 596     }
 597
 598   return result;
 599 }
 600
 601 //
 602 ASDCP::Result_t
 603 ASDCP::TimedText::MXFWriter::h__Writer::WriteTimedTextResource(const std::string& XMLDoc,
 604                                                                ASDCP::AESEncContext* Ctx, ASDCP::HMACContext* HMAC)
 605 {
 606   Result_t result = m_State.Goto_RUNNING();
 607
 608   if ( ASDCP_SUCCESS(result) )
 609     {
 610       // TODO: make sure it's XML
 611
 612       ui32_t str_size = XMLDoc.size();
 613       FrameBuffer FrameBuf(str_size);
 614
 615       memcpy(FrameBuf.Data(), XMLDoc.c_str(), str_size);
 616       FrameBuf.Size(str_size);
 617
 618       IndexTableSegment::IndexEntry Entry;
 619       Entry.StreamOffset = m_StreamOffset;
 620
 621       if ( ASDCP_SUCCESS(result) )
 622         result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC);
 623
 624       if ( ASDCP_SUCCESS(result) )
 625         {
 626           m_FooterPart.PushIndexEntry(Entry);
 627           m_FramesWritten++;
 628         }
 629     }
 630
 631   return result;
 632 }
 633
 634
 635 //
 636 ASDCP::Result_t
 637 ASDCP::TimedText::MXFWriter::h__Writer::WriteAncillaryResource(const ASDCP::TimedText::FrameBuffer& FrameBuf,
 638                                                                ASDCP::AESEncContext* Ctx, ASDCP::HMACContext* HMAC)
 639 {
 640   if ( ! m_State.Test_RUNNING() )
 641     return RESULT_STATE;
 642
 643   Kumu::fpos_t here = m_File.Tell();
 644   assert(m_Dict);
 645
 646   // create generic stream partition header
 647   static UL GenericStream_DataElement(m_Dict->ul(MDD_GenericStream_DataElement));
 648   MXF::Partition GSPart(m_Dict);
 649
 650   GSPart.ThisPartition = here;
 651   GSPart.PreviousPartition = m_RIP.PairArray.back().ByteOffset;
 652   GSPart.BodySID = m_EssenceStreamID;
 653   GSPart.OperationalPattern = m_HeaderPart.OperationalPattern;
 654
 655   m_RIP.PairArray.push_back(RIP::Pair(m_EssenceStreamID++, here));
 656   GSPart.EssenceContainers.push_back(UL(m_Dict->ul(MDD_TimedTextEssence)));
 657   UL TmpUL(m_Dict->ul(MDD_GenericStreamPartition));
 658   Result_t result = GSPart.WriteToFile(m_File, TmpUL);
 659
 660   if ( ASDCP_SUCCESS(result) )
 661     result = WriteEKLVPacket(FrameBuf, GenericStream_DataElement.Value(), Ctx, HMAC);
 662
 663   m_FramesWritten++;
 664   return result;
 665 }
 666
 667 //
 668 ASDCP::Result_t
 669 ASDCP::TimedText::MXFWriter::h__Writer::Finalize()
 670 {
 671   if ( ! m_State.Test_RUNNING() )
 672     return RESULT_STATE;
 673
 674   m_FramesWritten = m_TDesc.ContainerDuration;
 675   m_State.Goto_FINAL();
 676
 677   return WriteASDCPFooter();
 678 }
 679
 680
 681 //------------------------------------------------------------------------------------------
 682
 683 ASDCP::TimedText::MXFWriter::MXFWriter()
 684 {
 685 }
 686
 687 ASDCP::TimedText::MXFWriter::~MXFWriter()
 688 {
 689 }
 690
 691 // Warning: direct manipulation of MXF structures can interfere
 692 // with the normal operation of the wrapper.  Caveat emptor!
 693 //
 694 ASDCP::MXF::OP1aHeader&
 695 ASDCP::TimedText::MXFWriter::OP1aHeader()
 696 {
 697   if ( m_Writer.empty() )
 698     {
 699       assert(g_OP1aHeader);
 700       return *g_OP1aHeader;
 701     }
 702
 703   return m_Writer->m_HeaderPart;
 704 }
 705
 706 // Warning: direct manipulation of MXF structures can interfere
 707 // with the normal operation of the wrapper.  Caveat emptor!
 708 //
 709 ASDCP::MXF::OPAtomIndexFooter&
 710 ASDCP::TimedText::MXFWriter::OPAtomIndexFooter()
 711 {
 712   if ( m_Writer.empty() )
 713     {
 714       assert(g_OPAtomIndexFooter);
 715       return *g_OPAtomIndexFooter;
 716     }
 717
 718   return m_Writer->m_FooterPart;
 719 }
 720
 721 // Warning: direct manipulation of MXF structures can interfere
 722 // with the normal operation of the wrapper.  Caveat emptor!
 723 //
 724 ASDCP::MXF::RIP&
 725 ASDCP::TimedText::MXFWriter::RIP()
 726 {
 727   if ( m_Writer.empty() )
 728     {
 729       assert(g_RIP);
 730       return *g_RIP;
 731     }
 732
 733   return m_Writer->m_RIP;
 734 }
 735
 736 // Open the file for writing. The file must not exist. Returns error if
 737 // the operation cannot be completed.
 738 ASDCP::Result_t
 739 ASDCP::TimedText::MXFWriter::OpenWrite(const char* filename, const WriterInfo& Info,
 740                                        const TimedTextDescriptor& TDesc, ui32_t HeaderSize)
 741 {
 742   if ( Info.LabelSetType != LS_MXF_SMPTE )
 743     {
 744       DefaultLogSink().Error("Timed Text support requires LS_MXF_SMPTE\n");
 745       return RESULT_FORMAT;
 746     }
 747
 748   m_Writer = new h__Writer(DefaultSMPTEDict());
 749   m_Writer->m_Info = Info;
 750
 751   Result_t result = m_Writer->OpenWrite(filename, HeaderSize);
 752
 753   if ( ASDCP_SUCCESS(result) )
 754     result = m_Writer->SetSourceStream(TDesc);
 755
 756   if ( ASDCP_FAILURE(result) )
 757     m_Writer.release();
 758
 759   return result;
 760 }
 761
 762 //
 763 ASDCP::Result_t
 764 ASDCP::TimedText::MXFWriter::WriteTimedTextResource(const std::string& XMLDoc, AESEncContext* Ctx, HMACContext* HMAC)
 765 {
 766   if ( m_Writer.empty() )
 767     return RESULT_INIT;
 768
 769   return m_Writer->WriteTimedTextResource(XMLDoc, Ctx, HMAC);
 770 }
 771
 772 //
 773 ASDCP::Result_t
 774 ASDCP::TimedText::MXFWriter::WriteAncillaryResource(const FrameBuffer& FrameBuf, AESEncContext* Ctx, HMACContext* HMAC)
 775 {
 776   if ( m_Writer.empty() )
 777     return RESULT_INIT;
 778
 779   return m_Writer->WriteAncillaryResource(FrameBuf, Ctx, HMAC);
 780 }
 781
 782 // Closes the MXF file, writing the index and other closing information.
 783 ASDCP::Result_t
 784 ASDCP::TimedText::MXFWriter::Finalize()
 785 {
 786   if ( m_Writer.empty() )
 787     return RESULT_INIT;
 788
 789   return m_Writer->Finalize();
 790 }
 791
 792
 793
 794 //
 795 // end AS_DCP_timedText.cpp
 796 //