From 99f3c9bd7e314ed2342598ad0e2357c68c79e732 Mon Sep 17 00:00:00 2001 From: jhurst Date: Thu, 2 Feb 2012 01:58:43 +0000 Subject: [PATCH] make way for MCA --- src/AS_DCP.h | 85 +++++- src/AS_DCP_JP2K.cpp | 100 ++++++- src/AS_DCP_MPEG2.cpp | 53 +++- src/AS_DCP_PCM.cpp | 53 +++- src/AS_DCP_TimedText.cpp | 53 +++- src/MDD.cpp | 38 ++- src/MDD.h | 14 +- src/MXF.cpp | 10 +- src/MXF.h | 6 +- src/MXFTypes.cpp | 57 +++- src/MXFTypes.h | 48 +++- src/Metadata.cpp | 554 ++++++++++++++++++++++++++++++++++++++- src/Metadata.h | 214 ++++++++++++--- 13 files changed, 1221 insertions(+), 64 deletions(-) diff --git a/src/AS_DCP.h b/src/AS_DCP.h index 29f07c0..72d5261 100755 --- a/src/AS_DCP.h +++ b/src/AS_DCP.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2003-2011, John Hurst +Copyright (c) 2003-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -34,22 +34,23 @@ D-Cinema Technology Committee 21DC. The file format, labeled AS-DCP, is described in series of separate documents which include but may not be be limited to: - o SMPTE ST 429-2:2009 DCP Operational Constraints - o SMPTE ST 429-3:2006 Track File Specification - o SMPTE ST 429-4:2006 JPEG 2000 for D-Cinema + o SMPTE ST 429-2:2011 DCP Operational Constraints + o SMPTE ST 429-3:2006 Sound and Picture Track File + o SMPTE ST 429-4:2006 MXF JPEG 2000 Application o SMPTE ST 429-5:2009 Timed Text Track File - o SMPTE ST 429-6:2006 Essence Encryption - o SMPTE ST 429-10:2008 Stereoscopic Image Track File + o SMPTE ST 429-6:2006 MXF Track File Essence Encryption + o SMPTE ST 429-10:2008 Stereoscopic Picture Track File o SMPTE ST 330:2004 - UMID o SMPTE ST 336:2001 - KLV - o SMPTE ST 377:2000 - MXF - o SMPTE ST 390:2004 - MXF OP-Atom - o SMPTE ST 379:2004 - MXF Generic Container (GC) - o SMPTE ST 381:2005 - MPEG2 picture in GC + o SMPTE ST 377-1:2011 - MXF + o SMPTE ST 377-4:2012 - MXF Multichannel Audio Labeling Framework + o SMPTE ST 390:2011 - MXF OP-Atom + o SMPTE ST 379-1:2009 - MXF Generic Container (GC) + o SMPTE ST 381-1:2005 - MPEG2 picture in GC o SMPTE ST 422:2006 - JPEG 2000 picture in GC o SMPTE ST 382:2007 - WAV/PCM sound in GC o IETF RFC 2104 - HMAC/SHA1 - o NIST FIPS 197 - AES (Rijndael) + o NIST FIPS 197 - AES (Rijndael) (via OpenSSL) o MXF Interop Track File Specification o MXF Interop Track File Essence Encryption Specification @@ -551,6 +552,15 @@ namespace ASDCP { inline ui32_t PlaintextOffset() const { return m_PlaintextOffset; } }; + //--------------------------------------------------------------------------------- + // Accessors in the MXFReader and MXFWriter classes below return these types to + // provide direct access to MXF metadata structures declared in MXF.h and Metadata.h + + namespace MXF { + // #include to use these + class OPAtomHeader; + class OPAtomIndexFooter; + }; //--------------------------------------------------------------------------------- // MPEG2 video elementary stream support @@ -707,6 +717,11 @@ namespace ASDCP { MXFWriter(); virtual ~MXFWriter(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. @@ -734,6 +749,11 @@ namespace ASDCP { MXFReader(); virtual ~MXFReader(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. Result_t OpenRead(const char* filename) const; @@ -780,6 +800,9 @@ namespace ASDCP { //--------------------------------------------------------------------------------- // + + + namespace PCM { // The default value of the ChannelFormat element of the AudioDescriptor struct @@ -893,6 +916,11 @@ namespace ASDCP { MXFWriter(); virtual ~MXFWriter(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. @@ -920,6 +948,11 @@ namespace ASDCP { MXFReader(); virtual ~MXFReader(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. Result_t OpenRead(const char* filename) const; @@ -1124,6 +1157,11 @@ namespace ASDCP { MXFWriter(); virtual ~MXFWriter(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. @@ -1151,6 +1189,11 @@ namespace ASDCP { MXFReader(); virtual ~MXFReader(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. Result_t OpenRead(const char* filename) const; @@ -1211,6 +1254,11 @@ namespace ASDCP { MXFSWriter(); virtual ~MXFSWriter(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. @@ -1248,6 +1296,11 @@ namespace ASDCP { MXFSReader(); virtual ~MXFSReader(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. Result_t OpenRead(const char* filename) const; @@ -1401,6 +1454,11 @@ namespace ASDCP { MXFWriter(); virtual ~MXFWriter(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed or if nonsensical data is discovered // in the essence descriptor. @@ -1438,6 +1496,11 @@ namespace ASDCP { MXFReader(); virtual ~MXFReader(); + // Warning: direct manipulation of MXF structures can interfere + // with the normal operation of the wrapper. Caveat emptor! + virtual MXF::OPAtomHeader& OPAtomHeader(); + virtual MXF::OPAtomIndexFooter& OPAtomIndexFooter(); + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. Result_t OpenRead(const char* filename) const; diff --git a/src/AS_DCP_JP2K.cpp b/src/AS_DCP_JP2K.cpp index 72b975d..9e676ae 100755 --- a/src/AS_DCP_JP2K.cpp +++ b/src/AS_DCP_JP2K.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2004-2010, John Hurst +Copyright (c) 2004-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -38,6 +38,10 @@ using Kumu::GenRandomValue; //------------------------------------------------------------------------------------------ +static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict(); +static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict); +static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict); + static std::string JP2K_PACKAGE_LABEL = "File Package: SMPTE 429-4 frame wrapping of JPEG 2000 codestreams"; static std::string JP2K_S_PACKAGE_LABEL = "File Package: SMPTE 429-10 frame wrapping of stereoscopic JPEG 2000 codestreams"; static std::string PICT_DEF_LABEL = "Picture Track"; @@ -461,6 +465,30 @@ ASDCP::JP2K::MXFReader::~MXFReader() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::JP2K::MXFReader::OPAtomHeader() +{ + if ( m_Reader.empty() ) + return sg_OPAtomHeader; + + return m_Reader->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::JP2K::MXFReader::OPAtomIndexFooter() +{ + if ( m_Reader.empty() ) + return sg_OPAtomIndexFooter; + + return m_Reader->m_FooterPart; +} + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. ASDCP::Result_t @@ -635,6 +663,30 @@ ASDCP::JP2K::MXFSReader::~MXFSReader() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::JP2K::MXFSReader::OPAtomHeader() +{ + if ( m_Reader.empty() ) + return sg_OPAtomHeader; + + return m_Reader->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::JP2K::MXFSReader::OPAtomIndexFooter() +{ + if ( m_Reader.empty() ) + return sg_OPAtomIndexFooter; + + return m_Reader->m_FooterPart; +} + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. ASDCP::Result_t @@ -977,6 +1029,29 @@ 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() +{ + if ( m_Writer.empty() ) + return sg_OPAtomHeader; + + return m_Writer->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::JP2K::MXFWriter::OPAtomIndexFooter() +{ + if ( m_Writer.empty() ) + return sg_OPAtomIndexFooter; + + return m_Writer->m_FooterPart; +} // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. @@ -1079,6 +1154,29 @@ 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() +{ + if ( m_Writer.empty() ) + return sg_OPAtomHeader; + + return m_Writer->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::JP2K::MXFSWriter::OPAtomIndexFooter() +{ + if ( m_Writer.empty() ) + return sg_OPAtomIndexFooter; + + return m_Writer->m_FooterPart; +} // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. diff --git a/src/AS_DCP_MPEG2.cpp b/src/AS_DCP_MPEG2.cpp index 252c1fa..ea7ed74 100755 --- a/src/AS_DCP_MPEG2.cpp +++ b/src/AS_DCP_MPEG2.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2004-2011, John Hurst +Copyright (c) 2004-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -36,6 +36,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. //------------------------------------------------------------------------------------------ +static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict(); +static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict); +static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict); + static std::string MPEG_PACKAGE_LABEL = "File Package: SMPTE 381M frame wrapping of MPEG2 video elementary stream"; static std::string PICT_DEF_LABEL = "Picture Track"; @@ -335,6 +339,30 @@ ASDCP::MPEG2::MXFReader::~MXFReader() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::MPEG2::MXFReader::OPAtomHeader() +{ + if ( m_Reader.empty() ) + return sg_OPAtomHeader; + + return m_Reader->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::MPEG2::MXFReader::OPAtomIndexFooter() +{ + if ( m_Reader.empty() ) + return sg_OPAtomIndexFooter; + + return m_Reader->m_FooterPart; +} + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. ASDCP::Result_t @@ -611,6 +639,29 @@ ASDCP::MPEG2::MXFWriter::~MXFWriter() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::MPEG2::MXFWriter::OPAtomHeader() +{ + if ( m_Writer.empty() ) + return sg_OPAtomHeader; + + return m_Writer->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::MPEG2::MXFWriter::OPAtomIndexFooter() +{ + if ( m_Writer.empty() ) + return sg_OPAtomIndexFooter; + + return m_Writer->m_FooterPart; +} // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. diff --git a/src/AS_DCP_PCM.cpp b/src/AS_DCP_PCM.cpp index eb0c3b7..3956c71 100755 --- a/src/AS_DCP_PCM.cpp +++ b/src/AS_DCP_PCM.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2004-2011, John Hurst +Copyright (c) 2004-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -36,6 +36,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. //------------------------------------------------------------------------------------------ +static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict(); +static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict); +static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict); + static std::string PCM_PACKAGE_LABEL = "File Package: SMPTE 382M frame wrapping of wave audio"; static std::string SOUND_DEF_LABEL = "Sound Track"; @@ -313,6 +317,30 @@ ASDCP::PCM::MXFReader::~MXFReader() m_Reader->Close(); } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::PCM::MXFReader::OPAtomHeader() +{ + if ( m_Reader.empty() ) + return sg_OPAtomHeader; + + return m_Reader->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::PCM::MXFReader::OPAtomIndexFooter() +{ + if ( m_Reader.empty() ) + return sg_OPAtomIndexFooter; + + return m_Reader->m_FooterPart; +} + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. ASDCP::Result_t @@ -544,6 +572,29 @@ ASDCP::PCM::MXFWriter::~MXFWriter() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::PCM::MXFWriter::OPAtomHeader() +{ + if ( m_Writer.empty() ) + return sg_OPAtomHeader; + + return m_Writer->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::PCM::MXFWriter::OPAtomIndexFooter() +{ + if ( m_Writer.empty() ) + return sg_OPAtomIndexFooter; + + return m_Writer->m_FooterPart; +} // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. diff --git a/src/AS_DCP_TimedText.cpp b/src/AS_DCP_TimedText.cpp index f7d64bd..5d31a8d 100644 --- a/src/AS_DCP_TimedText.cpp +++ b/src/AS_DCP_TimedText.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2008-2011, John Hurst +Copyright (c) 2008-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -37,6 +37,10 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. using Kumu::GenRandomValue; +static const ASDCP::Dictionary *sg_dict = &DefaultSMPTEDict(); +static MXF::OPAtomHeader sg_OPAtomHeader(sg_dict); +static MXF::OPAtomIndexFooter sg_OPAtomIndexFooter(sg_dict); + 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"; @@ -341,6 +345,30 @@ ASDCP::TimedText::MXFReader::~MXFReader() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::TimedText::MXFReader::OPAtomHeader() +{ + if ( m_Reader.empty() ) + return sg_OPAtomHeader; + + return m_Reader->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::TimedText::MXFReader::OPAtomIndexFooter() +{ + if ( m_Reader.empty() ) + return sg_OPAtomIndexFooter; + + return m_Reader->m_FooterPart; +} + // Open the file for reading. The file must exist. Returns error if the // operation cannot be completed. ASDCP::Result_t @@ -647,6 +675,29 @@ ASDCP::TimedText::MXFWriter::~MXFWriter() { } +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomHeader& +ASDCP::TimedText::MXFWriter::OPAtomHeader() +{ + if ( m_Writer.empty() ) + return sg_OPAtomHeader; + + return m_Writer->m_HeaderPart; +} + +// Warning: direct manipulation of MXF structures can interfere +// with the normal operation of the wrapper. Caveat emptor! +// +ASDCP::MXF::OPAtomIndexFooter& +ASDCP::TimedText::MXFWriter::OPAtomIndexFooter() +{ + if ( m_Writer.empty() ) + return sg_OPAtomIndexFooter; + + return m_Writer->m_FooterPart; +} // Open the file for writing. The file must not exist. Returns error if // the operation cannot be completed. diff --git a/src/MDD.cpp b/src/MDD.cpp index 98666a8..5627624 100644 --- a/src/MDD.cpp +++ b/src/MDD.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2006-2011, John Hurst +Copyright (c) 2006-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -881,6 +881,42 @@ static const ASDCP::MDDEntry s_MDD_Table[] = { { { 0x06, 0x0e, 0x2b, 0x34, 0x04, 0x01, 0x01, 0x0b, // 281 0x04, 0x02, 0x02, 0x10, 0x03, 0x01, 0x05, 0x00 }, {0}, false, "DCAudioChannelCfg_5_7p1_DS" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 282 + 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6a, 0x00 }, + {0}, false, "MCALabelSubDescriptor" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 283 + 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6b, 0x00 }, + {0}, false, "AudioChannelLabelSubDescriptor" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 284 + 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6c, 0x00 }, + {0}, false, "SoundfieldGroupLabelSubDescriptor" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x02, 0x53, 0x01, 0x01, // 285 + 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6d, 0x00 }, + {0}, false, "GroupOfSoundfieldGroupsLabelSubDescriptor" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 286 + 0x01, 0x03, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00 }, + {0}, false, "MCALabelSubDescriptor_MCALabelDictionaryID" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 287 + 0x01, 0x03, 0x07, 0x01, 0x05, 0x00, 0x00, 0x00 }, + {0}, false, "MCALabelSubDescriptor_MCALinkID" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 288 + 0x01, 0x03, 0x07, 0x01, 0x02, 0x00, 0x00, 0x00 }, + {0}, false, "MCALabelSubDescriptor_MCATagSymbol" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 289 + 0x01, 0x03, 0x07, 0x01, 0x03, 0x00, 0x00, 0x00 }, + {0}, false, "MCALabelSubDescriptor_MCATagName" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0e, // 290 + 0x01, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00 }, + {0}, false, "MCALabelSubDescriptor_MCAChannelID" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0d, // 291 + 0x03, 0x01, 0x01, 0x02, 0x03, 0x15, 0x00, 0x00 }, + {0}, false, "MCALabelSubDescriptor_RFC5646SpokenLanguage" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0d, // 292 + 0x01, 0x03, 0x07, 0x01, 0x03, 0x00, 0x00, 0x00 }, + {0}, false, "AudioChannelLabelSubDescriptor_SoundfieldGroupLinkID" }, + { { 0x06, 0x0e, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x0d, // 293 + 0x01, 0x03, 0x07, 0x01, 0x04, 0x00, 0x00, 0x00 }, + {0}, false, "SoundfieldGroupLabelSubDescriptor_GroupOfSoundfieldGroupsLinkID" }, { {0}, {0}, false, 0 } }; diff --git a/src/MDD.h b/src/MDD.h index 3682e5e..358b874 100755 --- a/src/MDD.h +++ b/src/MDD.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2006-2009, John Hurst +Copyright (c) 2006-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -317,6 +317,18 @@ namespace ASDCP { MDD_DCAudioChannelCfg_3_7p1, // 279 MDD_DCAudioChannelCfg_4_WTF, // 280 MDD_DCAudioChannelCfg_5_7p1_DS, // 281 + MDD_MCALabelSubDescriptor, // 282 + MDD_AudioChannelLabelSubDescriptor, // 283 + MDD_SoundfieldGroupLabelSubDescriptor, // 284 + MDD_GroupOfSoundfieldGroupsLabelSubDescriptor, // 285 + MDD_MCALabelSubDescriptor_MCALabelDictionaryID, // 286 + MDD_MCALabelSubDescriptor_MCALinkID, // 287 + MDD_MCALabelSubDescriptor_MCATagSymbol, // 288 + MDD_MCALabelSubDescriptor_MCATagName, // 289 + MDD_MCALabelSubDescriptor_MCAChannelID, // 290 + MDD_MCALabelSubDescriptor_RFC5646SpokenLanguage, // 291 + MDD_AudioChannelLabelSubDescriptor_SoundfieldGroupLinkID, // 292 + MDD_SoundfieldGroupLabelSubDescriptor_GroupOfSoundfieldGroupsLinkID, // 293 MDD_Max }; // enum MDD_t diff --git a/src/MXF.cpp b/src/MXF.cpp index 4ba82cd..d1dd6d0 100755 --- a/src/MXF.cpp +++ b/src/MXF.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2009, John Hurst +Copyright (c) 2005-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -189,7 +189,7 @@ public: } // - void AddPacket(InterchangeObject* ThePacket) + void AddPacket(InterchangeObject* ThePacket) // takes ownership { assert(ThePacket); m_Map.insert(std::map::value_type(ThePacket->InstanceUID, ThePacket)); @@ -267,7 +267,7 @@ ASDCP::MXF::Partition::~Partition() { } -// +// takes ownership void ASDCP::MXF::Partition::AddChildObject(InterchangeObject* Object) { @@ -814,7 +814,7 @@ ASDCP::MXF::OPAtomHeader::InitFromBuffer(const byte_t* p, ui32_t l) } else { - m_PacketList->AddPacket(object); + m_PacketList->AddPacket(object); // takes ownership if ( object->IsA(m_Dict->ul(MDD_Preface)) && m_Preface == 0 ) m_Preface = (Preface*)object; @@ -1070,7 +1070,7 @@ ASDCP::MXF::OPAtomIndexFooter::InitFromBuffer(const byte_t* p, ui32_t l) if ( ASDCP_SUCCESS(result) ) { - m_PacketList->AddPacket(object); + m_PacketList->AddPacket(object); // takes ownership } else { diff --git a/src/MXF.h b/src/MXF.h index 3ae2c85..fbae834 100755 --- a/src/MXF.h +++ b/src/MXF.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2009, John Hurst +Copyright (c) 2005-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -136,7 +136,7 @@ namespace ASDCP Partition(const Dictionary*&); virtual ~Partition(); - virtual void AddChildObject(InterchangeObject*); + virtual void AddChildObject(InterchangeObject*); // takes ownership virtual Result_t InitFromFile(const Kumu::FileReader& Reader); virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l); virtual Result_t WriteToFile(Kumu::FileWriter& Writer, UL& PartitionLabel); @@ -363,7 +363,9 @@ namespace ASDCP ui32_t m_BytesPerEditUnit; Rational m_EditRate; ui32_t m_BodySID; + ASDCP_NO_COPY_CONSTRUCT(OPAtomIndexFooter); + OPAtomIndexFooter(); public: const Dictionary*& m_Dict; diff --git a/src/MXFTypes.cpp b/src/MXFTypes.cpp index 1418541..7b054c7 100755 --- a/src/MXFTypes.cpp +++ b/src/MXFTypes.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2011, John Hurst +Copyright (c) 2005-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -325,6 +325,61 @@ ASDCP::MXF::UTF16String::Archive(Kumu::MemIOWriter* Writer) const return true; } +//------------------------------------------------------------------------------------------ +// + +// +const ASDCP::MXF::ISO8String& +ASDCP::MXF::ISO8String::operator=(const char* sz) +{ + if ( sz == 0 || *sz == 0 ) + erase(); + + else + this->assign(sz); + + return *this; +} + +// +const ASDCP::MXF::ISO8String& +ASDCP::MXF::ISO8String::operator=(const std::string& str) +{ + this->assign(str); + return *this; +} + +// +const char* +ASDCP::MXF::ISO8String::EncodeString(char* str_buf, ui32_t buf_len) const +{ + ui32_t write_len = Kumu::xmin(buf_len - 1, (ui32_t)size()); + strncpy(str_buf, c_str(), write_len); + str_buf[write_len] = 0; + return str_buf; +} + +// +bool +ASDCP::MXF::ISO8String::Unarchive(Kumu::MemIOReader* Reader) +{ + assign((char*)Reader->CurrentData(), Reader->Remainder()); + return true; +} + +// +bool +ASDCP::MXF::ISO8String::Archive(Kumu::MemIOWriter* Writer) const +{ + if ( size() > IdentBufferLen ) + { + DefaultLogSink().Error("String length exceeds maximum %u bytes\n", IdentBufferLen); + return false; + } + + return Writer->WriteString(*this); +} + //------------------------------------------------------------------------------------------ // diff --git a/src/MXFTypes.h b/src/MXFTypes.h index fe03495..410fa8b 100755 --- a/src/MXFTypes.h +++ b/src/MXFTypes.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2009, John Hurst +Copyright (c) 2005-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -288,6 +288,23 @@ namespace ASDCP } }; + // + class ISO8String : public std::string, public Kumu::IArchive + { + public: + ISO8String() {} + ~ISO8String() {} + + const ISO8String& operator=(const char*); + const ISO8String& operator=(const std::string&); + + const char* EncodeString(char* str_buf, ui32_t buf_len) const; + inline virtual bool HasValue() const { return ! empty(); } + inline virtual ui32_t ArchiveLength() const { return sizeof(ui32_t) + size(); } + virtual bool Unarchive(Kumu::MemIOReader* Reader); + virtual bool Archive(Kumu::MemIOWriter* Writer) const; + }; + // class UTF16String : public std::string, public Kumu::IArchive { @@ -359,8 +376,6 @@ namespace ASDCP // class VersionType : public Kumu::IArchive { - ASDCP_NO_COPY_CONSTRUCT(VersionType); - public: enum Release_t { RL_UNKNOWN, RL_RELEASE, RL_DEVELOPMENT, RL_PATCHED, RL_BETA, RL_PRIVATE }; ui16_t Major; @@ -370,7 +385,19 @@ namespace ASDCP Release_t Release; VersionType() : Major(0), Minor(0), Patch(0), Build(0), Release(RL_UNKNOWN) {} - ~VersionType() {} + VersionType(const VersionType& rhs) { Copy(rhs); } + virtual ~VersionType() {} + + const VersionType& operator=(const VersionType& rhs) { Copy(rhs); return *this; } + + void Copy(const VersionType& rhs) { + Major = rhs.Major; + Minor = rhs.Minor; + Patch = rhs.Patch; + Build = rhs.Build; + Release = rhs.Release; + } + void Dump(FILE* = 0); const char* EncodeString(char* str_buf, ui32_t buf_len) const { @@ -405,11 +432,18 @@ namespace ASDCP // class Raw : public Kumu::ByteString { - ASDCP_NO_COPY_CONSTRUCT(Raw); - public: Raw(); - ~Raw(); + Raw(const Raw& rhs) { Copy(rhs); } + virtual ~Raw(); + + const Raw& operator=(const Raw& rhs) { Copy(rhs); return *this; } + void Copy(const Raw& rhs) { + if ( KM_SUCCESS(Capacity(rhs.Length())) ) + { + Set(rhs); + } + } // virtual bool Unarchive(Kumu::MemIOReader* Reader); diff --git a/src/Metadata.cpp b/src/Metadata.cpp index aeedbde..f62f273 100755 --- a/src/Metadata.cpp +++ b/src/Metadata.cpp @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2009, John Hurst +Copyright (c) 2005-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -69,6 +69,10 @@ static InterchangeObject* TimedTextDescriptor_Factory(const Dictionary*& Dict) { static InterchangeObject* TimedTextResourceSubDescriptor_Factory(const Dictionary*& Dict) { return new TimedTextResourceSubDescriptor(Dict); } static InterchangeObject* StereoscopicPictureSubDescriptor_Factory(const Dictionary*& Dict) { return new StereoscopicPictureSubDescriptor(Dict); } static InterchangeObject* NetworkLocator_Factory(const Dictionary*& Dict) { return new NetworkLocator(Dict); } +static InterchangeObject* MCALabelSubDescriptor_Factory(const Dictionary*& Dict) { return new MCALabelSubDescriptor(Dict); } +static InterchangeObject* AudioChannelLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new AudioChannelLabelSubDescriptor(Dict); } +static InterchangeObject* SoundfieldGroupLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new SoundfieldGroupLabelSubDescriptor(Dict); } +static InterchangeObject* GroupOfSoundfieldGroupsLabelSubDescriptor_Factory(const Dictionary*& Dict) { return new GroupOfSoundfieldGroupsLabelSubDescriptor(Dict); } void @@ -104,6 +108,10 @@ ASDCP::MXF::Metadata_InitTypes(const Dictionary*& Dict) SetObjectFactory(Dict->ul(MDD_TimedTextResourceSubDescriptor), TimedTextResourceSubDescriptor_Factory); SetObjectFactory(Dict->ul(MDD_StereoscopicPictureSubDescriptor), StereoscopicPictureSubDescriptor_Factory); SetObjectFactory(Dict->ul(MDD_NetworkLocator), NetworkLocator_Factory); + SetObjectFactory(Dict->ul(MDD_MCALabelSubDescriptor), MCALabelSubDescriptor_Factory); + SetObjectFactory(Dict->ul(MDD_AudioChannelLabelSubDescriptor), AudioChannelLabelSubDescriptor_Factory); + SetObjectFactory(Dict->ul(MDD_SoundfieldGroupLabelSubDescriptor), SoundfieldGroupLabelSubDescriptor_Factory); + SetObjectFactory(Dict->ul(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor_Factory); } //------------------------------------------------------------------------------------------ @@ -150,6 +158,21 @@ Identification::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +Identification::Copy(const Identification& rhs) +{ + ThisGenerationUID = rhs.ThisGenerationUID; + CompanyName = rhs.CompanyName; + ProductName = rhs.ProductName; + ProductVersion = rhs.ProductVersion; + VersionString = rhs.VersionString; + ProductUID = rhs.ProductUID; + ModificationDate = rhs.ModificationDate; + ToolkitVersion = rhs.ToolkitVersion; + Platform = rhs.Platform; +} + // void Identification::Dump(FILE* stream) @@ -215,6 +238,14 @@ ContentStorage::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +ContentStorage::Copy(const ContentStorage& rhs) +{ + Packages = rhs.Packages; + EssenceContainerData = rhs.EssenceContainerData; +} + // void ContentStorage::Dump(FILE* stream) @@ -277,6 +308,15 @@ EssenceContainerData::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +EssenceContainerData::Copy(const EssenceContainerData& rhs) +{ + LinkedPackageUID = rhs.LinkedPackageUID; + IndexSID = rhs.IndexSID; + BodySID = rhs.BodySID; +} + // void EssenceContainerData::Dump(FILE* stream) @@ -342,6 +382,17 @@ GenericPackage::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +GenericPackage::Copy(const GenericPackage& rhs) +{ + PackageUID = rhs.PackageUID; + Name = rhs.Name; + PackageCreationDate = rhs.PackageCreationDate; + PackageModifiedDate = rhs.PackageModifiedDate; + Tracks = rhs.Tracks; +} + // void GenericPackage::Dump(FILE* stream) @@ -383,6 +434,12 @@ MaterialPackage::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +MaterialPackage::Copy(const MaterialPackage& rhs) +{ +} + // void MaterialPackage::Dump(FILE* stream) @@ -437,6 +494,13 @@ SourcePackage::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +SourcePackage::Copy(const SourcePackage& rhs) +{ + Descriptor = rhs.Descriptor; +} + // void SourcePackage::Dump(FILE* stream) @@ -498,6 +562,16 @@ GenericTrack::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +GenericTrack::Copy(const GenericTrack& rhs) +{ + TrackID = rhs.TrackID; + TrackNumber = rhs.TrackNumber; + TrackName = rhs.TrackName; + Sequence = rhs.Sequence; +} + // void GenericTrack::Dump(FILE* stream) @@ -537,6 +611,12 @@ StaticTrack::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +StaticTrack::Copy(const StaticTrack& rhs) +{ +} + // void StaticTrack::Dump(FILE* stream) @@ -593,6 +673,14 @@ Track::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +Track::Copy(const Track& rhs) +{ + EditRate = rhs.EditRate; + Origin = rhs.Origin; +} + // void Track::Dump(FILE* stream) @@ -651,6 +739,14 @@ StructuralComponent::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +StructuralComponent::Copy(const StructuralComponent& rhs) +{ + DataDefinition = rhs.DataDefinition; + Duration = rhs.Duration; +} + // void StructuralComponent::Dump(FILE* stream) @@ -690,6 +786,13 @@ Sequence::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +Sequence::Copy(const Sequence& rhs) +{ + StructuralComponents = rhs.StructuralComponents; +} + // void Sequence::Dump(FILE* stream) @@ -750,6 +853,15 @@ SourceClip::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +SourceClip::Copy(const SourceClip& rhs) +{ + StartPosition = rhs.StartPosition; + SourcePackageID = rhs.SourcePackageID; + SourceTrackID = rhs.SourceTrackID; +} + // void SourceClip::Dump(FILE* stream) @@ -811,6 +923,15 @@ TimecodeComponent::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +TimecodeComponent::Copy(const TimecodeComponent& rhs) +{ + RoundedTimecodeBase = rhs.RoundedTimecodeBase; + StartTimecode = rhs.StartTimecode; + DropFrame = rhs.DropFrame; +} + // void TimecodeComponent::Dump(FILE* stream) @@ -870,6 +991,14 @@ GenericDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +GenericDescriptor::Copy(const GenericDescriptor& rhs) +{ + Locators = rhs.Locators; + SubDescriptors = rhs.SubDescriptors; +} + // void GenericDescriptor::Dump(FILE* stream) @@ -919,6 +1048,17 @@ FileDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +FileDescriptor::Copy(const FileDescriptor& rhs) +{ + LinkedTrackID = rhs.LinkedTrackID; + SampleRate = rhs.SampleRate; + ContainerDuration = rhs.ContainerDuration; + EssenceContainer = rhs.EssenceContainer; + Codec = rhs.Codec; +} + // void FileDescriptor::Dump(FILE* stream) @@ -988,6 +1128,18 @@ GenericSoundEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +GenericSoundEssenceDescriptor::Copy(const GenericSoundEssenceDescriptor& rhs) +{ + AudioSamplingRate = rhs.AudioSamplingRate; + Locked = rhs.Locked; + AudioRefLevel = rhs.AudioRefLevel; + ChannelCount = rhs.ChannelCount; + QuantizationBits = rhs.QuantizationBits; + DialNorm = rhs.DialNorm; +} + // void GenericSoundEssenceDescriptor::Dump(FILE* stream) @@ -1054,6 +1206,16 @@ WaveAudioDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +WaveAudioDescriptor::Copy(const WaveAudioDescriptor& rhs) +{ + BlockAlign = rhs.BlockAlign; + SequenceOffset = rhs.SequenceOffset; + AvgBps = rhs.AvgBps; + ChannelAssignment = rhs.ChannelAssignment; +} + // void WaveAudioDescriptor::Dump(FILE* stream) @@ -1120,6 +1282,17 @@ GenericPictureEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +GenericPictureEssenceDescriptor::Copy(const GenericPictureEssenceDescriptor& rhs) +{ + FrameLayout = rhs.FrameLayout; + StoredWidth = rhs.StoredWidth; + StoredHeight = rhs.StoredHeight; + AspectRatio = rhs.AspectRatio; + PictureEssenceCoding = rhs.PictureEssenceCoding; +} + // void GenericPictureEssenceDescriptor::Dump(FILE* stream) @@ -1181,6 +1354,14 @@ RGBAEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +RGBAEssenceDescriptor::Copy(const RGBAEssenceDescriptor& rhs) +{ + ComponentMaxRef = rhs.ComponentMaxRef; + ComponentMinRef = rhs.ComponentMinRef; +} + // void RGBAEssenceDescriptor::Dump(FILE* stream) @@ -1261,6 +1442,25 @@ JPEG2000PictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +JPEG2000PictureSubDescriptor::Copy(const JPEG2000PictureSubDescriptor& rhs) +{ + Rsize = rhs.Rsize; + Xsize = rhs.Xsize; + Ysize = rhs.Ysize; + XOsize = rhs.XOsize; + YOsize = rhs.YOsize; + XTsize = rhs.XTsize; + YTsize = rhs.YTsize; + XTOsize = rhs.XTOsize; + YTOsize = rhs.YTOsize; + Csize = rhs.Csize; + PictureComponentSizing = rhs.PictureComponentSizing; + CodingStyleDefault = rhs.CodingStyleDefault; + QuantizationDefault = rhs.QuantizationDefault; +} + // void JPEG2000PictureSubDescriptor::Dump(FILE* stream) @@ -1334,6 +1534,16 @@ CDCIEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +CDCIEssenceDescriptor::Copy(const CDCIEssenceDescriptor& rhs) +{ + ComponentDepth = rhs.ComponentDepth; + HorizontalSubsampling = rhs.HorizontalSubsampling; + VerticalSubsampling = rhs.VerticalSubsampling; + ColorSiting = rhs.ColorSiting; +} + // void CDCIEssenceDescriptor::Dump(FILE* stream) @@ -1398,6 +1608,16 @@ MPEG2VideoDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +MPEG2VideoDescriptor::Copy(const MPEG2VideoDescriptor& rhs) +{ + CodedContentType = rhs.CodedContentType; + LowDelay = rhs.LowDelay; + BitRate = rhs.BitRate; + ProfileAndLevel = rhs.ProfileAndLevel; +} + // void MPEG2VideoDescriptor::Dump(FILE* stream) @@ -1464,6 +1684,17 @@ DMSegment::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +DMSegment::Copy(const DMSegment& rhs) +{ + DataDefinition = rhs.DataDefinition; + EventStartPosition = rhs.EventStartPosition; + Duration = rhs.Duration; + EventComment = rhs.EventComment; + DMFramework = rhs.DMFramework; +} + // void DMSegment::Dump(FILE* stream) @@ -1523,6 +1754,13 @@ CryptographicFramework::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +CryptographicFramework::Copy(const CryptographicFramework& rhs) +{ + ContextSR = rhs.ContextSR; +} + // void CryptographicFramework::Dump(FILE* stream) @@ -1586,6 +1824,17 @@ CryptographicContext::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +CryptographicContext::Copy(const CryptographicContext& rhs) +{ + ContextID = rhs.ContextID; + SourceEssenceContainer = rhs.SourceEssenceContainer; + CipherAlgorithm = rhs.CipherAlgorithm; + MICAlgorithm = rhs.MICAlgorithm; + CryptographicKeyID = rhs.CryptographicKeyID; +} + // void CryptographicContext::Dump(FILE* stream) @@ -1645,6 +1894,13 @@ GenericDataEssenceDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +GenericDataEssenceDescriptor::Copy(const GenericDataEssenceDescriptor& rhs) +{ + DataEssenceCoding = rhs.DataEssenceCoding; +} + // void GenericDataEssenceDescriptor::Dump(FILE* stream) @@ -1704,6 +1960,15 @@ TimedTextDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +TimedTextDescriptor::Copy(const TimedTextDescriptor& rhs) +{ + ResourceID = rhs.ResourceID; + UCSEncoding = rhs.UCSEncoding; + NamespaceURI = rhs.NamespaceURI; +} + // void TimedTextDescriptor::Dump(FILE* stream) @@ -1765,6 +2030,15 @@ TimedTextResourceSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +TimedTextResourceSubDescriptor::Copy(const TimedTextResourceSubDescriptor& rhs) +{ + AncillaryResourceID = rhs.AncillaryResourceID; + MIMEMediaType = rhs.MIMEMediaType; + EssenceStreamID = rhs.EssenceStreamID; +} + // void TimedTextResourceSubDescriptor::Dump(FILE* stream) @@ -1820,6 +2094,12 @@ StereoscopicPictureSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +StereoscopicPictureSubDescriptor::Copy(const StereoscopicPictureSubDescriptor& rhs) +{ +} + // void StereoscopicPictureSubDescriptor::Dump(FILE* stream) @@ -1874,6 +2154,13 @@ NetworkLocator::WriteToTLVSet(TLVWriter& TLVSet) return result; } +// +void +NetworkLocator::Copy(const NetworkLocator& rhs) +{ + URLString = rhs.URLString; +} + // void NetworkLocator::Dump(FILE* stream) @@ -1906,6 +2193,271 @@ NetworkLocator::WriteToBuffer(ASDCP::FrameBuffer& Buffer) return InterchangeObject::WriteToBuffer(Buffer); } +//------------------------------------------------------------------------------------------ +// MCALabelSubDescriptor + +// +ASDCP::Result_t +MCALabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet) +{ + assert(m_Dict); + Result_t result = InterchangeObject::InitFromTLVSet(TLVSet); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCALinkID)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagSymbol)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, MCATagName)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadUi32(OBJ_READ_ARGS(MCALabelSubDescriptor, MCAChannelID)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage)); + return result; +} + +// +ASDCP::Result_t +MCALabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) +{ + assert(m_Dict); + Result_t result = InterchangeObject::WriteToTLVSet(TLVSet); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALabelDictionaryID)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCALinkID)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagSymbol)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCATagName)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteUi32(OBJ_WRITE_ARGS(MCALabelSubDescriptor, MCAChannelID)); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(MCALabelSubDescriptor, RFC5646SpokenLanguage)); + return result; +} + +// +void +MCALabelSubDescriptor::Copy(const MCALabelSubDescriptor& rhs) +{ + MCALabelDictionaryID = rhs.MCALabelDictionaryID; + MCALinkID = rhs.MCALinkID; + MCATagSymbol = rhs.MCATagSymbol; + MCATagName = rhs.MCATagName; + MCAChannelID = rhs.MCAChannelID; + RFC5646SpokenLanguage = rhs.RFC5646SpokenLanguage; +} + +// +void +MCALabelSubDescriptor::Dump(FILE* stream) +{ + char identbuf[IdentBufferLen]; + *identbuf = 0; + + if ( stream == 0 ) + stream = stderr; + + InterchangeObject::Dump(stream); + fprintf(stream, " %22s = %s\n", "MCALabelDictionaryID", MCALabelDictionaryID.EncodeString(identbuf, IdentBufferLen)); + fprintf(stream, " %22s = %s\n", "MCALinkID", MCALinkID.EncodeString(identbuf, IdentBufferLen)); + fprintf(stream, " %22s = %s\n", "MCATagSymbol", MCATagSymbol.EncodeString(identbuf, IdentBufferLen)); + fprintf(stream, " %22s = %s\n", "MCATagName", MCATagName.EncodeString(identbuf, IdentBufferLen)); + fprintf(stream, " %22s = %d\n", "MCAChannelID", MCAChannelID); + fprintf(stream, " %22s = %s\n", "RFC5646SpokenLanguage", RFC5646SpokenLanguage.EncodeString(identbuf, IdentBufferLen)); +} + +// +ASDCP::Result_t +MCALabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_MCALabelSubDescriptor)); + return InterchangeObject::InitFromBuffer(p, l); +} + +// +ASDCP::Result_t +MCALabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_MCALabelSubDescriptor)); + return InterchangeObject::WriteToBuffer(Buffer); +} + +//------------------------------------------------------------------------------------------ +// AudioChannelLabelSubDescriptor + +// +ASDCP::Result_t +AudioChannelLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet) +{ + assert(m_Dict); + Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID)); + return result; +} + +// +ASDCP::Result_t +AudioChannelLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) +{ + assert(m_Dict); + Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(AudioChannelLabelSubDescriptor, SoundfieldGroupLinkID)); + return result; +} + +// +void +AudioChannelLabelSubDescriptor::Copy(const AudioChannelLabelSubDescriptor& rhs) +{ + SoundfieldGroupLinkID = rhs.SoundfieldGroupLinkID; +} + +// +void +AudioChannelLabelSubDescriptor::Dump(FILE* stream) +{ + char identbuf[IdentBufferLen]; + *identbuf = 0; + + if ( stream == 0 ) + stream = stderr; + + MCALabelSubDescriptor::Dump(stream); + fprintf(stream, " %22s = %s\n", "SoundfieldGroupLinkID", SoundfieldGroupLinkID.EncodeString(identbuf, IdentBufferLen)); +} + +// +ASDCP::Result_t +AudioChannelLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_AudioChannelLabelSubDescriptor)); + return InterchangeObject::InitFromBuffer(p, l); +} + +// +ASDCP::Result_t +AudioChannelLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_AudioChannelLabelSubDescriptor)); + return InterchangeObject::WriteToBuffer(Buffer); +} + +//------------------------------------------------------------------------------------------ +// SoundfieldGroupLabelSubDescriptor + +// +ASDCP::Result_t +SoundfieldGroupLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet) +{ + assert(m_Dict); + Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.ReadObject(OBJ_READ_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID)); + return result; +} + +// +ASDCP::Result_t +SoundfieldGroupLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) +{ + assert(m_Dict); + Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet); + if ( ASDCP_SUCCESS(result) ) result = TLVSet.WriteObject(OBJ_WRITE_ARGS(SoundfieldGroupLabelSubDescriptor, GroupOfSoundfieldGroupsLinkID)); + return result; +} + +// +void +SoundfieldGroupLabelSubDescriptor::Copy(const SoundfieldGroupLabelSubDescriptor& rhs) +{ + GroupOfSoundfieldGroupsLinkID = rhs.GroupOfSoundfieldGroupsLinkID; +} + +// +void +SoundfieldGroupLabelSubDescriptor::Dump(FILE* stream) +{ + char identbuf[IdentBufferLen]; + *identbuf = 0; + + if ( stream == 0 ) + stream = stderr; + + MCALabelSubDescriptor::Dump(stream); + fprintf(stream, " %22s:\n", "GroupOfSoundfieldGroupsLinkID"); + GroupOfSoundfieldGroupsLinkID.Dump(stream); +} + +// +ASDCP::Result_t +SoundfieldGroupLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_SoundfieldGroupLabelSubDescriptor)); + return InterchangeObject::InitFromBuffer(p, l); +} + +// +ASDCP::Result_t +SoundfieldGroupLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_SoundfieldGroupLabelSubDescriptor)); + return InterchangeObject::WriteToBuffer(Buffer); +} + +//------------------------------------------------------------------------------------------ +// GroupOfSoundfieldGroupsLabelSubDescriptor + +// +ASDCP::Result_t +GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromTLVSet(TLVReader& TLVSet) +{ + assert(m_Dict); + Result_t result = MCALabelSubDescriptor::InitFromTLVSet(TLVSet); + return result; +} + +// +ASDCP::Result_t +GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToTLVSet(TLVWriter& TLVSet) +{ + assert(m_Dict); + Result_t result = MCALabelSubDescriptor::WriteToTLVSet(TLVSet); + return result; +} + +// +void +GroupOfSoundfieldGroupsLabelSubDescriptor::Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) +{ +} + +// +void +GroupOfSoundfieldGroupsLabelSubDescriptor::Dump(FILE* stream) +{ + char identbuf[IdentBufferLen]; + *identbuf = 0; + + if ( stream == 0 ) + stream = stderr; + + MCALabelSubDescriptor::Dump(stream); +} + +// +ASDCP::Result_t +GroupOfSoundfieldGroupsLabelSubDescriptor::InitFromBuffer(const byte_t* p, ui32_t l) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor)); + return InterchangeObject::InitFromBuffer(p, l); +} + +// +ASDCP::Result_t +GroupOfSoundfieldGroupsLabelSubDescriptor::WriteToBuffer(ASDCP::FrameBuffer& Buffer) +{ + assert(m_Dict); + m_Typeinfo = &(m_Dict->Type(MDD_GroupOfSoundfieldGroupsLabelSubDescriptor)); + return InterchangeObject::WriteToBuffer(Buffer); +} + // // end Metadata.cpp // diff --git a/src/Metadata.h b/src/Metadata.h index 891d155..bee893a 100755 --- a/src/Metadata.h +++ b/src/Metadata.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2009, John Hurst +Copyright (c) 2005-2012, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -45,7 +45,6 @@ namespace ASDCP // class Identification : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(Identification); Identification(); public: @@ -61,7 +60,10 @@ namespace ASDCP UTF16String Platform; Identification(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + Identification(const Identification& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~Identification() {} + const Identification& operator=(const Identification& rhs) { Copy(rhs); return *this; } + virtual void Copy(const Identification& rhs); virtual const char* HasName() { return "Identification"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -73,7 +75,6 @@ namespace ASDCP // class ContentStorage : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(ContentStorage); ContentStorage(); public: @@ -82,7 +83,10 @@ namespace ASDCP Batch EssenceContainerData; ContentStorage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + ContentStorage(const ContentStorage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~ContentStorage() {} + const ContentStorage& operator=(const ContentStorage& rhs) { Copy(rhs); return *this; } + virtual void Copy(const ContentStorage& rhs); virtual const char* HasName() { return "ContentStorage"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -94,7 +98,6 @@ namespace ASDCP // class EssenceContainerData : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(EssenceContainerData); EssenceContainerData(); public: @@ -104,7 +107,10 @@ namespace ASDCP ui32_t BodySID; EssenceContainerData(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), IndexSID(0), BodySID(0) {} + EssenceContainerData(const EssenceContainerData& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~EssenceContainerData() {} + const EssenceContainerData& operator=(const EssenceContainerData& rhs) { Copy(rhs); return *this; } + virtual void Copy(const EssenceContainerData& rhs); virtual const char* HasName() { return "EssenceContainerData"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -116,7 +122,6 @@ namespace ASDCP // class GenericPackage : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(GenericPackage); GenericPackage(); public: @@ -128,7 +133,10 @@ namespace ASDCP Batch Tracks; GenericPackage(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + GenericPackage(const GenericPackage& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~GenericPackage() {} + const GenericPackage& operator=(const GenericPackage& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GenericPackage& rhs); virtual const char* HasName() { return "GenericPackage"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -138,14 +146,16 @@ namespace ASDCP // class MaterialPackage : public GenericPackage { - ASDCP_NO_COPY_CONSTRUCT(MaterialPackage); MaterialPackage(); public: const Dictionary*& m_Dict; MaterialPackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {} + MaterialPackage(const MaterialPackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~MaterialPackage() {} + const MaterialPackage& operator=(const MaterialPackage& rhs) { Copy(rhs); return *this; } + virtual void Copy(const MaterialPackage& rhs); virtual const char* HasName() { return "MaterialPackage"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -157,7 +167,6 @@ namespace ASDCP // class SourcePackage : public GenericPackage { - ASDCP_NO_COPY_CONSTRUCT(SourcePackage); SourcePackage(); public: @@ -165,7 +174,10 @@ namespace ASDCP UUID Descriptor; SourcePackage(const Dictionary*& d) : GenericPackage(d), m_Dict(d) {} + SourcePackage(const SourcePackage& rhs) : GenericPackage(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~SourcePackage() {} + const SourcePackage& operator=(const SourcePackage& rhs) { Copy(rhs); return *this; } + virtual void Copy(const SourcePackage& rhs); virtual const char* HasName() { return "SourcePackage"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -177,7 +189,6 @@ namespace ASDCP // class GenericTrack : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(GenericTrack); GenericTrack(); public: @@ -188,7 +199,10 @@ namespace ASDCP UUID Sequence; GenericTrack(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), TrackID(0), TrackNumber(0) {} + GenericTrack(const GenericTrack& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~GenericTrack() {} + const GenericTrack& operator=(const GenericTrack& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GenericTrack& rhs); virtual const char* HasName() { return "GenericTrack"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -198,14 +212,16 @@ namespace ASDCP // class StaticTrack : public GenericTrack { - ASDCP_NO_COPY_CONSTRUCT(StaticTrack); StaticTrack(); public: const Dictionary*& m_Dict; StaticTrack(const Dictionary*& d) : GenericTrack(d), m_Dict(d) {} + StaticTrack(const StaticTrack& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~StaticTrack() {} + const StaticTrack& operator=(const StaticTrack& rhs) { Copy(rhs); return *this; } + virtual void Copy(const StaticTrack& rhs); virtual const char* HasName() { return "StaticTrack"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -217,7 +233,6 @@ namespace ASDCP // class Track : public GenericTrack { - ASDCP_NO_COPY_CONSTRUCT(Track); Track(); public: @@ -226,7 +241,10 @@ namespace ASDCP ui64_t Origin; Track(const Dictionary*& d) : GenericTrack(d), m_Dict(d), Origin(0) {} + Track(const Track& rhs) : GenericTrack(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~Track() {} + const Track& operator=(const Track& rhs) { Copy(rhs); return *this; } + virtual void Copy(const Track& rhs); virtual const char* HasName() { return "Track"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -238,7 +256,6 @@ namespace ASDCP // class StructuralComponent : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(StructuralComponent); StructuralComponent(); public: @@ -247,7 +264,10 @@ namespace ASDCP ui64_t Duration; StructuralComponent(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Duration(0) {} + StructuralComponent(const StructuralComponent& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~StructuralComponent() {} + const StructuralComponent& operator=(const StructuralComponent& rhs) { Copy(rhs); return *this; } + virtual void Copy(const StructuralComponent& rhs); virtual const char* HasName() { return "StructuralComponent"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -257,7 +277,6 @@ namespace ASDCP // class Sequence : public StructuralComponent { - ASDCP_NO_COPY_CONSTRUCT(Sequence); Sequence(); public: @@ -265,7 +284,10 @@ namespace ASDCP Batch StructuralComponents; Sequence(const Dictionary*& d) : StructuralComponent(d), m_Dict(d) {} + Sequence(const Sequence& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~Sequence() {} + const Sequence& operator=(const Sequence& rhs) { Copy(rhs); return *this; } + virtual void Copy(const Sequence& rhs); virtual const char* HasName() { return "Sequence"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -277,7 +299,6 @@ namespace ASDCP // class SourceClip : public StructuralComponent { - ASDCP_NO_COPY_CONSTRUCT(SourceClip); SourceClip(); public: @@ -287,7 +308,10 @@ namespace ASDCP ui32_t SourceTrackID; SourceClip(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), StartPosition(0), SourceTrackID(0) {} + SourceClip(const SourceClip& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~SourceClip() {} + const SourceClip& operator=(const SourceClip& rhs) { Copy(rhs); return *this; } + virtual void Copy(const SourceClip& rhs); virtual const char* HasName() { return "SourceClip"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -299,7 +323,6 @@ namespace ASDCP // class TimecodeComponent : public StructuralComponent { - ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent); TimecodeComponent(); public: @@ -309,7 +332,10 @@ namespace ASDCP ui8_t DropFrame; TimecodeComponent(const Dictionary*& d) : StructuralComponent(d), m_Dict(d), RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {} + TimecodeComponent(const TimecodeComponent& rhs) : StructuralComponent(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~TimecodeComponent() {} + const TimecodeComponent& operator=(const TimecodeComponent& rhs) { Copy(rhs); return *this; } + virtual void Copy(const TimecodeComponent& rhs); virtual const char* HasName() { return "TimecodeComponent"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -321,7 +347,6 @@ namespace ASDCP // class GenericDescriptor : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(GenericDescriptor); GenericDescriptor(); public: @@ -330,7 +355,10 @@ namespace ASDCP Batch SubDescriptors; GenericDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + GenericDescriptor(const GenericDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~GenericDescriptor() {} + const GenericDescriptor& operator=(const GenericDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GenericDescriptor& rhs); virtual const char* HasName() { return "GenericDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -340,7 +368,6 @@ namespace ASDCP // class FileDescriptor : public GenericDescriptor { - ASDCP_NO_COPY_CONSTRUCT(FileDescriptor); FileDescriptor(); public: @@ -352,7 +379,10 @@ namespace ASDCP UL Codec; FileDescriptor(const Dictionary*& d) : GenericDescriptor(d), m_Dict(d), LinkedTrackID(0), ContainerDuration(0) {} + FileDescriptor(const FileDescriptor& rhs) : GenericDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~FileDescriptor() {} + const FileDescriptor& operator=(const FileDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const FileDescriptor& rhs); virtual const char* HasName() { return "FileDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -364,7 +394,6 @@ namespace ASDCP // class GenericSoundEssenceDescriptor : public FileDescriptor { - ASDCP_NO_COPY_CONSTRUCT(GenericSoundEssenceDescriptor); GenericSoundEssenceDescriptor(); public: @@ -377,7 +406,10 @@ namespace ASDCP ui8_t DialNorm; GenericSoundEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {} + GenericSoundEssenceDescriptor(const GenericSoundEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~GenericSoundEssenceDescriptor() {} + const GenericSoundEssenceDescriptor& operator=(const GenericSoundEssenceDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GenericSoundEssenceDescriptor& rhs); virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -389,7 +421,6 @@ namespace ASDCP // class WaveAudioDescriptor : public GenericSoundEssenceDescriptor { - ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor); WaveAudioDescriptor(); public: @@ -400,7 +431,10 @@ namespace ASDCP UL ChannelAssignment; WaveAudioDescriptor(const Dictionary*& d) : GenericSoundEssenceDescriptor(d), m_Dict(d), BlockAlign(0), SequenceOffset(0), AvgBps(0) {} + WaveAudioDescriptor(const WaveAudioDescriptor& rhs) : GenericSoundEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~WaveAudioDescriptor() {} + const WaveAudioDescriptor& operator=(const WaveAudioDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const WaveAudioDescriptor& rhs); virtual const char* HasName() { return "WaveAudioDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -412,7 +446,6 @@ namespace ASDCP // class GenericPictureEssenceDescriptor : public FileDescriptor { - ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor); GenericPictureEssenceDescriptor(); public: @@ -424,7 +457,10 @@ namespace ASDCP UL PictureEssenceCoding; GenericPictureEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d), FrameLayout(0), StoredWidth(0), StoredHeight(0) {} + GenericPictureEssenceDescriptor(const GenericPictureEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~GenericPictureEssenceDescriptor() {} + const GenericPictureEssenceDescriptor& operator=(const GenericPictureEssenceDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GenericPictureEssenceDescriptor& rhs); virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -436,7 +472,6 @@ namespace ASDCP // class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor { - ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor); RGBAEssenceDescriptor(); public: @@ -445,7 +480,10 @@ namespace ASDCP ui32_t ComponentMinRef; RGBAEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentMaxRef(0), ComponentMinRef(0) {} + RGBAEssenceDescriptor(const RGBAEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~RGBAEssenceDescriptor() {} + const RGBAEssenceDescriptor& operator=(const RGBAEssenceDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const RGBAEssenceDescriptor& rhs); virtual const char* HasName() { return "RGBAEssenceDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -457,7 +495,6 @@ namespace ASDCP // class JPEG2000PictureSubDescriptor : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor); JPEG2000PictureSubDescriptor(); public: @@ -477,7 +514,10 @@ namespace ASDCP Raw QuantizationDefault; JPEG2000PictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {} + JPEG2000PictureSubDescriptor(const JPEG2000PictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~JPEG2000PictureSubDescriptor() {} + const JPEG2000PictureSubDescriptor& operator=(const JPEG2000PictureSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const JPEG2000PictureSubDescriptor& rhs); virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -489,7 +529,6 @@ namespace ASDCP // class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor { - ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor); CDCIEssenceDescriptor(); public: @@ -500,7 +539,10 @@ namespace ASDCP ui8_t ColorSiting; CDCIEssenceDescriptor(const Dictionary*& d) : GenericPictureEssenceDescriptor(d), m_Dict(d), ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {} + CDCIEssenceDescriptor(const CDCIEssenceDescriptor& rhs) : GenericPictureEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~CDCIEssenceDescriptor() {} + const CDCIEssenceDescriptor& operator=(const CDCIEssenceDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const CDCIEssenceDescriptor& rhs); virtual const char* HasName() { return "CDCIEssenceDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -512,7 +554,6 @@ namespace ASDCP // class MPEG2VideoDescriptor : public CDCIEssenceDescriptor { - ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor); MPEG2VideoDescriptor(); public: @@ -523,7 +564,10 @@ namespace ASDCP ui8_t ProfileAndLevel; MPEG2VideoDescriptor(const Dictionary*& d) : CDCIEssenceDescriptor(d), m_Dict(d), CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {} + MPEG2VideoDescriptor(const MPEG2VideoDescriptor& rhs) : CDCIEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~MPEG2VideoDescriptor() {} + const MPEG2VideoDescriptor& operator=(const MPEG2VideoDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const MPEG2VideoDescriptor& rhs); virtual const char* HasName() { return "MPEG2VideoDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -535,7 +579,6 @@ namespace ASDCP // class DMSegment : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(DMSegment); DMSegment(); public: @@ -547,7 +590,10 @@ namespace ASDCP UUID DMFramework; DMSegment(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EventStartPosition(0), Duration(0) {} + DMSegment(const DMSegment& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~DMSegment() {} + const DMSegment& operator=(const DMSegment& rhs) { Copy(rhs); return *this; } + virtual void Copy(const DMSegment& rhs); virtual const char* HasName() { return "DMSegment"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -559,7 +605,6 @@ namespace ASDCP // class CryptographicFramework : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework); CryptographicFramework(); public: @@ -567,7 +612,10 @@ namespace ASDCP UUID ContextSR; CryptographicFramework(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + CryptographicFramework(const CryptographicFramework& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~CryptographicFramework() {} + const CryptographicFramework& operator=(const CryptographicFramework& rhs) { Copy(rhs); return *this; } + virtual void Copy(const CryptographicFramework& rhs); virtual const char* HasName() { return "CryptographicFramework"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -579,7 +627,6 @@ namespace ASDCP // class CryptographicContext : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(CryptographicContext); CryptographicContext(); public: @@ -591,7 +638,10 @@ namespace ASDCP UUID CryptographicKeyID; CryptographicContext(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + CryptographicContext(const CryptographicContext& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~CryptographicContext() {} + const CryptographicContext& operator=(const CryptographicContext& rhs) { Copy(rhs); return *this; } + virtual void Copy(const CryptographicContext& rhs); virtual const char* HasName() { return "CryptographicContext"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -603,7 +653,6 @@ namespace ASDCP // class GenericDataEssenceDescriptor : public FileDescriptor { - ASDCP_NO_COPY_CONSTRUCT(GenericDataEssenceDescriptor); GenericDataEssenceDescriptor(); public: @@ -611,7 +660,10 @@ namespace ASDCP UL DataEssenceCoding; GenericDataEssenceDescriptor(const Dictionary*& d) : FileDescriptor(d), m_Dict(d) {} + GenericDataEssenceDescriptor(const GenericDataEssenceDescriptor& rhs) : FileDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~GenericDataEssenceDescriptor() {} + const GenericDataEssenceDescriptor& operator=(const GenericDataEssenceDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GenericDataEssenceDescriptor& rhs); virtual const char* HasName() { return "GenericDataEssenceDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -623,7 +675,6 @@ namespace ASDCP // class TimedTextDescriptor : public GenericDataEssenceDescriptor { - ASDCP_NO_COPY_CONSTRUCT(TimedTextDescriptor); TimedTextDescriptor(); public: @@ -633,7 +684,10 @@ namespace ASDCP UTF16String NamespaceURI; TimedTextDescriptor(const Dictionary*& d) : GenericDataEssenceDescriptor(d), m_Dict(d) {} + TimedTextDescriptor(const TimedTextDescriptor& rhs) : GenericDataEssenceDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~TimedTextDescriptor() {} + const TimedTextDescriptor& operator=(const TimedTextDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const TimedTextDescriptor& rhs); virtual const char* HasName() { return "TimedTextDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -645,7 +699,6 @@ namespace ASDCP // class TimedTextResourceSubDescriptor : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(TimedTextResourceSubDescriptor); TimedTextResourceSubDescriptor(); public: @@ -655,7 +708,10 @@ namespace ASDCP ui32_t EssenceStreamID; TimedTextResourceSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), EssenceStreamID(0) {} + TimedTextResourceSubDescriptor(const TimedTextResourceSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~TimedTextResourceSubDescriptor() {} + const TimedTextResourceSubDescriptor& operator=(const TimedTextResourceSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const TimedTextResourceSubDescriptor& rhs); virtual const char* HasName() { return "TimedTextResourceSubDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -667,14 +723,16 @@ namespace ASDCP // class StereoscopicPictureSubDescriptor : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(StereoscopicPictureSubDescriptor); StereoscopicPictureSubDescriptor(); public: const Dictionary*& m_Dict; StereoscopicPictureSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + StereoscopicPictureSubDescriptor(const StereoscopicPictureSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~StereoscopicPictureSubDescriptor() {} + const StereoscopicPictureSubDescriptor& operator=(const StereoscopicPictureSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const StereoscopicPictureSubDescriptor& rhs); virtual const char* HasName() { return "StereoscopicPictureSubDescriptor"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -686,7 +744,6 @@ namespace ASDCP // class NetworkLocator : public InterchangeObject { - ASDCP_NO_COPY_CONSTRUCT(NetworkLocator); NetworkLocator(); public: @@ -694,7 +751,10 @@ namespace ASDCP UTF16String URLString; NetworkLocator(const Dictionary*& d) : InterchangeObject(d), m_Dict(d) {} + NetworkLocator(const NetworkLocator& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } virtual ~NetworkLocator() {} + const NetworkLocator& operator=(const NetworkLocator& rhs) { Copy(rhs); return *this; } + virtual void Copy(const NetworkLocator& rhs); virtual const char* HasName() { return "NetworkLocator"; } virtual Result_t InitFromTLVSet(TLVReader& TLVSet); virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); @@ -703,6 +763,98 @@ namespace ASDCP virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&); }; + // + class MCALabelSubDescriptor : public InterchangeObject + { + MCALabelSubDescriptor(); + + public: + const Dictionary*& m_Dict; + UL MCALabelDictionaryID; + UUID MCALinkID; + UTF16String MCATagSymbol; + UTF16String MCATagName; + ui32_t MCAChannelID; + ISO8String RFC5646SpokenLanguage; + + MCALabelSubDescriptor(const Dictionary*& d) : InterchangeObject(d), m_Dict(d), MCAChannelID(0) {} + MCALabelSubDescriptor(const MCALabelSubDescriptor& rhs) : InterchangeObject(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } + virtual ~MCALabelSubDescriptor() {} + const MCALabelSubDescriptor& operator=(const MCALabelSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const MCALabelSubDescriptor& rhs); + virtual const char* HasName() { return "MCALabelSubDescriptor"; } + virtual Result_t InitFromTLVSet(TLVReader& TLVSet); + virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); + virtual void Dump(FILE* = 0); + virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l); + virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&); + }; + + // + class AudioChannelLabelSubDescriptor : public MCALabelSubDescriptor + { + AudioChannelLabelSubDescriptor(); + + public: + const Dictionary*& m_Dict; + UUID SoundfieldGroupLinkID; + + AudioChannelLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {} + AudioChannelLabelSubDescriptor(const AudioChannelLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } + virtual ~AudioChannelLabelSubDescriptor() {} + const AudioChannelLabelSubDescriptor& operator=(const AudioChannelLabelSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const AudioChannelLabelSubDescriptor& rhs); + virtual const char* HasName() { return "AudioChannelLabelSubDescriptor"; } + virtual Result_t InitFromTLVSet(TLVReader& TLVSet); + virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); + virtual void Dump(FILE* = 0); + virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l); + virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&); + }; + + // + class SoundfieldGroupLabelSubDescriptor : public MCALabelSubDescriptor + { + SoundfieldGroupLabelSubDescriptor(); + + public: + const Dictionary*& m_Dict; + Array GroupOfSoundfieldGroupsLinkID; + + SoundfieldGroupLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {} + SoundfieldGroupLabelSubDescriptor(const SoundfieldGroupLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } + virtual ~SoundfieldGroupLabelSubDescriptor() {} + const SoundfieldGroupLabelSubDescriptor& operator=(const SoundfieldGroupLabelSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const SoundfieldGroupLabelSubDescriptor& rhs); + virtual const char* HasName() { return "SoundfieldGroupLabelSubDescriptor"; } + virtual Result_t InitFromTLVSet(TLVReader& TLVSet); + virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); + virtual void Dump(FILE* = 0); + virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l); + virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&); + }; + + // + class GroupOfSoundfieldGroupsLabelSubDescriptor : public MCALabelSubDescriptor + { + GroupOfSoundfieldGroupsLabelSubDescriptor(); + + public: + const Dictionary*& m_Dict; + + GroupOfSoundfieldGroupsLabelSubDescriptor(const Dictionary*& d) : MCALabelSubDescriptor(d), m_Dict(d) {} + GroupOfSoundfieldGroupsLabelSubDescriptor(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) : MCALabelSubDescriptor(rhs.m_Dict), m_Dict(rhs.m_Dict) { Copy(rhs); } + virtual ~GroupOfSoundfieldGroupsLabelSubDescriptor() {} + const GroupOfSoundfieldGroupsLabelSubDescriptor& operator=(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs) { Copy(rhs); return *this; } + virtual void Copy(const GroupOfSoundfieldGroupsLabelSubDescriptor& rhs); + virtual const char* HasName() { return "GroupOfSoundfieldGroupsLabelSubDescriptor"; } + virtual Result_t InitFromTLVSet(TLVReader& TLVSet); + virtual Result_t WriteToTLVSet(TLVWriter& TLVSet); + virtual void Dump(FILE* = 0); + virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l); + virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&); + }; + } // namespace MXF } // namespace ASDCP -- 2.30.2