src/AS_02_JP2K.cpp

   1 /*
   2 Copyright (c) 2011-2013, Robert Scheler, Heiko Sparenberg Fraunhofer IIS,
   3 John Hurst
   4
   5 All rights reserved.
   6
   7 Redistribution and use in source and binary forms, with or without
   8 modification, are permitted provided that the following conditions
   9 are met:
  10 1. Redistributions of source code must retain the above copyright
  11    notice, this list of conditions and the following disclaimer.
  12 2. Redistributions in binary form must reproduce the above copyright
  13    notice, this list of conditions and the following disclaimer in the
  14    documentation and/or other materials provided with the distribution.
  15 3. The name of the author may not be used to endorse or promote products
  16    derived from this software without specific prior written permission.
  17
  18 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 */
  29 /*! \file    AS_02_JP2K.cpp
  30   \version $Id$
  31   \brief   AS-02 library, JPEG 2000 essence reader and writer implementation
  32 */
  33
  34 #include "AS_02_internal.h"
  35
  36 #include <iostream>
  37 #include <iomanip>
  38
  39 using namespace ASDCP;
  40 using namespace ASDCP::JP2K;
  41 using Kumu::GenRandomValue;
  42
  43 //------------------------------------------------------------------------------------------
  44
  45 static std::string JP2K_PACKAGE_LABEL = "File Package: SMPTE ST 422 / ST 2067-5 frame wrapping of JPEG 2000 codestreams";
  46 static std::string PICT_DEF_LABEL = "Image Track";
  47
  48 //------------------------------------------------------------------------------------------
  49 //
  50 // hidden, internal implementation of JPEG 2000 reader
  51
  52
  53 class AS_02::JP2K::MXFReader::h__Reader : public AS_02::h__AS02Reader
  54 {
  55   ASDCP_NO_COPY_CONSTRUCT(h__Reader);
  56
  57 public:
  58   h__Reader(const Dictionary& d) :
  59     AS_02::h__AS02Reader(d) {}
  60
  61   virtual ~h__Reader() {}
  62
  63   Result_t    OpenRead(const std::string&);
  64   Result_t    ReadFrame(ui32_t, ASDCP::JP2K::FrameBuffer&, AESDecContext*, HMACContext*);
  65 };
  66
  67 //
  68 Result_t
  69 AS_02::JP2K::MXFReader::h__Reader::OpenRead(const std::string& filename)
  70 {
  71   Result_t result = OpenMXFRead(filename.c_str());
  72
  73   if( KM_SUCCESS(result) )
  74     {
  75       InterchangeObject* tmp_iobj = 0;
  76
  77       m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(CDCIEssenceDescriptor), &tmp_iobj);
  78
  79       if ( tmp_iobj == 0 )
  80         {
  81           m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(RGBAEssenceDescriptor), &tmp_iobj);
  82         }
  83
  84       if ( tmp_iobj == 0 )
  85         {
  86           DefaultLogSink().Error("RGBAEssenceDescriptor nor CDCIEssenceDescriptor found.\n");
  87         }
  88
  89       m_HeaderPart.GetMDObjectByType(OBJ_TYPE_ARGS(JPEG2000PictureSubDescriptor), &tmp_iobj);
  90
  91       if ( tmp_iobj == 0 )
  92         {
  93           DefaultLogSink().Error("JPEG2000PictureSubDescriptor not found.\n");
  94         }
  95
  96       std::list<InterchangeObject*> ObjectList;
  97       m_HeaderPart.GetMDObjectsByType(OBJ_TYPE_ARGS(Track), ObjectList);
  98
  99       if ( ObjectList.empty() )
 100         {
 101           DefaultLogSink().Error("MXF Metadata contains no Track Sets.\n");
 102           return RESULT_AS02_FORMAT;
 103         }
 104     }
 105
 106   return result;
 107 }
 108
 109 //
 110 //
 111 Result_t
 112 AS_02::JP2K::MXFReader::h__Reader::ReadFrame(ui32_t FrameNum, ASDCP::JP2K::FrameBuffer& FrameBuf,
 113                       ASDCP::AESDecContext* Ctx, ASDCP::HMACContext* HMAC)
 114 {
 115   if ( ! m_File.IsOpen() )
 116     return RESULT_INIT;
 117
 118   assert(m_Dict);
 119   return ReadEKLVFrame(FrameNum, FrameBuf, m_Dict->ul(MDD_JPEG2000Essence), Ctx, HMAC);
 120 }
 121
 122 //------------------------------------------------------------------------------------------
 123 //
 124
 125 AS_02::JP2K::MXFReader::MXFReader()
 126 {
 127   m_Reader = new h__Reader(DefaultCompositeDict());
 128 }
 129
 130
 131 AS_02::JP2K::MXFReader::~MXFReader()
 132 {
 133 }
 134
 135 // Warning: direct manipulation of MXF structures can interfere
 136 // with the normal operation of the wrapper.  Caveat emptor!
 137 //
 138 ASDCP::MXF::OP1aHeader&
 139 AS_02::JP2K::MXFReader::OP1aHeader()
 140 {
 141   if ( m_Reader.empty() )
 142     {
 143       assert(g_OP1aHeader);
 144       return *g_OP1aHeader;
 145     }
 146
 147   return m_Reader->m_HeaderPart;
 148 }
 149
 150 // Warning: direct manipulation of MXF structures can interfere
 151 // with the normal operation of the wrapper.  Caveat emptor!
 152 //
 153 AS_02::MXF::AS02IndexReader&
 154 AS_02::JP2K::MXFReader::AS02IndexReader()
 155 {
 156   if ( m_Reader.empty() )
 157     {
 158       assert(g_AS02IndexReader);
 159       return *g_AS02IndexReader;
 160     }
 161
 162   return m_Reader->m_IndexAccess;
 163 }
 164
 165 // Warning: direct manipulation of MXF structures can interfere
 166 // with the normal operation of the wrapper.  Caveat emptor!
 167 //
 168 ASDCP::MXF::RIP&
 169 AS_02::JP2K::MXFReader::RIP()
 170 {
 171   if ( m_Reader.empty() )
 172     {
 173       assert(g_RIP);
 174       return *g_RIP;
 175     }
 176
 177   return m_Reader->m_RIP;
 178 }
 179
 180 // Open the file for reading. The file must exist. Returns error if the
 181 // operation cannot be completed.
 182 Result_t
 183 AS_02::JP2K::MXFReader::OpenRead(const std::string& filename) const
 184 {
 185   return m_Reader->OpenRead(filename);
 186 }
 187
 188 //
 189 Result_t
 190 AS_02::JP2K::MXFReader::Close() const
 191 {
 192   if ( m_Reader && m_Reader->m_File.IsOpen() )
 193     {
 194       m_Reader->Close();
 195       return RESULT_OK;
 196     }
 197
 198   return RESULT_INIT;
 199 }
 200
 201 //
 202 Result_t
 203 AS_02::JP2K::MXFReader::ReadFrame(ui32_t FrameNum, ASDCP::JP2K::FrameBuffer& FrameBuf,
 204                                            ASDCP::AESDecContext* Ctx, ASDCP::HMACContext* HMAC) const
 205 {
 206   if ( m_Reader && m_Reader->m_File.IsOpen() )
 207     return m_Reader->ReadFrame(FrameNum, FrameBuf, Ctx, HMAC);
 208
 209   return RESULT_INIT;
 210 }
 211
 212 // Fill the struct with the values from the file's header.
 213 // Returns RESULT_INIT if the file is not open.
 214 Result_t
 215 AS_02::JP2K::MXFReader::FillWriterInfo(WriterInfo& Info) const
 216 {
 217   if ( m_Reader && m_Reader->m_File.IsOpen() )
 218     {
 219       Info = m_Reader->m_Info;
 220       return RESULT_OK;
 221     }
 222
 223   return RESULT_INIT;
 224 }
 225
 226
 227 //------------------------------------------------------------------------------------------
 228
 229 //
 230 class AS_02::JP2K::MXFWriter::h__Writer : public AS_02::h__AS02WriterFrame
 231 {
 232   ASDCP_NO_COPY_CONSTRUCT(h__Writer);
 233   h__Writer();
 234
 235   JPEG2000PictureSubDescriptor* m_EssenceSubDescriptor;
 236
 237 public:
 238   byte_t            m_EssenceUL[SMPTE_UL_LENGTH];
 239
 240   h__Writer(const Dictionary& d) : h__AS02WriterFrame(d), m_EssenceSubDescriptor(0) {
 241     memset(m_EssenceUL, 0, SMPTE_UL_LENGTH);
 242   }
 243
 244   virtual ~h__Writer(){}
 245
 246   Result_t OpenWrite(const std::string&, ASDCP::MXF::FileDescriptor* essence_descriptor,
 247                      ASDCP::MXF::InterchangeObject_list_t& essence_sub_descriptor_list,
 248                      const AS_02::IndexStrategy_t& IndexStrategy,
 249                      const ui32_t& PartitionSpace, const ui32_t& HeaderSize);
 250   Result_t SetSourceStream(const std::string& label, const ASDCP::Rational& edit_rate);
 251   Result_t WriteFrame(const ASDCP::JP2K::FrameBuffer&, ASDCP::AESEncContext*, ASDCP::HMACContext*);
 252   Result_t Finalize();
 253 };
 254
 255
 256 // Open the file for writing. The file must not exist. Returns error if
 257 // the operation cannot be completed.
 258 Result_t
 259 AS_02::JP2K::MXFWriter::h__Writer::OpenWrite(const std::string& filename,
 260                                              ASDCP::MXF::FileDescriptor* essence_descriptor,
 261                                              ASDCP::MXF::InterchangeObject_list_t& essence_sub_descriptor_list,
 262                                              const AS_02::IndexStrategy_t& IndexStrategy,
 263                                              const ui32_t& PartitionSpace_sec, const ui32_t& HeaderSize)
 264 {
 265   if ( ! m_State.Test_BEGIN() )
 266     {
 267       return RESULT_STATE;
 268     }
 269
 270   if ( m_IndexStrategy != AS_02::IS_FOLLOW )
 271     {
 272       DefaultLogSink().Error("Only strategy IS_FOLLOW is supported at this time.\n");
 273       return Kumu::RESULT_NOTIMPL;
 274     }
 275
 276   Result_t result = m_File.OpenWrite(filename.c_str());
 277
 278   if ( KM_SUCCESS(result) )
 279     {
 280       m_IndexStrategy = IndexStrategy;
 281       m_PartitionSpace = PartitionSpace_sec; // later converted to edit units by SetSourceStream()
 282       m_HeaderSize = HeaderSize;
 283
 284       if ( essence_descriptor->GetUL() != UL(m_Dict->ul(MDD_RGBAEssenceDescriptor))
 285            && essence_descriptor->GetUL() != UL(m_Dict->ul(MDD_CDCIEssenceDescriptor)) )
 286         {
 287           DefaultLogSink().Error("Essence descriptor is not a RGBAEssenceDescriptor or CDCIEssenceDescriptor.\n");
 288           essence_descriptor->Dump();
 289           return RESULT_AS02_FORMAT;
 290         }
 291
 292       m_EssenceDescriptor = essence_descriptor;
 293
 294       ASDCP::MXF::InterchangeObject_list_t::iterator i;
 295       for ( i = essence_sub_descriptor_list.begin(); i != essence_sub_descriptor_list.end(); ++i )
 296         {
 297           if ( (*i)->GetUL() != UL(m_Dict->ul(MDD_JPEG2000PictureSubDescriptor)) )
 298             {
 299               DefaultLogSink().Error("Essence sub-descriptor is not a JPEG2000PictureSubDescriptor.\n");
 300               (*i)->Dump();
 301             }
 302
 303           m_EssenceSubDescriptorList.push_back(*i);
 304           GenRandomValue((*i)->InstanceUID);
 305           m_EssenceDescriptor->SubDescriptors.push_back((*i)->InstanceUID);
 306           *i = 0; // parent will only free the ones we don't keep
 307         }
 308
 309       result = m_State.Goto_INIT();
 310     }
 311
 312   return result;
 313 }
 314
 315 // Automatically sets the MXF file's metadata from the first jpeg codestream stream.
 316 Result_t
 317 AS_02::JP2K::MXFWriter::h__Writer::SetSourceStream(const std::string& label, const ASDCP::Rational& edit_rate)
 318 {
 319   assert(m_Dict);
 320   if ( ! m_State.Test_INIT() )
 321     {
 322       return RESULT_STATE;
 323     }
 324
 325   memcpy(m_EssenceUL, m_Dict->ul(MDD_JPEG2000Essence), SMPTE_UL_LENGTH);
 326   m_EssenceUL[SMPTE_UL_LENGTH-1] = 1; // first (and only) essence container
 327   Result_t result = m_State.Goto_READY();
 328
 329   if ( KM_SUCCESS(result) )
 330     {
 331       result = WriteAS02Header(label, UL(m_Dict->ul(MDD_JPEG_2000WrappingFrame)),
 332                                PICT_DEF_LABEL, UL(m_EssenceUL), UL(m_Dict->ul(MDD_PictureDataDef)),
 333                                edit_rate, derive_timecode_rate_from_edit_rate(edit_rate));
 334
 335       if ( KM_SUCCESS(result) )
 336         {
 337           this->m_IndexWriter.SetPrimerLookup(&this->m_HeaderPart.m_Primer);
 338         }
 339     }
 340
 341   return result;
 342 }
 343
 344 // Writes a frame of essence to the MXF file. If the optional AESEncContext
 345 // argument is present, the essence is encrypted prior to writing.
 346 // Fails if the file is not open, is finalized, or an operating system
 347 // error occurs.
 348 //
 349 Result_t
 350 AS_02::JP2K::MXFWriter::h__Writer::WriteFrame(const ASDCP::JP2K::FrameBuffer& FrameBuf,
 351                                               AESEncContext* Ctx, HMACContext* HMAC)
 352 {
 353   if ( FrameBuf.Size() == 0 )
 354     {
 355       DefaultLogSink().Error("The frame buffer size is zero.\n");
 356       return RESULT_PARAM;
 357     }
 358
 359   Result_t result = RESULT_OK;
 360
 361   if ( m_State.Test_READY() )
 362     {
 363       result = m_State.Goto_RUNNING(); // first time through
 364     }
 365
 366   if ( KM_SUCCESS(result) )
 367     {
 368       result = WriteEKLVPacket(FrameBuf, m_EssenceUL, Ctx, HMAC);
 369       m_FramesWritten++;
 370     }
 371
 372   return result;
 373 }
 374
 375 // Closes the MXF file, writing the index and other closing information.
 376 //
 377 Result_t
 378 AS_02::JP2K::MXFWriter::h__Writer::Finalize()
 379 {
 380   if ( ! m_State.Test_RUNNING() )
 381     return RESULT_STATE;
 382
 383   Result_t result = m_State.Goto_FINAL();
 384
 385   if ( KM_SUCCESS(result) )
 386     {
 387       result = WriteAS02Footer();
 388     }
 389
 390   return result;
 391 }
 392
 393
 394 //------------------------------------------------------------------------------------------
 395
 396
 397
 398 AS_02::JP2K::MXFWriter::MXFWriter()
 399 {
 400 }
 401
 402 AS_02::JP2K::MXFWriter::~MXFWriter()
 403 {
 404 }
 405
 406 // Warning: direct manipulation of MXF structures can interfere
 407 // with the normal operation of the wrapper.  Caveat emptor!
 408 //
 409 ASDCP::MXF::OP1aHeader&
 410 AS_02::JP2K::MXFWriter::OP1aHeader()
 411 {
 412   if ( m_Writer.empty() )
 413     {
 414       assert(g_OP1aHeader);
 415       return *g_OP1aHeader;
 416     }
 417
 418   return m_Writer->m_HeaderPart;
 419 }
 420
 421 // Warning: direct manipulation of MXF structures can interfere
 422 // with the normal operation of the wrapper.  Caveat emptor!
 423 //
 424 ASDCP::MXF::RIP&
 425 AS_02::JP2K::MXFWriter::RIP()
 426 {
 427   if ( m_Writer.empty() )
 428     {
 429       assert(g_RIP);
 430       return *g_RIP;
 431     }
 432
 433   return m_Writer->m_RIP;
 434 }
 435
 436 // Open the file for writing. The file must not exist. Returns error if
 437 // the operation cannot be completed.
 438 Result_t
 439 AS_02::JP2K::MXFWriter::OpenWrite(const std::string& filename, const ASDCP::WriterInfo& Info,
 440                                   ASDCP::MXF::FileDescriptor* essence_descriptor,
 441                                   ASDCP::MXF::InterchangeObject_list_t& essence_sub_descriptor_list,
 442                                   const ASDCP::Rational& edit_rate, const ui32_t& header_size,
 443                                   const IndexStrategy_t& strategy, const ui32_t& partition_space)
 444 {
 445   if ( essence_descriptor == 0 )
 446     {
 447       DefaultLogSink().Error("Essence descriptor object required.\n");
 448       return RESULT_PARAM;
 449     }
 450
 451   m_Writer = new AS_02::JP2K::MXFWriter::h__Writer(DefaultSMPTEDict());
 452   m_Writer->m_Info = Info;
 453
 454   Result_t result = m_Writer->OpenWrite(filename, essence_descriptor, essence_sub_descriptor_list,
 455                                         strategy, partition_space, header_size);
 456
 457   if ( KM_SUCCESS(result) )
 458     result = m_Writer->SetSourceStream(JP2K_PACKAGE_LABEL, edit_rate);
 459
 460   if ( KM_FAILURE(result) )
 461     m_Writer.release();
 462
 463   return result;
 464 }
 465
 466 // Writes a frame of essence to the MXF file. If the optional AESEncContext
 467 // argument is present, the essence is encrypted prior to writing.
 468 // Fails if the file is not open, is finalized, or an operating system
 469 // error occurs.
 470 Result_t
 471 AS_02::JP2K::MXFWriter::WriteFrame(const ASDCP::JP2K::FrameBuffer& FrameBuf, AESEncContext* Ctx, HMACContext* HMAC)
 472 {
 473   if ( m_Writer.empty() )
 474     return RESULT_INIT;
 475
 476   return m_Writer->WriteFrame(FrameBuf, Ctx, HMAC);
 477 }
 478
 479 // Closes the MXF file, writing the index and other closing information.
 480 Result_t
 481 AS_02::JP2K::MXFWriter::Finalize()
 482 {
 483   if ( m_Writer.empty() )
 484     return RESULT_INIT;
 485
 486   return m_Writer->Finalize();
 487 }
 488
 489
 490 //
 491 // end AS_02_JP2K.cpp
 492 //