/* Copyright (c) 2006-2009, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /*! \file Dict.cpp \version $Id: Dict.cpp,v 1.16 2013/06/07 00:41:00 jhurst Exp $ \brief MXF dictionary */ #include #include #include #include "MDD.cpp" //------------------------------------------------------------------------------------------ // The composite dict is the union of the SMPTE and Interop dicts // static ASDCP::Dictionary s_CompositeDict; static Kumu::Mutex s_CompositeDictLock; static bool s_CompositeDictInit = false; // const ASDCP::Dictionary& ASDCP::DefaultCompositeDict() { if ( ! s_CompositeDictInit ) { Kumu::AutoMutex AL(s_CompositeDictLock); if ( ! s_CompositeDictInit ) { s_CompositeDict.Init(); s_CompositeDictInit = true; } } return s_CompositeDict; } // // static ASDCP::Dictionary s_InteropDict; static Kumu::Mutex s_InteropDictLock; static bool s_InteropDictInit = false; // const ASDCP::Dictionary& ASDCP::DefaultInteropDict() { if ( ! s_InteropDictInit ) { Kumu::AutoMutex AL(s_InteropDictLock); if ( ! s_InteropDictInit ) { s_InteropDict.Init(); s_InteropDict.DeleteEntry(MDD_MXFInterop_OPAtom); s_InteropDict.DeleteEntry(MDD_MXFInterop_CryptEssence); s_InteropDict.DeleteEntry(MDD_MXFInterop_GenericDescriptor_SubDescriptors); s_InteropDict.AddEntry(s_MDD_Table[MDD_MXFInterop_OPAtom], MDD_OPAtom); s_InteropDict.AddEntry(s_MDD_Table[MDD_MXFInterop_CryptEssence], MDD_CryptEssence); s_InteropDict.AddEntry(s_MDD_Table[MDD_MXFInterop_GenericDescriptor_SubDescriptors], MDD_GenericDescriptor_SubDescriptors); s_InteropDictInit = true; } } return s_InteropDict; } // // static ASDCP::Dictionary s_SMPTEDict; static Kumu::Mutex s_SMPTEDictLock; static bool s_SMPTEDictInit = false; // const ASDCP::Dictionary& ASDCP::DefaultSMPTEDict() { if ( ! s_SMPTEDictInit ) { Kumu::AutoMutex AL(s_SMPTEDictLock); if ( ! s_SMPTEDictInit ) { s_SMPTEDict.Init(); s_SMPTEDict.DeleteEntry(MDD_MXFInterop_OPAtom); s_SMPTEDict.DeleteEntry(MDD_MXFInterop_CryptEssence); s_SMPTEDict.DeleteEntry(MDD_MXFInterop_GenericDescriptor_SubDescriptors); s_SMPTEDictInit = true; } } return s_SMPTEDict; } // const ASDCP::MDDEntry& ASDCP::MXFInterop_OPAtom_Entry() { return s_MDD_Table[MDD_MXFInterop_OPAtom]; } // const ASDCP::MDDEntry& ASDCP::SMPTE_390_OPAtom_Entry() { return s_MDD_Table[MDD_OPAtom]; } //------------------------------------------------------------------------------------------ // ASDCP::Dictionary::Dictionary() {} ASDCP::Dictionary::~Dictionary() {} // void ASDCP::Dictionary::Init() { m_md_lookup.clear(); memset(m_MDD_Table, 0, sizeof(m_MDD_Table)); for ( ui32_t x = 0; x < (ui32_t)ASDCP::MDD_Max; ++x ) { if ( x == MDD_PartitionMetadata_IndexSID_DEPRECATED // 30 || x == MDD_PartitionMetadata_BodySID_DEPRECATED // 32 || x == MDD_PartitionMetadata_OperationalPattern_DEPRECATED // 33 || x == MDD_PartitionMetadata_EssenceContainers_DEPRECATED // 34 || x == MDD_IndexTableSegmentBase_IndexSID_DEPRECATED // 56 || x == MDD_IndexTableSegmentBase_BodySID_DEPRECATED // 57 || x == MDD_PartitionArray_RandomIndexMetadata_BodySID_DEPRECATED // 73 || x == MDD_Preface_OperationalPattern_DEPRECATED // 84 || x == MDD_Preface_EssenceContainers_DEPRECATED // 85 || x == MDD_EssenceContainerData_IndexSID_DEPRECATED // 103 || x == MDD_EssenceContainerData_BodySID_DEPRECATED // 104 || x == MDD_TimedTextResourceSubDescriptor_EssenceStreamID_DEPRECATED // 264 || x == MDD_DMSegment_DataDefinition_DEPRECATED // 266 || x == MDD_DMSegment_Duration_DEPRECATED // 267 ) continue; AddEntry(s_MDD_Table[x], x); } } // bool ASDCP::Dictionary::AddEntry(const MDDEntry& Entry, ui32_t index) { if ( index >= (ui32_t)MDD_Max ) { Kumu::DefaultLogSink().Warn("UL Dictionary: index exceeds maximum: %d\n", index); return false; } bool result = true; // is this index already there? std::map::iterator rii = m_md_rev_lookup.find(index); if ( rii != m_md_rev_lookup.end() ) { DeleteEntry(index); result = false; } UL TmpUL(Entry.ul); #ifdef MDD_AUTHORING_MODE char buf[64]; std::map::iterator ii = m_md_lookup.find(TmpUL); if ( ii != m_md_lookup.end() ) { fprintf(stderr, "DUPE! %s (%02x, %02x) %s | (%02x, %02x) %s\n", TmpUL.EncodeString(buf, 64), m_MDD_Table[ii->second].tag.a, m_MDD_Table[ii->second].tag.b, m_MDD_Table[ii->second].name, Entry.tag.a, Entry.tag.b, Entry.name); } #endif m_md_lookup.insert(std::map::value_type(TmpUL, index)); m_md_rev_lookup.insert(std::map::value_type(index, TmpUL)); m_md_sym_lookup.insert(std::map::value_type(Entry.name, index)); m_MDD_Table[index] = Entry; return result; } // bool ASDCP::Dictionary::DeleteEntry(ui32_t index) { std::map::iterator rii = m_md_rev_lookup.find(index); if ( rii != m_md_rev_lookup.end() ) { std::map::iterator ii = m_md_lookup.find(rii->second); assert(ii != m_md_lookup.end()); MDDEntry NilEntry; memset(&NilEntry, 0, sizeof(NilEntry)); m_md_lookup.erase(ii); m_md_rev_lookup.erase(rii); m_MDD_Table[index] = NilEntry; return true; } return false; } // const ASDCP::MDDEntry& ASDCP::Dictionary::Type(MDD_t type_id) const { assert(m_MDD_Table[0].name[0]); std::map::const_iterator rii = m_md_rev_lookup.find(type_id); if ( rii == m_md_rev_lookup.end() ) Kumu::DefaultLogSink().Warn("UL Dictionary: unknown UL type_id: %d\n", type_id); return m_MDD_Table[type_id]; } // const ASDCP::MDDEntry* ASDCP::Dictionary::FindUL(const byte_t* ul_buf) const { assert(m_MDD_Table[0].name[0]); std::map::const_iterator i = m_md_lookup.find(UL(ul_buf)); if ( i == m_md_lookup.end() ) { byte_t tmp_ul[SMPTE_UL_LENGTH]; memcpy(tmp_ul, ul_buf, SMPTE_UL_LENGTH); tmp_ul[SMPTE_UL_LENGTH-1] = 0; i = m_md_lookup.find(UL(tmp_ul)); if ( i == m_md_lookup.end() ) { char buf[64]; UL TmpUL(ul_buf); Kumu::DefaultLogSink().Warn("UL Dictionary: unknown UL: %s\n", TmpUL.EncodeString(buf, 64)); return 0; } } return &m_MDD_Table[i->second]; } // const ASDCP::MDDEntry* ASDCP::Dictionary::FindSymbol(const std::string& str) const { assert(m_MDD_Table[0].name[0]); std::map::const_iterator i = m_md_sym_lookup.find(str); if ( i == m_md_sym_lookup.end() ) { Kumu::DefaultLogSink().Warn("UL Dictionary: unknown symbol: %s\n", str.c_str()); return 0; } return &m_MDD_Table[i->second]; } // void ASDCP::Dictionary::Dump(FILE* stream) const { if ( stream == 0 ) stream = stderr; MDD_t di = (MDD_t)0; char str_buf[64]; while ( di < MDD_Max ) { if ( m_MDD_Table[di].name != 0 ) { UL TmpUL(m_MDD_Table[di].ul); fprintf(stream, "%s: %s\n", TmpUL.EncodeString(str_buf, 64), m_MDD_Table[di].name); } di = (MDD_t)(di + 1); } } // // end Dict.cpp //