1 /* Copyright (c) MediaArea.net SARL. All Rights Reserved.
2 *
3 * Use of this source code is governed by a BSD-style license that can
4 * be found in the License.html file in the root of the source tree.
5 */
6
7 //---------------------------------------------------------------------------
8 // Pre-compilation
9 #include "MediaInfo/PreComp.h"
10 #ifdef __BORLANDC__
11 #pragma hdrstop
12 #endif
13 //---------------------------------------------------------------------------
14
15 //---------------------------------------------------------------------------
16 #include "MediaInfo/Setup.h"
17 //---------------------------------------------------------------------------
18
19 //---------------------------------------------------------------------------
20 #if defined(MEDIAINFO_MXF_YES)
21 //---------------------------------------------------------------------------
22
23 //---------------------------------------------------------------------------
24 #include "MediaInfo/Multiple/File_Mxf.h"
25 #include "MediaInfo/Video/File_DolbyVisionMetadata.h"
26 #include "MediaInfo/Audio/File_DolbyAudioMetadata.h"
27 #if defined(MEDIAINFO_DVDIF_YES)
28 #include "MediaInfo/Multiple/File_DvDif.h"
29 #endif
30 #if defined(MEDIAINFO_DVDIF_YES)
31 #include "MediaInfo/Multiple/File_DvDif.h"
32 #endif
33 #if defined(MEDIAINFO_VBI_YES)
34 #include "MediaInfo/Multiple/File_Vbi.h"
35 #endif
36 #if defined(MEDIAINFO_AVC_YES)
37 #include "MediaInfo/Video/File_Avc.h"
38 #endif
39 #if defined(MEDIAINFO_MPEG4V_YES)
40 #include "MediaInfo/Video/File_Mpeg4v.h"
41 #endif
42 #if defined(MEDIAINFO_MPEGV_YES)
43 #include "MediaInfo/Video/File_Mpegv.h"
44 #endif
45 #if defined(MEDIAINFO_PRORES_YES)
46 #include "MediaInfo/Video/File_ProRes.h"
47 #endif
48 #if defined(MEDIAINFO_VC3_YES)
49 #include "MediaInfo/Video/File_Vc3.h"
50 #endif
51 #if defined(MEDIAINFO_AAC_YES)
52 #include "MediaInfo/Audio/File_Aac.h"
53 #endif
54 #if defined(MEDIAINFO_AC3_YES)
55 #include "MediaInfo/Audio/File_Ac3.h"
56 #endif
57 #if defined(MEDIAINFO_ADM_YES)
58 #include "MediaInfo/Audio/File_Adm.h"
59 #endif
60 #if defined(MEDIAINFO_IAB_YES)
61 #include "MediaInfo/Audio/File_Iab.h"
62 #endif
63 #if defined(MEDIAINFO_SMPTEST0337_YES)
64 #include "MediaInfo/Audio/File_ChannelGrouping.h"
65 #endif
66 #if defined(MEDIAINFO_SMPTEST0337_YES)
67 #include "MediaInfo/Audio/File_ChannelSplitting.h"
68 #endif
69 #if defined(MEDIAINFO_MPEGA_YES)
70 #include "MediaInfo/Audio/File_Mpega.h"
71 #endif
72 #if defined(MEDIAINFO_PCM_YES)
73 #include "MediaInfo/Audio/File_Pcm.h"
74 #endif
75 #if defined(MEDIAINFO_SMPTEST0331_YES)
76 #include "MediaInfo/Audio/File_SmpteSt0331.h"
77 #endif
78 #if defined(MEDIAINFO_SMPTEST0337_YES)
79 #include "MediaInfo/Audio/File_SmpteSt0337.h"
80 #endif
81 #if defined(MEDIAINFO_JPEG_YES)
82 #include "MediaInfo/Image/File_Jpeg.h"
83 #endif
84 #if defined(MEDIAINFO_TTML_YES)
85 #include "MediaInfo/Text/File_Ttml.h"
86 #endif
87 #include "MediaInfo/MediaInfo_Config_MediaInfo.h"
88 #include "MediaInfo/TimeCode.h"
89 #include "MediaInfo/File_Unknown.h"
90 #if defined(MEDIAINFO_FILE_YES)
91 #include "ZenLib/File.h"
92 #endif //defined(MEDIAINFO_REFERENCES_YES)
93 #include "ZenLib/FileName.h"
94 #include "MediaInfo/MediaInfo_Internal.h"
95 #if defined(MEDIAINFO_REFERENCES_YES)
96 #include "MediaInfo/Multiple/File__ReferenceFilesHelper.h"
97 #endif //defined(MEDIAINFO_REFERENCES_YES)
98 #include "ZenLib/Format/Http/Http_Utils.h"
99 #include <cfloat>
100 #include <cmath>
101 #if MEDIAINFO_SEEK
102 #include <algorithm>
103 #endif //MEDIAINFO_SEEK
104 using namespace std;
105 //---------------------------------------------------------------------------
106
107 namespace MediaInfoLib
108 {
109
110 //***************************************************************************
111 //
112 // PartitionPack
113 // Primer
114 // Preface
115 // --> ContentStorage
116 // --> Packages --> Package (Material, Source)
117 // --> Tracks --> Track
118 // --> Sequence
119 // --> StructuralComponents --> StructuralComponent (Timecode, SourceClip)
120 // --> Descriptors --> Descriptor (Multiple, Essence)
121 // --> Descriptors --> Descriptor (Essence)
122 // --> EssenceContainerData
123 // --> Identifications --> Identification
124 //
125 //***************************************************************************
126
127 //***************************************************************************
128 // Constants
129 //***************************************************************************
130
131 //---------------------------------------------------------------------------
132 #if MEDIAINFO_TRACE
133 static const size_t MaxCountSameElementInTrace=10;
134 #endif // MEDIAINFO_TRACE
135
136 //---------------------------------------------------------------------------
137 #define UUID(PART1, PART2, PART3, PART4, LOCAL, NORM, NAME, DESCRIPTION) \
138 const int32u NAME##1=0x##PART1; \
139 const int32u NAME##2=0x##PART2; \
140 const int32u NAME##3=0x##PART3; \
141 const int32u NAME##4=0x##PART4; \
142
143 namespace Elements
144 {
145 // 01 - Identification and location
146 // 01 - Globally Unique Identifiers
147 // 15 - Object Identifiers
148 UUID(060E2B34, 0101010C, 01011512, 00000000, 0000, "SMPTE ST 429-5", ResourceID, "Resource ID")
149
150 // 02 - Globally Unique Locators
151 // 01 - Uniform Resource Locators
152 UUID(060E2B34, 0101010C, 01020105, 01000000, 0000, "SMPTE ST 429-5", NamespaceURI, "Namespace URI")
153
154 // 03 - Locally Unique Identifiers
155 // 04 - ?
156 UUID(060E2B34, 0101010D, 01030408, 00000000, 0000, "", Application_08_BodySID, "")
157 UUID(060E2B34, 0101010E, 0103040A, 00000000, 0000, "SMPTE ST 377-4", MCAChannelID, "MCA Channel ID")
158
159 // 07 - ?
160 // 01 - ?
161 UUID(060E2B34, 0101010E, 01030701, 01000000, 0000, "SMPTE ST 377-4", MCALabelDictionaryID, "MCA Label Dictionary ID")
162 UUID(060E2B34, 0101010E, 01030701, 02000000, 0000, "SMPTE ST 377-4", MCATagSymbol, "MCA Tag Symbol")
163 UUID(060E2B34, 0101010E, 01030701, 03000000, 0000, "SMPTE ST 377-4", MCATagName, "MCA Tag Name")
164 UUID(060E2B34, 0101010E, 01030701, 04000000, 0000, "SMPTE ST 377-4", GroupOfSoundfieldGroupsLinkID, "Group Of Soundfield Groups Link ID")
165 UUID(060E2B34, 0101010E, 01030701, 05000000, 0000, "SMPTE ST 377-4", MCALinkID, "MCA Link ID")
166 UUID(060E2B34, 0101010E, 01030701, 06000000, 0000, "SMPTE ST 377-4", SoundfieldGroupLinkID, "Soundfield Group Link ID")
167
168 // 04 - Locally Unique Locators
169 // 01 - ?
170 // 01 - ?
171 UUID(060E2B34, 0101010E, 01040105, 00000000, 0000, "SMPTE ST 377-4", MCAPartitionKind, "MCA Partition Kind")
172 UUID(060E2B34, 0101010E, 01040106, 00000000, 0000, "SMPTE ST 377-4", MCAPartitionNumber, "MCA Partition Number")
173
174 // 05 - Titles
175 UUID(060E2B34, 0101010E, 01051000, 00000000, 0000, "SMPTE ST 377-4", MCATitle, "MCA Title")
176 UUID(060E2B34, 0101010E, 01051100, 00000000, 0000, "SMPTE ST 377-4", MCATitleVersion, "MCA Title Version")
177 UUID(060E2B34, 0101010E, 01051200, 00000000, 0000, "SMPTE ST 377-4", MCATitleSubVersion, "MCA Title Sub-version")
178 UUID(060E2B34, 0101010E, 01051300, 00000000, 0000, "SMPTE ST 377-4", MCAEpisode, "MCA Episode")
179
180 // 02 - Administrative
181
182 // 03 - Interpretive
183 // 01 - Fundamental
184 // 01 - Countries and Languages
185 // 01 - Country and Region Codes
186
187 // 02 - Spoken Language Codes
188 UUID(060E2B34, 01010107, 03010102, 03010000, 0000, "", PrimarySpokenLanguage, "")
189 UUID(060E2B34, 01010107, 03010102, 03020000, 0000, "", SecondarySpokenLanguage, "")
190 UUID(060E2B34, 01010107, 03010102, 03030000, 0000, "", OriginalSpokenLanguage, "")
191 UUID(060E2B34, 01010107, 03010102, 03040000, 0000, "", SecondaryOriginalSpokenLanguage, "")
192 UUID(060E2B34, 01010107, 03010102, 03110000, 0000, "SMPTE ST 380", PrimaryExtendedSpokenLanguage, "Primary Extended Spoken Language")
193 UUID(060E2B34, 01010107, 03010102, 03120000, 0000, "SMPTE ST 380", SecondaryExtendedSpokenLanguage, "Secondary Extended Spoken Language")
194 UUID(060E2B34, 01010107, 03010102, 03130000, 0000, "SMPTE ST 380", OriginalExtendedSpokenLanguage, "Original Extended Spoken Language")
195 UUID(060E2B34, 01010107, 03010102, 03140000, 0000, "SMPTE ST 380", SecondaryOriginalExtendedSpokenLanguage, "Secondary Original Extended Spoken Language")
196 UUID(060E2B34, 0101010D, 03010102, 03150000, 0000, "SMPTE ST 377-4", RFC5646AudioLanguageCode, "RFC 5646 Spoken Language")
197
198 // 02 - Data Interpretations and Definitions
199 // 0A - Name-Value Construct Interpretations
200 UUID(060E2B34, 01010105, 0301020A, 01000000, 0000, "", Ansi_01, "")
201 UUID(060E2B34, 01010105, 0301020A, 01010000, 0000, "", UTF16_01, "")
202 UUID(060E2B34, 01010105, 0301020A, 02000000, 0000, "", Ansi_02, "")
203 UUID(060E2B34, 01010105, 0301020A, 02010000, 0000, "", UTF16_02, "")
204
205 // 10 - KLV Interpretations
206 UUID(060E2B34, 01010101, 03010210, 01000000, 0000, "", Filler01, "")
207 UUID(060E2B34, 01010102, 03010210, 01000000, 0000, "", Filler02, "")
208 UUID(060E2B34, 01010102, 03010210, 05000000, 0000, "", TerminatingFiller, "")
209
210 // 10 - XML Constructs and Interpretations
211 UUID(060E2B34, 01010105, 03010220, 01000000, 0000, "", XmlDocumentText, "")
212
213 // 02 - Human Assigned Descriptors
214 // 01 - Categorization
215 // 01 - Content Classification
216
217 // 02 - Cataloging and Indexing
218 UUID(060E2B34, 0101010E, 03020102, 20000000, 0000, "", MCAAudioContentKind, "")
219 UUID(060E2B34, 0101010E, 03020102, 21000000, 0000, "", MCAAudioElementKind, "")
220
221 // 04 - Parametric
222 // 01 - Video and Image Essence Characteristics
223 // 06 - Digital Video and Image Compression Parameters
224 // 02 - MPEG Coding Parameters
225 // 01 - MPEG-2 Coding Parameters
226 UUID(060E2B34, 01010105, 04010602, 01020000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_SingleSequence, "")
227 UUID(060E2B34, 01010105, 04010602, 01030000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_ConstantBFrames, "")
228 UUID(060E2B34, 01010105, 04010602, 01040000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_CodedContentType, "")
229 UUID(060E2B34, 01010105, 04010602, 01050000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_LowDelay, "")
230 UUID(060E2B34, 01010105, 04010602, 01060000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_ClosedGOP, "")
231 UUID(060E2B34, 01010105, 04010602, 01070000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_IdenticalGOP, "")
232 UUID(060E2B34, 01010105, 04010602, 01080000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_MaxGOP, "")
233 UUID(060E2B34, 01010105, 04010602, 01090000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_BPictureCount, "")
234 UUID(060E2B34, 01010105, 04010602, 010A0000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_ProfileAndLevel, "")
235 UUID(060E2B34, 01010105, 04010602, 010B0000, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor_BitRate, "")
236
237 // 02 - MPEG-4 Visual Coding Parameters
238 UUID(060E2B34, 01010105, 04010602, 02020000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_SingleSequence, "")
239 UUID(060E2B34, 01010105, 04010602, 02030000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_ConstantBFrames, "")
240 UUID(060E2B34, 01010105, 04010602, 02040000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_CodedContentType, "")
241 UUID(060E2B34, 01010105, 04010602, 02050000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_LowDelay, "")
242 UUID(060E2B34, 01010105, 04010602, 02060000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_ClosedGOP, "")
243 UUID(060E2B34, 01010105, 04010602, 02070000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_IdenticalGOP, "")
244 UUID(060E2B34, 01010105, 04010602, 02080000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_MaxGOP, "")
245 UUID(060E2B34, 01010105, 04010602, 02090000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_BPictureCount, "")
246 UUID(060E2B34, 01010105, 04010602, 020A0000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_ProfileAndLevel, "")
247 UUID(060E2B34, 01010105, 04010602, 020B0000, 0000, "SMPTE ST 381-2", Mpeg4VisualDescriptor_BitRate, "")
248
249 // 03 - JPEG 2000 Coding Parameters
250 UUID(060E2B34, 0101010A, 04010603, 01000000, 0000, "", JPEG2000PictureSubDescriptor_Rsiz, "")
251 UUID(060E2B34, 0101010A, 04010603, 02000000, 0000, "", JPEG2000PictureSubDescriptor_Xsiz, "")
252 UUID(060E2B34, 0101010A, 04010603, 03000000, 0000, "", JPEG2000PictureSubDescriptor_Ysiz, "")
253 UUID(060E2B34, 0101010A, 04010603, 04000000, 0000, "", JPEG2000PictureSubDescriptor_XOsiz, "")
254 UUID(060E2B34, 0101010A, 04010603, 05000000, 0000, "", JPEG2000PictureSubDescriptor_YOsiz, "")
255 UUID(060E2B34, 0101010A, 04010603, 06000000, 0000, "", JPEG2000PictureSubDescriptor_XTsiz, "")
256 UUID(060E2B34, 0101010A, 04010603, 07000000, 0000, "", JPEG2000PictureSubDescriptor_YTsiz, "")
257 UUID(060E2B34, 0101010A, 04010603, 08000000, 0000, "", JPEG2000PictureSubDescriptor_XTOsiz, "")
258 UUID(060E2B34, 0101010A, 04010603, 09000000, 0000, "", JPEG2000PictureSubDescriptor_YTOsiz, "")
259 UUID(060E2B34, 0101010A, 04010603, 0A000000, 0000, "", JPEG2000PictureSubDescriptor_Csiz, "")
260 UUID(060E2B34, 0101010A, 04010603, 0B000000, 0000, "", JPEG2000PictureSubDescriptor_PictureComponentSizing, "")
261 UUID(060E2B34, 0101010A, 04010603, 0C000000, 0000, "", JPEG2000PictureSubDescriptor_CodingStyleDefault, "")
262 UUID(060E2B34, 0101010A, 04010603, 0D000000, 0000, "", JPEG2000PictureSubDescriptor_QuantizationDefault, "")
263
264 // 06 - AVC Parameters
265 // 01 - AVC Parameters
266 UUID(060E2B34, 01010105, 04010606, 01030000, 0000, "SMPTE ST 381-3", AVCDescriptor_ConstantBFrames, "")
267 UUID(060E2B34, 01010105, 04010606, 01040000, 0000, "SMPTE ST 381-3", AVCDescriptor_CodedContentType, "")
268 UUID(060E2B34, 01010105, 04010606, 01060000, 0000, "SMPTE ST 381-3", AVCDescriptor_ClosedGOP, "")
269 UUID(060E2B34, 01010105, 04010606, 01070000, 0000, "SMPTE ST 381-3", AVCDescriptor_IdenticalGOP, "")
270 UUID(060E2B34, 01010105, 04010606, 01080000, 0000, "SMPTE ST 381-3", AVCDescriptor_MaxGOP, "")
271 UUID(060E2B34, 01010105, 04010606, 01090000, 0000, "SMPTE ST 381-3", AVCDescriptor_BPictureCount, "")
272 UUID(060E2B34, 01010105, 04010606, 010A0000, 0000, "SMPTE ST 381-3", AVCDescriptor_Profile, "")
273 UUID(060E2B34, 01010105, 04010606, 010B0000, 0000, "SMPTE ST 381-3", AVCDescriptor_MaximumBitRate, "")
274 UUID(060E2B34, 01010105, 04010606, 010C0000, 0000, "SMPTE ST 381-3", AVCDescriptor_ProfileConstraint, "")
275 UUID(060E2B34, 01010105, 04010606, 010D0000, 0000, "SMPTE ST 381-3", AVCDescriptor_Level, "")
276 UUID(060E2B34, 01010105, 04010606, 010E0000, 0000, "SMPTE ST 381-3", AVCDescriptor_DecodingDelay, "")
277 UUID(060E2B34, 01010105, 04010606, 010F0000, 0000, "SMPTE ST 381-3", AVCDescriptor_MaximumRefFrames, "")
278 UUID(060E2B34, 01010105, 04010606, 01100000, 0000, "SMPTE ST 381-3", AVCDescriptor_SequenceParameterSetFlag, "")
279 UUID(060E2B34, 01010105, 04010606, 01110000, 0000, "SMPTE ST 381-3", AVCDescriptor_PictureParameterSetFlag, "")
280 UUID(060E2B34, 01010105, 04010606, 01140000, 0000, "SMPTE ST 381-3", AVCDescriptor_AverageBitRate, "")
281
282 // 02 - Audio Essence Characteristics
283 // 04 - Audio Compression Parameters
284 // 03 - MPEG Coding Parameters
285 // 01 - MPEG-2 Coding Parameters
286 UUID(060E2B34, 01010105, 04020403, 01020000, 0000, "SMPTE ST 381-2", MpegAudioDescriptor_BitRate, "")
287
288 // 09 - Format Characteristics
289 UUID(060E2B34, 0101010C, 04090500, 00000000, 0000, "SMPTE ST 429-5", UCSEncoding, "UCS Encoding")
290
291 // 20 - Device Characteristics
292 // 04 - Display Characteristics
293 // 01 - Mastering Display Characteristics
294 // 01 - Mastering Display Color Volume
295 UUID(060E2B34, 0101010E, 04200401, 01010000, 0000, "SMPTE ST 2067-21", MasteringDisplayPrimaries, "Mastering Display Primaries")
296 UUID(060E2B34, 0101010E, 04200401, 01020000, 0000, "SMPTE ST 2067-21", MasteringDisplayWhitePointChromaticity, "Mastering Display White Point Chromaticity")
297 UUID(060E2B34, 0101010E, 04200401, 01030000, 0000, "SMPTE ST 2067-21", MasteringDisplayMaximumLuminance, "Mastering Display Maximum Luminance")
298 UUID(060E2B34, 0101010E, 04200401, 01040000, 0000, "SMPTE ST 2067-21", MasteringDisplayMinimumLuminance, "Mastering Display Minimum Luminance")
299
300 // 05 - Process
301
302 // 06 - Relational
303 // 01 - Essence and Metadata Relationships
304 // 04 - Essence to Essence Relationships
305 UUID(060E2B34, 01010109, 06010104, 06100000, 0000, "", SubDescriptors, "")
306
307 // 07 - Spatio-temporal
308
309 // 0C - Compound
310 // 02 - Metadata sets created at point of creation or capture
311 // 01 - Metadata sets associated with a video camera
312 // 01 - Frame-based metadata set
313 UUID(060E2B34, 02530101, 0C020101, 01010000, 0000, "SMPTE RDD 18", LensUnitMetadata, "")
314 UUID(060E2B34, 02530101, 0C020101, 02010000, 0000, "SMPTE RDD 18", CameraUnitMetadata, "")
315 UUID(060E2B34, 02530101, 0C020101, 7F010000, 0000, "SMPTE RDD 18", UserDefinedAcquisitionMetadata, "")
316
317 // 0D - Organizationally registered for public use
318 // 01 - AAF Association
319 // 01 - MXF Structural Metadata Sets
320 // 01 - Version 1
321 // 01 - MXF compatible sets and packs
322 UUID(060E2B34, 02530101, 0D010101, 01010100, 0000, "SMPTE ST 377-1", InterchangeObject, "Interchange Object")
323 UUID(060E2B34, 02530101, 0D010101, 01010200, 0000, "SMPTE ST 377-1", StructuralComponent, "Structural Component")
324 UUID(060E2B34, 02530101, 0D010101, 01010300, 0000, "SMPTE ST 377-1", Segment, "Segment")
325 UUID(060E2B34, 02530101, 0D010101, 01010600, 0000, "SMPTE ST 377-1", Event, "Event")
326 UUID(060E2B34, 02530101, 0D010101, 01010800, 0000, "SMPTE ST 377-1", CommentMarker, "Comment Marker")
327 UUID(060E2B34, 02530101, 0D010101, 01010900, 0000, "SMPTE ST 377-1", DMFiller, "")
328 UUID(060E2B34, 02530101, 0D010101, 01010F00, 0000, "SMPTE ST 377-1", Sequence, "")
329 UUID(060E2B34, 02530101, 0D010101, 01011100, 0000, "SMPTE ST 377-1", SourceClip, "")
330 UUID(060E2B34, 02530101, 0D010101, 01011400, 0000, "SMPTE ST 377-1", TimecodeComponent, "")
331 UUID(060E2B34, 02530101, 0D010101, 01011800, 0000, "SMPTE ST 377-1", ContentStorage, "")
332 UUID(060E2B34, 02530101, 0D010101, 01012300, 0000, "SMPTE ST 377-1", EssenceContainerData, "")
333 UUID(060E2B34, 02530101, 0D010101, 01012400, 0000, "SMPTE ST 377-1", GenericDescriptor, "Generic Descriptor")
334 UUID(060E2B34, 02530101, 0D010101, 01012500, 0000, "SMPTE ST 377-1", FileDescriptor, "")
335 UUID(060E2B34, 02530101, 0D010101, 01012700, 0000, "SMPTE ST 377-1", GenericPictureEssenceDescriptor, "")
336 UUID(060E2B34, 02530101, 0D010101, 01012800, 0000, "SMPTE ST 377-1", CDCIEssenceDescriptor, "")
337 UUID(060E2B34, 02530101, 0D010101, 01012900, 0000, "SMPTE ST 377-1", RGBAEssenceDescriptor, "")
338 UUID(060E2B34, 02530101, 0D010101, 01012F00, 0000, "SMPTE ST 377-1", Preface, "")
339 UUID(060E2B34, 02530101, 0D010101, 01013000, 0000, "SMPTE ST 377-1", Identification, "")
340 UUID(060E2B34, 02530101, 0D010101, 01013200, 0000, "SMPTE ST 377-1", NetworkLocator, "")
341 UUID(060E2B34, 02530101, 0D010101, 01013300, 0000, "SMPTE ST 377-1", TextLocator, "")
342 UUID(060E2B34, 02530101, 0D010101, 01013400, 0000, "SMPTE ST 377-1", GenericPackage, "Generic Package")
343 UUID(060E2B34, 02530101, 0D010101, 01013600, 0000, "SMPTE ST 377-1", MaterialPackage, "")
344 UUID(060E2B34, 02530101, 0D010101, 01013700, 0000, "SMPTE ST 377-1", SourcePackage, "")
345 UUID(060E2B34, 02530101, 0D010101, 01013800, 0000, "SMPTE ST 377-1", GenericTrack , "Generic Track")
346 UUID(060E2B34, 02530101, 0D010101, 01013900, 0000, "SMPTE ST 377-1", EventTrack, "")
347 UUID(060E2B34, 02530101, 0D010101, 01013A00, 0000, "SMPTE ST 377-1", StaticTrack, "")
348 UUID(060E2B34, 02530101, 0D010101, 01013B00, 0000, "SMPTE ST 377-1", TimelineTrack, "")
349 UUID(060E2B34, 02530101, 0D010101, 01014100, 0000, "SMPTE ST 377-1", DMSegment, "")
350 UUID(060E2B34, 02530101, 0D010101, 01014200, 0000, "SMPTE ST 377-1", GenericSoundEssenceDescriptor, "")
351 UUID(060E2B34, 02530101, 0D010101, 01014300, 0000, "SMPTE ST 377-1", GenericDataEssenceDescriptor, "")
352 UUID(060E2B34, 02530101, 0D010101, 01014400, 0000, "SMPTE ST 377-1", MultipleDescriptor, "")
353 UUID(060E2B34, 02530101, 0D010101, 01014500, 0000, "SMPTE ST 377-1", DMSourceClip, "")
354 UUID(060E2B34, 02530101, 0D010101, 01014700, 0000, "", AES3PCMDescriptor, "")
355 UUID(060E2B34, 02530101, 0D010101, 01014800, 0000, "", WaveAudioDescriptor, "")
356 UUID(060E2B34, 02530101, 0D010101, 01015100, 0000, "SMPTE ST 381-1", MPEG2VideoDescriptor, "")
357 UUID(060E2B34, 02530101, 0D010101, 01015900, 0000, "SMPTE ST 377-1", SubDescriptor, "Sub Descriptor")
358 UUID(060E2B34, 02530101, 0D010101, 01015A00, 0000, "", JPEG2000PictureSubDescriptor, "")
359 UUID(060E2B34, 02530101, 0D010101, 01015B00, 0000, "", VbiPacketsDescriptor, "")
360 UUID(060E2B34, 02530101, 0D010101, 01015C00, 0000, "", AncPacketsDescriptor, "")
361 UUID(060E2B34, 02530101, 0D010101, 01015E00, 0000, "SMPTE ST 381-2", MpegAudioDescriptor, "MPEG Audio Descriptor")
362 UUID(060E2B34, 02530101, 0D010101, 01016000, 0000, "SMPTE ST 377-1", PackageMarkerObject, "")
363 UUID(060E2B34, 02530101, 0D010101, 01016100, 0000, "SMPTE ST 377-1", ApplicationPlugInObject, "")
364 UUID(060E2B34, 02530101, 0D010101, 01016200, 0000, "SMPTE ST 377-1", ApplicationReferencedObject, "")
365 UUID(060E2B34, 0253010C, 0D010101, 01016300, 0000, "SMPTE ST 429-10", StereoscopicPictureSubDescriptor, "")
366 UUID(060E2B34, 02530101, 0D010101, 01016400, 0000, "SMPTE ST 429-5", TimedTextDescriptor, "")
367 UUID(060E2B34, 02530101, 0D010101, 01016500, 0000, "SMPTE ST 429-5", TimedTextResourceSubDescriptor, "")
368 UUID(060E2B34, 02530101, 0D010101, 01016600, 0000, "SMPTE ST 377-1", ApplicationObject, "Application Object")
369 UUID(060E2B34, 02530101, 0D010101, 01016700, 0000, "SMPTE ST ?", ContainerConstraintsSubDescriptor, "Container Constraints Sub-Descriptor")
370 UUID(060E2B34, 02530101, 0D010101, 01016800, 0000, "SMPTE ST 381-2", Mpeg4VisualSubDescriptor, "MPEG-4 Visual Sub-Descriptor")
371 UUID(060E2B34, 02530101, 0D010101, 01016A00, 0000, "SMPTE ST 377-4", MCALabelSubDescriptor, "")
372 UUID(060E2B34, 02530101, 0D010101, 01016B00, 0000, "SMPTE ST 377-4", AudioChannelLabelSubDescriptor, "")
373 UUID(060E2B34, 02530101, 0D010101, 01016C00, 0000, "SMPTE ST 377-4", SoundfieldGroupLabelSubDescriptor, "")
374 UUID(060E2B34, 02530101, 0D010101, 01016D00, 0000, "SMPTE ST 377-4", GroupOfSoundfieldGroupsLabelSubDescriptor, "")
375 UUID(060E2B34, 02530101, 0D010101, 01016E00, 0000, "SMPTE ST 381-3", AVCSubDescriptor, "AVC Sub-Descriptor")
376 UUID(060E2B34, 02530101, 0D010101, 01017B00, 0000, "SMPTE ST 207-201", IABEssenceDescriptor, "IAB Essence Descriptor")
377 UUID(060E2B34, 02530101, 0D010101, 01017C00, 0000, "SMPTE ST 207-201", IABSoundfieldLabelSubDescriptor, "IAB Soundfield Label SubDescriptor")
378
379 // 02 - MXF File Structure
380 // 01 - Version 1
381 // 01 - MXF File Structure sets & packs
382 UUID(060E2B34, 02050101, 0D010201, 01020100, 0000, "SMPTE ST 377-1", OpenIncompleteHeaderPartition, "")
383 UUID(060E2B34, 02050101, 0D010201, 01020200, 0000, "SMPTE ST 377-1", ClosedIncompleteHeaderPartition, "")
384 UUID(060E2B34, 02050101, 0D010201, 01020300, 0000, "SMPTE ST 377-1", OpenCompleteHeaderPartition, "")
385 UUID(060E2B34, 02050101, 0D010201, 01020400, 0000, "SMPTE ST 377-1", ClosedCompleteHeaderPartition, "")
386 UUID(060E2B34, 02050101, 0D010201, 01030100, 0000, "SMPTE ST 377-1", OpenIncompleteBodyPartition, "")
387 UUID(060E2B34, 02050101, 0D010201, 01030200, 0000, "SMPTE ST 377-1", ClosedIncompleteBodyPartition, "")
388 UUID(060E2B34, 02050101, 0D010201, 01030300, 0000, "SMPTE ST 377-1", OpenCompleteBodyPartition, "")
389 UUID(060E2B34, 02050101, 0D010201, 01030400, 0000, "SMPTE ST 377-1", ClosedCompleteBodyPartition, "")
390 UUID(060E2B34, 02050101, 0D010201, 01031100, 0000, "SMPTE ST 377-1", GenericStreamPartition, "")
391 UUID(060E2B34, 02050101, 0D010201, 01040100, 0000, "SMPTE ST 377-1", OpenIncompleteFooterPartition, "")
392 UUID(060E2B34, 02050101, 0D010201, 01040200, 0000, "SMPTE ST 377-1", ClosedIncompleteFooterPartition, "")
393 UUID(060E2B34, 02050101, 0D010201, 01040300, 0000, "SMPTE ST 377-1", OpenCompleteFooterPartition, "")
394 UUID(060E2B34, 02050101, 0D010201, 01040400, 0000, "SMPTE ST 377-1", ClosedCompleteFooterPartition, "")
395 UUID(060E2B34, 02050101, 0D010201, 01050100, 0000, "SMPTE ST 377-1", Primer, "")
396 UUID(060E2B34, 02530101, 0D010201, 01100100, 0000, "SMPTE ST 377-1", IndexTableSegment, "")
397 UUID(060E2B34, 02050101, 0D010201, 01110100, 0000, "SMPTE ST 377-1", RandomIndexPack, "")
398
399 // 03 - ?
400 // 01 - ?
401 // 00 - Generic
402 UUID(060E2B34, 01020101, 0D010301, 00000000, 0000, "", GenericContainer_Aaf, "")
403
404 // 04 - SDTI
405 UUID(060E2B34, 02050101, 0D010301, 04010100, 0000, "", SDTI_SystemMetadataPack, "")
406 UUID(060E2B34, 02430101, 0D010301, 04010200, 0000, "", SDTI_PackageMetadataSet, "")
407 UUID(060E2B34, 02430101, 0D010301, 04010300, 0000, "", SDTI_PictureMetadataSet, "")
408 UUID(060E2B34, 02430101, 0D010301, 04010400, 0000, "", SDTI_SoundMetadataSet, "")
409 UUID(060E2B34, 02430101, 0D010301, 04010500, 0000, "", SDTI_DataMetadataSet, "")
410 UUID(060E2B34, 02630101, 0D010301, 04010600, 0000, "", SDTI_ControlMetadataSet, "")
411
412 // 14 - System Scheme 1
413 UUID(060E2B34, 02530101, 0D010301, 14020000, 0000, "", SystemScheme1, "")
414
415 // 04 - ?
416 // 01 - ?
417 UUID(060E2B34, 02530101, 0D010401, 01010100, 0000, "", DMScheme1, "")
418 UUID(060E2B34, 02530101, 0D010401, 04010100, 0000, "", Application04_01_04_01_01, "")
419 UUID(060E2B34, 02530101, 0D010401, 04020100, 0000, "", Application04_01_04_02_01, "")
420
421 // 05 - ?
422 // 09 - ?
423 UUID(060E2B34, 0101010C, 0D010509, 01000000, 0000, "", Application05_09_01, "")
424
425 // 07 - AMWA AS-11
426 // 01 - ?
427 // 0B - ?
428 // 01 - AS-11 core metadata framework
429 UUID(060E2B34, 02530101, 0D010701, 0B010100, 0000, "AMWA AS-11", AS11_AAF_Core, "")
430 UUID(060E2B34, 01010101, 0D010701, 0B010101, 0000, "AMWA AS-11", AS11_Core_SeriesTitle, "")
431 UUID(060E2B34, 01010101, 0D010701, 0B010102, 0000, "AMWA AS-11", AS11_Core_ProgrammeTitle, "")
432 UUID(060E2B34, 01010101, 0D010701, 0B010103, 0000, "AMWA AS-11", AS11_Core_EpisodeTitleNumber, "")
433 UUID(060E2B34, 01010101, 0D010701, 0B010104, 0000, "AMWA AS-11", AS11_Core_ShimName, "")
434 UUID(060E2B34, 01010101, 0D010701, 0B010105, 0000, "AMWA AS-11", AS11_Core_AudioTrackLayout, "")
435 UUID(060E2B34, 01010101, 0D010701, 0B010106, 0000, "AMWA AS-11", AS11_Core_PrimaryAudioLanguage, "")
436 UUID(060E2B34, 01010101, 0D010701, 0B010107, 0000, "AMWA AS-11", AS11_Core_ClosedCaptionsPresent, "")
437 UUID(060E2B34, 01010101, 0D010701, 0B010108, 0000, "AMWA AS-11", AS11_Core_ClosedCaptionsType, "")
438 UUID(060E2B34, 01010101, 0D010701, 0B010109, 0000, "AMWA AS-11", AS11_Core_ClosedCaptionsLanguage, "")
439 UUID(060E2B34, 01010101, 0D010701, 0B01010A, 0000, "AMWA AS-11", AS11_Core_ShimVersion, "")
440
441 // 02 - AS-11 segmentation metadata framework
442 UUID(060E2B34, 02530101, 0D010701, 0B020100, 0000, "AMWA AS-11", AS11_AAF_Segmentation, "")
443 UUID(060E2B34, 01010101, 0D010701, 0B020101, 0000, "AMWA AS-11", AS11_Segment_PartNumber, "")
444 UUID(060E2B34, 01010101, 0D010701, 0B020102, 0000, "AMWA AS-11", AS11_Segment_PartTotal, "")
445
446 // 0C - BBC
447 // 01 - ?
448 // 01 - ?
449 // 01 - ?
450 // 01 - AS-11 UK DPP metadata framework
451 UUID(060E2B34, 02530101, 0D0C0101, 01010000, 0000, "AMWA AS-11", AS11_AAF_UKDPP, "")
452 UUID(060E2B34, 01010101, 0D0C0101, 01010100, 0000, "AMWA AS-11", AS11_UKDPP_ProductionNumber, "")
453 UUID(060E2B34, 01010101, 0D0C0101, 01010200, 0000, "AMWA AS-11", AS11_UKDPP_Synopsis, "")
454 UUID(060E2B34, 01010101, 0D0C0101, 01010300, 0000, "AMWA AS-11", AS11_UKDPP_Originator, "")
455 UUID(060E2B34, 01010101, 0D0C0101, 01010400, 0000, "AMWA AS-11", AS11_UKDPP_CopyrightYear, "")
456 UUID(060E2B34, 01010101, 0D0C0101, 01010500, 0000, "AMWA AS-11", AS11_UKDPP_OtherIdentifier, "")
457 UUID(060E2B34, 01010101, 0D0C0101, 01010600, 0000, "AMWA AS-11", AS11_UKDPP_OtherIdentifierType, "")
458 UUID(060E2B34, 01010101, 0D0C0101, 01010700, 0000, "AMWA AS-11", AS11_UKDPP_Genre, "")
459 UUID(060E2B34, 01010101, 0D0C0101, 01010800, 0000, "AMWA AS-11", AS11_UKDPP_Distributor, "")
460 UUID(060E2B34, 01010101, 0D0C0101, 01010900, 0000, "AMWA AS-11", AS11_UKDPP_PictureRatio, "")
461 UUID(060E2B34, 01010101, 0D0C0101, 01010A00, 0000, "AMWA AS-11", AS11_UKDPP_3D, "")
462 UUID(060E2B34, 01010101, 0D0C0101, 01010B00, 0000, "AMWA AS-11", AS11_UKDPP_3DType, "")
463 UUID(060E2B34, 01010101, 0D0C0101, 01010C00, 0000, "AMWA AS-11", AS11_UKDPP_ProductPlacement, "")
464 UUID(060E2B34, 01010101, 0D0C0101, 01010D00, 0000, "AMWA AS-11", AS11_UKDPP_FpaPass, "")
465 UUID(060E2B34, 01010101, 0D0C0101, 01010E00, 0000, "AMWA AS-11", AS11_UKDPP_FpaManufacturer, "")
466 UUID(060E2B34, 01010101, 0D0C0101, 01010F00, 0000, "AMWA AS-11", AS11_UKDPP_FpaVersion, "")
467 UUID(060E2B34, 01010101, 0D0C0101, 01011000, 0000, "AMWA AS-11", AS11_UKDPP_VideoComments, "")
468 UUID(060E2B34, 01010101, 0D0C0101, 01011100, 0000, "AMWA AS-11", AS11_UKDPP_SecondaryAudioLanguage, "")
469 UUID(060E2B34, 01010101, 0D0C0101, 01011200, 0000, "AMWA AS-11", AS11_UKDPP_TertiaryAudioLanguage, "")
470 UUID(060E2B34, 01010101, 0D0C0101, 01011300, 0000, "AMWA AS-11", AS11_UKDPP_AudioLoudnessStandard, "")
471 UUID(060E2B34, 01010101, 0D0C0101, 01011400, 0000, "AMWA AS-11", AS11_UKDPP_AudioComments, "")
472 UUID(060E2B34, 01010101, 0D0C0101, 01011500, 0000, "AMWA AS-11", AS11_UKDPP_LineUpStart, "")
473 UUID(060E2B34, 01010101, 0D0C0101, 01011600, 0000, "AMWA AS-11", AS11_UKDPP_IdentClockStart, "")
474 UUID(060E2B34, 01010101, 0D0C0101, 01011700, 0000, "AMWA AS-11", AS11_UKDPP_TotalNumberOfParts, "")
475 UUID(060E2B34, 01010101, 0D0C0101, 01011800, 0000, "AMWA AS-11", AS11_UKDPP_TotalProgrammeDuration, "")
476 UUID(060E2B34, 01010101, 0D0C0101, 01011900, 0000, "AMWA AS-11", AS11_UKDPP_AudioDescriptionPresent, "")
477 UUID(060E2B34, 01010101, 0D0C0101, 01011A00, 0000, "AMWA AS-11", AS11_UKDPP_AudioDescriptionType, "")
478 UUID(060E2B34, 01010101, 0D0C0101, 01011B00, 0000, "AMWA AS-11", AS11_UKDPP_OpenCaptionsPresent, "")
479 UUID(060E2B34, 01010101, 0D0C0101, 01011C00, 0000, "AMWA AS-11", AS11_UKDPP_OpenCaptionsType, "")
480 UUID(060E2B34, 01010101, 0D0C0101, 01011D00, 0000, "AMWA AS-11", AS11_UKDPP_OpenCaptionsLanguage, "")
481 UUID(060E2B34, 01010101, 0D0C0101, 01011E00, 0000, "AMWA AS-11", AS11_UKDPP_SigningPresent, "")
482 UUID(060E2B34, 01010101, 0D0C0101, 01011F00, 0000, "AMWA AS-11", AS11_UKDPP_SignLanguage, "")
483 UUID(060E2B34, 01010101, 0D0C0101, 01012000, 0000, "AMWA AS-11", AS11_UKDPP_CompletionDate, "")
484 UUID(060E2B34, 01010101, 0D0C0101, 01012100, 0000, "AMWA AS-11", AS11_UKDPP_TextlessElementsExist, "")
485 UUID(060E2B34, 01010101, 0D0C0101, 01012200, 0000, "AMWA AS-11", AS11_UKDPP_ProgrammeHasText, "")
486 UUID(060E2B34, 01010101, 0D0C0101, 01012300, 0000, "AMWA AS-11", AS11_UKDPP_ProgrammeTextLanguage, "")
487 UUID(060E2B34, 01010101, 0D0C0101, 01012400, 0000, "AMWA AS-11", AS11_UKDPP_ContactEmail, "")
488 UUID(060E2B34, 01010101, 0D0C0101, 01012500, 0000, "AMWA AS-11", AS11_UKDPP_ContactTelephoneNumber, "")
489
490 // 0E - Organizationally registered for private use
491 // 04 - Avid
492 UUID(060E2B34, 01020101, 0E040301, 00000000, 0000, "", GenericContainer_Avid, "")
493
494 // 06 - Sony
495 UUID(060E2B34, 01020101, 0E067F03, 00000000, 0000, "", GenericContainer_Sony, "")
496
497 // 09 - Dolby
498 UUID(060E2B34, 01020105, 0E090607, 01010100, 0000, "Dolby", Dolby_PHDRImageMetadataItem, "")
499 UUID(060E2B34, 02530105, 0E090607, 01010103, 0000, "Dolby", Dolby_PHDRMetadataTrackSubDescriptor, "")
500 UUID(060E2B34, 01010105, 0E090607, 01010104, 0000, "Dolby", Dolby_DataDefinition, "")
501 UUID(060E2B34, 01010105, 0E090607, 01010105, 0000, "Dolby", Dolby_SourceTrackID, "")
502 UUID(060E2B34, 01010105, 0E090607, 01010106, 0000, "Dolby", Dolby_SimplePayloadSID, "")
503
504 // 0B - Omneon Video Networks
505 UUID(060E2B34, 02530105, 0E0B0102, 01010100, 0000, "", Omneon_010201010100, "")
506 UUID(060E2B34, 02530105, 0E0B0102, 01020100, 0000, "", Omneon_010201020100, "")
507 }
508
509 //---------------------------------------------------------------------------
510 extern const char* Mpegv_profile_and_level_indication_profile[];
511 extern const char* Mpegv_profile_and_level_indication_level[];
512 extern const char* Mpeg4v_Profile_Level(int32u Profile_Level);
513 extern const char* Avc_profile_idc(int8u profile_idc);
514 extern string Jpeg2000_Rsiz(int16u Rsiz);
515
516 //---------------------------------------------------------------------------
517 extern const char* AfdBarData_active_format[];
518 extern const char* AfdBarData_active_format_4_3[];
519 extern const char* AfdBarData_active_format_16_9[];
520
521 //---------------------------------------------------------------------------
Mxf_Category(int8u Category)522 static const char* Mxf_Category(int8u Category)
523 {
524 switch(Category)
525 {
526 case 0x01 : return "Item";
527 case 0x02 : return "Group (Set/Pack)";
528 case 0x03 : return "Wrapper";
529 case 0x04 : return "Value";
530 default : return "";
531 }
532 }
533
534 //---------------------------------------------------------------------------
Mxf_Registry(int8u Category,int8u Registry)535 static const char* Mxf_Registry(int8u Category, int8u Registry)
536 {
537 switch(Category)
538 {
539 case 0x01 : //"Item"
540 switch(Registry)
541 {
542 case 0x01 : return "Metadata";
543 case 0x02 : return "Essence";
544 default : return "";
545 }
546 case 0x02 : //"Group (Set/Pack)"
547 switch(Registry)
548 {
549 case 0x05 : return "Predefined items";
550 case 0x43 : return "1-byte tag, 2-byte length";
551 case 0x53 : return "2-byte tag, 2-byte length";
552 case 0x63 : return "1-byte tag, 4-byte length";
553 default : return "";
554 }
555 case 0x04 : //"Value"
556 switch(Registry)
557 {
558 case 0x01 : return "Fixed";
559 default : return "";
560 }
561 default : return "";
562 }
563 }
564
565 //---------------------------------------------------------------------------
Mxf_Structure(int8u Category,int8u Registry,int8u Structure)566 static const char* Mxf_Structure(int8u Category, int8u Registry, int8u Structure)
567 {
568 switch(Category)
569 {
570 case 0x01 : //"Item"
571 switch(Registry)
572 {
573 case 0x02 : //Essence
574 switch(Structure)
575 {
576 case 0x01 : return "Standard";
577 default : return "";
578 }
579 default : return "";
580 }
581 default : return "";
582 }
583 }
584
585 //---------------------------------------------------------------------------
Mxf_MPEG2_CodedContentType(int8u CodedContentType)586 static const char* Mxf_MPEG2_CodedContentType(int8u CodedContentType)
587 {
588 switch(CodedContentType)
589 {
590 case 0x01 : return "Progressive";
591 case 0x02 : return "Interlaced";
592 case 0x03 : return ""; //Mixed
593 default : return "";
594 }
595 }
596
597 //---------------------------------------------------------------------------
Mxf_AVC_SequenceParameterSetFlag_Constancy(bool Constancy)598 static const char* Mxf_AVC_SequenceParameterSetFlag_Constancy(bool Constancy)
599 {
600 if (Constancy)
601 return "";
602 else
603 return "Constant";
604 }
605
606 //---------------------------------------------------------------------------
Mxf_OperationalPattern(const int128u OperationalPattern)607 static const char* Mxf_OperationalPattern(const int128u OperationalPattern)
608 {
609 //Item and Package Complexity
610 int32u Code_Compare4=(int32u)OperationalPattern.lo;
611 switch ((int8u)(Code_Compare4>>24))
612 {
613 case 0x01 : switch ((int8u)(Code_Compare4>>16))
614 {
615 case 0x01 : return "OP-1a";
616 case 0x02 : return "OP-1b";
617 case 0x03 : return "OP-1c";
618 default : return "";
619 }
620 case 0x02 : switch ((int8u)(Code_Compare4>>16))
621 {
622 case 0x01 : return "OP-2a";
623 case 0x02 : return "OP-2b";
624 case 0x03 : return "OP-2c";
625 default : return "";
626 }
627 case 0x03 : switch ((int8u)(Code_Compare4>>16))
628 {
629 case 0x01 : return "OP-3a";
630 case 0x02 : return "OP-3b";
631 case 0x03 : return "OP-3c";
632 default : return "";
633 }
634 case 0x10 : return "OP-Atom";
635 default : return "";
636 }
637 }
638
639 //---------------------------------------------------------------------------
Mxf_EssenceElement(const int128u EssenceElement)640 static const char* Mxf_EssenceElement(const int128u EssenceElement)
641 {
642 if ((EssenceElement.hi&0xFFFFFFFFFFFFFF00LL)!=0x060E2B3401020100LL)
643 return "";
644
645 int8u Code1=(int8u)((EssenceElement.lo&0xFF00000000000000LL)>>56);
646 int8u Code2=(int8u)((EssenceElement.lo&0x00FF000000000000LL)>>48);
647 int8u Code3=(int8u)((EssenceElement.lo&0x0000FF0000000000LL)>>40);
648 int8u Code4=(int8u)((EssenceElement.lo&0x000000FF00000000LL)>>32);
649 int8u Code5=(int8u)((EssenceElement.lo&0x00000000FF000000LL)>>24);
650 int8u Code7=(int8u)((EssenceElement.lo&0x000000000000FF00LL)>> 8);
651
652 switch (Code1)
653 {
654 case 0x0E : //Private
655 switch (Code2)
656 {
657 case 0x06 : //Sony
658 case 0x15 : //GC Picture
659 switch (Code5)
660 {
661 case 0x15 : return "Sony private picture stream";
662 default : return "Sony private stream";
663 }
664 case 0x09 : //Dolby
665 switch (Code3)
666 {
667 case 0x06 :
668 switch (Code4)
669 {
670 case 0x07 : return "Dolby Vision Frame Data";
671 default : return "Dolby private stream";
672 }
673 default : return "Dolby private stream";
674 }
675 default : return "Unknown private stream";
676 }
677 default : ;
678 }
679
680 switch (Code5)
681 {
682 case 0x05 : //CP Picture (SMPTE 386M)
683 switch (Code7)
684 {
685 case 0x01 : return "D-10 Video";
686 default : return "Unknown stream";
687 }
688 case 0x06 : //CP Sound (SMPTE 386M)
689 switch (Code7)
690 {
691 case 0x10 : return "D-10 Audio";
692 default : return "Unknown stream";
693 }
694 case 0x07 : //CP Data (SMPTE 386M)
695 return "";
696 case 0x14 : //MXF in MXF?
697 switch (Code7)
698 {
699 case 0x01 : return "MXF in MXF?";
700 default : return "Unknown stream";
701 }
702 case 0x15 : //GC Picture
703 switch (Code7)
704 {
705 case 0x01 : return "RGB";
706 case 0x05 : return "MPEG stream (Frame)";
707 case 0x06 : return "MPEG stream (Clip)";
708 case 0x07 : return "MPEG stream (Custom)";
709 case 0x08 : return "JPEG 2000";
710 case 0x17 : return "ProRes";
711 default : return "Unknown stream";
712 }
713 case 0x16 : //GC Sound
714 switch (Code7)
715 {
716 case 0x01 : return "PCM"; //BWF
717 case 0x02 : return "PCM"; //BWF
718 case 0x03 : return "PCM"; //DV Audio
719 case 0x04 : return "PCM"; //BWF
720 case 0x05 : return "MPEG Audio / AC-3";
721 case 0x0A : return "A-law";
722 case 0x0D : return "IAB";
723 default : return "Unknown stream";
724 }
725 case 0x17 : //GC Data
726 switch (Code7)
727 {
728 case 0x01 : return "VBI"; //Frame-Wrapped VBI Data Element
729 case 0x02 : return "ANC"; //Frame-Wrapped ANC Data Element
730 case 0x0B : return "Timed Text"; //Clip-Wrapped Timed Text Data Element, SMPTE ST 429-5
731 default : return "Unknown stream";
732 }
733 case 0x18 : //GC Compound
734 switch (Code7)
735 {
736 case 0x01 : return "DV"; //Frame
737 case 0x02 : return "DV"; //Clip
738 default : return "Unknown stream";
739 }
740 default : return "Unknown stream";
741 }
742 }
743
744 //---------------------------------------------------------------------------
Mxf_EssenceContainer(const int128u EssenceContainer)745 static const char* Mxf_EssenceContainer(const int128u EssenceContainer)
746 {
747 if ((EssenceContainer.hi&0xFFFFFFFFFFFFFF00LL)!=0x060E2B3404010100LL)
748 return "";
749
750 int8u Code1=(int8u)((EssenceContainer.lo&0xFF00000000000000LL)>>56);
751 int8u Code2=(int8u)((EssenceContainer.lo&0x00FF000000000000LL)>>48);
752 int8u Code3=(int8u)((EssenceContainer.lo&0x0000FF0000000000LL)>>40);
753 int8u Code4=(int8u)((EssenceContainer.lo&0x000000FF00000000LL)>>32);
754 int8u Code5=(int8u)((EssenceContainer.lo&0x00000000FF000000LL)>>24);
755 int8u Code6=(int8u)((EssenceContainer.lo&0x0000000000FF0000LL)>>16);
756 int8u Code7=(int8u)((EssenceContainer.lo&0x000000000000FF00LL)>> 8);
757
758 switch (Code1)
759 {
760 case 0x0D : //Public Use
761 switch (Code2)
762 {
763 case 0x01 : //AAF
764 switch (Code3)
765 {
766 case 0x03 : //Essence Container Application
767 switch (Code4)
768 {
769 case 0x01 : //MXF EC Structure version
770 switch (Code5)
771 {
772 case 0x02 : //Essence container kind
773 switch (Code6)
774 {
775 case 0x01 : return "D-10"; // Video and Audio
776 case 0x02 : return "DV";
777 case 0x05 : return "Uncompressed pictures";
778 case 0x06 : return "PCM";
779 case 0x04 : return "MPEG ES mappings with Stream ID";
780 case 0x0A : return "A-law";
781 case 0x0C : return "JPEG 2000";
782 case 0x10 : return "AVC";
783 case 0x11 : return "VC-3";
784 case 0x13 : return "Timed Text";
785 case 0x1C : return "ProRes";
786 case 0x1D : return "IAB";
787 default : return "";
788 }
789 default : return "";
790 }
791 default : return "";
792 }
793 default : return "";
794 }
795 default : return "";
796 }
797 case 0x0E : //Private Use
798 switch (Code2)
799 {
800 case 0x04 : //Avid
801 switch (Code3)
802 {
803 case 0x03 : //Essence Container Application
804 switch (Code4)
805 {
806 case 0x01 : //MXF EC Structure version
807 switch (Code5)
808 {
809 case 0x02 : //Essence container kind
810 switch (Code6)
811 {
812 case 0x06 : return "VC-3";
813 default : return "";
814 }
815 default : return "";
816 }
817 default : return "";
818 }
819 default : return "";
820 }
821 case 0x06 : //Sony
822 switch (Code3)
823 {
824 case 0x0D :
825 switch (Code4)
826 {
827 case 0x03 :
828 switch (Code5)
829 {
830 case 0x02 :
831 switch (Code6)
832 {
833 case 0x01 :
834 switch (Code7)
835 {
836 case 0x01 : return "Sony RAW?";
837 default : return "";
838 }
839 default : return "";
840 }
841 default : return "";
842 }
843 default : return "";
844 }
845 default : return "";
846 }
847 default : return "";
848 }
849 default : return "";
850 }
851 }
852
853 //---------------------------------------------------------------------------
Mxf_EssenceContainer_Mapping(int8u Code6,int8u Code7,int8u Code8)854 static const char* Mxf_EssenceContainer_Mapping(int8u Code6, int8u Code7, int8u Code8)
855 {
856 switch (Code6)
857 {
858 case 0x01 : //D-10, SMPTE 386M
859 return "Frame (D-10)";
860 case 0x02 : //DV, SMPTE 383M
861 switch (Code8)
862 {
863 case 0x01 : return "Frame";
864 case 0x02 : return "Clip";
865 default : return "";
866 }
867 case 0x04 : //MPEG ES, SMPTE 381M
868 case 0x07 : //MPEG PES, SMPTE 381M
869 case 0x08 : //MPEG PS, SMPTE 381M
870 case 0x09 : //MPEG TS, SMPTE 381M
871 case 0x10 : //AVC
872 case 0x15 : //YUV
873 switch (Code8)
874 {
875 case 0x01 : return "Frame";
876 case 0x02 : return "Clip";
877 case 0x03 : return "Custom: Stripe";
878 case 0x04 : return "Custom: PES";
879 case 0x05 : return "Custom: Fixed Audio Size";
880 case 0x06 : return "Custom: Splice";
881 case 0x07 : return "Custom: Closed GOP";
882 case 0x08 : return "Custom: Slave";
883 case 0x7F : return "Custom";
884 default : return "";
885 }
886 case 0x05 : //Uncompressed pictures, SMPTE 384M
887 switch (Code8)
888 {
889 case 0x01 : return "Frame";
890 case 0x02 : return "Clip";
891 case 0x03 : return "Line";
892 default : return "";
893 }
894 case 0x06 : //AES-PCM, SMPTE 382M
895 switch (Code7)
896 {
897 case 0x01 : return "Frame (BWF)";
898 case 0x02 : return "Clip (BWF)";
899 case 0x03 : return "Frame (AES)";
900 case 0x04 : return "Clip (AES)";
901 case 0x08 : return "Custom (BWF)";
902 case 0x09 : return "Custom (AES)";
903 default : return "";
904 }
905 case 0x0A : //A-Law
906 switch (Code7)
907 {
908 case 0x01 : return "Frame";
909 case 0x02 : return "Clip";
910 case 0x03 : return "?";
911 case 0x07 : return "Custom";
912 default : return "";
913 }
914 case 0x0C : //JPEG 2000
915 switch (Code7)
916 {
917 case 0x01 : return "Frame";
918 case 0x02 : return "Clip";
919 default : return "";
920 }
921 case 0x11 : //VC-3, SMPTE 2019-4
922 switch (Code7)
923 {
924 case 0x01 : return "Frame";
925 case 0x02 : return "Clip";
926 default : return "";
927 }
928 case 0x13 : //Timed Text
929 return "Clip";
930 case 0x1C : //ProRes
931 switch (Code7)
932 {
933 case 0x01 : return "Frame";
934 default : return "";
935 }
936 case 0x1D : //IAB
937 switch (Code7)
938 {
939 case 0x01 : return "Clip";
940 default : return "";
941 }
942 default : return "";
943 }
944 }
945
946 //---------------------------------------------------------------------------
Mxf_EssenceCompression(const int128u EssenceCompression)947 static const char* Mxf_EssenceCompression(const int128u EssenceCompression)
948 {
949 if ((EssenceCompression.hi&0xFFFFFFFFFFFFFF00LL)!=0x060E2B3404010100LL || !((EssenceCompression.lo&0xFF00000000000000LL)==0x0400000000000000LL || (EssenceCompression.lo&0xFF00000000000000LL)==0x0E00000000000000LL))
950 return "";
951
952 int8u Code1=(int8u)((EssenceCompression.lo&0xFF00000000000000LL)>>56);
953 int8u Code2=(int8u)((EssenceCompression.lo&0x00FF000000000000LL)>>48);
954 int8u Code3=(int8u)((EssenceCompression.lo&0x0000FF0000000000LL)>>40);
955 int8u Code4=(int8u)((EssenceCompression.lo&0x000000FF00000000LL)>>32);
956 int8u Code5=(int8u)((EssenceCompression.lo&0x00000000FF000000LL)>>24);
957 int8u Code6=(int8u)((EssenceCompression.lo&0x0000000000FF0000LL)>>16);
958 int8u Code7=(int8u)((EssenceCompression.lo&0x000000000000FF00LL)>> 8);
959
960 switch (Code1)
961 {
962 case 0x04 : //
963 switch (Code2)
964 {
965 case 0x01 : //Picture
966 switch (Code3)
967 {
968 case 0x02 : //Coding characteristics
969 switch (Code4)
970 {
971 case 0x01 : //Uncompressed coding
972 switch (Code5)
973 {
974 case 0x01 : //Uncompressed picture coding
975 return "YUV";
976 default : return "";
977 }
978 case 0x02 : //Compressed coding
979 switch (Code5)
980 {
981 case 0x01 : //MPEG Compression
982 switch (Code6)
983 {
984 case 0x00 : return "MPEG Video";
985 case 0x01 : return "MPEG Video"; //Version 2
986 case 0x02 : return "MPEG Video"; //Version 2
987 case 0x03 : return "MPEG Video"; //Version 2
988 case 0x04 : return "MPEG Video"; //Version 2
989 case 0x11 : return "MPEG Video"; //Version 1
990 case 0x20 : return "MPEG-4 Visual";
991 case 0x30 :
992 case 0x31 :
993 case 0x32 :
994 case 0x33 :
995 case 0x34 :
996 case 0x35 :
997 case 0x36 :
998 case 0x37 :
999 case 0x38 :
1000 case 0x39 :
1001 case 0x3A :
1002 case 0x3B :
1003 case 0x3C :
1004 case 0x3D :
1005 case 0x3E :
1006 case 0x3F : return "AVC";
1007 default : return "";
1008 }
1009 case 0x02 : return "DV";
1010 case 0x03 : //Individual Picture Coding Schemes
1011 switch (Code6)
1012 {
1013 case 0x01 : return "JPEG 2000";
1014 case 0x06 : return "ProRes";
1015 default : return "";
1016 }
1017 case 0x71 : return "VC-3";
1018 default : return "";
1019 }
1020 default : return "";
1021 }
1022 default : return "";
1023 }
1024 case 0x02 : //Sound
1025 switch (Code3)
1026 {
1027 case 0x02 : //Coding characteristics
1028 switch (Code4)
1029 {
1030 case 0x01 : //Uncompressed Sound Coding
1031 switch (Code5)
1032 {
1033 case 0x00 : return "PCM";
1034 case 0x01 : return "PCM";
1035 case 0x7E : return "PCM"; //AIFF
1036 case 0x7F : return "PCM"; // TODO: Undefined
1037 default : return "";
1038 }
1039 case 0x02 : //Compressed coding
1040 switch (Code5)
1041 {
1042 case 0x03 : //Compressed Audio Coding
1043 switch (Code6)
1044 {
1045 case 0x01 : //Compandeded Audio Coding
1046 switch (Code7)
1047 {
1048 case 0x01 : return "A-law";
1049 case 0x10 : return "DV Audio"; //DV 12-bit
1050 default : return ""; //Unknown
1051 }
1052 case 0x02 : //SMPTE 338M Audio Coding
1053 switch (Code7)
1054 {
1055 case 0x01 : return "AC-3";
1056 case 0x04 : return "MPEG-1 Audio Layer 1";
1057 case 0x05 : return "MPEG-1 Audio Layer 2 or 3";
1058 case 0x06 : return "MPEG-2 Audio Layer 1";
1059 case 0x1C : return "Dolby E";
1060 default : return ""; //Unknown
1061 }
1062 case 0x03 : //MPEG-2 Coding (not defined in SMPTE 338M)
1063 switch (Code7)
1064 {
1065 case 0x01 : return "AAC version 2";
1066 default : return ""; //Unknown
1067 }
1068 case 0x04 : //MPEG-4 Audio Coding
1069 switch (Code7)
1070 {
1071 case 0x01 : return "MPEG-4 Speech Profile";
1072 case 0x02 : return "MPEG-4 Synthesis Profile";
1073 case 0x03 : return "MPEG-4 Scalable Profile";
1074 case 0x04 : return "MPEG-4 Main Profile";
1075 case 0x05 : return "MPEG-4 High Quality Audio Profile";
1076 case 0x06 : return "MPEG-4 Low Delay Audio Profile";
1077 case 0x07 : return "MPEG-4 Natural Audio Profile";
1078 case 0x08 : return "MPEG-4 Mobile Audio Internetworking Profile";
1079 default : return ""; //Unknown
1080 }
1081 default : return "";
1082 }
1083 default : return "";
1084 }
1085 default : return "";
1086 }
1087 default : return "";
1088 }
1089 default : return "";
1090 }
1091 case 0x0E : //Private Use
1092 switch (Code2)
1093 {
1094 case 0x04 : //Avid
1095 switch (Code3)
1096 {
1097 case 0x02 : //Essence Compression ?
1098 switch (Code4)
1099 {
1100 case 0x01 : //?
1101 switch (Code5)
1102 {
1103 case 0x02 : //?
1104 switch (Code6)
1105 {
1106 case 0x04 : return "VC-3";
1107 default : return "";
1108 }
1109 default : return "";
1110 }
1111 default : return "";
1112 }
1113 default : return "";
1114 }
1115 case 0x06 : //Sony
1116 switch (Code3)
1117 {
1118 case 0x04 :
1119 switch (Code4)
1120 {
1121 case 0x01 :
1122 switch (Code5)
1123 {
1124 case 0x02 :
1125 switch (Code6)
1126 {
1127 case 0x04 :
1128 switch (Code7)
1129 {
1130 case 0x02 : return "Sony RAW SQ";
1131 default : return "";
1132 }
1133 default : return "";
1134 }
1135 default : return "";
1136 }
1137 default : return "";
1138 }
1139 default : return "";
1140 }
1141 case 0x09 : //Dolby
1142 switch (Code3)
1143 {
1144 case 0x06 :
1145 switch (Code4)
1146 {
1147 case 0x04 : return "IAB";
1148 default : return "";
1149 }
1150 default : return "";
1151 }
1152 default : return "";
1153 }
1154 default : return "";
1155 }
1156 }
1157
1158 //---------------------------------------------------------------------------
Mxf_EssenceCompression_Profile(const int128u & EssenceCompression)1159 static const char* Mxf_EssenceCompression_Profile(const int128u& EssenceCompression)
1160 {
1161 int8u Code2=(int8u)((EssenceCompression.lo&0x00FF000000000000LL)>>48);
1162 int8u Code3=(int8u)((EssenceCompression.lo&0x0000FF0000000000LL)>>40);
1163 int8u Code4=(int8u)((EssenceCompression.lo&0x000000FF00000000LL)>>32);
1164 int8u Code5=(int8u)((EssenceCompression.lo&0x00000000FF000000LL)>>24);
1165 int8u Code6=(int8u)((EssenceCompression.lo&0x0000000000FF0000LL)>>16);
1166 int8u Code7=(int8u)((EssenceCompression.lo&0x000000000000FF00LL)>> 8);
1167 int8u Code8=(int8u)((EssenceCompression.lo&0x00000000000000FFLL) );
1168
1169 switch (Code2)
1170 {
1171 case 0x01 : //Picture
1172 switch (Code3)
1173 {
1174 case 0x02 : //Coding characteristics
1175 switch (Code4)
1176 {
1177 case 0x02 : //Compressed coding
1178 switch (Code5)
1179 {
1180 case 0x01 : //MPEG Compression
1181 switch (Code6)
1182 {
1183 case 0x20 : //MPEG-4 Visual
1184 switch (Code7)
1185 {
1186 case 0x10 : //
1187 switch (Code8)
1188 {
1189 case 0x01 :
1190 case 0x02 :
1191 case 0x03 :
1192 case 0x04 :
1193 return Mpeg4v_Profile_Level(B8(11100000)+Code8);
1194 case 0x05 :
1195 case 0x06 :
1196 return Mpeg4v_Profile_Level(B8(11101011)-5+Code8);
1197 default : return "";
1198 }
1199 default : return "";
1200 }
1201 default : return "";
1202 }
1203 case 0x03 : //Individual Picure Coding Schemes
1204 switch (Code6)
1205 {
1206 case 0x06 : //ProRes
1207 switch (Code7)
1208 {
1209 case 0x01 : return "422 Proxy";
1210 case 0x02 : return "422 LT";
1211 case 0x03 : return "422";
1212 case 0x04 : return "422 HQ";
1213 case 0x05 : return "4444";
1214 case 0x06 : return "4444 XQ";
1215 default : return "";
1216 }
1217 default : return "";
1218 }
1219 default : return "";
1220 }
1221 default : return "";
1222 }
1223 default : return "";
1224 }
1225 default : return "";
1226 }
1227 }
1228 //---------------------------------------------------------------------------
Mxf_EssenceCompression_Version(const int128u & EssenceCompression)1229 static const char* Mxf_EssenceCompression_Version(const int128u& EssenceCompression)
1230 {
1231 int8u Code2=(int8u)((EssenceCompression.lo&0x00FF000000000000LL)>>48);
1232 int8u Code3=(int8u)((EssenceCompression.lo&0x0000FF0000000000LL)>>40);
1233 int8u Code4=(int8u)((EssenceCompression.lo&0x000000FF00000000LL)>>32);
1234 int8u Code5=(int8u)((EssenceCompression.lo&0x00000000FF000000LL)>>24);
1235 int8u Code6=(int8u)((EssenceCompression.lo&0x0000000000FF0000LL)>>16);
1236 int8u Code7=(int8u)((EssenceCompression.lo&0x000000000000FF00LL)>> 8);
1237
1238 switch (Code2)
1239 {
1240 case 0x01 : //Picture
1241 switch (Code3)
1242 {
1243 case 0x02 : //Coding characteristics
1244 switch (Code4)
1245 {
1246 case 0x02 : //Compressed coding
1247 switch (Code5)
1248 {
1249 case 0x01 : //MPEG Compression
1250 switch (Code6)
1251 {
1252 case 0x01 : return "Version 2";
1253 case 0x02 : return "Version 2";
1254 case 0x03 : return "Version 2";
1255 case 0x04 : return "Version 2";
1256 case 0x11 : return "Version 1";
1257 default : return "";
1258 }
1259 default : return "";
1260 }
1261 default : return "";
1262 }
1263 default : return "";
1264 }
1265 case 0x02 : //Sound
1266 switch (Code3)
1267 {
1268 case 0x02 : //Coding characteristics
1269 switch (Code4)
1270 {
1271 case 0x02 : //Compressed coding
1272 switch (Code5)
1273 {
1274 case 0x03 : //Compressed Audio Coding
1275 switch (Code6)
1276 {
1277 case 0x02 : //SMPTE 338M Audio Coding
1278 switch (Code7)
1279 {
1280 case 0x04 : return "Version 1"; //Layer 1
1281 case 0x05 : return "Version 1"; //Layer 2 or 3
1282 case 0x06 : return "Version 2"; //Layer 1
1283 default : return ""; //Unknown
1284 }
1285 default : return "";
1286 }
1287 default : return "";
1288 }
1289 default : return "";
1290 }
1291 default : return "";
1292 }
1293 default : return "";
1294 }
1295 }
1296
1297 //---------------------------------------------------------------------------
Mxf_Sequence_DataDefinition(const int128u DataDefinition)1298 static const char* Mxf_Sequence_DataDefinition(const int128u DataDefinition)
1299 {
1300 int8u Code4=(int8u)((DataDefinition.lo&0x000000FF00000000LL)>>32);
1301 int8u Code5=(int8u)((DataDefinition.lo&0x00000000FF000000LL)>>24);
1302
1303 switch (Code4)
1304 {
1305 case 0x01 :
1306 switch (Code5)
1307 {
1308 case 0x01 :
1309 case 0x02 :
1310 case 0x03 : return "Time";
1311 case 0x10 : return "Descriptive Metadata";
1312 default : return "";
1313 }
1314 case 0x02 :
1315 switch (Code5)
1316 {
1317 case 0x01 : return "Picture";
1318 case 0x02 : return "Sound";
1319 case 0x03 : return "Data";
1320 default : return "";
1321 }
1322 default : return "";
1323 }
1324 }
1325
1326 //---------------------------------------------------------------------------
Mxf_FrameLayout(int8u FrameLayout)1327 static const char* Mxf_FrameLayout(int8u FrameLayout)
1328 {
1329 switch (FrameLayout)
1330 {
1331 case 0x00 : return "Full frame";
1332 case 0x01 : return "Separated fields";
1333 case 0x02 : return "Single field";
1334 case 0x03 : return "Mixed fields";
1335 case 0x04 : return "Segmented frame";
1336 default : return "";
1337 }
1338 }
1339
1340 //---------------------------------------------------------------------------
Mxf_FrameLayout_ScanType(int8u FrameLayout)1341 static const char* Mxf_FrameLayout_ScanType(int8u FrameLayout)
1342 {
1343 switch (FrameLayout)
1344 {
1345 case 0x01 :
1346 case 0x04 :
1347 case 0xFF : //Seen in one file
1348 return "Interlaced";
1349 default :
1350 return "Progressive";
1351 }
1352 }
1353
1354 //---------------------------------------------------------------------------
Mxf_FrameLayout_Multiplier(int8u FrameLayout)1355 static int8u Mxf_FrameLayout_Multiplier(int8u FrameLayout)
1356 {
1357 switch (FrameLayout)
1358 {
1359 case 0x01 :
1360 case 0x04 :
1361 case 0xFF : //Seen in one file
1362 return 2;
1363 default :
1364 return 1;
1365 }
1366 }
1367
1368 //---------------------------------------------------------------------------
Mxf_ColorPrimaries(const int128u ColorPrimaries)1369 static const char* Mxf_ColorPrimaries(const int128u ColorPrimaries)
1370 {
1371 int32u Code_Compare4=(int32u)ColorPrimaries.lo;
1372 switch ((int8u)(Code_Compare4>>16))
1373 {
1374 case 0x01 : return "BT.601 NTSC";
1375 case 0x02 : return "BT.601 PAL";
1376 case 0x03 : return "BT.709";
1377 case 0x04 : return "BT.2020";
1378 case 0x05 : return "XYZ";
1379 case 0x06 : return "Display P3";
1380 case 0x07 : return "ACES"; // SMPTE ST 2065-1
1381 case 0x08 : return "XYZ"; // SMPTE ST 2067-40 / ISO 11664-3
1382 default : return "";
1383 }
1384 }
1385
1386 //---------------------------------------------------------------------------
Mxf_TransferCharacteristic(const int128u TransferCharacteristic)1387 static const char* Mxf_TransferCharacteristic(const int128u TransferCharacteristic)
1388 {
1389 int32u Code_Compare4=(int32u)TransferCharacteristic.lo;
1390 switch ((int8u)(Code_Compare4>>16))
1391 {
1392 case 0x01 : return "BT.601";
1393 case 0x02 : return "BT.709";
1394 case 0x03 : return "SMPTE 240M";
1395 case 0x04 : return "SMPTE 274M";
1396 case 0x05 : return "BT.1361";
1397 case 0x06 : return "Linear";
1398 case 0x07 : return "SMPTE 428M";
1399 case 0x08 : return "xvYCC";
1400 case 0x09 : return "BT.2020"; // ISO does a difference of value between 10 and 12 bit
1401 case 0x0A : return "PQ";
1402 case 0x0B : return "HLG";
1403 case 0x0C : return "Gamma 2.6"; // SMPTE ST 2067-50
1404 case 0x0D : return "sRGB/sYCC"; // IEC 61966-2-1
1405 default : return "";
1406 }
1407 }
1408
1409 //---------------------------------------------------------------------------
Mxf_CodingEquations(const int128u CodingEquations)1410 static const char* Mxf_CodingEquations(const int128u CodingEquations)
1411 {
1412 int32u Code_Compare4=(int32u)CodingEquations.lo;
1413 switch ((int8u)(Code_Compare4>>16))
1414 {
1415 case 0x01 : return "BT.601";
1416 case 0x02 : return "BT.709";
1417 case 0x03 : return "SMPTE 240M";
1418 case 0x04 : return "YCgCo";
1419 case 0x05 : return "Identity";
1420 case 0x06 : return "BT.2020 non-constant";
1421 default : return "";
1422 }
1423 }
1424
1425 //---------------------------------------------------------------------------
Mxf_ChannelAssignment_ChannelLayout(const int128u & ChannelLayout,int32u ChannelsCount=(int32u)-1)1426 static const char* Mxf_ChannelAssignment_ChannelLayout(const int128u& ChannelLayout, int32u ChannelsCount=(int32u)-1)
1427 {
1428 //Sound Channel Labeling
1429 if ((ChannelLayout.hi&0xFFFFFFFFFFFFFF00LL)!=0x060E2B3404010100LL && (ChannelLayout.lo&0xFFFFFFFF00000000LL)!=0x0402021000000000LL)
1430 return "";
1431
1432 int8u Code5=(int8u)((ChannelLayout.lo&0x00000000FF000000LL)>>24);
1433 int8u Code6=(int8u)((ChannelLayout.lo&0x0000000000FF0000LL)>>16);
1434 int8u Code7=(int8u)((ChannelLayout.lo&0x000000000000FF00LL)>> 8);
1435
1436 switch (Code5)
1437 {
1438 case 0x03 : //SMPTE 429-2
1439 switch (Code6)
1440 {
1441 case 0x01 : //Sets
1442 switch (Code7)
1443 {
1444 case 0x01 : //Config 1
1445 switch (ChannelsCount)
1446 {
1447 case 6 : return "L R C LFE Ls Rs";
1448 default : return "L R C LFE Ls Rs HI VI-N";
1449 }
1450 case 0x02 : //Config 2
1451 switch (ChannelsCount)
1452 {
1453 case 6 : return "L R C LFE Ls Rs";
1454 case 8 : return "L R C LFE Ls Rs Cs X";
1455 default : return "L R C LFE Ls Rs Cs X HI VI-N";
1456 }
1457 case 0x03 : //Config 3
1458 switch (ChannelsCount)
1459 {
1460 case 6 : return "L R C LFE Ls Rs";
1461 case 8 : return "L R C LFE Ls Rs Rls Rrs";
1462 default : return "L R C LFE Ls Rs Rls Rrs HI VI-N";
1463 }
1464 default : return "";
1465 }
1466 default : return "";
1467 }
1468 default : return "";
1469 }
1470 }
Mxf_ChannelAssignment_ChannelLayout(const int128u ChannelLayout)1471 static const char* Mxf_ChannelAssignment_ChannelLayout(const int128u ChannelLayout)
1472 {
1473 return Mxf_ChannelAssignment_ChannelLayout(ChannelLayout, (int32u)-1);
1474 }
1475
MXF_MCALabelDictionaryID_ChannelPositions(const std::vector<int128u> & MCALabelDictionaryIDs)1476 static string MXF_MCALabelDictionaryID_ChannelPositions(const std::vector<int128u> &MCALabelDictionaryIDs)
1477 {
1478 string ToReturn;
1479 std::bitset<8> Front, Side, Back, Lfe;
1480 bool IsOk=true;
1481
1482 for (size_t Pos=0; Pos<MCALabelDictionaryIDs.size(); Pos++)
1483 {
1484 if ((MCALabelDictionaryIDs[Pos].hi&0xFFFFFFFFFFFFFF00LL)==0x060E2B3404010100LL && (MCALabelDictionaryIDs[Pos].lo&0xFF00000000000000LL)==0x0300000000000000LL)
1485 {
1486 switch ((MCALabelDictionaryIDs[Pos].lo>>48)&0xFF)
1487 {
1488 case 0x01 :
1489 switch ((MCALabelDictionaryIDs[Pos].lo>>40)&0xFF)
1490 {
1491 case 0x01 :
1492 switch ((MCALabelDictionaryIDs[Pos].lo>>32)&0xFF)
1493 {
1494 case 0x01 : Front[0]=true; break; //L
1495 case 0x02 : Front[1]=true; break; //R
1496 case 0x03 : Front[2]=true; break; //C
1497 case 0x04 : Lfe[0]=true; break; //LFE
1498 case 0x05 : Side[0]=true; break; //Ls
1499 case 0x06 : Side[1]=true; break; //Rs
1500 case 0x20 : Front[6]=true; break; //M1 //TODO: split M1 and M2 in 2 services
1501 case 0x21 : Front[7]=true; break; //M2 //TODO: split M1 and M2 in 2 services
1502 case 0x22 : Front[4]=true; break; //Lt
1503 case 0x23 : Front[5]=true; break; //Rt
1504 default : IsOk=false;
1505 }
1506 break;
1507 default : IsOk=false;
1508 }
1509 break;
1510 case 0x02 :
1511 switch ((MCALabelDictionaryIDs[Pos].lo>>40)&0xFF)
1512 {
1513 case 0x01 :
1514 switch ((MCALabelDictionaryIDs[Pos].lo>>32)&0xFF)
1515 {
1516 case 0x01 : Front[0]=true; break; //L
1517 case 0x02 : Front[1]=true; break; //R
1518 case 0x03 : Front[2]=true; break; //C
1519 case 0x04 : Lfe[0]=true; break; //LFE
1520 case 0x05 : Side[0]=true; break; //Ls
1521 case 0x06 : Side[1]=true; break; //Rs
1522 case 0x20 :
1523 switch ((MCALabelDictionaryIDs[Pos].lo>>24)&0xFF)
1524 {
1525 case 0x03 : Front[4]=true; break; //Lt
1526 case 0x04 : Front[5]=true; break; //Rt
1527 default : IsOk=false;
1528 }
1529 break;
1530 default : IsOk=false;
1531 }
1532 break;
1533 default : IsOk=false;
1534 }
1535 break;
1536 default : IsOk=false;
1537 }
1538 }
1539 else
1540 IsOk=false;
1541 }
1542
1543 if (IsOk)
1544 {
1545 string FrontS, SideS, BackS, LfeS;
1546 if (Front.any())
1547 {
1548 FrontS+="Front: ";
1549 if (Front[0])
1550 FrontS+="L ";
1551 if (Front[2])
1552 FrontS+="C ";
1553 if (Front[1])
1554 FrontS+="R ";
1555 if (Front[4])
1556 FrontS+="Lt ";
1557 if (Front[5])
1558 FrontS+="Rt ";
1559 if (Front[6])
1560 FrontS+="M ";
1561 if (Front[7])
1562 FrontS+="M ";
1563 FrontS.resize(FrontS.size()-1);
1564 }
1565 if (Side.any())
1566 {
1567 SideS+="Side: ";
1568 if (Side[0])
1569 SideS+="L ";
1570 if (Side[1])
1571 SideS+="R ";
1572 SideS.resize(SideS.size()-1);
1573 }
1574 if (Back.any())
1575 {
1576 BackS+="Back: ";
1577 if (Back[0])
1578 BackS+="L ";
1579 if (Back[2])
1580 BackS+="C ";
1581 if (Back[1])
1582 BackS+="R ";
1583 BackS.resize(BackS.size()-1);
1584 }
1585 if (Lfe.any())
1586 {
1587 if (Lfe[0])
1588 LfeS+="LFE";
1589 }
1590 if (!FrontS.empty())
1591 ToReturn+=FrontS;
1592 if (!SideS.empty())
1593 {
1594 if (!ToReturn.empty())
1595 ToReturn+=", ";
1596 ToReturn+=SideS;
1597 }
1598 if (!BackS.empty())
1599 {
1600 if (!ToReturn.empty())
1601 ToReturn+=", ";
1602 ToReturn+=BackS;
1603 }
1604 if (!LfeS.empty())
1605 {
1606 if (!ToReturn.empty())
1607 ToReturn+=", ";
1608 ToReturn+=LfeS;
1609 }
1610 }
1611
1612 return ToReturn;
1613 }
1614
MXF_MCALabelDictionaryID_ChannelLayout(const std::vector<int128u> & MCALabelDictionaryIDs)1615 static string MXF_MCALabelDictionaryID_ChannelLayout(const std::vector<int128u> &MCALabelDictionaryIDs)
1616 {
1617 string ToReturn;
1618
1619 for (size_t Pos=0; Pos<MCALabelDictionaryIDs.size(); Pos++)
1620 {
1621 const char* Value="";
1622 if ((MCALabelDictionaryIDs[Pos].hi&0xFFFFFFFFFFFFFF00LL)==0x060E2B3404010100LL && (MCALabelDictionaryIDs[Pos].lo&0xFF00000000000000LL)==0x0300000000000000LL)
1623 {
1624 switch ((MCALabelDictionaryIDs[Pos].lo>>48)&0xFF)
1625 {
1626 case 0x01 :
1627 switch ((MCALabelDictionaryIDs[Pos].lo>>40)&0xFF)
1628 {
1629 case 0x01 :
1630 switch ((MCALabelDictionaryIDs[Pos].lo>>32)&0xFF)
1631 {
1632 case 0x01 : Value="L"; break;
1633 case 0x02 : Value="R"; break;
1634 case 0x03 : Value="C"; break;
1635 case 0x04 : Value="LFE"; break;
1636 case 0x05 : Value="Ls"; break;
1637 case 0x06 : Value="Rs"; break;
1638 case 0x20 : Value="M"; break;
1639 case 0x21 : Value="M"; break;
1640 case 0x22 : Value="Lt"; break;
1641 case 0x23 : Value="Rt"; break;
1642 default : Value="";
1643 }
1644 break;
1645 default : Value="";
1646 }
1647 break;
1648 case 0x02 :
1649 switch ((MCALabelDictionaryIDs[Pos].lo>>40)&0xFF)
1650 {
1651 case 0x01 :
1652 switch ((MCALabelDictionaryIDs[Pos].lo>>32)&0xFF)
1653 {
1654 case 0x01 : Value="L"; break;
1655 case 0x02 : Value="R"; break;
1656 case 0x03 : Value="C"; break;
1657 case 0x04 : Value="LFE"; break;
1658 case 0x05 : Value="Ls"; break;
1659 case 0x06 : Value="Rs"; break;
1660 case 0x20 :
1661 switch ((MCALabelDictionaryIDs[Pos].lo>>24)&0xFF)
1662 {
1663 case 0x03 : Value="Lt"; break;
1664 case 0x04 : Value="Rt"; break;
1665 default : Value="";
1666 }
1667 break;
1668 case 0x22 : Value="Lt"; break;
1669 case 0x23 : Value="Rt"; break;
1670 default : Value="";
1671 }
1672 break;
1673 default : Value="";
1674 }
1675 break;
1676 default : Value="";
1677 }
1678 }
1679 if (!ToReturn.empty())
1680 ToReturn+=' ';
1681 if (strlen(Value))
1682 ToReturn+=Value;
1683 else
1684 {
1685 Ztring Value; Value.From_Number(MCALabelDictionaryIDs[Pos].lo>>32, 16);
1686 if (Value.size()<8)
1687 Value.insert(0, 8-Value.size(), __T('0'));
1688 ToReturn+=Value.To_UTF8();
1689 }
1690 }
1691
1692 return ToReturn;
1693 }
1694
1695 //---------------------------------------------------------------------------
1696 const size_t Mxf_AS11_ClosedCaptionType_Count=2;
1697 static const char* Mxf_AS11_ClosedCaptionType[Mxf_AS11_ClosedCaptionType_Count]=
1698 {
1699 "Hard of Hearing",
1700 "Translation",
1701 };
1702
1703 //---------------------------------------------------------------------------
1704 const size_t Mxf_AS11_AudioTrackLayout_Count=0x35;
1705 static const char* Mxf_AS11_AudioTrackLayout[Mxf_AS11_AudioTrackLayout_Count]=
1706 {
1707 "EBU R 48: 1a",
1708 "EBU R 48: 1b",
1709 "EBU R 48: 1c",
1710 "EBU R 48: 2a",
1711 "EBU R 48: 2b",
1712 "EBU R 48: 2c",
1713 "EBU R 48: 3a",
1714 "EBU R 48: 3b",
1715 "EBU R 48: 4a",
1716 "EBU R 48: 4b",
1717 "EBU R 48: 4c",
1718 "EBU R 48: 5a",
1719 "EBU R 48: 5b",
1720 "EBU R 48: 6a",
1721 "EBU R 48: 6b",
1722 "EBU R 48: 7a",
1723 "EBU R 48: 7b",
1724 "EBU R 48: 8a",
1725 "EBU R 48: 8b",
1726 "EBU R 48: 8c",
1727 "EBU R 48: 9a",
1728 "EBU R 48: 9b",
1729 "EBU R 48: 10a",
1730 "EBU R 48: 11a",
1731 "EBU R 48: 11b",
1732 "EBU R 48: 11c",
1733 "EBU R 123: 2a",
1734 "EBU R 123: 4a",
1735 "EBU R 123: 4b",
1736 "EBU R 123: 4c",
1737 "EBU R 123: 8a",
1738 "EBU R 123: 8b",
1739 "EBU R 123: 8c",
1740 "EBU R 123: 8d",
1741 "EBU R 123: 8e",
1742 "EBU R 123: 8f",
1743 "EBU R 123: 8g",
1744 "EBU R 123: 8h",
1745 "EBU R 123: 8i",
1746 "EBU R 123: 12a",
1747 "EBU R 123: 12b",
1748 "EBU R 123: 12c",
1749 "EBU R 123: 12d",
1750 "EBU R 123: 12e",
1751 "EBU R 123: 12f",
1752 "EBU R 123: 12g",
1753 "EBU R 123: 12h",
1754 "EBU R 123: 16a",
1755 "EBU R 123: 16b",
1756 "EBU R 123: 16c",
1757 "EBU R 123: 16d",
1758 "EBU R 123: 16e",
1759 "EBU R 123: 16f",
1760 };
1761 struct mxf_as11_audiotracklayout_assignment
1762 {
1763 const int8u Count;
1764 const char* Assign[16];
1765 };
1766 static const mxf_as11_audiotracklayout_assignment Mxf_AS11_AudioTrackLayout_ChannelPositions[Mxf_AS11_AudioTrackLayout_Count]=
1767 {
1768 { 2, "Front: C", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 1a
1769 { 4, "Front: C", NULL, "Front: C", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 1b
1770 { 8, "Front: C", NULL, "Front: C", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 1c
1771 { 2, "Front: L", "Front: R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 2a
1772 { 4, "Front: L", "Front: R", "Front: L", "Front: R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 2b
1773 { 8, "Front: L", "Front: R", "Front: L", "Front: R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 2c
1774 { 4, "Front: L", "Front: R", "Front: L", "Front: R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 3a
1775 { 8, "Front: L", "Front: R", "Front: L", "Front: R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 3b
1776 { 2, "EBU R 48: 4a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1777 { 4, "EBU R 48: 4b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1778 { 8, "EBU R 48: 4c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1779 { 4, "EBU R 48: 5a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1780 { 8, "EBU R 48: 5b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1781 { 4, "EBU R 48: 6a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1782 { 8, "EBU R 48: 6b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1783 { 4, "EBU R 48: 7a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1784 { 8, "EBU R 48: 7b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1785 { 2, "EBU R 48: 8a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1786 { 4, "EBU R 48: 8b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1787 { 8, "EBU R 48: 8c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1788 { 4, "EBU R 48: 9a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1789 { 8, "EBU R 48: 9b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1790 { 2, "EBU R 48: 10a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1791 { 4, "EBU R 48: 11a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1792 { 8, "EBU R 48: 11b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1793 { 8, "EBU R 48: 11c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1794 { 2, "EBU R 123: 2a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1795 { 4, "EBU R 123: 4a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1796 { 4, "EBU R 123: 4b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1797 { 4, "EBU R 123: 4c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1798 { 8, "EBU R 123: 8a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1799 { 8, "EBU R 123: 8b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1800 { 8, "EBU R 123: 8c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1801 { 8, "EBU R 123: 8d", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1802 { 8, "EBU R 123: 8e", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1803 { 8, "EBU R 123: 8f", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1804 { 8, "EBU R 123: 8g", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1805 { 8, "EBU R 123: 8h", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1806 { 8, "EBU R 123: 8i", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1807 { 12, "EBU R 123: 12a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1808 { 12, "EBU R 123: 12b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1809 { 12, "EBU R 123: 12c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1810 { 12, "EBU R 123: 12d", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1811 { 12, "EBU R 123: 12e", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1812 { 12, "EBU R 123: 12f", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1813 { 12, "EBU R 123: 12g", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1814 { 12, "EBU R 123: 12h", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1815 { 16, "Front: L", "Front: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Front: L", "Front: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", }, //123 16a
1816 { 16, "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", }, //123 16b
1817 { 16, "Front: L", "Front: R", "Front: L", "Front: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", }, //123 16c
1818 { 16, "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Front: L", "Front: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Front: L", "Front: R", }, //123 16d
1819 { 16, "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Front: L", "Front: R", "Front: C", "LFE", "Side: L", "Side: R", "Side: L", "Side: R", "Side: L", "Side: R", }, //123 16e
1820 { 16, "Front: L", "Front: R", NULL, NULL, "Front: L", "Front: R", NULL, NULL, "Front: L", "Front: R", NULL, NULL, "Front: L", "Front: R", "Front: L", "Front: R", }, //123 16f
1821 };
1822 static const mxf_as11_audiotracklayout_assignment Mxf_AS11_AudioTrackLayout_ChannelLayout[Mxf_AS11_AudioTrackLayout_Count]=
1823 {
1824 { 2, "C", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 1a
1825 { 4, "C", NULL, "C", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 1b
1826 { 8, "C", NULL, "C", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 1c
1827 { 2, "L", "R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 2a
1828 { 4, "L", "R", "L", "R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 2b
1829 { 8, "L", "R", "L", "R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 2c
1830 { 4, "L", "R", "L", "R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 3a
1831 { 8, "L", "R", "L", "R", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, //48 3b
1832 { 2, "EBU R 48: 4a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1833 { 4, "EBU R 48: 4b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1834 { 8, "EBU R 48: 4c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1835 { 4, "EBU R 48: 5a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1836 { 8, "EBU R 48: 5b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1837 { 4, "EBU R 48: 6a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1838 { 8, "EBU R 48: 6b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1839 { 4, "EBU R 48: 7a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1840 { 8, "EBU R 48: 7b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1841 { 2, "EBU R 48: 8a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1842 { 4, "EBU R 48: 8b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1843 { 8, "EBU R 48: 8c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1844 { 4, "EBU R 48: 9a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1845 { 8, "EBU R 48: 9b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1846 { 2, "EBU R 48: 10a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1847 { 4, "EBU R 48: 11a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1848 { 8, "EBU R 48: 11b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1849 { 8, "EBU R 48: 11c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1850 { 2, "EBU R 123: 2a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1851 { 4, "EBU R 123: 4a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1852 { 4, "EBU R 123: 4b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1853 { 4, "EBU R 123: 4c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1854 { 8, "EBU R 123: 8a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1855 { 8, "EBU R 123: 8b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1856 { 8, "EBU R 123: 8c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1857 { 8, "EBU R 123: 8d", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1858 { 8, "EBU R 123: 8e", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1859 { 8, "EBU R 123: 8f", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1860 { 8, "EBU R 123: 8g", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1861 { 8, "EBU R 123: 8h", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1862 { 8, "EBU R 123: 8i", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1863 { 12, "EBU R 123: 12a", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1864 { 12, "EBU R 123: 12b", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1865 { 12, "EBU R 123: 12c", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1866 { 12, "EBU R 123: 12d", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1867 { 12, "EBU R 123: 12e", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1868 { 12, "EBU R 123: 12f", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1869 { 12, "EBU R 123: 12g", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1870 { 12, "EBU R 123: 12h", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
1871 { 16, "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", }, //123 16a
1872 { 16, "L", "R", "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", "L", "R", "C", "LFE", "Ls", "Rs", }, //123 16b
1873 { 16, "L", "R", "L", "R", "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", "C", "LFE", "Ls", "Rs", }, //123 16c
1874 { 16, "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", }, //123 16d
1875 { 16, "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", "C", "LFE", "Ls", "Rs", "L", "R", "L", "R", }, //123 16e
1876 { 16, "L", "R", NULL, NULL, "L", "R", NULL, NULL, "L", "R", NULL, NULL, "L", "R", "L", "R", }, //123 16f
1877 };
1878
1879
1880 //---------------------------------------------------------------------------
1881 const size_t Mxf_AS11_FpaPass_Count=3;
1882 static const char* Mxf_AS11_FpaPass[Mxf_AS11_FpaPass_Count]=
1883 {
1884 "Yes",
1885 "No",
1886 "Not tested",
1887 };
1888
1889 //---------------------------------------------------------------------------
1890 const size_t Mxf_AS11_SigningPresent_Count=3;
1891 static const char* Mxf_AS11_SigningPresent[Mxf_AS11_SigningPresent_Count]=
1892 {
1893 "Yes",
1894 "No",
1895 "Signer only",
1896 };
1897
1898 //---------------------------------------------------------------------------
1899 const size_t Mxf_AS11_3D_Type_Count=4;
1900 static const char* Mxf_AS11_3D_Type[Mxf_AS11_3D_Type_Count]=
1901 {
1902 "Side by side",
1903 "Dual",
1904 "Left eye only",
1905 "Right eye only",
1906 };
1907
1908 //---------------------------------------------------------------------------
1909 const size_t Mxf_AS11_AudioLoudnessStandard_Count=2;
1910 static const char* Mxf_AS11_AudioLoudnessStandard[Mxf_AS11_AudioLoudnessStandard_Count]=
1911 {
1912 "",
1913 "EBU R 128",
1914 };
1915
1916 //---------------------------------------------------------------------------
1917 const size_t Mxf_AS11_AudioDescriptionType_Count=2;
1918 static const char* Mxf_AS11_AudioDescriptionType[Mxf_AS11_AudioDescriptionType_Count]=
1919 {
1920 "Control data / Narration",
1921 "AD Mix",
1922 };
1923
1924 //---------------------------------------------------------------------------
1925 const size_t Mxf_AS11_OpenCaptionsType_Count=2;
1926 static const char* Mxf_AS11_OpenCaptionsType[Mxf_AS11_OpenCaptionsType_Count]=
1927 {
1928 "Hard of Hearing",
1929 "Translation",
1930 };
1931
1932 //---------------------------------------------------------------------------
1933 const size_t Mxf_AS11_SignLanguage_Count=2;
1934 static const char* Mxf_AS11_SignLanguage[Mxf_AS11_SignLanguage_Count]=
1935 {
1936 "BSL (British Sign Language)",
1937 "BSL (Makaton)",
1938 };
1939
1940
1941 //---------------------------------------------------------------------------
1942 // EBU Tech 3349
Mxf_CameraUnitMetadata_GammaforCDL(int8u Value)1943 static string Mxf_CameraUnitMetadata_GammaforCDL(int8u Value)
1944 {
1945 switch(Value)
1946 {
1947 case 0x00 : return "Same as Capture Gamma";
1948 case 0x01 : return "Scene Linear";
1949 case 0x02 : return "S-Log";
1950 case 0x03 : return "Cine-Log";
1951 case 0xFF : return "Undefined";
1952 default : return Ztring::ToZtring(Value).To_UTF8();
1953 }
1954 };
1955
1956 //---------------------------------------------------------------------------
1957 // EBU Tech 3349
Mxf_CameraUnitMetadata_NeutralDensityFilterWheelSetting(int16u Value)1958 static string Mxf_CameraUnitMetadata_NeutralDensityFilterWheelSetting(int16u Value)
1959 {
1960 switch(Value)
1961 {
1962 case 0x01 : return "Clear";
1963 default : return Ztring::ToZtring(Value).To_UTF8();
1964 }
1965 };
1966
1967 //---------------------------------------------------------------------------
1968 // EBU Tech 3349
Mxf_CameraUnitMetadata_ImageSensorReadoutMode(int8u Value)1969 static string Mxf_CameraUnitMetadata_ImageSensorReadoutMode(int8u Value)
1970 {
1971 switch(Value)
1972 {
1973 case 0x00 : return "Interlaced field";
1974 case 0x01 : return "Interlaced frame";
1975 case 0x02 : return "Progressive frame";
1976 case 0xFF : return "Undefined";
1977 default : return Ztring::ToZtring(Value).To_UTF8();
1978 }
1979 };
1980
1981 //---------------------------------------------------------------------------
1982 // EBU Tech 3349
Mxf_CameraUnitMetadata_CaptureGammaEquation(int128u Value)1983 static string Mxf_CameraUnitMetadata_CaptureGammaEquation(int128u Value)
1984 {
1985 switch(Value.lo)
1986 {
1987 case 0x0401010101010000LL : return "BT.470"; // Directly from SMPTE registry
1988 case 0x0401010101020000LL : return "BT.709";
1989 case 0x0401010101030000LL : return "SMPTE ST 240";
1990 case 0x0401010101040000LL : return "SMPTE ST 274"; // Directly from SMPTE registry
1991 case 0x0401010101050000LL : return "BT.1361"; // Directly from SMPTE registry
1992 case 0x0401010101060000LL : return "SceneLinear"; // Directly from SMPTE registry
1993 case 0x0E06040101010101LL : return "DVW-709 Like"; // 0x0E06x values are read from SR Viewer program
1994 case 0x0E06040101010102LL : return "E10/E30STD for J EK";
1995 case 0x0E06040101010103LL : return "E10/E30STD for UC";
1996 case 0x0E06040101010106LL : return "BBC Initial50";
1997 case 0x0E06040101010107LL : return "SD CamCorder STD";
1998 case 0x0E06040101010108LL : return "BVW-400 Like";
1999 case 0x0E06040101010109LL : return "Ikegami";
2000 case 0x0E0604010101017FLL : return "reproduced unknown label";
2001 case 0x0E06040101010201LL : return "HG3250G36";
2002 case 0x0E06040101010202LL : return "HG4600G30";
2003 case 0x0E06040101010203LL : return "HG3259G40";
2004 case 0x0E06040101010204LL : return "HG4609G33";
2005 case 0x0E06040101010205LL : return "HG8000G36";
2006 case 0x0E06040101010206LL : return "HG8000G30";
2007 case 0x0E06040101010207LL : return "HG8009G40";
2008 case 0x0E06040101010208LL : return "HG8009G33";
2009 case 0x0E06040101010301LL : return "CINE1 of EX1/EX3";
2010 case 0x0E06040101010302LL : return "CINE2 of EX1/EX3";
2011 case 0x0E06040101010303LL : return "CINE3 of EX1/EX3";
2012 case 0x0E06040101010304LL : return "CINE4 of EX1/EX3";
2013 case 0x0E06040101010305LL : return "Kodak 5248 film like";
2014 case 0x0E06040101010306LL : return "Kodak 5245 film like";
2015 case 0x0E06040101010307LL : return "Kodak 5293 film like";
2016 case 0x0E06040101010308LL : return "Kodak 5296 film like";
2017 case 0x0E06040101010309LL : return "Average of Film of MSW-900";
2018 case 0x0E06040101010401LL : return "User defined curve1";
2019 case 0x0E06040101010402LL : return "User defined curve2";
2020 case 0x0E06040101010403LL : return "User defined curve3";
2021 case 0x0E06040101010404LL : return "User defined curve4";
2022 case 0x0E06040101010405LL : return "User defined curve5";
2023 case 0x0E06040101010406LL : return "User defined curve6";
2024 case 0x0E06040101010407LL : return "User defined curve7";
2025 case 0x0E06040101010408LL : return "User defined curve8";
2026 case 0x0E06040101010501LL : return "S-Log";
2027 case 0x0E06040101010502LL : return "FS-Log";
2028 case 0x0E06040101010503LL : return "R709 180%";
2029 case 0x0E06040101010504LL : return "R709 800%";
2030 case 0x0E06040101010506LL : return "Cine-Log";
2031 case 0x0E06040101010507LL : return "ASC-CDL";
2032
2033
2034 default :
2035 {
2036 Ztring ValueS;
2037 ValueS.From_Number(Value.lo, 16);
2038 if (ValueS.size()<16)
2039 ValueS.insert(0, 16-ValueS.size(), __T('0'));
2040 return ValueS.To_UTF8();
2041 }
2042 }
2043 };
2044
2045 //---------------------------------------------------------------------------
2046 // RDD 18
Mxf_CameraUnitMetadata_AutoExposureMode(int128u Value)2047 static string Mxf_CameraUnitMetadata_AutoExposureMode(int128u Value)
2048 {
2049 switch(Value.lo)
2050 {
2051 case 0x0510010101010000LL : return "Manual";
2052 case 0x0510010101020000LL : return "Full Auto";
2053 case 0x0510010101030000LL : return "Gain Priority Auto";
2054 case 0x0510010101040000LL : return "Iris Priority Auto";
2055 case 0x0510010101050000LL : return "Shutter Priority Auto";
2056 default :
2057 {
2058 Ztring ValueS;
2059 ValueS.From_Number(Value.lo, 16);
2060 if (ValueS.size()<16)
2061 ValueS.insert(0, 16-ValueS.size(), __T('0'));
2062 return ValueS.To_UTF8();
2063 }
2064 }
2065 }
2066
2067 //---------------------------------------------------------------------------
2068 // RDD 18
Mxf_CameraUnitMetadata_AutoFocusSensingAreaSetting(int8u Value)2069 static string Mxf_CameraUnitMetadata_AutoFocusSensingAreaSetting(int8u Value)
2070 {
2071 switch(Value)
2072 {
2073 case 0x00 : return "Manual";
2074 case 0x01 : return "Center Sensitive Auto";
2075 case 0x02 : return "Full Screen Sensing Auto";
2076 case 0x03 : return "Multi Spot Sensing Auto";
2077 case 0x04 : return "Single Spot Sensing Auto";
2078 default : return Ztring::ToZtring(Value).To_UTF8();
2079 }
2080 }
2081
2082 //---------------------------------------------------------------------------
2083 // RDD 18
Mxf_CameraUnitMetadata_ColorCorrectionFilterWheelSetting(int8u Value)2084 static string Mxf_CameraUnitMetadata_ColorCorrectionFilterWheelSetting(int8u Value)
2085 {
2086 switch(Value)
2087 {
2088 case 0x00 : return "Cross effect";
2089 case 0x01 : return "Color Compensation 3200 K";
2090 case 0x02 : return "Color Compensation 4300 K";
2091 case 0x03 : return "Color Compensation 6300 K";
2092 case 0x04 : return "Color Compensation 5600 K";
2093 default : return Ztring::ToZtring(Value).To_UTF8();
2094 }
2095 }
2096
2097 //---------------------------------------------------------------------------
2098 // RDD 18
Mxf_CameraUnitMetadata_AutoWhiteBalanceMode(int8u Value)2099 static string Mxf_CameraUnitMetadata_AutoWhiteBalanceMode(int8u Value)
2100 {
2101 switch(Value)
2102 {
2103 case 0x00 : return "Preset";
2104 case 0x01 : return "Automatic";
2105 case 0x02 : return "Hold";
2106 case 0x03 : return "One Push";
2107 default : return Ztring::ToZtring(Value).To_UTF8();
2108 }
2109 }
2110
2111 //---------------------------------------------------------------------------
2112 // CameraUnitMetadata
Mxf_AcquisitionMetadata_ElementName(int16u Value,bool IsSony=false)2113 static string Mxf_AcquisitionMetadata_ElementName(int16u Value, bool IsSony=false)
2114 {
2115 if (IsSony)
2116 switch (Value)
2117 {
2118 case 0xE101: return "EffectiveMarkerCoverage";
2119 case 0xE102: return "EffectiveMarkerAspectRatio";
2120 case 0xE103: return "CameraProcessDiscriminationCode";
2121 case 0xE104: return "RotaryShutterMode";
2122 case 0xE105: return "RawBlackCodeValue";
2123 case 0xE106: return "RawGrayCodeValue";
2124 case 0xE107: return "RawWhiteCodeValue";
2125 case 0xE109: return "MonitoringDescriptions";
2126 case 0xE10B: return "MonitoringBaseCurve";
2127 //case 0xE201: return "CookeProtocol_BinaryMetadata"; //Not used
2128 case 0xE202: return "CookeProtocol_UserMetadata";
2129 case 0xE203: return "CookeProtocol_CalibrationType";
2130 default: ;
2131 }
2132
2133 switch (Value) // From EBU Tech 3349
2134 {
2135 case 0x3210: return "CaptureGammaEquation";
2136 case 0x8000: return "IrisFNumber";
2137 case 0x8001: return "FocusPositionFromImagePlane";
2138 case 0x8002: return "FocusPositionFromFrontLensVertex";
2139 case 0x8003: return "MacroSetting";
2140 case 0x8004: return "LensZoom35mmStillCameraEquivalent";
2141 case 0x8005: return "LensZoomActualFocalLength";
2142 case 0x8006: return "OpticalExtenderMagnification";
2143 case 0x8007: return "LensAttributes";
2144 case 0x8008: return "IrisTNumber";
2145 case 0x8009: return "IrisRingPosition";
2146 case 0x800A: return "FocusRingPosition";
2147 case 0x800B: return "ZoomRingPosition";
2148 case 0x8100: return "AutoExposureMode";
2149 case 0x8101: return "AutoFocusSensingAreaSetting";
2150 case 0x8102: return "ColorCorrectionFilterWheelSetting";
2151 case 0x8103: return "NeutralDensityFilterWheelSetting";
2152 case 0x8104: return "ImageSensorDimensionEffectiveWidth";
2153 case 0x8105: return "ImageSensorDimensionEffectiveHeight";
2154 case 0x8106: return "CaptureFrameRate";
2155 case 0x8107: return "ImageSensorReadoutMode";
2156 case 0x8108: return "ShutterSpeed_Angle";
2157 case 0x8109: return "ShutterSpeed_Time";
2158 case 0x810A: return "CameraMasterGainAdjustment";
2159 case 0x810B: return "ISOSensitivity";
2160 case 0x810C: return "ElectricalExtenderMagnification";
2161 case 0x810D: return "AutoWhiteBalanceMode";
2162 case 0x810E: return "WhiteBalance";
2163 case 0x810F: return "CameraMasterBlackLevel";
2164 case 0x8110: return "CameraKneePoint";
2165 case 0x8111: return "CameraKneeSlope";
2166 case 0x8112: return "CameraLuminanceDynamicRange";
2167 case 0x8113: return "CameraSettingFileURI";
2168 case 0x8114: return "CameraAttributes";
2169 case 0x8115: return "ExposureIndexofPhotoMeter";
2170 case 0x8116: return "GammaForCDL";
2171 case 0x8117: return "ASC_CDL_V12";
2172 case 0x8118: return "ColorMatrix";
2173 default: return Ztring(Ztring::ToZtring(Value, 16)).To_UTF8();
2174 }
2175 }
2176
2177 //---------------------------------------------------------------------------
2178 // CameraUnitMetadata - Sony E201 (Values are internal MI)
2179 const size_t Mxf_AcquisitionMetadata_Sony_E201_ElementCount = 11;
2180 static const char* Mxf_AcquisitionMetadata_Sony_E201_ElementName[Mxf_AcquisitionMetadata_Sony_E201_ElementCount] =
2181 {
2182 "FocusDistance",
2183 "ApertureValue",
2184 "ApertureScale",
2185 "EffectiveFocaleLength",
2186 "HyperfocalDistance",
2187 "NearFocusDistance",
2188 "FarFocusDistance",
2189 "HorizontalFieldOfView",
2190 "EntrancePupilPosition",
2191 "NormalizedZoomValue",
2192 "LensSerialNumber",
2193 };
2194
2195 //---------------------------------------------------------------------------
2196 // Read from SR Viewer program
Mxf_AcquisitionMetadata_Sony_CameraProcessDiscriminationCode(int16u Value)2197 static string Mxf_AcquisitionMetadata_Sony_CameraProcessDiscriminationCode(int16u Value)
2198 {
2199 switch (Value)
2200 {
2201 case 0x0101: return "F65 RAW Mode released in December 2011";
2202 case 0x0102: return "F65 HD Mode released in April 2012";
2203 case 0x0103: return "F65 RAW High Frame Rate Mode released in July 2012";
2204 default: return Ztring(Ztring::ToZtring(Value, 16)).To_UTF8();
2205 }
2206 };
2207
2208 //---------------------------------------------------------------------------
2209 // Read from SR Viewer program
Mxf_AcquisitionMetadata_Sony_MonitoringBaseCurve(int128u Value)2210 static string Mxf_AcquisitionMetadata_Sony_MonitoringBaseCurve(int128u Value)
2211 {
2212 switch(Value.lo)
2213 {
2214 case 0x0E06040101010508LL : return "S-Log2";
2215 default :
2216 {
2217 Ztring ValueS;
2218 ValueS.From_Number(Value.lo, 16);
2219 if (ValueS.size()<16)
2220 ValueS.insert(0, 16-ValueS.size(), __T('0'));
2221 return ValueS.To_UTF8();
2222 }
2223 }
2224 }
2225
2226 //***************************************************************************
2227 // Config
2228 //***************************************************************************
2229
2230 //---------------------------------------------------------------------------
2231 static const char* ShowSource_List[] =
2232 {
2233 "colour_description",
2234 "colour_range",
2235 "colour_primaries",
2236 "matrix_coefficients",
2237 "transfer_characteristics",
2238 "MasteringDisplay_ColorPrimaries",
2239 "MasteringDisplay_Luminance",
2240 "MaxCLL",
2241 "MaxFALL",
2242 NULL
2243 };
ShowSource_IsInList(const string & Value)2244 static bool ShowSource_IsInList(const string &Value)
2245 {
2246 for (size_t i = 0; ShowSource_List[i]; i++)
2247 if (ShowSource_List[i] == Value)
2248 return true;
2249 return false;
2250 }
2251
2252 //***************************************************************************
2253 // Constructor/Destructor
2254 //***************************************************************************
2255
2256 //---------------------------------------------------------------------------
File_Mxf()2257 File_Mxf::File_Mxf()
2258 :File__Analyze(), File__HasReferences()
2259 {
2260 //Configuration
2261 ParserName="MXF";
2262 #if MEDIAINFO_EVENTS
2263 ParserIDs[0]=MediaInfo_Parser_Mxf;
2264 StreamIDs_Width[0]=8;
2265 #endif //MEDIAINFO_EVENTS
2266 #if MEDIAINFO_DEMUX
2267 Demux_Level=2; //Container
2268 #endif //MEDIAINFO_DEMUX
2269 MustSynchronize=true;
2270 DataMustAlwaysBeComplete=false;
2271 Buffer_TotalBytes_Fill_Max=(int64u)-1; //Disabling this feature for this format, this is done in the parser
2272 FrameInfo.DTS=0;
2273 Frame_Count_NotParsedIncluded=0;
2274 #if MEDIAINFO_DEMUX
2275 Demux_EventWasSent_Accept_Specific=true;
2276 #endif //MEDIAINFO_DEMUX
2277
2278 //Hints
2279 File_Buffer_Size_Hint_Pointer=NULL;
2280 Synched_Count=0;
2281
2282 //Temp
2283 RandomIndexPacks_AlreadyParsed=false;
2284 Streams_Count=(size_t)-1;
2285 OperationalPattern=0;
2286 Buffer_Begin=(int64u)-1;
2287 Buffer_End=0;
2288 Buffer_End_Unlimited=false;
2289 Buffer_Header_Size=0;
2290 Preface_Current.hi=0;
2291 Preface_Current.lo=0;
2292 IsParsingMiddle_MaxOffset=(int64u)-1;
2293 Track_Number_IsAvailable=false;
2294 IsParsingEnd=false;
2295 IsCheckingRandomAccessTable=false;
2296 IsCheckingFooterPartitionAddress=false;
2297 IsSearchingFooterPartitionAddress=false;
2298 FooterPartitionAddress_Jumped=false;
2299 PartitionPack_Parsed=false;
2300 HeaderPartition_IsOpen=false;
2301 IdIsAlwaysSame_Offset=0;
2302 PartitionMetadata_PreviousPartition=(int64u)-1;
2303 PartitionMetadata_FooterPartition=(int64u)-1;
2304 RandomIndexPacks_MaxOffset=(int64u)-1;
2305 DTS_Delay=0;
2306 SDTI_TimeCode_RepetitionCount=0;
2307 SDTI_SizePerFrame=0;
2308 SDTI_IsPresent=false;
2309 SDTI_IsInIndexStreamOffset=true;
2310 #if MEDIAINFO_TRACE
2311 SDTI_SystemMetadataPack_Trace_Count=0;
2312 SDTI_PackageMetadataSet_Trace_Count=0;
2313 Padding_Trace_Count=0;
2314 #endif // MEDIAINFO_TRACE
2315 SystemScheme1_TimeCodeArray_StartTimecode_ms=(int64u)-1;
2316 SystemScheme1_FrameRateFromDescriptor=0;
2317 Essences_FirstEssence_Parsed=false;
2318 MayHaveCaptionsInStream=false;
2319 StereoscopicPictureSubDescriptor_IsPresent=false;
2320 UserDefinedAcquisitionMetadata_UdamSetIdentifier_IsSony=false;
2321 Essences_UsedForFrameCount=(int32u)-1;
2322 #if MEDIAINFO_ADVANCED
2323 Footer_Position=(int64u)-1;
2324 #endif //MEDIAINFO_ADVANCED
2325 #if MEDIAINFO_NEXTPACKET
2326 ReferenceFiles_IsParsing=false;
2327 #endif //MEDIAINFO_NEXTPACKET
2328 #if defined(MEDIAINFO_ANCILLARY_YES)
2329 Ancillary=NULL;
2330 Ancillary_IsBinded=false;
2331 #endif //defined(MEDIAINFO_ANCILLARY_YES)
2332
2333 ExtraMetadata_Offset=(int64u)-1;
2334 DolbyVisionMetadata=NULL;
2335 DolbyAudioMetadata=NULL;
2336 #if defined(MEDIAINFO_ADM_YES)
2337 Adm=NULL;
2338 #endif
2339
2340 #if MEDIAINFO_DEMUX
2341 Demux_HeaderParsed=false;
2342 #endif //MEDIAINFO_DEMUX
2343
2344 Partitions_Pos=0;
2345 Partitions_IsCalculatingHeaderByteCount=false;
2346 Partitions_IsCalculatingSdtiByteCount=false;
2347 Partitions_IsFooter=false;
2348
2349 #if MEDIAINFO_SEEK
2350 IndexTables_Pos=0;
2351 Clip_Header_Size=0;
2352 Clip_Begin=(int64u)-1;
2353 Clip_End=0;
2354 OverallBitrate_IsCbrForSure=0;
2355 Duration_Detected=false;
2356 #endif //MEDIAINFO_SEEK
2357 #if MEDIAINFO_DEMUX
2358 DemuxedSampleCount_Total=(int64u)-1;
2359 DemuxedSampleCount_Current=(int64u)-1;
2360 DemuxedSampleCount_AddedToFirstFrame=0;
2361 DemuxedElementSize_AddedToFirstFrame=0;
2362 #endif //MEDIAINFO_DEMUX
2363 }
2364
2365 //---------------------------------------------------------------------------
~File_Mxf()2366 File_Mxf::~File_Mxf()
2367 {
2368 #if defined(MEDIAINFO_ANCILLARY_YES)
2369 if (!Ancillary_IsBinded)
2370 delete Ancillary;
2371 #endif //defined(MEDIAINFO_ANCILLARY_YES)
2372
2373 for (size_t i = 0; i < AcquisitionMetadataLists.size(); i++)
2374 delete AcquisitionMetadataLists[ i ];
2375
2376 AcquisitionMetadataLists.clear();
2377
2378 for (size_t i = 0; i < AcquisitionMetadata_Sony_E201_Lists.size(); i++)
2379 delete AcquisitionMetadata_Sony_E201_Lists[ i ];
2380
2381 AcquisitionMetadata_Sony_E201_Lists.clear();
2382 delete DolbyVisionMetadata;
2383 delete DolbyAudioMetadata;
2384 #if defined(MEDIAINFO_ADM_YES)
2385 delete Adm;
2386 #endif
2387 }
2388
2389 //***************************************************************************
2390 // Streams management
2391 //***************************************************************************
2392
2393 //---------------------------------------------------------------------------
Streams_Accept()2394 void File_Mxf::Streams_Accept()
2395 {
2396 Fill(Stream_General, 0, General_Format, "MXF");
2397
2398 //Configuration
2399 Buffer_MaximumSize=64*1024*1024; //Some big frames are possible (e.g YUV 4:2:2 10 bits 1080p, 4K)
2400 File_Buffer_Size_Hint_Pointer=Config->File_Buffer_Size_Hint_Pointer_Get();
2401 }
2402
2403 //---------------------------------------------------------------------------
Streams_Fill()2404 void File_Mxf::Streams_Fill()
2405 {
2406 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
2407 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
2408 Fill(*Parser);
2409 }
2410
2411 //---------------------------------------------------------------------------
Streams_Finish()2412 void File_Mxf::Streams_Finish()
2413 {
2414 #if MEDIAINFO_NEXTPACKET && defined(MEDIAINFO_REFERENCES_YES)
2415 //Locators only
2416 if (ReferenceFiles_IsParsing)
2417 {
2418 ReferenceFiles->ParseReferences();
2419 #if MEDIAINFO_DEMUX
2420 if (Config->Demux_EventWasSent)
2421 return;
2422 #endif //MEDIAINFO_DEMUX
2423
2424 Streams_Finish_CommercialNames();
2425 return;
2426 }
2427 #endif //MEDIAINFO_NEXTPACKET && defined(MEDIAINFO_REFERENCES_YES)
2428
2429 //Per stream
2430 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
2431 {
2432 if (Essence->second.Parsers.size()>1 && Essence->second.StreamKind==Stream_Audio) // Last parser is PCM, impossible to detect with another method if there is only one block
2433 {
2434 for (size_t Pos=0; Pos<Essence->second.Parsers.size()-1; Pos++)
2435 delete Essence->second.Parsers[Pos];
2436 Essence->second.Parsers.erase(Essence->second.Parsers.begin(), Essence->second.Parsers.begin()+Essence->second.Parsers.size()-1);
2437 Essence->second.Parsers[0]->Accept();
2438 Essence->second.Parsers[0]->Fill();
2439 }
2440 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
2441 {
2442 if (!(*Parser)->Status[IsFinished])
2443 {
2444 if (Config->ParseSpeed>=1)
2445 {
2446 int64u File_Size_Temp=File_Size;
2447 File_Size=File_Offset+Buffer_Offset+Element_Offset;
2448 Open_Buffer_Continue(*Parser, Buffer, 0);
2449 File_Size=File_Size_Temp;
2450 }
2451 Finish(*Parser);
2452 #if MEDIAINFO_DEMUX
2453 if (Config->Demux_EventWasSent)
2454 return;
2455 #endif //MEDIAINFO_DEMUX
2456 }
2457 }
2458 }
2459
2460 if (!Track_Number_IsAvailable)
2461 {
2462 if (Tracks.empty())
2463 {
2464 //Clear
2465 for (size_t StreamKind=Stream_General+1; StreamKind<Stream_Max; StreamKind++)
2466 {
2467 (*Stream)[StreamKind].clear();
2468 (*Stream_More)[StreamKind].clear();
2469 }
2470 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
2471 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
2472 {
2473 Merge(*(*Parser));
2474
2475 Ztring LawRating=(*Parser)->Retrieve(Stream_General, 0, General_LawRating);
2476 if (!LawRating.empty())
2477 Fill(Stream_General, 0, General_LawRating, LawRating, true);
2478 Ztring Title=(*Parser)->Retrieve(Stream_General, 0, General_Title);
2479 if (!Title.empty() && Retrieve(Stream_General, 0, General_Title).empty())
2480 Fill(Stream_General, 0, General_Title, Title);
2481
2482 if (IsSub && StreamKind_Last!=Stream_Max && Retrieve(StreamKind_Last, StreamPos_Last, "MuxingMode").empty())
2483 Fill(StreamKind_Last, StreamPos_Last, "MuxingMode", "MXF");
2484 }
2485 }
2486 else
2487 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
2488 {
2489 //Searching the corresponding Descriptor
2490 stream_t StreamKind=Stream_Max;
2491 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
2492 if (Descriptor->second.LinkedTrackID==Track->second.TrackID)
2493 {
2494 StreamKind=Descriptor->second.StreamKind;
2495 break;
2496 }
2497 if (StreamKind!=Stream_Max)
2498 {
2499 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
2500 if (Essence->second.StreamKind==StreamKind && !Essence->second.Track_Number_IsMappedToTrack)
2501 {
2502 Track->second.TrackNumber=Essence->first;
2503 Essence->second.Track_Number_IsMappedToTrack=true;
2504 break;
2505 }
2506 }
2507 }
2508 }
2509
2510 File_Size_Total=File_Size;
2511 StreamKind_Last=Stream_Max;
2512 StreamPos_Last=(size_t)-1;
2513
2514 Streams_Finish_Preface(Preface_Current);
2515
2516 //OperationalPattern
2517 Fill(Stream_General, 0, General_Format_Profile, Mxf_OperationalPattern(OperationalPattern));
2518
2519 //Time codes
2520 if (SDTI_TimeCode_StartTimecode.IsValid())
2521 {
2522 bool IsDuplicate=false;
2523 for (size_t Pos2=0; Pos2<Count_Get(Stream_Other); Pos2++)
2524 if (Retrieve(Stream_Other, Pos2, "TimeCode_Source")==__T("SDTI"))
2525 IsDuplicate=true;
2526 if (!IsDuplicate)
2527 {
2528 Fill_Flush();
2529 Stream_Prepare(Stream_Other);
2530 Fill(Stream_Other, StreamPos_Last, Other_Type, "Time code");
2531 Fill(Stream_Other, StreamPos_Last, Other_Format, "SMPTE TC");
2532 Fill(Stream_Other, StreamPos_Last, Other_MuxingMode, "SDTI");
2533 Fill(Stream_Other, StreamPos_Last, Other_TimeCode_FirstFrame, SDTI_TimeCode_StartTimecode.ToString());
2534 Fill(Stream_Other, StreamPos_Last, Other_FrameRate, SDTI_TimeCode_StartTimecode.FramesPerSecond/(SDTI_TimeCode_StartTimecode.DropFrame?1.001:1.000)*(SDTI_TimeCode_StartTimecode.MustUseSecondField?2:1));
2535 }
2536 }
2537 if (SystemScheme1_TimeCodeArray_StartTimecode_ms!=(int64u)-1)
2538 {
2539 bool IsDuplicate=false;
2540 for (size_t Pos2=0; Pos2<Count_Get(Stream_Other); Pos2++)
2541 if (Retrieve(Stream_Other, Pos2, "TimeCode_Source")==__T("System scheme 1"))
2542 IsDuplicate=true;
2543 if (!IsDuplicate)
2544 {
2545 Fill_Flush();
2546 Stream_Prepare(Stream_Other);
2547 Fill(Stream_Other, StreamPos_Last, Other_Type, "Time code");
2548 Fill(Stream_Other, StreamPos_Last, Other_Format, "SMPTE TC");
2549 Fill(Stream_Other, StreamPos_Last, Other_MuxingMode, "System scheme 1");
2550 Fill(Stream_Other, StreamPos_Last, Other_TimeCode_FirstFrame, SystemScheme1_TimeCodeArray_StartTimecode.c_str());
2551 }
2552 }
2553
2554 //Parsing locators
2555 Locators_Test();
2556 #if defined(MEDIAINFO_REFERENCES_YES) && MEDIAINFO_NEXTPACKET
2557 if (Config->NextPacket_Get() && ReferenceFiles)
2558 {
2559 ReferenceFiles_IsParsing=true;
2560 return;
2561 }
2562 #endif //MEDIAINFO_NEXTPACKET
2563
2564 //Sizes
2565 #if MEDIAINFO_ADVANCED
2566 if (Footer_Position!=(int64u)-1)
2567 Fill(Stream_General, 0, General_FooterSize, File_Size-Footer_Position);
2568 else
2569 Fill(Stream_General, 0, "IsTruncated", "Yes", Unlimited, true, true);
2570 #endif //MEDIAINFO_ADVANCED
2571
2572 //Commercial names
2573 Streams_Finish_CommercialNames();
2574
2575 //Handling separate streams
2576 for (size_t StreamKind=Stream_General+1; StreamKind<Stream_Max; StreamKind++)
2577 for (size_t StreamPos=0; StreamPos<Count_Get((stream_t)StreamKind); StreamPos++)
2578 if (Retrieve((stream_t)StreamKind, StreamPos, Fill_Parameter((stream_t)StreamKind, Generic_StreamSize_Encoded)).empty() && !Retrieve((stream_t)StreamKind, StreamPos, Fill_Parameter((stream_t)StreamKind, Generic_BitRate_Encoded)).empty() && !Retrieve((stream_t)StreamKind, StreamPos, Fill_Parameter((stream_t)StreamKind, Generic_Duration)).empty())
2579 {
2580 float64 BitRate_Encoded=Retrieve((stream_t)StreamKind, StreamPos, Fill_Parameter((stream_t)StreamKind, Generic_BitRate_Encoded)).To_float64();
2581 float64 Duration=Retrieve((stream_t)StreamKind, StreamPos, Fill_Parameter((stream_t)StreamKind, Generic_Duration)).To_float64();
2582 if (Duration)
2583 Fill((stream_t)StreamKind, StreamPos, Fill_Parameter((stream_t)StreamKind, Generic_StreamSize_Encoded), BitRate_Encoded/8*(Duration/1000), 0);
2584 }
2585
2586 //File size in case of partial file analysis
2587 if (Config->File_IgnoreEditsBefore || Config->File_IgnoreEditsAfter!=(int64u)-1)
2588 {
2589 int64u FrameCount_FromComponent=(int64u)-1;
2590 for (components::iterator Component=Components.begin(); Component!=Components.end(); ++Component)
2591 if (FrameCount_FromComponent>Component->second.Duration)
2592 FrameCount_FromComponent=Component->second.Duration;
2593 float64 EditRate_FromTrack=DBL_MAX;
2594 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
2595 if (EditRate_FromTrack>Track->second.EditRate)
2596 EditRate_FromTrack=Track->second.EditRate;
2597 if (FrameCount_FromComponent!=(int64u)-1 && FrameCount_FromComponent && EditRate_FromTrack!=DBL_MAX && EditRate_FromTrack)
2598 {
2599 int64u FrameCount=FrameCount_FromComponent;
2600 int64u File_IgnoreEditsBefore=Config->File_IgnoreEditsBefore;
2601 if (File_IgnoreEditsBefore && Config->File_EditRate && (EditRate_FromTrack<Config->File_EditRate*0.9 || EditRate_FromTrack>Config->File_EditRate*1.1)) //In case of problem or EditRate being sampling rate
2602 File_IgnoreEditsBefore=float64_int64s(((float64)File_IgnoreEditsBefore)/Config->File_EditRate*EditRate_FromTrack);
2603 int64u File_IgnoreEditsAfter=Config->File_IgnoreEditsAfter;
2604 if (File_IgnoreEditsAfter!=(int64u)-1 && Config->File_EditRate && (EditRate_FromTrack<Config->File_EditRate*0.9 || EditRate_FromTrack>Config->File_EditRate*1.1)) //In case of problem or EditRate being sampling rate
2605 File_IgnoreEditsAfter=float64_int64s(((float64)File_IgnoreEditsAfter)/Config->File_EditRate*EditRate_FromTrack);
2606 if (File_IgnoreEditsAfter<FrameCount)
2607 FrameCount=File_IgnoreEditsAfter;
2608 if (FrameCount<File_IgnoreEditsBefore)
2609 FrameCount=File_IgnoreEditsBefore;
2610 FrameCount-=File_IgnoreEditsBefore;
2611
2612 float64 File_Size_Temp=(float64)File_Size;
2613 File_Size_Temp/=FrameCount_FromComponent;
2614 File_Size_Temp*=FrameCount;
2615 Fill(Stream_General, 0, General_FileSize, File_Size_Temp, 0, true);
2616 }
2617 }
2618
2619 //System scheme 1
2620 for (systemschemes::iterator SystemScheme=SystemSchemes.begin(); SystemScheme!=SystemSchemes.end(); ++SystemScheme)
2621 {
2622 if (!SystemScheme->second.IsTimeCode) //Already done somewhere else
2623 {
2624 Fill_Flush(); //TODO: remove it there is a refactoring
2625 Stream_Prepare(Stream_Other);
2626 Fill(Stream_Other, StreamPos_Last, "ID", __T("System scheme 1-")+Ztring().From_Number((int8u)(SystemScheme->first>8))+__T('-')+Ztring().From_Number((int8u)(SystemScheme->first&0xFF)));
2627 Fill(Stream_Other, StreamPos_Last, "MuxingMode", "System scheme 1");
2628 }
2629 }
2630
2631 //Primary package info
2632 bool PrimaryPackageIsSourcePackage=false;
2633 bool PrimaryPackageIsMaterialPackage=false;
2634 for (prefaces::iterator Preface=Prefaces.begin(); Preface!=Prefaces.end(); ++Preface)
2635 {
2636 for (packages::iterator Package=Packages.begin(); Package!=Packages.end(); ++Package)
2637 if (Package->first==Preface->second.PrimaryPackage)
2638 {
2639 if (Package->second.IsSourcePackage)
2640 PrimaryPackageIsSourcePackage=true;
2641 else
2642 PrimaryPackageIsMaterialPackage=true;
2643 }
2644 }
2645 if (PrimaryPackageIsSourcePackage && !PrimaryPackageIsMaterialPackage)
2646 {
2647 Fill(Stream_General, 0, "PrimaryPackage", "Source Package");
2648 Fill_SetOptions(Stream_General, 0, "PrimaryPackage", "N NT");
2649 }
2650 if (!PrimaryPackageIsSourcePackage && PrimaryPackageIsMaterialPackage)
2651 {
2652 Fill(Stream_General, 0, "PrimaryPackage", "Material Package");
2653 Fill_SetOptions(Stream_General, 0, "PrimaryPackage", "N NT");
2654 }
2655
2656 //CameraUnitMetadata
2657 if (!AcquisitionMetadataLists.empty())
2658 {
2659 Stream_Prepare(Stream_Other);
2660
2661 for (size_t Pos = 0; Pos < AcquisitionMetadataLists.size(); Pos++)
2662 {
2663 if (UserDefinedAcquisitionMetadata_UdamSetIdentifier_IsSony && Pos==0xE201 && !AcquisitionMetadata_Sony_E201_Lists.empty())
2664 {
2665 for (size_t i=0; i<Mxf_AcquisitionMetadata_Sony_E201_ElementCount; ++i)
2666 if (AcquisitionMetadata_Sony_E201_Lists[i] && !AcquisitionMetadata_Sony_E201_Lists[i]->empty())
2667 {
2668 string ElementName(Mxf_AcquisitionMetadata_Sony_E201_ElementName[i]);
2669 string ElementName_FirstFrame(ElementName+"_FirstFrame");
2670 string ElementName_Values(ElementName+"_Values");
2671 string ElementName_FrameCounts(ElementName+"_FrameCounts");
2672 Fill(Stream_Other, 0, ElementName_FirstFrame.c_str(), (*AcquisitionMetadata_Sony_E201_Lists[i])[0].Value);
2673 switch (i)
2674 {
2675 case 0 : //FocusDistance
2676 case 4 : //HyperfocalDistance
2677 case 5 : //NearFocusDistance
2678 case 6 : //FarFocusDistance
2679 case 8 : //EntrancePupilPosition
2680 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2681 if (AcquisitionMetadataLists[0xE203] && !AcquisitionMetadataLists[0xE203]->empty()) //Calibration Type
2682 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadata_Sony_E201_Lists[i])[0].Value+' '+(*AcquisitionMetadataLists[0xE203])[0].Value);
2683 break;
2684 case 3 : //EffectiveFocaleLength
2685 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2686 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadata_Sony_E201_Lists[i])[0].Value+" mm");
2687 break;
2688 case 7 : //HorizontalFieldOfView
2689 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2690 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadata_Sony_E201_Lists[i])[0].Value+"\xc2\xB0");
2691 break;
2692 default : ;
2693 }
2694 for (size_t List_Pos=0; List_Pos<AcquisitionMetadata_Sony_E201_Lists[i]->size(); List_Pos++)
2695 {
2696 Fill(Stream_Other, 0, ElementName_Values.c_str(), (*AcquisitionMetadata_Sony_E201_Lists[i])[List_Pos].Value);
2697 Fill(Stream_Other, 0, ElementName_FrameCounts.c_str(), (*AcquisitionMetadata_Sony_E201_Lists[i])[List_Pos].FrameCount);
2698 }
2699 Fill_SetOptions(Stream_Other, 0, ElementName_Values.c_str(), "N NT");
2700 Fill_SetOptions(Stream_Other, 0, ElementName_FrameCounts.c_str(), "N NT");
2701 }
2702 }
2703 else if (AcquisitionMetadataLists[Pos] && !AcquisitionMetadataLists[Pos]->empty())
2704 {
2705 string ElementName(Mxf_AcquisitionMetadata_ElementName((int16u)Pos, UserDefinedAcquisitionMetadata_UdamSetIdentifier_IsSony));
2706 string ElementName_FirstFrame(ElementName+"_FirstFrame");
2707 string ElementName_Values(ElementName+"_Values");
2708 string ElementName_FrameCounts(ElementName+"_FrameCounts");
2709 Fill(Stream_Other, 0, ElementName_FirstFrame.c_str(), (*AcquisitionMetadataLists[Pos])[0].Value);
2710 switch (Pos)
2711 {
2712 case 0x8001 : //FocusPosition_ImagePlane
2713 case 0x8002 : //FocusPosition_FrontLensVertex
2714 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2715 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" m");
2716 break;
2717 case 0x8004 : //LensZoom35mmStillCameraEquivalent
2718 case 0x8005 : //LensZoomActualFocalLength
2719 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2720 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" mm");
2721 break;
2722 case 0x8006 : //OpticalExtenderMagnification
2723 case 0x8009 : //IrisRingPosition
2724 case 0x800A : //FocusRingPosition
2725 case 0x800B : //ZoomRingPosition
2726 case 0x810C : //ElectricalExtenderMagnification
2727 case 0x810F : //CameraMasterBlackLevel
2728 case 0x8110 : //CameraKneePoint
2729 case 0x8112 : //CameraLuminanceDynamicRange
2730 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2731 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+"%");
2732 break;
2733 case 0x8104 : //ImagerDimension_EffectiveWidth
2734 case 0x8105 : //ImagerDimension_EffectiveHeight
2735 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2736 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" mm");
2737 break;
2738 case 0x8106 : //CaptureFrameRate
2739 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2740 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" fps");
2741 break;
2742 case 0x8108 : //ShutterSpeed_Angle
2743 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2744 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+"\xc2\xB0");
2745 break;
2746 case 0x8109 : //ShutterSpeed_Time
2747 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2748 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" s");
2749 break;
2750 case 0x810A : //CameraMasterGainAdjustment
2751 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2752 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" dB");
2753 break;
2754 case 0x810E : //WhiteBalance
2755 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2756 Fill(Stream_Other, 0, (ElementName_FirstFrame+"/String").c_str(), (*AcquisitionMetadataLists[Pos])[0].Value+" K");
2757 break;
2758 default : ;
2759 }
2760 if (UserDefinedAcquisitionMetadata_UdamSetIdentifier_IsSony && Pos==0xE203) // Calibration Type, not for display
2761 Fill_SetOptions(Stream_Other, 0, ElementName_FirstFrame.c_str(), "N NT");
2762 for (size_t List_Pos=0; List_Pos<AcquisitionMetadataLists[Pos]->size(); List_Pos++)
2763 {
2764 Fill(Stream_Other, 0, ElementName_Values.c_str(), (*AcquisitionMetadataLists[Pos])[List_Pos].Value);
2765 Fill(Stream_Other, 0, ElementName_FrameCounts.c_str(), (*AcquisitionMetadataLists[Pos])[List_Pos].FrameCount);
2766 }
2767 Fill_SetOptions(Stream_Other, 0, ElementName_Values.c_str(), "N NT");
2768 Fill_SetOptions(Stream_Other, 0, ElementName_FrameCounts.c_str(), "N NT");
2769 }
2770 }
2771 }
2772
2773 //Metadata
2774 if (DolbyVisionMetadata)
2775 Merge(*DolbyVisionMetadata, Stream_Video, 0, 0);
2776 if (DolbyAudioMetadata) //Before ADM for having content before all ADM stuff
2777 Merge(*DolbyAudioMetadata, Stream_Audio, 0, 0);
2778 if (Adm)
2779 Merge(*Adm, Stream_Audio, 0, 0);
2780 if (Adm && (!DolbyAudioMetadata || !DolbyAudioMetadata->HasSegment9) && Retrieve_Const(Stream_Audio, 0, "AdmProfile_Format")==__T("Dolby Atmos Master"))
2781 {
2782 Clear(Stream_Audio, 0, "AdmProfile");
2783 Clear(Stream_Audio, 0, "AdmProfile_Format");
2784 Clear(Stream_Audio, 0, "AdmProfile_Version");
2785 }
2786 }
2787
2788 //---------------------------------------------------------------------------
Streams_Finish_Preface(const int128u PrefaceUID)2789 void File_Mxf::Streams_Finish_Preface (const int128u PrefaceUID)
2790 {
2791 prefaces::iterator Preface=Prefaces.find(PrefaceUID);
2792 if (Preface==Prefaces.end())
2793 return;
2794
2795 //ContentStorage
2796 Streams_Finish_ContentStorage(Preface->second.ContentStorage);
2797
2798 //ContenStorage, for AS11
2799 Streams_Finish_ContentStorage_ForAS11(Preface->second.ContentStorage);
2800
2801 //Identifications
2802 for (size_t Pos=0; Pos<Preface->second.Identifications.size(); Pos++)
2803 Streams_Finish_Identification(Preface->second.Identifications[Pos]);
2804 }
2805
2806 //---------------------------------------------------------------------------
Streams_Finish_Preface_ForTimeCode(const int128u PrefaceUID)2807 void File_Mxf::Streams_Finish_Preface_ForTimeCode (const int128u PrefaceUID)
2808 {
2809 prefaces::iterator Preface=Prefaces.find(PrefaceUID);
2810 if (Preface==Prefaces.end())
2811 return;
2812
2813 //ContentStorage
2814 Streams_Finish_ContentStorage_ForTimeCode(Preface->second.ContentStorage);
2815 }
2816
2817 //---------------------------------------------------------------------------
Streams_Finish_ContentStorage(const int128u ContentStorageUID)2818 void File_Mxf::Streams_Finish_ContentStorage (const int128u ContentStorageUID)
2819 {
2820 contentstorages::iterator ContentStorage=ContentStorages.find(ContentStorageUID);
2821 if (ContentStorage==ContentStorages.end())
2822 return;
2823
2824 for (size_t Pos=0; Pos<ContentStorage->second.Packages.size(); Pos++)
2825 Streams_Finish_Package(ContentStorage->second.Packages[Pos]);
2826 }
2827
2828 //---------------------------------------------------------------------------
Streams_Finish_ContentStorage_ForTimeCode(const int128u ContentStorageUID)2829 void File_Mxf::Streams_Finish_ContentStorage_ForTimeCode (const int128u ContentStorageUID)
2830 {
2831 contentstorages::iterator ContentStorage=ContentStorages.find(ContentStorageUID);
2832 if (ContentStorage==ContentStorages.end())
2833 return;
2834
2835 //Searching the right Time code track first TODO: this is an hack in order to get material or source time code, we need to have something more conform in the future
2836 // Material Package then Source Package
2837 for (size_t Pos=0; Pos<ContentStorage->second.Packages.size(); Pos++)
2838 {
2839 packages::iterator Package=Packages.find(ContentStorage->second.Packages[Pos]);
2840 if (Package!=Packages.end() && !Package->second.IsSourcePackage)
2841 Streams_Finish_Package_ForTimeCode(ContentStorage->second.Packages[Pos]);
2842 }
2843 for (size_t Pos=0; Pos<ContentStorage->second.Packages.size(); Pos++)
2844 {
2845 packages::iterator Package=Packages.find(ContentStorage->second.Packages[Pos]);
2846 if (Package!=Packages.end() && Package->second.IsSourcePackage)
2847 Streams_Finish_Package_ForTimeCode(ContentStorage->second.Packages[Pos]);
2848 }
2849 }
2850
2851 //---------------------------------------------------------------------------
Streams_Finish_ContentStorage_ForAS11(const int128u ContentStorageUID)2852 void File_Mxf::Streams_Finish_ContentStorage_ForAS11 (const int128u ContentStorageUID)
2853 {
2854 contentstorages::iterator ContentStorage=ContentStorages.find(ContentStorageUID);
2855 if (ContentStorage==ContentStorages.end())
2856 return;
2857
2858 for (size_t Pos=0; Pos<ContentStorage->second.Packages.size(); Pos++)
2859 Streams_Finish_Package_ForAS11(ContentStorage->second.Packages[Pos]);
2860 }
2861
2862 //---------------------------------------------------------------------------
Streams_Finish_Package(const int128u PackageUID)2863 void File_Mxf::Streams_Finish_Package (const int128u PackageUID)
2864 {
2865 packages::iterator Package=Packages.find(PackageUID);
2866 if (Package==Packages.end() || !Package->second.IsSourcePackage)
2867 return;
2868
2869 for (size_t Pos=0; Pos<Package->second.Tracks.size(); Pos++)
2870 Streams_Finish_Track(Package->second.Tracks[Pos]);
2871
2872 Streams_Finish_Descriptor(Package->second.Descriptor, PackageUID);
2873 }
2874
2875 //---------------------------------------------------------------------------
Streams_Finish_Package_ForTimeCode(const int128u PackageUID)2876 void File_Mxf::Streams_Finish_Package_ForTimeCode (const int128u PackageUID)
2877 {
2878 packages::iterator Package=Packages.find(PackageUID);
2879 if (Package==Packages.end())
2880 return;
2881
2882 for (size_t Pos=0; Pos<Package->second.Tracks.size(); Pos++)
2883 Streams_Finish_Track_ForTimeCode(Package->second.Tracks[Pos], Package->second.IsSourcePackage);
2884 }
2885
2886 //---------------------------------------------------------------------------
Streams_Finish_Package_ForAS11(const int128u PackageUID)2887 void File_Mxf::Streams_Finish_Package_ForAS11 (const int128u PackageUID)
2888 {
2889 packages::iterator Package=Packages.find(PackageUID);
2890 if (Package==Packages.end() || Package->second.IsSourcePackage)
2891 return;
2892
2893 for (size_t Pos=0; Pos<Package->second.Tracks.size(); Pos++)
2894 Streams_Finish_Track_ForAS11(Package->second.Tracks[Pos]);
2895 }
2896
2897 //---------------------------------------------------------------------------
Streams_Finish_Track(const int128u TrackUID)2898 void File_Mxf::Streams_Finish_Track(const int128u TrackUID)
2899 {
2900 tracks::iterator Track=Tracks.find(TrackUID);
2901 if (Track==Tracks.end() || Track->second.Stream_Finish_Done)
2902 return;
2903
2904 StreamKind_Last=Stream_Max;
2905 StreamPos_Last=(size_t)-1;
2906
2907 Streams_Finish_Essence(Track->second.TrackNumber, TrackUID);
2908
2909 //Sequence
2910 Streams_Finish_Component(Track->second.Sequence, Track->second.EditRate_Real?Track->second.EditRate_Real:Track->second.EditRate, Track->second.TrackID, Track->second.Origin);
2911
2912 //Done
2913 Track->second.Stream_Finish_Done=true;
2914 }
2915
2916 //---------------------------------------------------------------------------
Streams_Finish_Track_ForTimeCode(const int128u TrackUID,bool IsSourcePackage)2917 void File_Mxf::Streams_Finish_Track_ForTimeCode(const int128u TrackUID, bool IsSourcePackage)
2918 {
2919 tracks::iterator Track=Tracks.find(TrackUID);
2920 if (Track==Tracks.end() || Track->second.Stream_Finish_Done)
2921 return;
2922
2923 StreamKind_Last=Stream_Max;
2924 StreamPos_Last=(size_t)-1;
2925
2926 //Sequence
2927 Streams_Finish_Component_ForTimeCode(Track->second.Sequence, Track->second.EditRate_Real?Track->second.EditRate_Real:Track->second.EditRate, Track->second.TrackID, Track->second.Origin, IsSourcePackage, Track->second.TrackName);
2928 }
2929
2930 //---------------------------------------------------------------------------
Streams_Finish_Track_ForAS11(const int128u TrackUID)2931 void File_Mxf::Streams_Finish_Track_ForAS11(const int128u TrackUID)
2932 {
2933 tracks::iterator Track=Tracks.find(TrackUID);
2934 if (Track==Tracks.end() || Track->second.Stream_Finish_Done)
2935 return;
2936
2937 StreamKind_Last=Stream_Max;
2938 StreamPos_Last=(size_t)-1;
2939
2940 //Sequence
2941 Streams_Finish_Component_ForAS11(Track->second.Sequence, Track->second.EditRate_Real?Track->second.EditRate_Real:Track->second.EditRate, Track->second.TrackID, Track->second.Origin);
2942
2943 //TrackName
2944 if (StreamKind_Last!=Stream_Max && !Track->second.TrackName.empty())
2945 Fill(StreamKind_Last, StreamPos_Last, "Title", Track->second.TrackName);
2946
2947 //Done
2948 Track->second.Stream_Finish_Done=true;
2949 }
2950
2951 //---------------------------------------------------------------------------
Streams_Finish_Essence(int32u EssenceUID,int128u TrackUID)2952 void File_Mxf::Streams_Finish_Essence(int32u EssenceUID, int128u TrackUID)
2953 {
2954 essences::iterator Essence=Essences.find(EssenceUID);
2955 if (Essence==Essences.end() || Essence->second.Stream_Finish_Done)
2956 return;
2957
2958 if (Essence->second.Parsers.size()!=1)
2959 return;
2960 parsers::iterator Parser=Essence->second.Parsers.begin();
2961
2962 //Descriptive Metadata
2963 std::vector<int128u> DMScheme1s_List;
2964 int32u TrackID=(int32u)-1;
2965 tracks::iterator Track=Tracks.find(TrackUID);
2966 if (Track!=Tracks.end())
2967 TrackID=Track->second.TrackID;
2968
2969 for (dmsegments::iterator DMSegment=DMSegments.begin(); DMSegment!=DMSegments.end(); ++DMSegment)
2970 for (size_t Pos=0; Pos<DMSegment->second.TrackIDs.size(); Pos++)
2971 if (DMSegment->second.TrackIDs[Pos]==TrackID)
2972 DMScheme1s_List.push_back(DMSegment->second.Framework);
2973
2974 if (Config->ParseSpeed<1.0 && !(*Parser)->Status[IsFinished])
2975 {
2976 Fill(*Parser);
2977 (*Parser)->Open_Buffer_Unsynch();
2978 }
2979 Finish(*Parser);
2980 StreamKind_Last=Stream_Max;
2981 if ((*Parser)->Count_Get(Stream_Video))
2982 {
2983 Stream_Prepare(Stream_Video);
2984 if (IsSub)
2985 Fill(Stream_Video, StreamPos_Last, Video_MuxingMode, "MXF");
2986 }
2987 else if ((*Parser)->Count_Get(Stream_Audio))
2988 Stream_Prepare(Stream_Audio);
2989 else if ((*Parser)->Count_Get(Stream_Text))
2990 Stream_Prepare(Stream_Text);
2991 else if ((*Parser)->Count_Get(Stream_Other))
2992 Stream_Prepare(Stream_Other);
2993 else if (Essence->second.StreamKind!=Stream_Max)
2994 Stream_Prepare(Essence->second.StreamKind);
2995 else
2996 {
2997 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
2998 if (Descriptor->second.LinkedTrackID==Essence->second.TrackID)
2999 {
3000 if (Descriptor->second.StreamKind!=Stream_Max)
3001 {
3002 Stream_Prepare(Descriptor->second.StreamKind);
3003 Descriptor->second.StreamPos=StreamPos_Last;
3004 }
3005 break;
3006 }
3007 if (StreamKind_Last==Stream_Max)
3008 return; //Not found
3009 }
3010 if (IsSub)
3011 Fill(StreamKind_Last, StreamPos_Last, "MuxingMode", "MXF");
3012
3013 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
3014 if (Descriptor->second.LinkedTrackID==Essence->second.TrackID)
3015 {
3016 if (Descriptor->second.StreamKind!=Stream_Max)
3017 Descriptor->second.StreamPos=StreamPos_Last;
3018 break;
3019 }
3020
3021 for (std::map<std::string, Ztring>::iterator Info=Essence->second.Infos.begin(); Info!=Essence->second.Infos.end(); ++Info)
3022 Fill(StreamKind_Last, StreamPos_Last, Info->first.c_str(), Info->second, true);
3023 if (MxfTimeCodeForDelay.IsInit())
3024 {
3025 const float64 TimeCode_StartTimecode_Temp = MxfTimeCodeForDelay.Get_TimeCode_StartTimecode_Temp(Config->File_IgnoreEditsBefore);
3026 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Delay), TimeCode_StartTimecode_Temp*1000, 0, true);
3027 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Delay_Source), "Container");
3028 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Delay_DropFrame), MxfTimeCodeForDelay.DropFrame?"Yes":"No");
3029
3030 //TimeCode TC(MxfTimeCodeForDelay.StartTimecode, MxfTimeCodeForDelay.RoundedTimecodeBase, MxfTimeCodeForDelay.DropFrame);
3031 //Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_TimeCode_FirstFrame), TC.ToString().c_str());
3032 //Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_TimeCode_Source), "Time code track (stripped)");
3033 }
3034 if (SDTI_TimeCode_StartTimecode.IsValid())
3035 {
3036 Fill(StreamKind_Last, StreamPos_Last, "Delay_SDTI", SDTI_TimeCode_StartTimecode.ToMilliseconds());
3037 if (StreamKind_Last!=Stream_Max)
3038 Fill_SetOptions(StreamKind_Last, StreamPos_Last, "Delay_SDTI", "N NT");
3039
3040 //Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_TimeCode_FirstFrame), SDTI_TimeCode_StartTimecode.c_str());
3041 //Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_TimeCode_Source), "SDTI");
3042 }
3043 if (SystemScheme1_TimeCodeArray_StartTimecode_ms!=(int64u)-1)
3044 {
3045 Fill(StreamKind_Last, StreamPos_Last, "Delay_SystemScheme1", SystemScheme1_TimeCodeArray_StartTimecode_ms);
3046 if (StreamKind_Last!=Stream_Max)
3047 Fill_SetOptions(StreamKind_Last, StreamPos_Last, "Delay_SystemScheme1", "N NT");
3048
3049 //Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_TimeCode_FirstFrame), SystemScheme1_TimeCodeArray_StartTimecode.c_str());
3050 //Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_TimeCode_Source), "System scheme 1");
3051 }
3052
3053 //Special case - Multiple sub-streams in a stream
3054 if (((*Parser)->Retrieve(Stream_General, 0, General_Format)==__T("ChannelGrouping") || (*Parser)->Count_Get(StreamKind_Last)>1) && (*Parser)->Count_Get(Stream_Audio))
3055 {
3056 //Before
3057 if (StreamKind_Last==Stream_Audio)
3058 {
3059 Clear(Stream_Audio, StreamPos_Last, Audio_Format_Settings_Sign);
3060 }
3061 ZtringList StreamSave; StreamSave.Write((*File__Analyze::Stream)[StreamKind_Last][StreamPos_Last].Read());
3062 ZtringListList StreamMoreSave; StreamMoreSave.Write((*Stream_More)[StreamKind_Last][StreamPos_Last].Read());
3063
3064 //Erasing former streams data
3065 stream_t NewKind=StreamKind_Last;
3066 size_t NewPos1;
3067 Ztring ID;
3068 if ((*Parser)->Retrieve(Stream_General, 0, General_Format)==__T("ChannelGrouping"))
3069 {
3070 //Searching second stream
3071 size_t StreamPos_Difference=Essence->second.StreamPos-Essence->second.StreamPos_Initial;
3072 essences::iterator Essence1=Essence;
3073 --Essence1;
3074 Essence->second.StreamPos=Essence1->second.StreamPos;
3075 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
3076 {
3077 if (Descriptor->second.LinkedTrackID==Essence1->second.TrackID)
3078 Descriptor->second.StreamPos=Essence1->second.StreamPos;
3079 if (Descriptor->second.LinkedTrackID==Essence->second.TrackID)
3080 Descriptor->second.StreamPos=Essence->second.StreamPos;
3081 }
3082
3083 //Removing the 2 corresponding streams
3084 NewPos1=Essence->second.StreamPos_Initial-1+StreamPos_Difference;
3085 ID=Ztring::ToZtring(Essence1->second.TrackID)+__T(" / ")+Ztring::ToZtring(Essence->second.TrackID);
3086
3087 Stream_Erase(NewKind, NewPos1+1);
3088 Stream_Erase(NewKind, NewPos1);
3089
3090 essences::iterator NextStream=Essence1;
3091 ++NextStream;
3092 size_t NewAudio_Count=Essence->second.Parsers[0]->Count_Get(Stream_Audio);
3093 while (NextStream!=Essences.end())
3094 {
3095 if (NextStream->second.StreamKind==Stream_Audio)
3096 {
3097 NextStream->second.StreamPos-=2;
3098 NextStream->second.StreamPos+=NewAudio_Count;
3099 NextStream->second.StreamPos_Initial-=2;
3100 NextStream->second.StreamPos_Initial+=NewAudio_Count;
3101 }
3102 ++NextStream;
3103 }
3104 }
3105 else
3106 {
3107 NewPos1=StreamPos_Last;
3108 ID=Ztring::ToZtring(Essence->second.TrackID);
3109 Stream_Erase(NewKind, NewPos1);
3110 }
3111
3112 //After
3113 for (size_t StreamPos=0; StreamPos<(*Parser)->Count_Get(NewKind); StreamPos++)
3114 {
3115 Stream_Prepare(NewKind, NewPos1+StreamPos);
3116 Merge(*(*Parser), StreamKind_Last, StreamPos, StreamPos_Last);
3117 Ztring Parser_ID=Retrieve(StreamKind_Last, StreamPos_Last, General_ID);
3118 Fill(StreamKind_Last, StreamPos_Last, General_ID, ID+(Parser_ID.empty()?Ztring():(__T("-")+Parser_ID)), true);
3119 for (size_t Pos=0; Pos<StreamSave.size(); Pos++)
3120 {
3121 if (Pos==Fill_Parameter(StreamKind_Last, Generic_BitRate) && (*Parser)->Count_Get(NewKind)>1 && (!StreamSave[Pos].empty() || StreamPos))
3122 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate_Encoded), StreamPos?0:(StreamSave[Pos].To_int64u()*2), 10, true);
3123 else if (Pos==Fill_Parameter(StreamKind_Last, Generic_StreamSize) && (*Parser)->Count_Get(NewKind)>1 && (!StreamSave[Pos].empty() || StreamPos))
3124 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_StreamSize_Encoded), StreamPos?0:(StreamSave[Pos].To_int64u()*2), 10, true);
3125 else if (Retrieve(StreamKind_Last, StreamPos_Last, Pos).empty())
3126 Fill(StreamKind_Last, StreamPos_Last, Pos, StreamSave[Pos]);
3127 }
3128 for (size_t Pos=0; Pos<StreamMoreSave.size(); Pos++)
3129 {
3130 Fill(StreamKind_Last, StreamPos_Last, StreamMoreSave(Pos, 0).To_UTF8().c_str(), StreamMoreSave(Pos, 1));
3131 if (StreamMoreSave(Pos, Info_Name)==__T("Delay_SDTI"))
3132 Fill_SetOptions(StreamKind_Last, StreamPos_Last, "Delay_SDTI", "N NT");
3133 if (StreamMoreSave(Pos, Info_Name)==__T("Delay_SystemScheme1"))
3134 Fill_SetOptions(StreamKind_Last, StreamPos_Last, "Delay_SystemScheme1", "N NT");
3135 }
3136
3137 for (size_t Pos=0; Pos<DMScheme1s_List.size(); Pos++)
3138 {
3139 dmscheme1s::iterator DMScheme1=DMScheme1s.find(DMScheme1s_List[Pos]);
3140 if (DMScheme1!=DMScheme1s.end())
3141 {
3142 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Language), DMScheme1->second.PrimaryExtendedSpokenLanguage, true);
3143 }
3144 }
3145 }
3146 }
3147 else //Normal
3148 {
3149 //From descriptor
3150 if ((*Parser)->Retrieve(Stream_Audio, StreamPos_Last, Audio_Format)==__T("PCM")) // MXF handles channel count only with PCM, not with compressed data
3151 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
3152 if (Descriptor->second.LinkedTrackID==Essence->second.TrackID && Descriptor->second.StreamKind==Stream_Audio && StreamKind_Last==Stream_Audio && Descriptor->second.ChannelCount!=(int32u)-1)
3153 {
3154 Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, Descriptor->second.ChannelCount);
3155 break;
3156 }
3157
3158 MergedStreams_Last.clear(); //TODO: better way to do this
3159
3160 Merge(*(*Parser), StreamKind_Last, 0, StreamPos_Last);
3161 MergedStreams_Last.push_back(streamidentity(StreamKind_Last, StreamPos_Last));
3162
3163 Ztring LawRating=(*Parser)->Retrieve(Stream_General, 0, General_LawRating);
3164 if (!LawRating.empty())
3165 Fill(Stream_General, 0, General_LawRating, LawRating, true);
3166 Ztring Title=(*Parser)->Retrieve(Stream_General, 0, General_Title);
3167 if (!Title.empty() && Retrieve(Stream_General, 0, General_Title).empty())
3168 Fill(Stream_General, 0, General_Title, Title);
3169
3170 for (size_t Pos=0; Pos<DMScheme1s_List.size(); Pos++)
3171 {
3172 dmscheme1s::iterator DMScheme1=DMScheme1s.find(DMScheme1s_List[Pos]);
3173 if (DMScheme1!=DMScheme1s.end())
3174 {
3175 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Language), DMScheme1->second.PrimaryExtendedSpokenLanguage, true);
3176 }
3177 }
3178
3179 for (size_t StreamPos=1; StreamPos<(*Parser)->Count_Get(StreamKind_Last); StreamPos++) //If more than 1 stream, TODO: better way to do this
3180 {
3181 Stream_Prepare(StreamKind_Last);
3182 Fill(StreamKind_Last, StreamPos_Last, "Title", Retrieve_Const(StreamKind_Last, StreamPos_Last-StreamPos, "Title"));
3183 Merge(*(*Parser), StreamKind_Last, StreamPos, StreamPos_Last);
3184 MergedStreams_Last.push_back(streamidentity(StreamKind_Last, StreamPos_Last));
3185 }
3186
3187 if (StreamKind_Last!=Stream_Other && (*Parser)->Count_Get(Stream_Other))
3188 {
3189 stream_t StreamKind_Last_Main=StreamKind_Last;
3190 size_t StreamPos_Last_Main=StreamPos_Last;
3191 for (size_t StreamPos=0; StreamPos<(*Parser)->Count_Get(Stream_Other); StreamPos++)
3192 {
3193 Stream_Prepare(Stream_Other);
3194 Merge(*(*Parser), Stream_Other, StreamPos, StreamPos_Last);
3195 }
3196 Streams_Finish_Essence_FillID(EssenceUID, TrackUID);
3197 StreamKind_Last=StreamKind_Last_Main;
3198 StreamPos_Last=StreamPos_Last_Main;
3199 }
3200 }
3201
3202 Streams_Finish_Essence_FillID(EssenceUID, TrackUID);
3203
3204 //Special case - DV
3205 #if defined(MEDIAINFO_DVDIF_YES)
3206 if (StreamKind_Last==Stream_Video && Retrieve(Stream_Video, StreamPos_Last, Video_Format)==__T("DV"))
3207 {
3208 if (Retrieve(Stream_General, 0, General_Recorded_Date).empty())
3209 Fill(Stream_General, 0, General_Recorded_Date, (*Parser)->Retrieve(Stream_General, 0, General_Recorded_Date));
3210
3211 //Video and Audio are together
3212 size_t Audio_Count=(*Parser)->Count_Get(Stream_Audio);
3213 for (size_t Audio_Pos=0; Audio_Pos<Audio_Count; Audio_Pos++)
3214 {
3215 Fill_Flush();
3216 Stream_Prepare(Stream_Audio);
3217 size_t Pos=Count_Get(Stream_Audio)-1;
3218 (*Parser)->Finish();
3219 if (MxfTimeCodeForDelay.IsInit())
3220 {
3221 const float64 TimeCode_StartTimecode_Temp = MxfTimeCodeForDelay.Get_TimeCode_StartTimecode_Temp(Config->File_IgnoreEditsBefore);
3222 Fill(Stream_Audio, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Delay), TimeCode_StartTimecode_Temp*1000, 0, true);
3223 Fill(Stream_Audio, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Delay_Source), "Container");
3224 }
3225 Merge(*(*Parser), Stream_Audio, Audio_Pos, StreamPos_Last);
3226 if (Retrieve(Stream_Audio, Pos, Audio_MuxingMode).empty())
3227 Fill(Stream_Audio, Pos, Audio_MuxingMode, Retrieve(Stream_Video, Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1), Video_Format), true);
3228 else
3229 Fill(Stream_Audio, Pos, Audio_MuxingMode, Retrieve(Stream_Video, Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1), Video_Format)+__T(" / ")+Retrieve(Stream_Audio, Pos, Audio_MuxingMode), true);
3230 Fill(Stream_Audio, Pos, Audio_Duration, Retrieve(Stream_Video, Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1), Video_Duration));
3231 Fill(Stream_Audio, Pos, Audio_StreamSize_Encoded, 0); //Included in the DV stream size
3232 Ztring ID=Retrieve(Stream_Audio, Pos, Audio_ID);
3233 Fill(Stream_Audio, Pos, Audio_ID, Retrieve(Stream_Video, Count_Get(Stream_Video)-1, Video_ID)+__T("-")+ID, true);
3234 Fill(Stream_Audio, Pos, Audio_ID_String, Retrieve(Stream_Video, Count_Get(Stream_Video)-1, Video_ID_String)+__T("-")+ID, true);
3235 Fill(Stream_Audio, Pos, Audio_Title, Retrieve(Stream_Video, Count_Get(Stream_Video)-1, Video_Title), true);
3236 }
3237
3238 StreamKind_Last=Stream_Video;
3239 StreamPos_Last=Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1);
3240 }
3241 #endif
3242
3243 //Special case - MPEG Video + Captions
3244 if (StreamKind_Last==Stream_Video && (*Parser)->Count_Get(Stream_Text))
3245 {
3246 //Video and Text are together
3247 size_t Parser_Text_Count=(*Parser)->Count_Get(Stream_Text);
3248 for (size_t Parser_Text_Pos=0; Parser_Text_Pos<Parser_Text_Count; Parser_Text_Pos++)
3249 {
3250 size_t StreamPos_Video=StreamPos_Last;
3251 Fill_Flush();
3252 Stream_Prepare(Stream_Text);
3253 (*Parser)->Finish();
3254 if (MxfTimeCodeForDelay.IsInit())
3255 {
3256 const float64 TimeCode_StartTimecode_Temp= MxfTimeCodeForDelay.Get_TimeCode_StartTimecode_Temp(Config->File_IgnoreEditsBefore);
3257 Fill(Stream_Text, Parser_Text_Pos, Fill_Parameter(StreamKind_Last, Generic_Delay), TimeCode_StartTimecode_Temp*1000, 0, true);
3258 Fill(Stream_Text, Parser_Text_Pos, Fill_Parameter(StreamKind_Last, Generic_Delay_Source), "Container");
3259 }
3260 Merge(*(*Parser), Stream_Text, Parser_Text_Pos, StreamPos_Last);
3261 Fill(Stream_Text, StreamPos_Last, Text_Duration, Retrieve(Stream_Video, StreamPos_Video, Video_Duration));
3262 Ztring ID=Retrieve(Stream_Text, StreamPos_Last, Text_ID);
3263 if (Retrieve(Stream_Text, StreamPos_Last, Text_MuxingMode).find(__T("Ancillary"))!=string::npos)
3264 {
3265 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
3266 if (Descriptor->second.Type==descriptor::Type_AncPackets)
3267 {
3268 Fill(Stream_Text, StreamPos_Last, Text_ID, Ztring::ToZtring(Descriptor->second.LinkedTrackID)+__T("-")+ID, true);
3269 Fill(Stream_Text, StreamPos_Last, Text_ID_String, Ztring::ToZtring(Descriptor->second.LinkedTrackID)+__T("-")+ID, true);
3270 Fill(Stream_Text, StreamPos_Last, Text_Title, Tracks[TrackUID].TrackName, true);
3271 break;
3272 }
3273 }
3274 else
3275 {
3276 Fill(Stream_Text, StreamPos_Last, Text_ID, Retrieve(Stream_Video, Count_Get(Stream_Video)-1, Video_ID)+__T("-")+ID, true);
3277 Fill(Stream_Text, StreamPos_Last, Text_ID_String, Retrieve(Stream_Video, Count_Get(Stream_Video)-1, Video_ID_String)+__T("-")+ID, true);
3278 Fill(Stream_Text, StreamPos_Last, Text_Title, Retrieve(Stream_Video, Count_Get(Stream_Video)-1, Video_Title), true);
3279 }
3280
3281 for (size_t Pos=0; Pos<DMScheme1s_List.size(); Pos++)
3282 {
3283 dmscheme1s::iterator DMScheme1=DMScheme1s.find(DMScheme1s_List[Pos]);
3284 if (DMScheme1!=DMScheme1s.end())
3285 {
3286 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Language), DMScheme1->second.PrimaryExtendedSpokenLanguage, true);
3287 }
3288 }
3289 }
3290
3291 Ztring LawRating=(*Parser)->Retrieve(Stream_General, 0, General_LawRating);
3292 if (!LawRating.empty())
3293 Fill(Stream_General, 0, General_LawRating, LawRating, true);
3294 Ztring Title=(*Parser)->Retrieve(Stream_General, 0, General_Title);
3295 if (!Title.empty() && Retrieve(Stream_General, 0, General_Title).empty())
3296 Fill(Stream_General, 0, General_Title, Title);
3297
3298 StreamKind_Last=Stream_Video;
3299 StreamPos_Last=Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1);
3300 }
3301
3302 //Stream size
3303 if (StreamKind_Last!=Stream_Max && Count_Get(Stream_Video)+Count_Get(Stream_Audio)==1 && Essence->second.Stream_Size!=(int64u)-1)
3304 {
3305 //TODO: Stream_Size is present only if there is one stream, so it works in most cases. We should find a better way.
3306 int64u Stream_Size=Essence->second.Stream_Size;
3307 if (Config->File_IgnoreEditsBefore || Config->File_IgnoreEditsAfter!=(int64u)-1)
3308 {
3309 int64u FrameCount_FromComponent=(int64u)-1;
3310 for (components::iterator Component=Components.begin(); Component!=Components.end(); ++Component)
3311 if (FrameCount_FromComponent>Component->second.Duration)
3312 FrameCount_FromComponent=Component->second.Duration;
3313 float64 EditRate_FromTrack=DBL_MAX;
3314 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
3315 if (EditRate_FromTrack>Track->second.EditRate)
3316 EditRate_FromTrack=Track->second.EditRate;
3317 if (FrameCount_FromComponent!=(int64u)-1 && FrameCount_FromComponent && EditRate_FromTrack!=DBL_MAX && EditRate_FromTrack)
3318 {
3319 int64u FrameCount=FrameCount_FromComponent;
3320 int64u File_IgnoreEditsBefore=Config->File_IgnoreEditsBefore;
3321 if (File_IgnoreEditsBefore && Config->File_EditRate && (EditRate_FromTrack<Config->File_EditRate*0.9 || EditRate_FromTrack>Config->File_EditRate*1.1)) //In case of problem or EditRate being sampling rate
3322 File_IgnoreEditsBefore=float64_int64s(((float64)File_IgnoreEditsBefore)/Config->File_EditRate*EditRate_FromTrack);
3323 int64u File_IgnoreEditsAfter=Config->File_IgnoreEditsAfter;
3324 if (File_IgnoreEditsAfter!=(int64u)-1 && Config->File_EditRate && (EditRate_FromTrack<Config->File_EditRate*0.9 || EditRate_FromTrack>Config->File_EditRate*1.1)) //In case of problem or EditRate being sampling rate
3325 File_IgnoreEditsAfter=float64_int64s(((float64)File_IgnoreEditsAfter)/Config->File_EditRate*EditRate_FromTrack);
3326 if (File_IgnoreEditsAfter<FrameCount)
3327 FrameCount=File_IgnoreEditsAfter;
3328 if (FrameCount<File_IgnoreEditsBefore)
3329 FrameCount=File_IgnoreEditsBefore;
3330 FrameCount-=File_IgnoreEditsBefore;
3331
3332 float64 Stream_Size_Temp=(float64)Stream_Size;
3333 Stream_Size_Temp/=FrameCount_FromComponent;
3334 Stream_Size_Temp*=FrameCount;
3335 Stream_Size=float64_int64s(Stream_Size_Temp);
3336 }
3337 }
3338
3339 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_StreamSize), Stream_Size);
3340 }
3341
3342 //Done
3343 Essence->second.Stream_Finish_Done=true;
3344 }
3345
3346 //---------------------------------------------------------------------------
Streams_Finish_Essence_FillID(int32u EssenceUID,int128u TrackUID)3347 void File_Mxf::Streams_Finish_Essence_FillID(int32u EssenceUID, int128u TrackUID)
3348 {
3349 essences::iterator Essence=Essences.find(EssenceUID);
3350 if (Essence==Essences.end() || Essence->second.Stream_Finish_Done)
3351 return;
3352
3353 parsers::iterator Parser=Essence->second.Parsers.begin();
3354
3355 if (Retrieve(StreamKind_Last, StreamPos_Last, General_ID).empty() || StreamKind_Last==Stream_Text || StreamKind_Last==Stream_Other) //TODO: better way to do detect subID
3356 {
3357 //Looking for Material package TrackID
3358 int32u TrackID=(int32u)-1;
3359 for (packages::iterator SourcePackage=Packages.begin(); SourcePackage!=Packages.end(); ++SourcePackage)
3360 if (SourcePackage->second.PackageUID.hi.hi) //Looking fo a SourcePackage with PackageUID only
3361 {
3362 //Testing if the Track is in this SourcePackage
3363 for (size_t Tracks_Pos=0; Tracks_Pos<SourcePackage->second.Tracks.size(); Tracks_Pos++)
3364 if (SourcePackage->second.Tracks[Tracks_Pos]==TrackUID)
3365 {
3366 tracks::iterator Track=Tracks.find(SourcePackage->second.Tracks[Tracks_Pos]);
3367 if (Track!=Tracks.end())
3368 TrackID=Track->second.TrackID;
3369 }
3370 }
3371
3372 Ztring ID;
3373 Ztring ID_String;
3374 if (TrackID!=(int32u)-1)
3375 ID=Ztring::ToZtring(TrackID);
3376 else if (Tracks[TrackUID].TrackID!=(int32u)-1)
3377 ID=Ztring::ToZtring(Tracks[TrackUID].TrackID);
3378 else
3379 {
3380 ID=Ztring::ToZtring(Essence->first);
3381 ID_String=Ztring::ToZtring(Essence->first, 16);
3382 }
3383 if (!ID.empty())
3384 {
3385 for (size_t StreamPos=StreamPos_Last-((*Parser)->Count_Get(StreamKind_Last)?((*Parser)->Count_Get(StreamKind_Last)-1):0); StreamPos<=StreamPos_Last; StreamPos++) //If more than 1 stream
3386 {
3387 Ztring ID_Temp(ID);
3388 if (!Retrieve(StreamKind_Last, StreamPos, General_ID).empty())
3389 {
3390 ID_Temp+=__T("-");
3391 ID_Temp+=Retrieve(StreamKind_Last, StreamPos, General_ID);
3392 }
3393 Fill(StreamKind_Last, StreamPos, General_ID, ID_Temp, true);
3394 if (!ID_String.empty())
3395 Fill(StreamKind_Last, StreamPos, General_ID_String, ID_String, true);
3396 }
3397 }
3398 if (!Tracks[TrackUID].TrackName.empty())
3399 {
3400 for (size_t StreamPos=StreamPos_Last-((*Parser)->Count_Get(StreamKind_Last)?((*Parser)->Count_Get(StreamKind_Last)-1):0); StreamPos<=StreamPos_Last; StreamPos++) //If more than 1 stream
3401 {
3402 Ztring Title_Temp=Retrieve(StreamKind_Last, StreamPos, "Title");
3403 Fill(StreamKind_Last, StreamPos, "Title", Title_Temp.empty()?Tracks[TrackUID].TrackName:(Tracks[TrackUID].TrackName+__T(" - ")+Title_Temp), true);
3404 }
3405 }
3406 }
3407 }
3408
3409 //---------------------------------------------------------------------------
Streams_Finish_Descriptor(const int128u DescriptorUID,const int128u PackageUID)3410 void File_Mxf::Streams_Finish_Descriptor(const int128u DescriptorUID, const int128u PackageUID)
3411 {
3412 descriptors::iterator Descriptor=Descriptors.find(DescriptorUID);
3413 if (Descriptor==Descriptors.end())
3414 return;
3415
3416 //Subs
3417 if (Descriptor->second.Type==descriptor::type_Mutiple)
3418 {
3419 for (size_t Pos=0; Pos<Descriptor->second.SubDescriptors.size(); Pos++)
3420 Streams_Finish_Descriptor(Descriptor->second.SubDescriptors[Pos], PackageUID);
3421 return; //Is not a real descriptor
3422 }
3423
3424 StreamKind_Last=Descriptor->second.StreamKind;
3425 StreamPos_Last=Descriptor->second.StreamPos;
3426 if (StreamPos_Last==(size_t)-1)
3427 {
3428 for (size_t Pos=0; Pos<Count_Get(StreamKind_Last); Pos++)
3429 {
3430 Ztring ID=Retrieve(StreamKind_Last, Pos, General_ID);
3431 size_t ID_Dash_Pos=ID.find(__T('-'));
3432 if (ID_Dash_Pos!=string::npos)
3433 ID.resize(ID_Dash_Pos);
3434 if (Ztring::ToZtring(Descriptor->second.LinkedTrackID)==ID)
3435 {
3436 StreamPos_Last=Pos;
3437 break;
3438 }
3439 }
3440 }
3441 if (StreamPos_Last==(size_t)-1)
3442 {
3443 if (Descriptors.size()==1)
3444 {
3445 if (Count_Get(Descriptor->second.StreamKind)==0)
3446 Stream_Prepare(Descriptor->second.StreamKind);
3447 else
3448 StreamPos_Last=0;
3449 }
3450 else if (Descriptor->second.LinkedTrackID!=(int32u)-1)
3451 {
3452 //Workaround for a specific file with same ID
3453 if (!Locators.empty())
3454 for (descriptors::iterator Descriptor1=Descriptors.begin(); Descriptor1!=Descriptor; ++Descriptor1)
3455 if (Descriptor1->second.LinkedTrackID==Descriptor->second.LinkedTrackID)
3456 {
3457 IdIsAlwaysSame_Offset++;
3458 break;
3459 }
3460
3461 Stream_Prepare(Descriptor->second.StreamKind);
3462 Fill(StreamKind_Last, StreamPos_Last, General_ID, Descriptor->second.LinkedTrackID+IdIsAlwaysSame_Offset);
3463 }
3464 else
3465 {
3466 //Looking for Material package TrackID
3467 packages::iterator SourcePackage=Packages.find(PackageUID);
3468 //We have the the right PackageUID, looking for SourceClip from Sequence from Track from MaterialPackage
3469 for (components::iterator SourceClip=Components.begin(); SourceClip!=Components.end(); ++SourceClip)
3470 if (SourceClip->second.SourcePackageID.lo==SourcePackage->second.PackageUID.lo) //int256u doesn't support yet ==
3471 {
3472 //We have the right SourceClip, looking for the Sequence from Track from MaterialPackage
3473 for (components::iterator Sequence=Components.begin(); Sequence!=Components.end(); ++Sequence)
3474 for (size_t StructuralComponents_Pos=0; StructuralComponents_Pos<Sequence->second.StructuralComponents.size(); StructuralComponents_Pos++)
3475 if (Sequence->second.StructuralComponents[StructuralComponents_Pos]==SourceClip->first)
3476 {
3477 //We have the right Sequence, looking for Track from MaterialPackage
3478 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
3479 {
3480 if (Track->second.Sequence==Sequence->first)
3481 {
3482 Ztring ID=Ztring::ToZtring(Track->second.TrackID);
3483 StreamKind_Last=Stream_Max;
3484 StreamPos_Last=(size_t)-1;
3485 for (size_t StreamKind=Stream_General+1; StreamKind<Stream_Max; StreamKind++)
3486 for (size_t StreamPos=0; StreamPos<Count_Get((stream_t)StreamKind); StreamPos++)
3487 if (ID==Retrieve((stream_t)StreamKind, StreamPos, General_ID))
3488 {
3489 StreamKind_Last=(stream_t)StreamKind;
3490 StreamPos_Last=(stream_t)StreamPos;
3491 }
3492 if (StreamPos_Last==(size_t)-1 && !Descriptor->second.Locators.empty()) //TODO: 1 file has a TimeCode stream linked to a video stream, and it is displayed if Locator test is removed. Why? AS02 files streams are not filled if I remove completely this block, why?
3493 {
3494 if (Descriptor->second.StreamKind!=Stream_Max)
3495 Stream_Prepare(Descriptor->second.StreamKind);
3496 if (Track->second.TrackID!=(int32u)-1)
3497 {
3498 if (Descriptor->second.LinkedTrackID==(int32u)-1)
3499 Descriptor->second.LinkedTrackID=Track->second.TrackID;
3500 if (Descriptor->second.StreamKind!=Stream_Max)
3501 {
3502 Fill(StreamKind_Last, StreamPos_Last, General_ID, ID);
3503 Fill(StreamKind_Last, StreamPos_Last, "Title", Track->second.TrackName);
3504 }
3505 }
3506 }
3507 }
3508 }
3509 }
3510 }
3511 }
3512 }
3513
3514 //Locators
3515 size_t Before_Count[Stream_Max];
3516 for (size_t Pos=0; Pos<Stream_Max; Pos++)
3517 Before_Count[Pos]=(size_t)-1;
3518 Before_Count[Stream_Video]=Count_Get(Stream_Video);
3519 Before_Count[Stream_Audio]=Count_Get(Stream_Audio);
3520 Before_Count[Stream_Text]=Count_Get(Stream_Text);
3521 for (size_t Locator_Pos=0; Locator_Pos<Descriptor->second.Locators.size(); Locator_Pos++)
3522 {
3523 //Locator
3524 Streams_Finish_Locator(DescriptorUID, Descriptor->second.Locators[Locator_Pos]);
3525 }
3526
3527 if (StreamPos_Last==(size_t)-1 && Essences.size()==1)
3528 {
3529 //Only one essence, there is sometimes no LinkedTrackID
3530 if (Count_Get(Stream_Video)==1)
3531 {
3532 StreamKind_Last=Stream_Video;
3533 StreamPos_Last=0;
3534 }
3535 else if (Count_Get(Stream_Audio)==1)
3536 {
3537 StreamKind_Last=Stream_Audio;
3538 StreamPos_Last=0;
3539 }
3540 }
3541
3542 if (StreamKind_Last!=Stream_Max && StreamPos_Last!=(size_t)-1)
3543 {
3544 //Handling buggy files
3545 if (Descriptor->second.Is_Interlaced() && Descriptor->second.Height==1152 && Descriptor->second.Height_Display==1152 && Descriptor->second.Width==720) //Height value is height of the frame instead of the field
3546 Descriptor->second.Height_Display/=2;
3547
3548 //ID
3549 if (Descriptor->second.LinkedTrackID!=(int32u)-1 && Retrieve(StreamKind_Last, StreamPos_Last, General_ID).empty())
3550 {
3551 for (size_t StreamKind=0; StreamKind<Stream_Max; StreamKind++)
3552 for (size_t StreamPos=Before_Count[StreamKind]; StreamPos<Count_Get((stream_t)StreamKind); StreamPos++)
3553 {
3554 Ztring ID=Retrieve((stream_t)StreamKind, StreamPos, General_ID);
3555 if (ID.empty() || Config->File_ID_OnlyRoot_Get())
3556 Fill((stream_t)StreamKind, StreamPos, General_ID, Descriptor->second.LinkedTrackID, 10, true);
3557 else
3558 Fill((stream_t)StreamKind, StreamPos, General_ID, Ztring::ToZtring(Descriptor->second.LinkedTrackID)+ID, true);
3559 }
3560 }
3561
3562 if (Descriptor->second.Width!=(int32u)-1 && Retrieve(Stream_Video, StreamPos_Last, Video_Width).empty())
3563 Fill(Stream_Video, StreamPos_Last, Video_Width, Descriptor->second.Width, 10, true);
3564 if (Descriptor->second.Width_Display!=(int32u)-1 && Descriptor->second.Width_Display!=Retrieve(Stream_Video, StreamPos_Last, Video_Width).To_int32u()
3565 && !(Retrieve(Stream_Video, StreamPos_Last, Video_Format) == __T("DV") && Descriptor->second.Width_Display == 1920 && (Retrieve(Stream_Video, StreamPos_Last, Video_Width) == __T("1280") || Retrieve(Stream_Video, StreamPos_Last, Video_Width) == __T("1440")))) // Exception: DVCPRO HD is really 1440 but lot of containers fill the width value with the marketing width 1920, we ignore it
3566 {
3567 Fill(Stream_Video, StreamPos_Last, Video_Width_Original, Retrieve(Stream_Video, StreamPos_Last, Video_Width), true);
3568 if (Retrieve(Stream_Video, StreamPos_Last, Video_PixelAspectRatio_Original).empty())
3569 Fill(Stream_Video, StreamPos_Last, Video_PixelAspectRatio_Original, Retrieve(Stream_Video, StreamPos_Last, Video_PixelAspectRatio), true);
3570 Clear(Stream_Video, StreamPos_Last, Video_PixelAspectRatio);
3571 Fill(Stream_Video, StreamPos_Last, Video_Width, Descriptor->second.Width_Display, 10, true);
3572 if (Descriptor->second.Width_Display_Offset!=(int32u)-1)
3573 Fill(Stream_Video, StreamPos_Last, Video_Width_Offset, Descriptor->second.Width_Display_Offset, 10, true);
3574 }
3575 if (Descriptor->second.Height!=(int32u)-1 && Retrieve(Stream_Video, StreamPos_Last, Video_Height).empty())
3576 Fill(Stream_Video, StreamPos_Last, Video_Height, Descriptor->second.Height, 10, true);
3577 if (Descriptor->second.Height_Display!=(int32u)-1 && Descriptor->second.Height_Display!=Retrieve(Stream_Video, StreamPos_Last, Video_Height).To_int32u())
3578 {
3579 Fill(Stream_Video, StreamPos_Last, Video_Height_Original, Retrieve(Stream_Video, StreamPos_Last, Video_Height), true);
3580 if (Retrieve(Stream_Video, StreamPos_Last, Video_PixelAspectRatio_Original).empty())
3581 Fill(Stream_Video, StreamPos_Last, Video_PixelAspectRatio_Original, Retrieve(Stream_Video, StreamPos_Last, Video_PixelAspectRatio), true);
3582 Clear(Stream_Video, StreamPos_Last, Video_PixelAspectRatio);
3583 Fill(Stream_Video, StreamPos_Last, Video_Height, Descriptor->second.Height_Display, 10, true);
3584 if (Descriptor->second.Height_Display_Offset!=(int32u)-1)
3585 Fill(Stream_Video, StreamPos_Last, Video_Height_Offset, Descriptor->second.Height_Display_Offset, 10, true);
3586 }
3587
3588 //Info
3589 const Ztring &ID=Retrieve(StreamKind_Last, StreamPos_Last, General_ID);
3590 size_t ID_Dash_Pos=ID.find(__T('-'));
3591 size_t StreamWithSameID=1;
3592 if (ID_Dash_Pos!=(size_t)-1)
3593 {
3594 Ztring RealID=ID.substr(0, ID_Dash_Pos+1);
3595 while (StreamPos_Last+StreamWithSameID<Count_Get(StreamKind_Last) && Retrieve(StreamKind_Last, StreamPos_Last+StreamWithSameID, General_ID).find(RealID)==0)
3596 StreamWithSameID++;
3597 }
3598 if (Descriptor->second.SampleRate && StreamKind_Last==Stream_Video)
3599 {
3600 float64 SampleRate=Descriptor->second.SampleRate;
3601 if (StereoscopicPictureSubDescriptor_IsPresent)
3602 {
3603 SampleRate/=2;
3604 Fill(Stream_Video, StreamPos_Last, Video_MultiView_Count, 2, 10, true);
3605 }
3606 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
3607 if (Essence->second.StreamKind==Stream_Video && Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1)==StreamPos_Last)
3608 {
3609 if (Essence->second.Field_Count_InThisBlock_1 && !Essence->second.Field_Count_InThisBlock_2)
3610 SampleRate/=2;
3611 break;
3612 }
3613 Ztring SampleRate_Container; SampleRate_Container.From_Number(SampleRate); //TODO: fill frame rate before the merge with raw stream information
3614 const Ztring &SampleRate_RawStream=Retrieve(Stream_Video, StreamPos_Last, Video_FrameRate);
3615 if (!SampleRate_RawStream.empty() && SampleRate_Container!=SampleRate_RawStream)
3616 Fill(Stream_Video, StreamPos_Last, Video_FrameRate_Original, SampleRate_RawStream);
3617 Fill(Stream_Video, StreamPos_Last, Video_FrameRate, SampleRate, 3, true);
3618 }
3619 if (StreamKind_Last==Stream_Video)
3620 ColorLevels_Compute(Descriptor, true, Retrieve(Stream_Video, StreamPos_Last, Video_BitDepth).To_int32u());
3621
3622 //MasteringDisplay specific info
3623 std::map<std::string, Ztring>::iterator Info_MasteringDisplay_Primaries = Descriptor->second.Infos.find("MasteringDisplay_Primaries");
3624 std::map<std::string, Ztring>::iterator Info_MasteringDisplay_WhitePointChromaticity = Descriptor->second.Infos.find("MasteringDisplay_WhitePointChromaticity");
3625 std::map<std::string, Ztring>::iterator MasteringDisplay_Luminance_Max = Descriptor->second.Infos.find("MasteringDisplay_Luminance_Max");
3626 std::map<std::string, Ztring>::iterator MasteringDisplay_Luminance_Min = Descriptor->second.Infos.find("MasteringDisplay_Luminance_Min");
3627 mastering_metadata_2086 MasteringMeta;
3628 memset(&MasteringMeta, 0xFF, sizeof(MasteringMeta));
3629 if (Info_MasteringDisplay_Primaries!= Descriptor->second.Infos.end())
3630 {
3631 ZtringList Primaries (Info_MasteringDisplay_Primaries->second);
3632 if (Primaries.size() == 6)
3633 {
3634 MasteringMeta.Primaries[0] = Primaries[0].To_int16u();
3635 MasteringMeta.Primaries[1] = Primaries[1].To_int16u();
3636 MasteringMeta.Primaries[2] = Primaries[2].To_int16u();
3637 MasteringMeta.Primaries[3] = Primaries[3].To_int16u();
3638 MasteringMeta.Primaries[4] = Primaries[4].To_int16u();
3639 MasteringMeta.Primaries[5] = Primaries[5].To_int16u();
3640 }
3641 }
3642 if (Info_MasteringDisplay_WhitePointChromaticity!= Descriptor->second.Infos.end())
3643 {
3644 ZtringList WhitePoint (Info_MasteringDisplay_WhitePointChromaticity->second);
3645 if (WhitePoint.size() == 2)
3646 {
3647 MasteringMeta.Primaries[6] = WhitePoint[0].To_int16u();
3648 MasteringMeta.Primaries[7] = WhitePoint[1].To_int16u();
3649 }
3650 }
3651 if (MasteringDisplay_Luminance_Min!=Descriptor->second.Infos.end())
3652 {
3653 MasteringMeta.Luminance[0] = MasteringDisplay_Luminance_Min->second.To_int32u();
3654 }
3655 if (MasteringDisplay_Luminance_Max!=Descriptor->second.Infos.end())
3656 {
3657 MasteringMeta.Luminance[1] = MasteringDisplay_Luminance_Max->second.To_int32u();
3658 }
3659 Ztring MasteringDisplay_ColorPrimaries;
3660 Ztring MasteringDisplay_Luminance;
3661 Get_MasteringDisplayColorVolume(MasteringDisplay_ColorPrimaries, MasteringDisplay_Luminance, MasteringMeta);
3662 Descriptor->second.Infos["MasteringDisplay_ColorPrimaries"]=MasteringDisplay_ColorPrimaries;
3663 Descriptor->second.Infos["MasteringDisplay_Luminance"]=MasteringDisplay_Luminance;
3664
3665 for (std::map<std::string, Ztring>::iterator Info=Descriptor->second.Infos.begin(); Info!=Descriptor->second.Infos.end(); ++Info)
3666 if (Info!=Info_MasteringDisplay_Primaries
3667 && Info!=Info_MasteringDisplay_WhitePointChromaticity
3668 && Info!=MasteringDisplay_Luminance_Max
3669 && Info!=MasteringDisplay_Luminance_Min)
3670 {
3671 //Special case
3672 if (Info->first=="BitRate" && Retrieve(StreamKind_Last, StreamPos_Last, General_ID).find(__T(" / "))!=string::npos)
3673 {
3674 if (!Retrieve(StreamKind_Last, StreamPos_Last, Info->first.c_str()).empty())
3675 continue; // Not always valid e.g. Dolby E or AC-3 in AES3. TODO: check in case of normal check
3676 if (Retrieve(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate)).empty() || Retrieve(StreamKind_Last, StreamPos_Last, General_ID).find(__T('-'))!=string::npos)
3677 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate_Encoded), Info->second.To_int64u()*2, 10, true);
3678 else
3679 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_BitRate), Info->second.To_int64u()*2, 10, true);
3680 }
3681 else if (!Info->second.empty())
3682 {
3683 const Ztring FromEssence=Retrieve_Const(StreamKind_Last, StreamPos_Last, Info->first.c_str());
3684 for (size_t Pos=0; Pos<StreamWithSameID; Pos++)
3685 {
3686 if (FromEssence.empty())
3687 {
3688 Fill(StreamKind_Last, StreamPos_Last+Pos, Info->first.c_str(), Info->second);
3689 }
3690 else if (FromEssence!=Info->second)
3691 {
3692 // Special cases
3693 if (Info->first=="ColorSpace" && ((Info->second==__T("RGB") && FromEssence==__T("XYZ")) || (Info->second==__T("RGBA") && FromEssence==__T("XYZA"))))
3694 continue; // "RGB" is used by MXF for "XYZ" too
3695 if (Info->first=="Format")
3696 continue; // Too much important to show the essence format, ignoring for the moment. TODO: display something in such case
3697 if (Info->first=="Duration")
3698 continue; // Found 1 file with descriptor with wrong descriptor SampleRate. TODO: better display in such case (should not take precedence other other durations, how to display the issue between component duration and descriptor duration, both container metadata?). Must also take care about StereoscopicPictureSubDescriptor (SampleRate divided by 2 in that case)
3699 if (Info->first=="DisplayAspectRatio")
3700 continue; // Handled separately
3701 if (Info->first=="Channel(s)")
3702 continue; // Not always valid e.g. Dolby E. TODO: check in case of normal check
3703 if (Info->first=="BitDepth")
3704 continue; // Not always valid e.g. Dolby E. TODO: check in case of normal check
3705 if (Info->first=="BitRate")
3706 continue; // Not always valid e.g. Dolby E. TODO: check in case of normal check
3707 if (Info->first=="StreamOrder")
3708 continue; // Is not useful and has some issues with Dolby E
3709
3710 // Filling both values
3711 Fill(StreamKind_Last, StreamPos_Last+Pos, (Info->first+"_Original").c_str(), FromEssence); //TODO: use the generic engine by filling descriptor info before merging essence info
3712 Fill(StreamKind_Last, StreamPos_Last+Pos, Info->first.c_str(), Info->second, true); //TODO: use the generic engine by filling descriptor info before merging essence info
3713 if (ShowSource_IsInList(Info->first))
3714 {
3715 Fill(StreamKind_Last, StreamPos_Last+Pos, (Info->first+"_Source").c_str(), "Container", Unlimited, true, true);
3716 Fill(StreamKind_Last, StreamPos_Last+Pos, (Info->first+"_Original_Source").c_str(), "Stream");
3717 }
3718 }
3719 else
3720 {
3721 if (ShowSource_IsInList(Info->first))
3722 Fill(StreamKind_Last, StreamPos_Last+Pos, (Info->first+"_Source").c_str(), "Container / Stream", Unlimited, true, true);
3723 }
3724 }
3725 }
3726 }
3727 Ztring Format, CodecID;
3728 if (Descriptor->second.EssenceContainer.hi!=(int64u)-1)
3729 {
3730 CodecID.From_Number(Descriptor->second.EssenceContainer.lo, 16);
3731 if (CodecID.size()<16)
3732 CodecID.insert(0, 16-CodecID.size(), __T('0'));
3733 Format.From_UTF8(Mxf_EssenceContainer(Descriptor->second.EssenceContainer));
3734 }
3735 if (Descriptor->second.EssenceCompression.hi!=(int64u)-1)
3736 {
3737 if (!CodecID.empty())
3738 CodecID+=__T('-');
3739 Ztring EssenceCompression;
3740 EssenceCompression.From_Number(Descriptor->second.EssenceCompression.lo, 16);
3741 if (EssenceCompression.size()<16)
3742 EssenceCompression.insert(0, 16-EssenceCompression.size(), __T('0'));
3743 CodecID+=EssenceCompression;
3744 Ztring Format_FromCompression; Format_FromCompression.From_UTF8(Mxf_EssenceCompression(Descriptor->second.EssenceCompression));
3745 if (!Format_FromCompression.empty())
3746 Format=Format_FromCompression; //EssenceCompression has priority
3747 }
3748 if (!CodecID.empty())
3749 for (size_t Pos=0; Pos<StreamWithSameID; Pos++)
3750 Fill(StreamKind_Last, StreamPos_Last+Pos, Fill_Parameter(StreamKind_Last, Generic_CodecID), CodecID, true);
3751 if (!Format.empty())
3752 for (size_t Pos=0; Pos<StreamWithSameID; Pos++)
3753 if (Retrieve(StreamKind_Last, StreamPos_Last+Pos, Fill_Parameter(StreamKind_Last, Generic_Format)).empty())
3754 Fill(StreamKind_Last, StreamPos_Last+Pos, Fill_Parameter(StreamKind_Last, Generic_Format), Format);
3755
3756 //Bitrate (PCM)
3757 if (StreamKind_Last==Stream_Audio && Retrieve(Stream_Audio, StreamPos_Last, Audio_BitRate).empty() && Retrieve(Stream_Audio, StreamPos_Last, Audio_Format)==__T("PCM") && Retrieve(Stream_Audio, StreamPos_Last, Audio_Format_Settings_Wrapping).find(__T("D-10"))!=string::npos)
3758 {
3759 int64u SamplingRate=Retrieve(Stream_Audio, StreamPos_Last, Audio_SamplingRate).To_int64u();
3760 if (SamplingRate)
3761 Fill(Stream_Audio, StreamPos_Last, Audio_BitRate, 8*SamplingRate*32);
3762 }
3763 if (StreamKind_Last==Stream_Audio && Retrieve(Stream_Audio, StreamPos_Last, Audio_BitRate).empty() && Retrieve(Stream_Audio, StreamPos_Last, Audio_Format)==__T("PCM"))
3764 {
3765 int64u Channels=Retrieve(Stream_Audio, StreamPos_Last, Audio_Channel_s_).To_int64u();
3766 int64u SamplingRate=Retrieve(Stream_Audio, StreamPos_Last, Audio_SamplingRate).To_int64u();
3767 int64u Resolution=Retrieve(Stream_Audio, StreamPos_Last, Audio_BitDepth).To_int64u();
3768 if (Channels && SamplingRate && Resolution)
3769 Fill(Stream_Audio, StreamPos_Last, Audio_BitRate, Channels*SamplingRate*Resolution);
3770 }
3771
3772 //Bitrate (Video)
3773 if (StreamKind_Last==Stream_Video && Retrieve(Stream_Video, StreamPos_Last, Video_BitRate).empty())
3774 {
3775 //Until now, I only found CBR files
3776 Fill(Stream_Video, StreamPos_Last, Video_BitRate, Retrieve(Stream_Video, StreamPos_Last, Video_BitRate_Nominal));
3777 }
3778
3779 //Display Aspect Ratio
3780 if (StreamKind_Last==Stream_Video && !Descriptor->second.Infos["DisplayAspectRatio"].empty() && Retrieve(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio)!=Descriptor->second.Infos["DisplayAspectRatio"])
3781 {
3782 Ztring DAR=Retrieve(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio);
3783 Clear(Stream_Video, StreamPos_Last, Video_PixelAspectRatio);
3784 Fill(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio, Descriptor->second.Infos["DisplayAspectRatio"], true);
3785 Fill(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio_Original, DAR);
3786 float32 Width =Retrieve(Stream_Video, StreamPos_Last, Video_Width ).To_float32();
3787 float32 Height=Retrieve(Stream_Video, StreamPos_Last, Video_Height ).To_float32();
3788 float32 DAR_F =DAR.To_float32();
3789 if (Width && Height && DAR_F)
3790 {
3791 float32 PAR =1/(Width/Height/DAR_F);
3792 if (PAR>(float32)12/(float32)11*0.99 && PAR<(float32)12/(float32)11*1.01)
3793 PAR=(float32)12/(float32)11;
3794 if (PAR>(float32)10/(float32)11*0.99 && PAR<(float32)10/(float32)11*1.01)
3795 PAR=(float32)10/(float32)11;
3796 if (PAR>(float32)16/(float32)11*0.99 && PAR<(float32)16/(float32)11*1.01)
3797 PAR=(float32)16/(float32)11;
3798 if (PAR>(float32)40/(float32)33*0.99 && PAR<(float32)40/(float32)33*1.01)
3799 PAR=(float32)40/(float32)33;
3800 if (PAR>(float32)24/(float32)11*0.99 && PAR<(float32)24/(float32)11*1.01)
3801 PAR=(float32)24/(float32)11;
3802 if (PAR>(float32)20/(float32)11*0.99 && PAR<(float32)20/(float32)11*1.01)
3803 PAR=(float32)20/(float32)11;
3804 if (PAR>(float32)32/(float32)11*0.99 && PAR<(float32)32/(float32)11*1.01)
3805 PAR=(float32)32/(float32)11;
3806 if (PAR>(float32)80/(float32)33*0.99 && PAR<(float32)80/(float32)33*1.01)
3807 PAR=(float32)80/(float32)33;
3808 if (PAR>(float32)18/(float32)11*0.99 && PAR<(float32)18/(float32)11*1.01)
3809 PAR=(float32)18/(float32)11;
3810 if (PAR>(float32)15/(float32)11*0.99 && PAR<(float32)15/(float32)11*1.01)
3811 PAR=(float32)15/(float32)11;
3812 if (PAR>(float32)64/(float32)33*0.99 && PAR<(float32)64/(float32)33*1.01)
3813 PAR=(float32)64/(float32)33;
3814 if (PAR>(float32)160/(float32)99*0.99 && PAR<(float32)160/(float32)99*1.01)
3815 PAR=(float32)160/(float32)99;
3816 if (PAR>(float32)4/(float32)3*0.99 && PAR<(float32)4/(float32)3*1.01)
3817 PAR=(float32)4/(float32)3;
3818 if (PAR>(float32)3/(float32)2*0.99 && PAR<(float32)3/(float32)2*1.01)
3819 PAR=(float32)3/(float32)2;
3820 if (PAR>(float32)2/(float32)1*0.99 && PAR<(float32)2/(float32)1*1.01)
3821 PAR=(float32)2;
3822 if (PAR>(float32)59/(float32)54*0.99 && PAR<(float32)59/(float32)54*1.01)
3823 PAR=(float32)59/(float32)54;
3824 }
3825 }
3826
3827 //ActiveFormatDescriptor
3828 if (StreamKind_Last==Stream_Video && Descriptor->second.ActiveFormat!=(int8u)-1 && Retrieve(Stream_Video, StreamPos_Last, Video_ActiveFormatDescription).empty())
3829 {
3830 Fill(Stream_Video, 0, Video_ActiveFormatDescription, Descriptor->second.ActiveFormat);
3831 if (Descriptor->second.ActiveFormat<16)
3832 {
3833 float32 DAR=Retrieve(Stream_Video, StreamPos_Last, Video_DisplayAspectRatio).To_float32();
3834 if (DAR>(float32)4/(float32)3*0.99 && DAR<(float32)4/(float32)3*1.01)
3835 Fill(Stream_Video, 0, Video_ActiveFormatDescription_String, AfdBarData_active_format_4_3[Descriptor->second.ActiveFormat]);
3836 if (DAR>(float32)16/(float32)9*0.99 && DAR<(float32)16/(float32)9*1.01)
3837 Fill(Stream_Video, 0, Video_ActiveFormatDescription_String, AfdBarData_active_format_16_9[Descriptor->second.ActiveFormat]);
3838 }
3839 if (Retrieve(Stream_Video, 0, Video_ActiveFormatDescription_String).empty())
3840 Fill(Stream_Video, 0, Video_ActiveFormatDescription_String, Descriptor->second.ActiveFormat);
3841 }
3842
3843 //ScanType / ScanOrder
3844 if (StreamKind_Last==Stream_Video && Retrieve(Stream_Video, StreamPos_Last, Video_ScanType_Original).empty())
3845 {
3846 //ScanType
3847 if (!Descriptor->second.ScanType.empty() && (Descriptor->second.ScanType!=Retrieve(Stream_Video, StreamPos_Last, Video_ScanType) && !(Descriptor->second.Is_Interlaced() && Retrieve(Stream_Video, StreamPos_Last, Video_ScanType)==__T("MBAFF"))))
3848 {
3849 Fill(Stream_Video, StreamPos_Last, Video_ScanType_Original, Retrieve(Stream_Video, StreamPos_Last, Video_ScanType));
3850 Fill(Stream_Video, StreamPos_Last, Video_ScanType, Descriptor->second.ScanType, true);
3851 }
3852
3853 //ScanOrder
3854 Ztring ScanOrder_Temp;
3855 if ((Descriptor->second.FieldDominance==1 && Descriptor->second.FieldTopness==1) || (Descriptor->second.FieldDominance!=1 && Descriptor->second.FieldTopness==2))
3856 ScanOrder_Temp.From_UTF8("TFF");
3857 if ((Descriptor->second.FieldDominance==1 && Descriptor->second.FieldTopness==2) || (Descriptor->second.FieldDominance!=1 && Descriptor->second.FieldTopness==1))
3858 ScanOrder_Temp.From_UTF8("BFF");
3859 if ((!ScanOrder_Temp.empty() && ScanOrder_Temp!=Retrieve(Stream_Video, StreamPos_Last, Video_ScanOrder)) || !Retrieve(Stream_Video, StreamPos_Last, Video_ScanType_Original).empty())
3860 {
3861 Fill(Stream_Video, StreamPos_Last, Video_ScanOrder_Original, Retrieve(Stream_Video, StreamPos_Last, Video_ScanOrder), true);
3862 if (ScanOrder_Temp.empty())
3863 {
3864 Clear(Stream_Video, StreamPos_Last, Video_ScanOrder);
3865 Clear(Stream_Video, StreamPos_Last, Video_ScanOrder_String);
3866 }
3867 else
3868 Fill(Stream_Video, StreamPos_Last, Video_ScanOrder, ScanOrder_Temp, true);
3869 }
3870 }
3871
3872 //BlockAlignment
3873 if (StreamKind_Last==Stream_Audio && Descriptor->second.BlockAlign!=(int16u)-1)
3874 {
3875 if (Retrieve(Stream_Audio, StreamPos_Last, "BlockAlignment").empty()) //TODO: check the reason it is sometimes call several times.
3876 {
3877 Fill(Stream_Audio, StreamPos_Last, "BlockAlignment", Descriptor->second.BlockAlign);
3878 Fill_SetOptions(Stream_Audio, StreamPos_Last, "BlockAlignment", "N NT");
3879 }
3880 }
3881
3882 //Subs and ChannelAssignment
3883 Ztring ChannelAssignment;
3884 if (Descriptor->second.ChannelAssignment.lo!=(int64u)-1)
3885 {
3886 ChannelAssignment.From_Number(Descriptor->second.ChannelAssignment.lo, 16);
3887 if (ChannelAssignment.size()<16)
3888 ChannelAssignment.insert(0, 16-ChannelAssignment.size(), __T('0'));
3889 }
3890 if (!Descriptor->second.SubDescriptors.empty())
3891 {
3892 std::vector<int128u> AudioChannelLabels_MCALabelDictionaryID;
3893
3894 for (size_t Pos=0; Pos<Descriptor->second.SubDescriptors.size(); Pos++)
3895 {
3896 descriptors::iterator SubDescriptor=Descriptors.find(Descriptor->second.SubDescriptors[Pos]);
3897 if (SubDescriptor!=Descriptors.end())
3898 {
3899 switch (SubDescriptor->second.Type)
3900 {
3901 case descriptor::Type_AudioChannelLabelSubDescriptor:
3902 AudioChannelLabels_MCALabelDictionaryID.push_back(SubDescriptor->second.MCALabelDictionaryID);
3903 break;
3904 case descriptor::Type_SoundfieldGroupLabelSubDescriptor:
3905 Fill(Stream_Audio, StreamPos_Last, "MCA Partition kind", SubDescriptor->second.MCAPartitionKind);
3906 Fill(Stream_Audio, StreamPos_Last, "MCA Partition Number", SubDescriptor->second.MCAPartitionNumber);
3907 Fill(Stream_Audio, StreamPos_Last, "MCA Title", SubDescriptor->second.MCATitle);
3908 Fill(Stream_Audio, StreamPos_Last, "MCA Title Version", SubDescriptor->second.MCATitleVersion);
3909 Fill(Stream_Audio, StreamPos_Last, "MCA Title Sub-Version", SubDescriptor->second.MCATitleSubVersion);
3910 Fill(Stream_Audio, StreamPos_Last, "MCA Episode", SubDescriptor->second.MCAEpisode);
3911 Fill(Stream_Audio, StreamPos_Last, "MCA Audio Content Kind", SubDescriptor->second.MCAAudioContentKind);
3912 Fill(Stream_Audio, StreamPos_Last, "MCA Audio Element Kind", SubDescriptor->second.MCAAudioElementKind);
3913 //if (SubDescriptor->second.MCALabelDictionaryID.lo!=(int64u)-1)
3914 //{
3915 // Ztring ChannelAssignment2;
3916 // ChannelAssignment2.From_Number(SubDescriptor->second.MCALabelDictionaryID.lo, 16);
3917 // if (ChannelAssignment2.size()<16)
3918 // ChannelAssignment2.insert(0, 16-ChannelAssignment2.size(), __T('0'));
3919 // if (!ChannelAssignment.empty())
3920 // ChannelAssignment+=__T('-');
3921 // ChannelAssignment+=ChannelAssignment2;
3922 //}
3923 for (std::map<std::string, Ztring>::iterator Info=SubDescriptor->second.Infos.begin(); Info!=SubDescriptor->second.Infos.end(); ++Info)
3924 Fill(Stream_Audio, StreamPos_Last, Info->first.c_str(), Info->second, true);
3925 break;
3926 default: ;
3927 #if MEDIAINFO_ADVANCED
3928 if (SubDescriptor->second.Jpeg2000_Rsiz!=(int16u)-1 && !Retrieve(StreamKind_Last, StreamPos_Last, "Format_Profile").empty() && Jpeg2000_Rsiz(SubDescriptor->second.Jpeg2000_Rsiz)!=Retrieve(StreamKind_Last, StreamPos_Last, "Format_Profile").To_UTF8())
3929 {
3930 Fill(StreamKind_Last, StreamPos_Last, "Format_Profile_FromStream", Retrieve(StreamKind_Last, StreamPos_Last, "Format_Profile"));
3931 Fill(StreamKind_Last, StreamPos_Last, "Format_Profile_FromContainer", Jpeg2000_Rsiz(SubDescriptor->second.Jpeg2000_Rsiz));
3932 }
3933 #endif //MEDIAINFO_ADVANCED
3934 }
3935
3936 //Special cases
3937 std::map<std::string, Ztring>::iterator Info_Level=SubDescriptor->second.Infos.find("Temp_AVC_Format_Level");
3938 std::map<std::string, Ztring>::iterator Info_constraint=SubDescriptor->second.Infos.find("Temp_AVC_constraint_set3_flag");
3939 if (Info_Level!=SubDescriptor->second.Infos.end() || Info_constraint!=SubDescriptor->second.Infos.end())
3940 {
3941 //AVC Descriptor creates that, adapting
3942 std::map<std::string, Ztring>::iterator Info_Profile=SubDescriptor->second.Infos.find("Format_Profile");
3943 if (Info_Profile!=SubDescriptor->second.Infos.end())
3944 {
3945 if (Info_constraint!=SubDescriptor->second.Infos.end())
3946 {
3947 if (Info_constraint->second==__T("1"))
3948 Info_Profile->second+=__T(" Intra");
3949 SubDescriptor->second.Infos.erase(Info_constraint);
3950 }
3951 if (Info_Level!=SubDescriptor->second.Infos.end())
3952 {
3953 Info_Profile->second+=__T("@L")+Info_Level->second;
3954 SubDescriptor->second.Infos.erase(Info_Level);
3955 }
3956 }
3957 }
3958
3959 for (std::map<std::string, Ztring>::iterator Info=SubDescriptor->second.Infos.begin(); Info!=SubDescriptor->second.Infos.end(); ++Info)
3960 if (Info->first=="ComponentCount")
3961 {
3962 if (Info->second==__T("4") && !Retrieve(StreamKind_Last, StreamPos_Last, "ColorSpace").empty())
3963 Fill(StreamKind_Last, StreamPos_Last, "ColorSpace", Retrieve(StreamKind_Last, StreamPos_Last, "ColorSpace")+__T('A'), true); // Descriptor name is "RGBA"...
3964 }
3965 else if (Retrieve(StreamKind_Last, StreamPos_Last, Info->first.c_str()).empty())
3966 Fill(StreamKind_Last, StreamPos_Last, Info->first.c_str(), Info->second);
3967 else if (Retrieve(StreamKind_Last, StreamPos_Last, Info->first.c_str()) != Info->second)
3968 {
3969 Fill(StreamKind_Last, StreamPos_Last, (Info->first+"_Original").c_str(), Retrieve(StreamKind_Last, StreamPos_Last, Info->first.c_str()));
3970 Fill(StreamKind_Last, StreamPos_Last, Info->first.c_str(), Info->second, true);
3971 }
3972 }
3973 }
3974
3975 if (!AudioChannelLabels_MCALabelDictionaryID.empty())
3976 {
3977 Fill(Stream_Audio, StreamPos_Last, Audio_ChannelPositions, MXF_MCALabelDictionaryID_ChannelPositions(AudioChannelLabels_MCALabelDictionaryID));
3978 Fill(Stream_Audio, StreamPos_Last, Audio_ChannelLayout, MXF_MCALabelDictionaryID_ChannelLayout(AudioChannelLabels_MCALabelDictionaryID));
3979 }
3980 }
3981 if (!ChannelAssignment.empty())
3982 Fill(Stream_Audio, StreamPos_Last, Audio_ChannelLayoutID, ChannelAssignment);
3983 }
3984
3985 //Fallback on partition data if classic methods failed
3986 if (StreamKind_Last!=Stream_Max && StreamPos_Last!=(size_t)-1 && Retrieve(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format)).empty() && Descriptors.size()==1 && Count_Get(StreamKind_Last)==1)
3987 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Format), Mxf_EssenceContainer(EssenceContainer_FromPartitionMetadata));
3988 }
3989
3990 //---------------------------------------------------------------------------
Streams_Finish_Locator(const int128u DescriptorUID,const int128u LocatorUID)3991 void File_Mxf::Streams_Finish_Locator(const int128u DescriptorUID, const int128u LocatorUID)
3992 {
3993 descriptors::iterator Descriptor=Descriptors.find(DescriptorUID);
3994 if (Descriptor==Descriptors.end())
3995 return;
3996
3997 locators::iterator Locator=Locators.find(LocatorUID);
3998 if (Locator==Locators.end())
3999 return;
4000
4001 //External file name specific
4002 if (!Locator->second.IsTextLocator && !Locator->second.EssenceLocator.empty())
4003 {
4004 //Preparing
4005 Locator->second.StreamKind=StreamKind_Last;
4006 Locator->second.StreamPos=StreamPos_Last;
4007 Locator->second.LinkedTrackID=Descriptor->second.LinkedTrackID;
4008 }
4009 }
4010
4011 //---------------------------------------------------------------------------
Streams_Finish_CommercialNames()4012 void File_Mxf::Streams_Finish_CommercialNames ()
4013 {
4014 //Commercial names
4015 if (Count_Get(Stream_Video)==1)
4016 {
4017 Streams_Finish_StreamOnly();
4018 if (!Retrieve(Stream_Video, 0, Video_Format_Commercial_IfAny).empty())
4019 {
4020 Fill(Stream_General, 0, General_Format_Commercial_IfAny, Retrieve(Stream_Video, 0, Video_Format_Commercial_IfAny));
4021 Fill(Stream_General, 0, General_Format_Commercial, __T("MXF ")+Retrieve(Stream_Video, 0, Video_Format_Commercial_IfAny));
4022 }
4023 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("DV"))
4024 {
4025 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "DV");
4026 Fill(Stream_General, 0, General_Format_Commercial, "MXF DV");
4027 }
4028 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("AVC") && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)==__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:0") && Retrieve(Stream_Video, 0, Video_BitRate)==__T("56064000"))
4029 {
4030 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "AVC-Intra 50");
4031 Fill(Stream_General, 0, General_Format_Commercial, "MXF AVC-Intra 50");
4032 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "AVC-Intra 50");
4033 }
4034 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("AVC") && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)==__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:2") && Retrieve(Stream_Video, 0, Video_BitRate)==__T("113664000"))
4035 {
4036 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "AVC-Intra 100");
4037 Fill(Stream_General, 0, General_Format_Commercial, "MXF AVC-Intra 100");
4038 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "AVC-Intra 100");
4039 }
4040 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)==__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:2") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("30000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("30000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("30000000")))
4041 {
4042 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "IMX 30");
4043 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "IMX 30");
4044 }
4045 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)==__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:2") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("40000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("40000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("40000000")))
4046 {
4047 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "IMX 40");
4048 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "IMX 40");
4049 }
4050 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)==__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:2") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("50000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("50000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("50000000")))
4051 {
4052 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "IMX 50");
4053 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "IMX 50");
4054 }
4055 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && !Retrieve(Stream_Video, 0, Video_Format_Settings_GOP).empty() && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)!=__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:0") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("18000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("18000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("18000000")))
4056 {
4057 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "XDCAM HD 18");
4058 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "XDCAM HD 18");
4059 }
4060 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && !Retrieve(Stream_Video, 0, Video_Format_Settings_GOP).empty() && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)!=__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:0") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("25000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("25000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("25000000")))
4061 {
4062 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "XDCAM HD 25");
4063 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "XDCAM HD 25");
4064 }
4065 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && !Retrieve(Stream_Video, 0, Video_Format_Settings_GOP).empty() && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)!=__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:0") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("35000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("35000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("35000000")))
4066 {
4067 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "XDCAM HD 35");
4068 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "XDCAM HD 35");
4069 }
4070 else if (Retrieve(Stream_Video, 0, Video_Format)==__T("MPEG Video") && !Retrieve(Stream_Video, 0, Video_Format_Settings_GOP).empty() && Retrieve(Stream_Video, 0, Video_Format_Settings_GOP)!=__T("N=1") && Retrieve(Stream_Video, 0, Video_ChromaSubsampling)==__T("4:2:2") && (Retrieve(Stream_Video, 0, Video_BitRate)==__T("50000000") || Retrieve(Stream_Video, 0, Video_BitRate_Nominal)==__T("50000000") || Retrieve(Stream_Video, 0, Video_BitRate_Maximum)==__T("50000000")))
4071 {
4072 Fill(Stream_General, 0, General_Format_Commercial_IfAny, "XDCAM HD422");
4073 Fill(Stream_Video, 0, Video_Format_Commercial_IfAny, "XDCAM HD422");
4074 }
4075 }
4076 }
4077
4078 //---------------------------------------------------------------------------
Streams_Finish_Component(const int128u ComponentUID,float64 EditRate,int32u TrackID,int64s Origin)4079 void File_Mxf::Streams_Finish_Component(const int128u ComponentUID, float64 EditRate, int32u TrackID, int64s Origin)
4080 {
4081 components::iterator Component=Components.find(ComponentUID);
4082 if (Component==Components.end())
4083 return;
4084
4085 //Duration
4086 if (EditRate && StreamKind_Last!=Stream_Max && Component->second.Duration!=(int64u)-1)
4087 {
4088 int64u FrameCount=Component->second.Duration;
4089 if (StreamKind_Last==Stream_Video || Config->File_EditRate)
4090 {
4091 int64u File_IgnoreEditsBefore=Config->File_IgnoreEditsBefore;
4092 if (File_IgnoreEditsBefore && Config->File_EditRate && (EditRate<Config->File_EditRate*0.9 || EditRate>Config->File_EditRate*1.1)) //In case of problem or EditRate being sampling rate
4093 File_IgnoreEditsBefore=float64_int64s(((float64)File_IgnoreEditsBefore)/Config->File_EditRate*EditRate);
4094 int64u File_IgnoreEditsAfter=Config->File_IgnoreEditsAfter;
4095 if (File_IgnoreEditsAfter!=(int64u)-1 && Config->File_EditRate && (EditRate<Config->File_EditRate*0.9 || EditRate>Config->File_EditRate*1.1)) //In case of problem or EditRate being sampling rate
4096 File_IgnoreEditsAfter=float64_int64s(((float64)File_IgnoreEditsAfter)/Config->File_EditRate*EditRate);
4097 if (File_IgnoreEditsAfter<FrameCount)
4098 FrameCount=File_IgnoreEditsAfter;
4099 if (FrameCount<File_IgnoreEditsBefore)
4100 FrameCount=File_IgnoreEditsBefore;
4101 FrameCount-=File_IgnoreEditsBefore;
4102 }
4103 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_Duration), FrameCount*1000/EditRate, 0, true);
4104 size_t ID_SubStreamInfo_Pos=Retrieve(StreamKind_Last, StreamPos_Last, General_ID).find(__T('-'));
4105 if (ID_SubStreamInfo_Pos!=string::npos)
4106 {
4107 Ztring ID=Retrieve(StreamKind_Last, StreamPos_Last, General_ID);
4108 ID.resize(ID_SubStreamInfo_Pos+1);
4109 size_t StreamPos_Last_Temp=StreamPos_Last;
4110 while (StreamPos_Last_Temp)
4111 {
4112 StreamPos_Last_Temp--;
4113 if (Retrieve(StreamKind_Last, StreamPos_Last_Temp, General_ID).find(ID)!=0)
4114 break;
4115 Fill(StreamKind_Last, StreamPos_Last_Temp, Fill_Parameter(StreamKind_Last, Generic_Duration), FrameCount*1000/EditRate, 0, true);
4116 }
4117 }
4118
4119 // Hack, TODO: find a correct method for detecting fiel/frame differene
4120 if (StreamKind_Last==Stream_Video)
4121 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
4122 if (Essence->second.StreamKind==Stream_Video && Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1)==StreamPos_Last)
4123 {
4124 if (Essence->second.Field_Count_InThisBlock_1 && !Essence->second.Field_Count_InThisBlock_2)
4125 FrameCount/=2;
4126 break;
4127 }
4128
4129 FillAllMergedStreams=true;
4130
4131 if (Retrieve(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_FrameCount)).empty())
4132 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_FrameCount), FrameCount);
4133
4134 if (Retrieve(StreamKind_Last, StreamPos_Last, "FrameRate").empty())
4135 Fill(StreamKind_Last, StreamPos_Last, "FrameRate", EditRate);
4136
4137 FillAllMergedStreams=false;
4138
4139 const Ztring& FrameRate_FromStream=Retrieve(StreamKind_Last, StreamPos_Last, "FrameRate");
4140 if (FrameRate_FromStream.empty())
4141 Fill(StreamKind_Last, StreamPos_Last, Fill_Parameter(StreamKind_Last, Generic_FrameRate), EditRate);
4142 else if (StreamKind_Last!=Stream_Audio || (Retrieve(Stream_Audio, StreamPos_Last, Audio_Format)==__T("Dolby E") && EditRate<1000)) //Arbitrary number for detecting frame rate vs sample rate (both are possible with Clip-wrapped MXF PCM e.g. 29.97 or 48000)
4143 {
4144 Ztring FrameRate_FromContainer; FrameRate_FromContainer.From_Number(EditRate);
4145 if (FrameRate_FromStream!=FrameRate_FromContainer)
4146 {
4147 size_t ID_SubStreamInfo_Pos=Retrieve(StreamKind_Last, StreamPos_Last, General_ID).find(__T('-')); //Filling all tracks with same ID (e.g. Dolby E). TODO: merge code
4148 size_t StreamPos_Last_Temp=StreamPos_Last;
4149 Ztring ID;
4150 if (ID_SubStreamInfo_Pos!=string::npos)
4151 {
4152 ID=Retrieve(StreamKind_Last, StreamPos_Last, General_ID);
4153 ID.resize(ID_SubStreamInfo_Pos+1);
4154 }
4155 for (;;)
4156 {
4157 //Merge was already done, we need to do here Container/Stream coherency test. TODO: merge of code
4158 Fill(StreamKind_Last, StreamPos_Last_Temp, "FrameRate_Original", FrameRate_FromStream);
4159 Fill(StreamKind_Last, StreamPos_Last_Temp, Fill_Parameter(StreamKind_Last, Generic_FrameRate), FrameRate_FromContainer, true);
4160 if (ID.empty() || !StreamPos_Last_Temp)
4161 break;
4162 StreamPos_Last_Temp--;
4163 if (Retrieve(StreamKind_Last, StreamPos_Last_Temp, General_ID).find(ID)!=0)
4164 break;
4165 }
4166 }
4167 }
4168 }
4169 }
4170
4171 //---------------------------------------------------------------------------
Streams_Finish_Component_ForTimeCode(const int128u ComponentUID,float64 EditRate,int32u TrackID,int64s Origin,bool IsSourcePackage,const Ztring & TrackName)4172 void File_Mxf::Streams_Finish_Component_ForTimeCode(const int128u ComponentUID, float64 EditRate, int32u TrackID, int64s Origin, bool IsSourcePackage, const Ztring& TrackName)
4173 {
4174 components::iterator Component=Components.find(ComponentUID);
4175 if (Component==Components.end())
4176 return;
4177
4178 //For the sequence, searching Structural componenents
4179 for (size_t Pos=0; Pos<Component->second.StructuralComponents.size(); Pos++)
4180 {
4181 components::iterator Component2=Components.find(Component->second.StructuralComponents[Pos]);
4182 if (Component2!=Components.end() && Component2->second.MxfTimeCode.StartTimecode!=(int64u)-1 && !Config->File_IsReferenced_Get())
4183 {
4184 //Note: Origin is not part of the StartTimecode for the first frame in the source package. From specs: "For a Timecode Track with a single Timecode Component and with origin N, where N greater than 0, the timecode value at the Zero Point of the Track equals the start timecode of the Timecode Component incremented by N units."
4185 TimeCode TC(Component2->second.MxfTimeCode.StartTimecode+Config->File_IgnoreEditsBefore, (int8u)Component2->second.MxfTimeCode.RoundedTimecodeBase, Component2->second.MxfTimeCode.DropFrame);
4186 bool IsHybridTimeCode=false;
4187 if (Component->second.StructuralComponents.size()==2 && !Pos)
4188 {
4189 components::iterator Component_TC2=Components.find(Component->second.StructuralComponents[1]);
4190 if (Component_TC2!=Components.end() && Component_TC2->second.MxfTimeCode.StartTimecode!=(int64u)-1)
4191 {
4192 TimeCode TC2(Component_TC2->second.MxfTimeCode.StartTimecode+Config->File_IgnoreEditsBefore, (int8u)Component_TC2->second.MxfTimeCode.RoundedTimecodeBase, Component2->second.MxfTimeCode.DropFrame);
4193 if (TC2.ToFrames()-TC.ToFrames()==2)
4194 {
4195 TC++;
4196 IsHybridTimeCode=true;
4197 }
4198 }
4199 }
4200 Stream_Prepare(Stream_Other);
4201 Fill(Stream_Other, StreamPos_Last, Other_ID, Ztring::ToZtring(TrackID)+(IsSourcePackage?__T("-Source"):__T("-Material")));
4202 Fill(Stream_Other, StreamPos_Last, Other_Type, "Time code");
4203 Fill(Stream_Other, StreamPos_Last, Other_Format, "MXF TC");
4204 if (Component2->second.MxfTimeCode.RoundedTimecodeBase<=(int8u)-1) // Found files with RoundedTimecodeBase of 0x8000
4205 Fill(Stream_Other, StreamPos_Last, Other_FrameRate, Component2->second.MxfTimeCode.RoundedTimecodeBase/(Component2->second.MxfTimeCode.DropFrame?1.001:1.000));
4206 Fill(Stream_Other, StreamPos_Last, Other_TimeCode_FirstFrame, TC.ToString().c_str());
4207 Fill(Stream_Other, StreamPos_Last, Other_TimeCode_Settings, IsSourcePackage?__T("Source Package"):__T("Material Package"));
4208 Fill(Stream_Other, StreamPos_Last, Other_TimeCode_Striped, "Yes");
4209 Fill(Stream_Other, StreamPos_Last, Other_Title, TrackName);
4210
4211 if ((!TimeCodeFromMaterialPackage && IsSourcePackage) || (TimeCodeFromMaterialPackage && !IsSourcePackage))
4212 {
4213 MxfTimeCodeForDelay=Component2->second.MxfTimeCode;
4214
4215 DTS_Delay=((float64)MxfTimeCodeForDelay.StartTimecode)/MxfTimeCodeForDelay.RoundedTimecodeBase;
4216 if (MxfTimeCodeForDelay.DropFrame)
4217 {
4218 DTS_Delay*=1001;
4219 DTS_Delay/=1000;
4220 }
4221 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000);
4222 #if MEDIAINFO_DEMUX
4223 Config->Demux_Offset_DTS_FromStream=FrameInfo.DTS;
4224 #endif //MEDIAINFO_DEMUX
4225 }
4226
4227 if (!IsSourcePackage)
4228 {
4229 MxfTimeCodeMaterial=Component2->second.MxfTimeCode;
4230 }
4231
4232 if (IsHybridTimeCode)
4233 break;
4234 }
4235 }
4236 }
4237
4238 //---------------------------------------------------------------------------
Streams_Finish_Component_ForAS11(const int128u ComponentUID,float64 EditRate,int32u TrackID,int64s Origin)4239 void File_Mxf::Streams_Finish_Component_ForAS11(const int128u ComponentUID, float64 EditRate, int32u TrackID, int64s Origin)
4240 {
4241 components::iterator Component=Components.find(ComponentUID);
4242 if (Component==Components.end())
4243 return;
4244
4245 //Computing frame rate
4246 int64u TC_Temp=0;
4247 int8u FrameRate_TempI;
4248 bool DropFrame_Temp;
4249 if (MxfTimeCodeMaterial.IsInit())
4250 {
4251 TC_Temp=MxfTimeCodeMaterial.StartTimecode;
4252 FrameRate_TempI=(int8u)MxfTimeCodeMaterial.RoundedTimecodeBase;
4253 DropFrame_Temp=MxfTimeCodeMaterial.DropFrame;
4254 }
4255 else
4256 {
4257 TC_Temp=0;
4258 Ztring FrameRateS=Retrieve(Stream_Video, 0, Video_FrameRate);
4259 int32u FrameRate_TempI32=float32_int32s(FrameRateS.To_float32());
4260 if (FrameRate_TempI32 && FrameRate_TempI32<256)
4261 {
4262 FrameRate_TempI=(int8u)FrameRate_TempI32;
4263 float32 FrameRateF=FrameRateS.To_float32();
4264 float FrameRateF_Min=((float32)FrameRate_TempI)/((float32)1.002);
4265 float FrameRateF_Max=(float32)FrameRate_TempI;
4266 if (FrameRateF>=FrameRateF_Min && FrameRateF<FrameRateF_Max)
4267 DropFrame_Temp=true;
4268 else
4269 DropFrame_Temp=false;
4270 }
4271 else
4272 {
4273 FrameRate_TempI=25;
4274 DropFrame_Temp=false;
4275 }
4276 }
4277
4278 //For the sequence, searching Structural componenents
4279 int64u Duration_CurrentPos=0;
4280 int64u Duration_Programme=0;
4281 for (size_t Pos=0; Pos<Component->second.StructuralComponents.size(); Pos++)
4282 {
4283 // AS-11
4284 dmsegments::iterator DMSegment=DMSegments.find(Component->second.StructuralComponents[Pos]);
4285 if (DMSegment!=DMSegments.end())
4286 {
4287 as11s::iterator AS11=AS11s.find(DMSegment->second.Framework);
4288 if (AS11!=AS11s.end())
4289 {
4290 if (StreamKind_Last==Stream_Max)
4291 {
4292 Stream_Prepare(Stream_Other);
4293 Fill(Stream_Other, StreamPos_Last, Other_ID, TrackID);
4294 Fill(Stream_Other, StreamPos_Last, Other_Type, "Metadata");
4295 if (AS11->second.Type==as11::Type_Segmentation)
4296 {
4297 if (AS11->second.PartTotal!=(int16u)-1)
4298 Fill(Stream_Other, StreamPos_Last, "PartTotal", AS11->second.PartTotal);
4299 }
4300 }
4301
4302 switch (AS11->second.Type)
4303 {
4304 case as11::Type_Core:
4305 Fill(Stream_Other, StreamPos_Last, "Format", "AS-11 Core");
4306 Fill(Stream_Other, StreamPos_Last, "SeriesTitle", AS11->second.SeriesTitle);
4307 Fill(Stream_Other, StreamPos_Last, "ProgrammeTitle", AS11->second.ProgrammeTitle);
4308 Fill(Stream_Other, StreamPos_Last, "EpisodeTitleNumber", AS11->second.EpisodeTitleNumber);
4309 Fill(Stream_Other, StreamPos_Last, "ShimName", AS11->second.ShimName);
4310 if (AS11->second.ShimVersion_Major!=(int8u)-1)
4311 {
4312 Ztring Version=Ztring::ToZtring(AS11->second.ShimVersion_Major);
4313 if (AS11->second.ShimVersion_Minor!=(int8u)-1)
4314 {
4315 Version+=__T('.');
4316 Version+=Ztring::ToZtring(AS11->second.ShimVersion_Minor);
4317 }
4318 Fill(Stream_Other, StreamPos_Last, "ShimVersion", Version);
4319 }
4320 if (AS11->second.AudioTrackLayout<Mxf_AS11_AudioTrackLayout_Count)
4321 {
4322 Fill(Stream_Other, StreamPos_Last, "AudioTrackLayout", Mxf_AS11_AudioTrackLayout[AS11->second.AudioTrackLayout]);
4323
4324 //Per track
4325 const mxf_as11_audiotracklayout_assignment &ChP=Mxf_AS11_AudioTrackLayout_ChannelPositions[AS11->second.AudioTrackLayout];
4326 const mxf_as11_audiotracklayout_assignment &ChL=Mxf_AS11_AudioTrackLayout_ChannelLayout[AS11->second.AudioTrackLayout];
4327 if (Count_Get(Stream_Audio)>=ChP.Count)
4328 for (int8u Pos=0; Pos<ChP.Count; ++Pos)
4329 {
4330 if (ChP.Assign[Pos])
4331 Fill(Stream_Audio, Pos, Audio_ChannelPositions, ChP.Assign[Pos]);
4332 if (ChL.Assign[Pos])
4333 Fill(Stream_Audio, Pos, Audio_ChannelLayout, ChL.Assign[Pos]);
4334 Fill(Stream_Audio, Pos, Audio_ChannelLayoutID, Mxf_AS11_AudioTrackLayout[AS11->second.AudioTrackLayout]);
4335 }
4336 }
4337 Fill(Stream_Other, StreamPos_Last, "PrimaryAudioLanguage", AS11->second.PrimaryAudioLanguage);
4338 //Fill_SetOptions(Stream_Other][StreamPos_Last](Ztring().From_UTF8("PrimaryAudioLanguage", "N NT");
4339 //if (MediaInfoLib::Config.Iso639_Find(AS11->second.PrimaryAudioLanguage).empty())
4340 // Fill(Stream_Other, StreamPos_Last, "PrimaryAudioLanguage/String", MediaInfoLib::Config.Iso639_Translate(AS11->second.PrimaryAudioLanguage));
4341 if (AS11->second.ClosedCaptionsPresent<2)
4342 Fill(Stream_Other, StreamPos_Last, "ClosedCaptionsPresent", AS11->second.ClosedCaptionsPresent?"Yes":"No");
4343 if (AS11->second.ClosedCaptionsType<Mxf_AS11_ClosedCaptionType_Count)
4344 Fill(Stream_Other, StreamPos_Last, "ClosedCaptionType", Mxf_AS11_ClosedCaptionType[AS11->second.ClosedCaptionsType]);
4345 Fill(Stream_Other, StreamPos_Last, "ClosedCaptionsLanguage", AS11->second.ClosedCaptionsLanguage);
4346 break;
4347 case as11::Type_Segmentation:
4348 Fill(Stream_Other, StreamPos_Last, "Format", "AS-11 Segmentation", Unlimited, true, true);
4349 if (AS11->second.PartNumber!=(int16u)-1 && AS11->second.PartTotal!=(int16u)-1)
4350 {
4351 string S;
4352 S+=TimeCode(TC_Temp+Duration_CurrentPos, FrameRate_TempI, DropFrame_Temp).ToString();
4353 if (DMSegment->second.Duration!=(int64u)-1)
4354 {
4355 S+=" + ";
4356 S+=TimeCode(DMSegment->second.Duration, FrameRate_TempI, DropFrame_Temp).ToString();
4357 S+=" = ";
4358 Duration_CurrentPos+=DMSegment->second.Duration;
4359 S+=TimeCode(TC_Temp+Duration_CurrentPos, FrameRate_TempI, DropFrame_Temp).ToString();
4360 Duration_Programme+=DMSegment->second.Duration;
4361 }
4362 Fill(Stream_Other, StreamPos_Last, Ztring::ToZtring(AS11->second.PartNumber).To_UTF8().c_str(), S);
4363 }
4364 break;
4365 case as11::Type_UKDPP:
4366 Fill(Stream_Other, StreamPos_Last, "Format", "AS-11 UKDPP");
4367 Fill(Stream_Other, StreamPos_Last, "ProductionNumber", AS11->second.ProductionNumber);
4368 Fill(Stream_Other, StreamPos_Last, "Synopsis", AS11->second.Synopsis);
4369 Fill(Stream_Other, StreamPos_Last, "Originator", AS11->second.Originator);
4370 if (AS11->second.CopyrightYear!=(int16u)-1)
4371 Fill(Stream_Other, StreamPos_Last, "CopyrightYear", AS11->second.CopyrightYear);
4372 Fill(Stream_Other, StreamPos_Last, "OtherIdentifier", AS11->second.OtherIdentifier);
4373 Fill(Stream_Other, StreamPos_Last, "OtherIdentifierType", AS11->second.OtherIdentifierType);
4374 Fill(Stream_Other, StreamPos_Last, "Genre", AS11->second.Genre);
4375 Fill(Stream_Other, StreamPos_Last, "Distributor", AS11->second.Distributor);
4376 if (AS11->second.PictureRatio_D!=(int32u)-1)
4377 Fill(Stream_Other, StreamPos_Last, "PictureRatio", Ztring::ToZtring(AS11->second.PictureRatio_N)+__T(':')+Ztring::ToZtring(AS11->second.PictureRatio_D));
4378 if (AS11->second.ThreeD!=(int8u)-1)
4379 Fill(Stream_Other, StreamPos_Last, "3D", AS11->second.ThreeD?__T("Yes"):__T("No"));
4380 if (AS11->second.ThreeDType<Mxf_AS11_3D_Type_Count)
4381 Fill(Stream_Other, StreamPos_Last, "3DType", Mxf_AS11_3D_Type[AS11->second.ThreeDType]);
4382 if (AS11->second.ProductPlacement!=(int8u)-1)
4383 Fill(Stream_Other, StreamPos_Last, "ProductPlacement", AS11->second.ProductPlacement?__T("Yes"):__T("No"));
4384 if (AS11->second.ThreeDType<Mxf_AS11_FpaPass_Count)
4385 Fill(Stream_Other, StreamPos_Last, "FpaPass", Mxf_AS11_FpaPass[AS11->second.FpaPass]);
4386 Fill(Stream_Other, StreamPos_Last, "FpaManufacturer", AS11->second.FpaManufacturer);
4387 Fill(Stream_Other, StreamPos_Last, "FpaVersion", AS11->second.FpaVersion);
4388 Fill(Stream_Other, StreamPos_Last, "VideoComments", AS11->second.VideoComments);
4389 if (AS11->second.SecondaryAudioLanguage!=__T("zxx"))
4390 Fill(Stream_Other, StreamPos_Last, "SecondaryAudioLanguage", AS11->second.SecondaryAudioLanguage);
4391 if (AS11->second.TertiaryAudioLanguage!=__T("zxx"))
4392 Fill(Stream_Other, StreamPos_Last, "TertiaryAudioLanguage", AS11->second.TertiaryAudioLanguage);
4393 if (AS11->second.AudioLoudnessStandard<Mxf_AS11_AudioLoudnessStandard_Count)
4394 Fill(Stream_Other, StreamPos_Last, "AudioLoudnessStandard", Mxf_AS11_AudioLoudnessStandard[AS11->second.AudioLoudnessStandard]);
4395 Fill(Stream_Other, StreamPos_Last, "AudioComments", AS11->second.AudioComments);
4396 if (AS11->second.LineUpStart!=(int64u)-1)
4397 Fill(Stream_Other, StreamPos_Last, "LineUpStart", Ztring().From_UTF8(TimeCode(TC_Temp+AS11->second.LineUpStart, FrameRate_TempI, DropFrame_Temp).ToString()));
4398 if (AS11->second.IdentClockStart!=(int64u)-1)
4399 Fill(Stream_Other, StreamPos_Last, "IdentClockStart", Ztring().From_UTF8(TimeCode(TC_Temp+AS11->second.IdentClockStart, FrameRate_TempI, DropFrame_Temp).ToString()));
4400 if (AS11->second.TotalNumberOfParts!=(int16u)-1)
4401 Fill(Stream_Other, StreamPos_Last, "TotalNumberOfParts", AS11->second.TotalNumberOfParts);
4402 if (AS11->second.TotalProgrammeDuration!=(int64u)-1)
4403 Fill(Stream_Other, StreamPos_Last, "TotalProgrammeDuration", Ztring().From_UTF8(TimeCode(AS11->second.TotalProgrammeDuration, FrameRate_TempI, DropFrame_Temp).ToString()));
4404 if (AS11->second.AudioDescriptionPresent!=(int8u)-1)
4405 Fill(Stream_Other, StreamPos_Last, "AudioDescriptionPresent", AS11->second.AudioDescriptionPresent?__T("Yes"):__T("No"));
4406 if (AS11->second.AudioDescriptionType<Mxf_AS11_AudioDescriptionType_Count)
4407 Fill(Stream_Other, StreamPos_Last, "AudioDescriptionType", Mxf_AS11_AudioLoudnessStandard[AS11->second.AudioDescriptionType]);
4408 if (AS11->second.OpenCaptionsPresent!=(int8u)-1)
4409 Fill(Stream_Other, StreamPos_Last, "OpenCaptionsPresent", AS11->second.OpenCaptionsPresent?__T("Yes"):__T("No"));
4410 if (AS11->second.OpenCaptionsType<Mxf_AS11_OpenCaptionsType_Count)
4411 Fill(Stream_Other, StreamPos_Last, "OpenCaptionsType", Mxf_AS11_OpenCaptionsType[AS11->second.OpenCaptionsType]);
4412 Fill(Stream_Other, StreamPos_Last, "OpenCaptionsLanguage", AS11->second.OpenCaptionsLanguage);
4413 if (AS11->second.SigningPresent<Mxf_AS11_SigningPresent_Count)
4414 Fill(Stream_Other, StreamPos_Last, "SigningPresent", Mxf_AS11_SigningPresent[AS11->second.SigningPresent]);
4415 if (AS11->second.SignLanguage<Mxf_AS11_SignLanguage_Count)
4416 Fill(Stream_Other, StreamPos_Last, "SignLanguage", Mxf_AS11_SignLanguage[AS11->second.SignLanguage]);
4417 //if (AS11->second.CompletionDate!=(int64u)-1)
4418 // Fill(Stream_Other, StreamPos_Last, "CompletionDate", Ztring::ToZtring(AS11->second.CompletionDate)+__T(" (TODO: Timestamp translation)")); //TODO: Timestamp
4419 if (AS11->second.TextlessElementsExist!=(int8u)-1)
4420 Fill(Stream_Other, StreamPos_Last, "TextlessElementsExist", AS11->second.TextlessElementsExist?__T("Yes"):__T("No"));
4421 if (AS11->second.ProgrammeHasText!=(int8u)-1)
4422 Fill(Stream_Other, StreamPos_Last, "ProgrammeHasText", AS11->second.ProgrammeHasText?__T("Yes"):__T("No"));
4423 Fill(Stream_Other, StreamPos_Last, "ProgrammeTextLanguage", AS11->second.ProgrammeTextLanguage);
4424 Fill(Stream_Other, StreamPos_Last, "ContactEmail", AS11->second.ContactEmail);
4425 Fill(Stream_Other, StreamPos_Last, "ContactTelephoneNumber", AS11->second.ContactTelephoneNumber);
4426 break;
4427 default: ;
4428 }
4429 }
4430 else if (DMSegment->second.IsAs11SegmentFiller && DMSegment->second.Duration!=(int64u)-1)
4431 Duration_CurrentPos+=DMSegment->second.Duration;
4432 }
4433 }
4434 if (Duration_Programme)
4435 Fill(Stream_Other, StreamPos_Last, "TotalProgrammeDuration", TimeCode(Duration_Programme, FrameRate_TempI, DropFrame_Temp).ToString());
4436 }
4437
4438 //---------------------------------------------------------------------------
Streams_Finish_Identification(const int128u IdentificationUID)4439 void File_Mxf::Streams_Finish_Identification (const int128u IdentificationUID)
4440 {
4441 identifications::iterator Identification=Identifications.find(IdentificationUID);
4442 if (Identification==Identifications.end())
4443 return;
4444
4445 //Product part
4446 Ztring Encoded_Application_Version=Identification->second.ProductVersion.empty()?Identification->second.VersionString:Identification->second.ProductVersion;
4447 Ztring Encoded_Application_ProductName(Identification->second.ProductName);
4448 if (!Identification->second.CompanyName.empty() && Identification->second.CompanyName.size()<Encoded_Application_ProductName.size())
4449 {
4450 Ztring ProductName_Begin(Encoded_Application_ProductName.c_str(), Identification->second.CompanyName.size());
4451 if (Identification->second.CompanyName.Compare(ProductName_Begin) && Encoded_Application_ProductName[Identification->second.CompanyName.size()]==__T(' '))
4452 Encoded_Application_ProductName.erase(0, Identification->second.CompanyName.size()+1);
4453 }
4454 size_t Encoded_Application_ProductName_Pos = Encoded_Application_ProductName.find_last_of(__T(' '));
4455 if (Encoded_Application_ProductName_Pos!=string::npos)
4456 {
4457 Ztring Encoded_Application_ProductName_End(Encoded_Application_ProductName.c_str()+Encoded_Application_ProductName_Pos+1);
4458 if (Encoded_Application_Version.find(Encoded_Application_ProductName_End)==0)
4459 Encoded_Application_ProductName.resize(Encoded_Application_ProductName_Pos); //Removing version number from the name (format not conform)
4460 }
4461 Fill(Stream_General, 0, General_Encoded_Application_CompanyName, Identification->second.CompanyName, true);
4462 Fill(Stream_General, 0, General_Encoded_Application_Name, Encoded_Application_ProductName, true);
4463 Fill(Stream_General, 0, General_Encoded_Application_Version, Encoded_Application_Version, true);
4464
4465 //Platform part
4466 Ztring Library_Name(Identification->second.Platform);
4467 size_t Library_Name_Pos = Library_Name.find_last_of(__T(' '));
4468 if (Library_Name_Pos!=string::npos)
4469 {
4470 Ztring Library_Name_End(Library_Name.c_str()+Library_Name_Pos+1);
4471 if (Identification->second.ToolkitVersion.find(Library_Name_End)==0)
4472 Library_Name.resize(Library_Name_Pos); //Removing version number from the name (format not conform)
4473 }
4474 Fill(Stream_General, 0, General_Encoded_Library_Name, Library_Name, true);
4475 Fill(Stream_General, 0, General_Encoded_Library_Version, Identification->second.ToolkitVersion, true);
4476
4477 for (std::map<std::string, Ztring>::iterator Info=Identification->second.Infos.begin(); Info!=Identification->second.Infos.end(); ++Info)
4478 Fill(Stream_General, 0, Info->first.c_str(), Info->second, true);
4479 }
4480
4481 //***************************************************************************
4482 // Buffer - Global
4483 //***************************************************************************
4484
4485 //---------------------------------------------------------------------------
Read_Buffer_Init()4486 void File_Mxf::Read_Buffer_Init()
4487 {
4488 EssenceContainer_FromPartitionMetadata=0;
4489 #if MEDIAINFO_DEMUX
4490 Demux_UnpacketizeContainer=Config->Demux_Unpacketize_Get();
4491 Demux_Rate=Config->Demux_Rate_Get();
4492 #endif //MEDIAINFO_DEMUX
4493
4494 //Config
4495 TimeCodeFromMaterialPackage=Config->File_Mxf_TimeCodeFromMaterialPackage_Get();
4496 }
4497
4498 //---------------------------------------------------------------------------
Read_Buffer_Continue()4499 void File_Mxf::Read_Buffer_Continue()
4500 {
4501 #if MEDIAINFO_DEMUX
4502 if (Demux_CurrentParser)
4503 {
4504 if (Frame_Count_NotParsedIncluded!=(int64u)-1)
4505 Frame_Count_NotParsedIncluded--;
4506 Open_Buffer_Continue(Demux_CurrentParser, Buffer+Buffer_Offset, 0, false);
4507 if (Frame_Count_NotParsedIncluded!=(int64u)-1)
4508 Frame_Count_NotParsedIncluded++;
4509 if (Config->Demux_EventWasSent)
4510 return;
4511 switch (Demux_CurrentParser->Field_Count_InThisBlock)
4512 {
4513 case 1 : Demux_CurrentEssence->second.Field_Count_InThisBlock_1++; break;
4514 case 2 : Demux_CurrentEssence->second.Field_Count_InThisBlock_2++; break;
4515 default: ;
4516 }
4517 if (Demux_CurrentParser->Buffer_Size)
4518 Demux_CurrentParser=NULL; //No more need of it
4519 }
4520 #endif //MEDIAINFO_DEMUX
4521
4522 Read_Buffer_CheckFileModifications();
4523
4524 if (IsSearchingFooterPartitionAddress)
4525 {
4526 if (File_Offset+Buffer_Size<File_Size)
4527 {
4528 Element_WaitForMoreData();
4529 return;
4530 }
4531
4532 IsSearchingFooterPartitionAddress=false;
4533 Buffer_Offset=Buffer_Size; //Default is end of file (not found)
4534
4535 const int8u* B_Cur06=Buffer+Buffer_Size-16;
4536 while (B_Cur06>=Buffer)
4537 {
4538 while (B_Cur06>=Buffer)
4539 {
4540 if (*B_Cur06==0x06)
4541 break;
4542 B_Cur06--;
4543 }
4544 if (B_Cur06<Buffer)
4545 break;
4546
4547 const int8u* B_Cur=B_Cur06;
4548 if (*(B_Cur++)==0x06
4549 && *(B_Cur++)==0x0E
4550 && *(B_Cur++)==0x2B
4551 && *(B_Cur++)==0x34
4552 && *(B_Cur++)==0x02
4553 && *(B_Cur++)==0x05
4554 && *(B_Cur++)==0x01
4555 && *(B_Cur++)==0x01
4556 && *(B_Cur++)==0x0D
4557 && *(B_Cur++)==0x01
4558 && *(B_Cur++)==0x02
4559 && *(B_Cur++)==0x01
4560 && *(B_Cur++)==0x01
4561 && *(B_Cur++)==0x04)
4562 {
4563 IsCheckingFooterPartitionAddress=true;
4564 Buffer_Offset=B_Cur06-Buffer;
4565 break;
4566 }
4567
4568 B_Cur06--;
4569 }
4570
4571 if (B_Cur06<Buffer)
4572 {
4573 GoToFromEnd(0);
4574 return;
4575 }
4576 }
4577
4578 if (IsCheckingFooterPartitionAddress)
4579 {
4580 if (Buffer_Offset+17>Buffer_Size)
4581 {
4582 Element_WaitForMoreData();
4583 return;
4584 }
4585
4586 IsCheckingFooterPartitionAddress=false;
4587
4588 const int8u* B_Cur=Buffer+Buffer_Offset;
4589 if (*(B_Cur++)==0x06
4590 && *(B_Cur++)==0x0E
4591 && *(B_Cur++)==0x2B
4592 && *(B_Cur++)==0x34
4593 && *(B_Cur++)==0x02
4594 && *(B_Cur++)==0x05
4595 && *(B_Cur++)==0x01
4596 && *(B_Cur++)==0x01
4597 && *(B_Cur++)==0x0D
4598 && *(B_Cur++)==0x01
4599 && *(B_Cur++)==0x02
4600 && *(B_Cur++)==0x01
4601 && *(B_Cur++)==0x01
4602 && *(B_Cur++)==0x04)
4603 {
4604 int64u Size=*(B_Cur++);
4605 if (Size >= 0x80)
4606 {
4607 Size&=0x7F;
4608 if (17+Size>Buffer_Size)
4609 {
4610 if (File_Offset+17+Size<File_Size)
4611 {
4612 Element_WaitForMoreData();
4613 return;
4614 }
4615
4616 Fill(Stream_General, 0, "IsTruncated", "Yes", Unlimited, true, true);
4617 }
4618 }
4619 }
4620 else
4621 {
4622 GoToFromEnd(4); //For random access table because it is invalid footer
4623 return;
4624 }
4625 }
4626
4627 if (IsCheckingRandomAccessTable)
4628 {
4629 if (17>Buffer_Size)
4630 {
4631 Element_WaitForMoreData();
4632 return;
4633 }
4634 IsCheckingRandomAccessTable=false;
4635 if (CC4(Buffer+Buffer_Offset)!=0x060E2B34 || CC3(Buffer+Buffer_Offset+4)!=0x020501 || CC3(Buffer+Buffer_Offset+8)!=0x0D0102 || CC1(Buffer+Buffer_Offset+12)!=0x01) // Checker if it is a Partition
4636 {
4637 if (File_Size>=64*1024)
4638 {
4639 IsSearchingFooterPartitionAddress=true;
4640 GoToFromEnd(64*1024); // Wrong offset, searching from end of file
4641 }
4642 else
4643 GoToFromEnd(0);
4644 return;
4645 }
4646 }
4647
4648 if (Config->ParseSpeed<1.0 && File_Offset+Buffer_Offset+4==File_Size)
4649 {
4650 int32u Length;
4651 Get_B4 (Length, "Length (Random Index)");
4652 if (Length>=16+4 && Length<File_Size/2)
4653 {
4654 GoToFromEnd(Length); //For random access table
4655 IsCheckingRandomAccessTable=true;
4656 Open_Buffer_Unsynch();
4657 }
4658 else
4659 {
4660 if (File_Size>=64*1024)
4661 {
4662 IsSearchingFooterPartitionAddress=true;
4663 GoToFromEnd(64*1024); // Wrong offset, searching from end of file
4664 }
4665 else
4666 GoToFromEnd(0);
4667 return;
4668 }
4669 }
4670 }
4671
4672 //---------------------------------------------------------------------------
4673 #if defined(MEDIAINFO_FILE_YES)
Read_Buffer_CheckFileModifications()4674 void File_Mxf::Read_Buffer_CheckFileModifications()
4675 {
4676 if (!IsSub)
4677 {
4678 if (Config->ParseSpeed>=1.0)
4679 {
4680 bool Buffer_End_IsUpdated=false;
4681 if (HeaderPartition_IsOpen && !Config->File_IsNotGrowingAnymore)
4682 {
4683 File F;
4684 F.Open(File_Name);
4685 std::vector<int8u> SearchingPartitionPack(65536);
4686 size_t SearchingPartitionPack_Size=F.Read(&SearchingPartitionPack[0], SearchingPartitionPack.size());
4687 for (size_t Pos=0; Pos+16<SearchingPartitionPack_Size; Pos++)
4688 if (SearchingPartitionPack[Pos ]==0x06
4689 && SearchingPartitionPack[Pos+ 1]==0x0E
4690 && SearchingPartitionPack[Pos+ 2]==0x2B
4691 && SearchingPartitionPack[Pos+ 3]==0x34
4692 && SearchingPartitionPack[Pos+ 4]==0x02
4693 && SearchingPartitionPack[Pos+ 5]==0x05
4694 && SearchingPartitionPack[Pos+ 6]==0x01
4695 && SearchingPartitionPack[Pos+ 7]==0x01
4696 && SearchingPartitionPack[Pos+ 8]==0x0D
4697 && SearchingPartitionPack[Pos+ 9]==0x01
4698 && SearchingPartitionPack[Pos+10]==0x02
4699 && SearchingPartitionPack[Pos+11]==0x01
4700 && SearchingPartitionPack[Pos+12]==0x01
4701 && SearchingPartitionPack[Pos+13]==0x02) //Header Partition Pack
4702 {
4703 switch (SearchingPartitionPack[Pos+14])
4704 {
4705 case 0x02 :
4706 case 0x04 :
4707 {
4708 //Filling duration
4709 F.Close();
4710 Config->File_IsNotGrowingAnymore=true;
4711 MediaInfo_Internal MI;
4712 Ztring ParseSpeed_Save=MI.Option(__T("ParseSpeed_Get"), __T(""));
4713 Ztring Demux_Save=MI.Option(__T("Demux_Get"), __T(""));
4714 MI.Option(__T("ParseSpeed"), __T("0"));
4715 MI.Option(__T("Demux"), Ztring());
4716 size_t MiOpenResult=MI.Open(File_Name);
4717 MI.Option(__T("ParseSpeed"), ParseSpeed_Save); //This is a global value, need to reset it. TODO: local value
4718 MI.Option(__T("Demux"), Demux_Save); //This is a global value, need to reset it. TODO: local value
4719 if (MiOpenResult)
4720 {
4721 Fill(Stream_General, 0, General_Format_Settings, MI.Get(Stream_General, 0, General_Format_Settings), true);
4722 Fill(Stream_General, 0, General_Duration, MI.Get(Stream_General, 0, General_Duration), true);
4723 Fill(Stream_General, 0, General_FileSize, MI.Get(Stream_General, 0, General_FileSize), true);
4724 Fill(Stream_General, 0, General_StreamSize, MI.Get(Stream_General, 0, General_StreamSize), true);
4725 if (Buffer_End_Unlimited)
4726 {
4727 Buffer_End=MI.Get(Stream_General, 0, General_FileSize).To_int64u()-MI.Get(Stream_General, 0, General_FooterSize).To_int64u();
4728 Buffer_End_IsUpdated=true;
4729 }
4730 #if defined(MEDIAINFO_REFERENCES_YES)
4731 if (!Config->File_IsReferenced_Get() && ReferenceFiles && Retrieve(Stream_General, 0, General_StreamSize).To_int64u())
4732 {
4733 //Playlist file size is not correctly modified
4734 Config->File_Size-=File_Size;
4735 File_Size=Retrieve(Stream_General, 0, General_StreamSize).To_int64u();
4736 Config->File_Size+=File_Size;
4737 }
4738 #endif //MEDIAINFO_REFERENCES_YES
4739 }
4740 }
4741 break;
4742 default : ;
4743 }
4744 }
4745
4746 if (Buffer_End && Buffer_End_Unlimited && !Buffer_End_IsUpdated)
4747 Buffer_End=Config->File_Size; //Updating Clip end in case the
4748 }
4749
4750 Config->State_Set(((float)Buffer_TotalBytes)/Config->File_Size);
4751 }
4752 }
4753 }
4754 #endif //defined(MEDIAINFO_FILE_YES)
4755
4756 //---------------------------------------------------------------------------
Read_Buffer_AfterParsing()4757 void File_Mxf::Read_Buffer_AfterParsing()
4758 {
4759 if (File_GoTo==(int64u)-1 && File_Offset+Buffer_Offset>=IsParsingMiddle_MaxOffset)
4760 {
4761 Fill();
4762 Open_Buffer_Unsynch();
4763 Finish();
4764 return;
4765 }
4766
4767 if (Config->IsFinishing)
4768 {
4769 if (Partitions_IsCalculatingHeaderByteCount)
4770 {
4771 Partitions_IsCalculatingHeaderByteCount=false;
4772 if (Partitions_Pos<Partitions.size())
4773 Partitions[Partitions_Pos].PartitionPackByteCount=File_Offset+Buffer_Offset-Partitions[Partitions_Pos].StreamOffset;
4774 }
4775
4776 if (IsParsingEnd)
4777 {
4778 if (PartitionMetadata_PreviousPartition && RandomIndexPacks.empty() && !RandomIndexPacks_AlreadyParsed)
4779 {
4780 Partitions_Pos=0;
4781 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset!=PartitionMetadata_PreviousPartition)
4782 Partitions_Pos++;
4783 if (Partitions_Pos==Partitions.size())
4784 {
4785 GoTo(PartitionMetadata_PreviousPartition);
4786 Open_Buffer_Unsynch();
4787 return;
4788 }
4789 }
4790 }
4791
4792 //Checking if we want to seek again
4793 if (File_GoTo==(int64u)-1)
4794 GoToFromEnd(0);
4795 }
4796 }
4797
4798 //---------------------------------------------------------------------------
Read_Buffer_Unsynched()4799 void File_Mxf::Read_Buffer_Unsynched()
4800 {
4801 //Adapting DataSizeToParse
4802 if (Buffer_End)
4803 {
4804 if (File_GoTo>=Buffer_End //Too much late
4805 || File_GoTo<=Buffer_Begin) //Too much early
4806 {
4807 Buffer_Begin=(int64u)-1;
4808 Buffer_End=0;
4809 Buffer_End_Unlimited=false;
4810 Buffer_Header_Size=0;
4811 MustSynchronize=true;
4812 Synched=false;
4813 UnSynched_IsNotJunk=true;
4814 }
4815 else
4816 Synched=true; //Always in clip data
4817 }
4818
4819 FrameInfo=frame_info();
4820 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000);
4821 Frame_Count_NotParsedIncluded=(int64u)-1;
4822 #if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
4823 if (!Tracks.empty() && Tracks.begin()->second.EditRate) //TODO: use the corresponding track instead of the first one
4824 FrameInfo.DUR=float64_int64s(1000000000/Tracks.begin()->second.EditRate);
4825 else if (!IndexTables.empty() && IndexTables[0].IndexEditRate)
4826 FrameInfo.DUR=float64_int64s(1000000000/IndexTables[0].IndexEditRate);
4827
4828 //Calculating the byte count not included in seek information (partition, index...)
4829 int64u FutureFileOffset=File_GoTo==(int64u)-1?(File_Offset+Buffer_Offset):File_GoTo;
4830 int64u StreamOffset_Offset=0;
4831 Partitions_Pos=0;
4832 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<=FutureFileOffset)
4833 {
4834 StreamOffset_Offset+=Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
4835 Partitions_Pos++;
4836 }
4837
4838 if (Partitions_Pos==2 && Partitions[1].StreamOffset==FutureFileOffset && Descriptors.size()==1 && Descriptors.begin()->second.StreamKind==Stream_Text)
4839 Frame_Count_NotParsedIncluded=0;
4840
4841 if (Descriptors.size()==1 && Descriptors.begin()->second.ByteRate!=(int32u)-1 && Descriptors.begin()->second.SampleRate)
4842 {
4843 float64 BytePerFrame=Descriptors.begin()->second.ByteRate/Descriptors.begin()->second.SampleRate;
4844 float64 Frame_Count_NotParsedIncluded_Precise;
4845 if (FutureFileOffset>(StreamOffset_Offset+Buffer_Header_Size))
4846 Frame_Count_NotParsedIncluded_Precise=(FutureFileOffset-(StreamOffset_Offset+Buffer_Header_Size))/BytePerFrame; //In case of audio at frame rate not an integer
4847 else
4848 Frame_Count_NotParsedIncluded_Precise=0;
4849 Frame_Count_NotParsedIncluded=float64_int64s(Frame_Count_NotParsedIncluded_Precise);
4850 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000+((float64)Frame_Count_NotParsedIncluded_Precise)*1000000000/Descriptors.begin()->second.SampleRate);
4851 FrameInfo.PTS=FrameInfo.DTS;
4852 if (!Tracks.empty() && Tracks.begin()->second.EditRate) //TODO: use the corresponding track instead of the first one
4853 FrameInfo.DUR=float64_int64s(1000000000/Tracks.begin()->second.EditRate);
4854 else if (!IndexTables.empty() && IndexTables[0].IndexEditRate)
4855 FrameInfo.DUR=float64_int64s(1000000000/IndexTables[0].IndexEditRate);
4856 else
4857 FrameInfo.DUR=float64_int64s(1000000000/Descriptors.begin()->second.SampleRate);
4858 #if MEDIAINFO_DEMUX
4859 Demux_random_access=true;
4860 #endif //MEDIAINFO_DEMUX
4861 }
4862 else if (!IndexTables.empty() && IndexTables[0].EditUnitByteCount)
4863 {
4864 int64u Position=0;
4865 Frame_Count_NotParsedIncluded=0;
4866 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
4867 {
4868 if (IndexTables[0].IndexDuration && FutureFileOffset>=((Buffer_End?Buffer_Begin:(StreamOffset_Offset+Buffer_Header_Size))+Position)+IndexTables[Pos].IndexDuration*IndexTables[Pos].EditUnitByteCount) //Considering IndexDuration=0 as unlimited
4869 {
4870 Position+=SDTI_SizePerFrame+IndexTables[Pos].EditUnitByteCount*IndexTables[Pos].IndexDuration;
4871 Frame_Count_NotParsedIncluded+=IndexTables[Pos].IndexDuration;
4872 }
4873 else
4874 {
4875 int64u FramesToAdd;
4876 if (FutureFileOffset>((Buffer_End?Buffer_Begin:(StreamOffset_Offset+Buffer_Header_Size))+Position))
4877 FramesToAdd=(FutureFileOffset-((Buffer_End?Buffer_Begin:(StreamOffset_Offset+Buffer_Header_Size))+Position))/IndexTables[Pos].EditUnitByteCount;
4878 else
4879 FramesToAdd=0;
4880 Position+=(SDTI_SizePerFrame+IndexTables[Pos].EditUnitByteCount)*FramesToAdd;
4881 if (IndexTables[Pos].IndexEditRate)
4882 {
4883 if (Descriptors.size()==1 && Descriptors.begin()->second.SampleRate!=IndexTables[Pos].IndexEditRate)
4884 {
4885 float64 Frame_Count_NotParsedIncluded_Precise=((float64)FramesToAdd)/IndexTables[Pos].IndexEditRate*Descriptors.begin()->second.SampleRate;
4886 Frame_Count_NotParsedIncluded+=float64_int64s(((float64)FramesToAdd)/IndexTables[Pos].IndexEditRate*Descriptors.begin()->second.SampleRate);
4887 FrameInfo.PTS=FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000+((float64)Frame_Count_NotParsedIncluded_Precise)*1000000000/Descriptors.begin()->second.SampleRate);
4888 }
4889 else
4890 {
4891 Frame_Count_NotParsedIncluded+=FramesToAdd;
4892 FrameInfo.PTS=FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000+((float64)Frame_Count_NotParsedIncluded)*1000000000/IndexTables[Pos].IndexEditRate);
4893 }
4894 }
4895 else
4896 FrameInfo.PTS=FrameInfo.DTS=(int64u)-1;
4897 #if MEDIAINFO_DEMUX
4898 Demux_random_access=true;
4899 #endif //MEDIAINFO_DEMUX
4900
4901 break;
4902 }
4903 }
4904 }
4905 else if (!IndexTables.empty() && !IndexTables[0].Entries.empty())
4906 {
4907 int64u StreamOffset;
4908 if (StreamOffset_Offset<FutureFileOffset)
4909 StreamOffset=FutureFileOffset-StreamOffset_Offset;
4910 else
4911 StreamOffset=0;
4912 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
4913 {
4914 //Searching the right index
4915 if (!IndexTables[Pos].Entries.empty() && StreamOffset>=IndexTables[Pos].Entries[0].StreamOffset+(IndexTables[Pos].IndexStartPosition)*SDTI_SizePerFrame && (Pos+1>=IndexTables.size() || IndexTables[Pos+1].Entries.empty() || StreamOffset<IndexTables[Pos+1].Entries[0].StreamOffset+(IndexTables[Pos+1].IndexStartPosition)*SDTI_SizePerFrame))
4916 {
4917 //Searching the frame pos
4918 for (size_t EntryPos=0; EntryPos<IndexTables[Pos].Entries.size(); EntryPos++)
4919 {
4920 //Testing coherency
4921 int64u Entry0_StreamOffset=0; //For coherency checking
4922 int64u Entry_StreamOffset=IndexTables[Pos].Entries[EntryPos].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos)*SDTI_SizePerFrame;
4923 int64u Entry1_StreamOffset=File_Size; //For coherency checking
4924 if (EntryPos==0 && Pos && !IndexTables[Pos-1].Entries.empty())
4925 Entry0_StreamOffset=IndexTables[Pos-1].Entries[IndexTables[Pos-1].Entries.size()-1].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos-1)*SDTI_SizePerFrame;
4926 else if (EntryPos)
4927 Entry0_StreamOffset=IndexTables[Pos].Entries[EntryPos-1].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos-1)*SDTI_SizePerFrame;
4928 if (EntryPos+1<IndexTables[Pos].Entries.size())
4929 Entry1_StreamOffset=IndexTables[Pos].Entries[EntryPos+1].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos+1)*SDTI_SizePerFrame;
4930 else if (Pos+1<IndexTables.size() && !IndexTables[Pos+1].Entries.empty())
4931 Entry1_StreamOffset=IndexTables[Pos+1].Entries[0].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos+1)*SDTI_SizePerFrame;
4932
4933 if (Entry0_StreamOffset>Entry_StreamOffset || Entry_StreamOffset>Entry1_StreamOffset)
4934 break; //Problem
4935
4936 if (StreamOffset>=Entry_StreamOffset && StreamOffset<Entry1_StreamOffset)
4937 {
4938 //Special case: we are not sure the last index is the last frame, doing nothing
4939 if (Pos+1==IndexTables.size() && EntryPos+1==IndexTables[Pos].Entries.size())
4940 break;
4941
4942 Frame_Count_NotParsedIncluded=IndexTables[Pos].IndexStartPosition+EntryPos;
4943 if (IndexTables[Pos].IndexEditRate)
4944 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000+((float64)Frame_Count_NotParsedIncluded)/IndexTables[Pos].IndexEditRate*1000000000);
4945
4946
4947 #if MEDIAINFO_DEMUX
4948 Demux_random_access=IndexTables[Pos].Entries[EntryPos].Type?false:true;
4949 #endif //MEDIAINFO_DEMUX
4950 break;
4951 }
4952 }
4953 }
4954 }
4955 }
4956 else if (OverallBitrate_IsCbrForSure)
4957 {
4958 int64u Begin=Partitions[0].StreamOffset+Partitions[0].PartitionPackByteCount+Partitions[0].HeaderByteCount+Partitions[0].IndexByteCount;
4959 Frame_Count_NotParsedIncluded=(FutureFileOffset-Begin)/OverallBitrate_IsCbrForSure;
4960 if (!Descriptors.empty() && Descriptors.begin()->second.SampleRate)
4961 FrameInfo.PTS=FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000+((float64)Frame_Count_NotParsedIncluded)*1000000000/Descriptors.begin()->second.SampleRate);
4962 }
4963 else if (Frame_Count_NotParsedIncluded==0)
4964 {
4965 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000);
4966 }
4967
4968 #endif //if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
4969
4970 if (!Tracks.empty() && Tracks.begin()->second.EditRate) //TODO: use the corresponding track instead of the first one
4971 FrameInfo.DUR=float64_int64s(1000000000/Tracks.begin()->second.EditRate);
4972 #if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
4973 else if (!IndexTables.empty() && IndexTables[0].IndexEditRate)
4974 FrameInfo.DUR=float64_int64s(1000000000/IndexTables[0].IndexEditRate);
4975 #endif //if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
4976
4977 for (essences::iterator Essence=Essences.begin(); Essence!=Essences.end(); ++Essence)
4978 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
4979 {
4980 (*Parser)->Open_Buffer_Unsynch();
4981 Essence->second.FrameInfo=FrameInfo;
4982 Essence->second.Frame_Count_NotParsedIncluded=Frame_Count_NotParsedIncluded;
4983 }
4984
4985 Partitions_Pos=0;
4986 if (Partitions_IsCalculatingHeaderByteCount)
4987 {
4988 Partitions.erase(Partitions.end()-1);
4989 Partitions_IsCalculatingHeaderByteCount=false;
4990 }
4991 if (Partitions_IsCalculatingSdtiByteCount)
4992 Partitions_IsCalculatingSdtiByteCount=false;
4993
4994 #if MEDIAINFO_SEEK
4995 IndexTables_Pos=0;
4996 #endif //MEDIAINFO_SEEK
4997 }
4998
4999 //---------------------------------------------------------------------------
5000 #if (MEDIAINFO_DEMUX || MEDIAINFO_SEEK) && defined(MEDIAINFO_FILE_YES)
DetectDuration()5001 bool File_Mxf::DetectDuration ()
5002 {
5003 if (Duration_Detected)
5004 return false;
5005
5006 MediaInfo_Internal MI;
5007 MI.Option(__T("File_IsDetectingDuration"), __T("1"));
5008 MI.Option(__T("File_KeepInfo"), __T("1"));
5009 Ztring ParseSpeed_Save=MI.Option(__T("ParseSpeed_Get"), __T(""));
5010 Ztring Demux_Save=MI.Option(__T("Demux_Get"), __T(""));
5011 MI.Option(__T("ParseSpeed"), __T("0"));
5012 MI.Option(__T("Demux"), Ztring());
5013 MI.Option(__T("File_Mxf_ParseIndex"), __T("1"));
5014 size_t MiOpenResult=MI.Open(File_Name);
5015 MI.Option(__T("ParseSpeed"), ParseSpeed_Save); //This is a global value, need to reset it. TODO: local value
5016 MI.Option(__T("Demux"), Demux_Save); //This is a global value, need to reset it. TODO: local value
5017 if (!MiOpenResult || MI.Get(Stream_General, 0, General_Format)!=__T("MXF"))
5018 return false;
5019 Partitions=((File_Mxf*)MI.Info)->Partitions;
5020 std::sort(Partitions.begin(), Partitions.end());
5021 IndexTables=((File_Mxf*)MI.Info)->IndexTables;
5022 std::sort(IndexTables.begin(), IndexTables.end());
5023 SDTI_SizePerFrame=((File_Mxf*)MI.Info)->SDTI_SizePerFrame;
5024 Clip_Begin=((File_Mxf*)MI.Info)->Clip_Begin;
5025 Clip_End=((File_Mxf*)MI.Info)->Clip_End;
5026 Clip_Header_Size=((File_Mxf*)MI.Info)->Clip_Header_Size;
5027 Clip_Code=((File_Mxf*)MI.Info)->Clip_Code;
5028 Tracks=((File_Mxf*)MI.Info)->Tracks; //In one file (*-009.mxf), the TrackNumber is known only at the end of the file (Open and incomplete header/footer)
5029 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
5030 Track->second.Stream_Finish_Done=false; //Reseting the value, it is not done in this instance
5031 if (MI.Get(Stream_General, 0, General_OverallBitRate_Mode)==__T("CBR") && Partitions.size()==2 && Partitions[0].FooterPartition==Partitions[1].StreamOffset && !Descriptors.empty())
5032 {
5033 //Searching duration
5034 int64u Duration=0;
5035 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
5036 if (Descriptor->second.Duration!=(int64u)-1 && Descriptor->second.Duration)
5037 {
5038 if (Duration && Duration!=Descriptor->second.Duration)
5039 {
5040 Duration=0;
5041 break; //Not supported
5042 }
5043 Duration=Descriptor->second.Duration;
5044 }
5045
5046 //Computing the count of bytes per frame
5047 if (Duration)
5048 {
5049 int64u Begin=Partitions[0].StreamOffset+Partitions[0].PartitionPackByteCount+Partitions[0].HeaderByteCount+Partitions[0].IndexByteCount;
5050 float64 BytesPerFrameF=((float64)(Partitions[0].FooterPartition-Begin)/Duration);
5051 OverallBitrate_IsCbrForSure=float64_int64s(BytesPerFrameF);
5052 if (OverallBitrate_IsCbrForSure!=BytesPerFrameF) //Testing integrity of the computing
5053 OverallBitrate_IsCbrForSure=0;
5054 }
5055 }
5056 Duration_Detected=true;
5057
5058 return true;
5059 }
5060 #endif //(MEDIAINFO_DEMUX || MEDIAINFO_SEEK) && defined(MEDIAINFO_FILE_YES)
5061
5062 #if MEDIAINFO_SEEK
Read_Buffer_Seek(size_t Method,int64u Value,int64u ID)5063 size_t File_Mxf::Read_Buffer_Seek (size_t Method, int64u Value, int64u ID)
5064 {
5065 #if defined(MEDIAINFO_REFERENCES_YES)
5066 if (ReferenceFiles)
5067 return ReferenceFiles->Seek(Method, Value, ID);
5068 #endif //defined(MEDIAINFO_REFERENCES_YES)
5069
5070 //Init
5071 if (!Duration_Detected)
5072 {
5073 if (!DetectDuration())
5074 return 0;
5075 }
5076
5077 //Config - TODO: merge with the one in Data_Parse()
5078 if (!Essences_FirstEssence_Parsed)
5079 {
5080 //Searching single descriptor if it is the only valid descriptor
5081 descriptors::iterator SingleDescriptor=Descriptors.end();
5082 for (descriptors::iterator SingleDescriptor_Temp=Descriptors.begin(); SingleDescriptor_Temp!=Descriptors.end(); ++SingleDescriptor_Temp)
5083 if (SingleDescriptor_Temp->second.StreamKind!=Stream_Max)
5084 {
5085 if (SingleDescriptor!=Descriptors.end())
5086 {
5087 SingleDescriptor=Descriptors.end();
5088 break; // 2 or more descriptors, can not be used
5089 }
5090 SingleDescriptor=SingleDescriptor_Temp;
5091 }
5092
5093 if (SingleDescriptor!=Descriptors.end() && SingleDescriptor->second.StreamKind==Stream_Audio)
5094 {
5095 //Configuring bitrate is not available in descriptor
5096 if (Descriptors.begin()->second.ByteRate==(int32u)-1)
5097 {
5098 std::map<std::string, Ztring>::const_iterator i=Descriptors.begin()->second.Infos.find("SamplingRate");
5099 if (i!=Descriptors.begin()->second.Infos.end())
5100 {
5101 int32u SamplingRate=i->second.To_int32u();
5102
5103 if (Descriptors.begin()->second.BlockAlign!=(int16u)-1)
5104 Descriptors.begin()->second.ByteRate=SamplingRate*Descriptors.begin()->second.BlockAlign;
5105 else if (Descriptors.begin()->second.QuantizationBits!=(int8u)-1)
5106 Descriptors.begin()->second.ByteRate=SamplingRate*Descriptors.begin()->second.QuantizationBits / 8;
5107 }
5108 }
5109 }
5110
5111 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
5112 {
5113 //Configuring EditRate if needed (e.g. audio at 48000 Hz)
5114 if (Descriptor->second.SampleRate>1000)
5115 {
5116 float64 EditRate_FromTrack=DBL_MAX;
5117 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
5118 if (Track->second.EditRate && EditRate_FromTrack>Track->second.EditRate)
5119 EditRate_FromTrack=Track->second.EditRate;
5120 if (EditRate_FromTrack>1000)
5121 EditRate_FromTrack=Demux_Rate; //Default value;
5122 Descriptor->second.SampleRate=EditRate_FromTrack;
5123 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
5124 if (Track->second.EditRate>EditRate_FromTrack)
5125 {
5126 Track->second.EditRate_Real=Track->second.EditRate;
5127 Track->second.EditRate=EditRate_FromTrack;
5128 }
5129 }
5130 }
5131
5132 Essences_FirstEssence_Parsed=true;
5133 }
5134 //Parsing
5135 switch (Method)
5136 {
5137 case 0 :
5138 {
5139 if (Config->File_IgnoreEditsBefore && Config->File_EditRate)
5140 {
5141 Read_Buffer_Seek(3, 0, (int64u)-1);
5142 if (File_GoTo!=(int64u)-1)
5143 Value+=File_GoTo;
5144 }
5145
5146 //Calculating the byte count not included in seek information (partition, index...)
5147 Partitions_Pos=0;
5148 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<Value)
5149 Partitions_Pos++;
5150 if (Partitions_Pos && (Partitions_Pos==Partitions.size() || Partitions[Partitions_Pos].StreamOffset!=Value))
5151 Partitions_Pos--; //This is the previous item
5152 if (Partitions_Pos>=Partitions.size())
5153 {
5154 GoTo(0);
5155 Open_Buffer_Unsynch();
5156 return 1;
5157 }
5158 int64u StreamOffset_Offset=Partitions[Partitions_Pos].StreamOffset-Partitions[Partitions_Pos].BodyOffset+Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5159
5160 //If in header
5161 if ((Clip_Begin!=(int64u)-1 && Value<Clip_Begin) || Value<StreamOffset_Offset)
5162 {
5163 GoTo(StreamOffset_Offset);
5164 Open_Buffer_Unsynch();
5165 return 1;
5166 }
5167
5168 if (Buffer_End
5169 && Descriptors.size()==1 && Descriptors.begin()->second.ByteRate!=(int32u)-1 && Descriptors.begin()->second.BlockAlign && Descriptors.begin()->second.BlockAlign!=(int16u)-1 && Descriptors.begin()->second.SampleRate)
5170 {
5171 if (Value>StreamOffset_Offset)
5172 {
5173 float64 BytesPerFrame=Descriptors.begin()->second.ByteRate/Descriptors.begin()->second.SampleRate;
5174 int64u FrameCount=(int64u)((Value-Buffer_Begin)/BytesPerFrame);
5175 int64u SizeBlockAligned=float64_int64s(FrameCount*BytesPerFrame);
5176 SizeBlockAligned/=Descriptors.begin()->second.BlockAlign;
5177 SizeBlockAligned*=Descriptors.begin()->second.BlockAlign;
5178
5179 GoTo(Buffer_Begin+SizeBlockAligned);
5180 Open_Buffer_Unsynch();
5181 return 1;
5182 }
5183 }
5184 else if (Buffer_End
5185 && !IndexTables.empty() && IndexTables[0].EditUnitByteCount)
5186 {
5187 int64u Stream_Offset=0;
5188 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
5189 {
5190 if (IndexTables[Pos].IndexDuration==0 || Value<StreamOffset_Offset+Stream_Offset+IndexTables[Pos].IndexDuration*IndexTables[Pos].EditUnitByteCount)
5191 {
5192 int64u FrameToAdd=(Value-(StreamOffset_Offset+Stream_Offset))/IndexTables[Pos].EditUnitByteCount;
5193 Stream_Offset+=FrameToAdd*IndexTables[Pos].EditUnitByteCount;
5194
5195 GoTo(Buffer_Begin+Stream_Offset);
5196 Open_Buffer_Unsynch();
5197 return 1;
5198 }
5199 else
5200 Stream_Offset+=IndexTables[Pos].IndexDuration*IndexTables[Pos].EditUnitByteCount;
5201 }
5202 return 2; //Invalid value
5203 }
5204
5205 GoTo(Value);
5206 Open_Buffer_Unsynch();
5207 return 1;
5208 }
5209 case 1 :
5210 return Read_Buffer_Seek(0, File_Size*Value/10000, ID);
5211 case 2 : //Timestamp
5212 {
5213 //We transform TimeStamp to a frame number
5214 descriptors::iterator Descriptor;
5215 for (Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
5216 if (Descriptor->second.SampleRate)
5217 break;
5218 if (Descriptor==Descriptors.end())
5219 return (size_t)-1; //Not supported
5220
5221 else if (MxfTimeCodeForDelay.StartTimecode!=(int64u)-1)
5222 {
5223 int64u Delay=float64_int64s(DTS_Delay*1000000000);
5224 if (Value<Delay)
5225 return 2; //Invalid value
5226 Value-=Delay;
5227 }
5228 Value=float64_int64s(((float64)Value)/1000000000*Descriptor->second.SampleRate);
5229 }
5230 //No break;
5231 case 3 : //FrameNumber
5232 Value+=Config->File_IgnoreEditsBefore;
5233
5234 if (Descriptors.size()==1 && Descriptors.begin()->second.ByteRate!=(int32u)-1 && Descriptors.begin()->second.BlockAlign && Descriptors.begin()->second.BlockAlign!=(int16u)-1 && Descriptors.begin()->second.SampleRate)
5235 {
5236 if (Descriptors.begin()->second.SampleRate!=Config->File_EditRate && Config->File_IgnoreEditsBefore)
5237 {
5238 //Edit rate and Demux rate are different, not well supported for the moment
5239 Value-=Config->File_IgnoreEditsBefore;
5240 Value+=float64_int64s(((float64)Config->File_IgnoreEditsBefore)/Config->File_EditRate*Descriptors.begin()->second.SampleRate);
5241 }
5242
5243 float64 BytesPerFrame=Descriptors.begin()->second.ByteRate/Descriptors.begin()->second.SampleRate;
5244 int64u StreamOffset=(int64u)(Value*BytesPerFrame);
5245 StreamOffset/=Descriptors.begin()->second.BlockAlign;
5246 StreamOffset*=Descriptors.begin()->second.BlockAlign;
5247
5248 //Calculating the byte count not included in seek information (partition, index...)
5249 int64u StreamOffset_Offset=0;
5250 Partitions_Pos=0;
5251 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<=StreamOffset_Offset+StreamOffset+Value*SDTI_SizePerFrame)
5252 {
5253 StreamOffset_Offset+=Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5254 Partitions_Pos++;
5255 }
5256
5257 if (Clip_Begin!=(int64u)-1)
5258 {
5259 Buffer_Begin=Clip_Begin;
5260 Buffer_End=Clip_End;
5261 Buffer_Header_Size=Clip_Header_Size;
5262 Code=Clip_Code;
5263 MustSynchronize=false;
5264 #if MEDIAINFO_DEMUX
5265 if (Buffer_End && Demux_UnpacketizeContainer && Essences.size()==1 && Essences.begin()->second.Parsers.size()==1 && (*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer)
5266 {
5267 (*(Essences.begin()->second.Parsers.begin()))->Demux_Level=2; //Container
5268 (*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer=true;
5269 }
5270 #endif //MEDIAINFO_DEMUX
5271 }
5272
5273 GoTo(StreamOffset_Offset+Buffer_Header_Size+StreamOffset+Value*SDTI_SizePerFrame);
5274 Open_Buffer_Unsynch();
5275 return 1;
5276 }
5277 else if (!IndexTables.empty() && IndexTables[0].EditUnitByteCount)
5278 {
5279 if (Descriptors.size()==1 && Descriptors.begin()->second.SampleRate!=IndexTables[0].IndexEditRate)
5280 {
5281 float64 ValueF=(float64)Value;
5282 ValueF/=Descriptors.begin()->second.SampleRate;
5283 ValueF*=IndexTables[0].IndexEditRate;
5284 Value=float64_int64s(ValueF);
5285 }
5286
5287 if (IndexTables[IndexTables.size()-1].IndexDuration && IndexTables[IndexTables.size()-1].IndexStartPosition!=(int64u)-1 && Value>=IndexTables[IndexTables.size()-1].IndexStartPosition+IndexTables[IndexTables.size()-1].IndexDuration) //Considering IndexDuration=0 as unlimited
5288 return 2; //Invalid value
5289
5290 int64u StreamOffset=0;
5291 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
5292 {
5293 if (IndexTables[Pos].IndexDuration && Value>IndexTables[Pos].IndexStartPosition+IndexTables[Pos].IndexDuration) //Considering IndexDuration=0 as unlimited
5294 StreamOffset+=IndexTables[Pos].EditUnitByteCount*IndexTables[Pos].IndexDuration;
5295 else
5296 {
5297 StreamOffset+=IndexTables[Pos].EditUnitByteCount*(Value-IndexTables[Pos].IndexStartPosition);
5298 break;
5299 }
5300 }
5301
5302 //Calculating the byte count not included in seek information (partition, index...)
5303 int64u StreamOffset_Offset=0;
5304 Partitions_Pos=0;
5305 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<=StreamOffset_Offset+StreamOffset+Value*SDTI_SizePerFrame)
5306 {
5307 StreamOffset_Offset+=Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5308 Partitions_Pos++;
5309 }
5310
5311 if (Clip_Begin!=(int64u)-1)
5312 {
5313 Buffer_Begin=Clip_Begin;
5314 Buffer_End=Clip_End;
5315 Buffer_Header_Size=Clip_Header_Size;
5316 Code=Clip_Code;
5317 MustSynchronize=false;
5318 #if MEDIAINFO_DEMUX
5319 if (Buffer_End && Demux_UnpacketizeContainer && Essences.size()==1 && Essences.begin()->second.Parsers.size()==1 && (*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer)
5320 {
5321 (*(Essences.begin()->second.Parsers.begin()))->Demux_Level=2; //Container
5322 (*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer=true;
5323 }
5324 #endif //MEDIAINFO_DEMUX
5325 }
5326
5327 GoTo(StreamOffset_Offset+Buffer_Header_Size+StreamOffset+Value*SDTI_SizePerFrame);
5328 Open_Buffer_Unsynch();
5329 return 1;
5330 }
5331 else if (!IndexTables.empty() && !IndexTables[0].Entries.empty())
5332 {
5333 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
5334 {
5335 if (Value>=IndexTables[Pos].IndexStartPosition && Value<IndexTables[Pos].IndexStartPosition+IndexTables[Pos].IndexDuration)
5336 {
5337 while (Value>=IndexTables[Pos].IndexStartPosition && IndexTables[Pos].Entries[(size_t)(Value-IndexTables[Pos].IndexStartPosition)].Type)
5338 {
5339 Value--;
5340 if (Value<IndexTables[Pos].IndexStartPosition)
5341 {
5342 if (Pos==0)
5343 break; //There is a problem
5344 Pos--; //In previous index
5345 }
5346 }
5347
5348 int64u StreamOffset=IndexTables[Pos].Entries[(size_t)(Value-IndexTables[Pos].IndexStartPosition)].StreamOffset;
5349
5350 //Calculating the byte count not included in seek information (partition, index...)
5351 int64u StreamOffset_Offset=0;
5352 Partitions_Pos=0;
5353 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<=StreamOffset_Offset+StreamOffset+Value*SDTI_SizePerFrame)
5354 {
5355 StreamOffset_Offset+=Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5356 Partitions_Pos++;
5357 }
5358
5359 if (Clip_Begin!=(int64u)-1)
5360 {
5361 Buffer_Begin=Clip_Begin;
5362 Buffer_End=Clip_End;
5363 Buffer_Header_Size=Clip_Header_Size;
5364 Code=Clip_Code;
5365 MustSynchronize=false;
5366 #if MEDIAINFO_DEMUX
5367 if (Buffer_End && Demux_UnpacketizeContainer && Essences.size()==1 && Essences.begin()->second.Parsers.size()==1 && (*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer)
5368 {
5369 (*(Essences.begin()->second.Parsers.begin()))->Demux_Level=2; //Container
5370 (*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer=true;
5371 }
5372 #endif //MEDIAINFO_DEMUX
5373 }
5374
5375 GoTo(StreamOffset_Offset+Buffer_Header_Size+StreamOffset+Value*SDTI_SizePerFrame);
5376 Open_Buffer_Unsynch();
5377 return 1;
5378 }
5379 }
5380 return 2; //Invalid value
5381 }
5382 else if (OverallBitrate_IsCbrForSure)
5383 {
5384 int64u Begin=Partitions[0].StreamOffset+Partitions[0].PartitionPackByteCount+Partitions[0].HeaderByteCount+Partitions[0].IndexByteCount;
5385 GoTo(Begin+Value*OverallBitrate_IsCbrForSure);
5386 Open_Buffer_Unsynch();
5387 return 1;
5388 }
5389 else
5390 return (size_t)-1; //Not supported
5391 default : return (size_t)-1; //Not supported
5392 }
5393 }
5394 #endif //MEDIAINFO_SEEK
5395
5396 //***************************************************************************
5397 // Buffer - File header
5398 //***************************************************************************
5399
5400 //---------------------------------------------------------------------------
FileHeader_Begin()5401 bool File_Mxf::FileHeader_Begin()
5402 {
5403 //Element_Size
5404 if (Buffer_Size<0x18)
5405 return false; //Must wait for more data
5406
5407 //AAF has some MXF start codes
5408 if (Buffer[ 0x0]==0xD0
5409 && Buffer[ 0x1]==0xCF
5410 && Buffer[ 0x2]==0x11
5411 && Buffer[ 0x3]==0xE0
5412 && Buffer[ 0x4]==0xA1
5413 && Buffer[ 0x5]==0xB1
5414 && Buffer[ 0x6]==0x1A
5415 && Buffer[ 0x7]==0xE1
5416 && Buffer[ 0x8]==0x41
5417 && Buffer[ 0x9]==0x41
5418 && Buffer[ 0xA]==0x46
5419 && Buffer[ 0xB]==0x42
5420 && Buffer[ 0xC]==0x0D
5421 && Buffer[ 0xD]==0x00
5422 && Buffer[ 0xE]==0x4F
5423 && Buffer[ 0xF]==0x4D
5424 && Buffer[0x10]==0x06
5425 && Buffer[0x11]==0x0E
5426 && Buffer[0x12]==0x2B
5427 && Buffer[0x13]==0x34
5428 && Buffer[0x14]==0x01
5429 && Buffer[0x15]==0x01
5430 && Buffer[0x16]==0x01
5431 && Buffer[0x17]==0xFF)
5432 {
5433 Reject("Mxf");
5434 return false;
5435 }
5436
5437 return true;
5438 }
5439
5440 //***************************************************************************
5441 // Buffer - Synchro
5442 //***************************************************************************
5443
5444 //---------------------------------------------------------------------------
Synchronize()5445 bool File_Mxf::Synchronize()
5446 {
5447 //Synchronizing
5448 while (Buffer_Offset+4<=Buffer_Size && (Buffer[Buffer_Offset ]!=0x06
5449 || Buffer[Buffer_Offset+1]!=0x0E
5450 || Buffer[Buffer_Offset+2]!=0x2B
5451 || Buffer[Buffer_Offset+3]!=0x34))
5452 {
5453 Buffer_Offset++;
5454 while (Buffer_Offset<Buffer_Size && Buffer[Buffer_Offset]!=0x06)
5455 Buffer_Offset++;
5456 }
5457
5458
5459 while (Buffer_Offset+4<=Buffer_Size
5460 && CC4(Buffer+Buffer_Offset)!=0x060E2B34)
5461 Buffer_Offset++;
5462
5463 //Parsing last bytes if needed
5464 if (Buffer_Offset+4>Buffer_Size)
5465 {
5466 if (Buffer_Offset+3==Buffer_Size && CC3(Buffer+Buffer_Offset)!=0x060E2B)
5467 Buffer_Offset++;
5468 if (Buffer_Offset+2==Buffer_Size && CC2(Buffer+Buffer_Offset)!=0x060E)
5469 Buffer_Offset++;
5470 if (Buffer_Offset+1==Buffer_Size && CC1(Buffer+Buffer_Offset)!=0x06)
5471 Buffer_Offset++;
5472 return false;
5473 }
5474
5475 if (IsSub && !Status[IsAccepted])
5476 Accept();
5477
5478 //Synched is OK
5479 return true;
5480 }
5481
5482 //---------------------------------------------------------------------------
Synched_Test()5483 bool File_Mxf::Synched_Test()
5484 {
5485 //Must have enough buffer for having header
5486 if (Buffer_Offset+16>Buffer_Size)
5487 return false;
5488
5489 //Quick test of synchro
5490 if (CC4(Buffer+Buffer_Offset)!=0x060E2B34)
5491 {
5492 Synched=false;
5493 if (!Status[IsAccepted])
5494 Trusted_IsNot("Sync"); //If there is an unsynch before the parser accepts the stream, very high risk the that the file is not MXF
5495 }
5496 else if (!Status[IsAccepted])
5497 {
5498 if (Synched_Count>=8)
5499 Accept();
5500 else
5501 Synched_Count++;
5502 }
5503
5504 //Trace config
5505 #if MEDIAINFO_TRACE
5506 if (Synched)
5507 {
5508 int64u Compare=CC8(Buffer+Buffer_Offset+ 4);
5509 if (Compare==0x010201010D010301LL //Raw stream
5510 || (Compare==0x0101010203010210LL && CC1(Buffer+Buffer_Offset+12)==0x01) //Filler
5511 || (Compare==0x020501010D010301LL && CC3(Buffer+Buffer_Offset+12)==0x040101) //SDTI Package Metadata Pack
5512 || (Compare==0x024301010D010301LL && CC3(Buffer+Buffer_Offset+12)==0x040102) //SDTI Package Metadata Set
5513 || (Compare==0x025301010D010301LL && CC3(Buffer+Buffer_Offset+12)==0x140201)) //System Scheme 1
5514 {
5515 Trace_Layers_Update(8); //Stream
5516 }
5517 else
5518 {
5519 Trace_Layers_Update(0); //Container1
5520 }
5521 }
5522 #endif //MEDIAINFO_TRACE
5523
5524 //We continue
5525 return true;
5526 }
5527
5528 //***************************************************************************
5529 // Buffer - Per element
5530 //***************************************************************************
5531
5532 //---------------------------------------------------------------------------
Header_Begin()5533 bool File_Mxf::Header_Begin()
5534 {
5535 while (Buffer_End)
5536 {
5537 #if MEDIAINFO_DEMUX
5538 //Searching single descriptor if it is the only valid descriptor
5539 descriptors::iterator SingleDescriptor=Descriptors.end();
5540 for (descriptors::iterator SingleDescriptor_Temp=Descriptors.begin(); SingleDescriptor_Temp!=Descriptors.end(); ++SingleDescriptor_Temp)
5541 if (SingleDescriptor_Temp->second.StreamKind!=Stream_Max)
5542 {
5543 if (SingleDescriptor!=Descriptors.end())
5544 {
5545 SingleDescriptor=Descriptors.end();
5546 break; // 2 or more descriptors, can not be used
5547 }
5548 SingleDescriptor=SingleDescriptor_Temp;
5549 }
5550
5551 if (Demux_UnpacketizeContainer && SingleDescriptor!=Descriptors.end() && SingleDescriptor->second.ByteRate!=(int32u)-1 && SingleDescriptor->second.BlockAlign && SingleDescriptor->second.BlockAlign!=(int16u)-1 && SingleDescriptor->second.SampleRate)
5552 {
5553 float64 BytesPerFrame=((float64)SingleDescriptor->second.ByteRate)/SingleDescriptor->second.SampleRate;
5554 int64u FramesAlreadyParsed=float64_int64s(((float64)(File_Offset+Buffer_Offset-Buffer_Begin))/BytesPerFrame);
5555 Element_Size=float64_int64s(SingleDescriptor->second.ByteRate/SingleDescriptor->second.SampleRate*(FramesAlreadyParsed+1));
5556 #if MEDIAINFO_DEMUX
5557 Element_Size+=DemuxedElementSize_AddedToFirstFrame;
5558 #endif //MEDIAINFO_DEMUX
5559 Element_Size/=SingleDescriptor->second.BlockAlign;
5560 Element_Size*=SingleDescriptor->second.BlockAlign;
5561 Element_Size-=File_Offset+Buffer_Offset-Buffer_Begin;
5562 if (Config->File_IsGrowing && Element_Size && File_Offset+Buffer_Offset+Element_Size>Buffer_End)
5563 return false; //Waiting for more data
5564 while (Element_Size && File_Offset+Buffer_Offset+Element_Size>Buffer_End)
5565 Element_Size-=SingleDescriptor->second.BlockAlign;
5566 if (Element_Size==0)
5567 Element_Size=Buffer_End-(File_Offset+Buffer_Offset);
5568 if (Buffer_Offset+Element_Size>Buffer_Size)
5569 return false;
5570
5571 #if MEDIAINFO_DEMUX
5572 if (!DemuxedSampleCount_Total && Config->Demux_Offset_DTS!=(int64u)-1 && Config->File_EditRate)
5573 {
5574 //Need to sync to a rounded value compared to the whole stream (including previous files)
5575 float64 TimeStamp=((float64)Config->Demux_Offset_DTS)/1000000000;
5576 int64u FramesBeForeThisFileMinusOne=(int64u)(TimeStamp*SingleDescriptor->second.SampleRate);
5577 if ((((float64)FramesBeForeThisFileMinusOne)/SingleDescriptor->second.SampleRate)!=TimeStamp)
5578 {
5579 float64 Delta=(((float64)FramesBeForeThisFileMinusOne+1)/SingleDescriptor->second.SampleRate)-TimeStamp;
5580 DemuxedSampleCount_AddedToFirstFrame=float64_int64s(Delta*Config->File_EditRate);
5581 DemuxedElementSize_AddedToFirstFrame=DemuxedSampleCount_AddedToFirstFrame*SingleDescriptor->second.BlockAlign;
5582 Element_Size+=DemuxedElementSize_AddedToFirstFrame;
5583 }
5584 }
5585 if (DemuxedSampleCount_Total!=(int64u)-1 && Config->File_IgnoreEditsAfter!=(int64u)-1)
5586 {
5587 DemuxedSampleCount_Current=Element_Size/SingleDescriptor->second.BlockAlign;
5588 int64u RealSampleRate=SingleDescriptor->second.Infos["SamplingRate"].To_int64u();
5589 int64u IgnoreSamplesAfter;
5590 if (RealSampleRate==Config->File_EditRate)
5591 IgnoreSamplesAfter=Config->File_IgnoreEditsAfter;
5592 else
5593 IgnoreSamplesAfter=float64_int64s(((float64)Config->File_IgnoreEditsAfter)/Config->File_EditRate*RealSampleRate);
5594 if (DemuxedSampleCount_Total+DemuxedSampleCount_Current>IgnoreSamplesAfter)
5595 {
5596 DemuxedSampleCount_Current=Config->File_IgnoreEditsAfter-DemuxedSampleCount_Total;
5597 Element_Size=DemuxedSampleCount_Current*SingleDescriptor->second.BlockAlign;
5598 }
5599 if (DemuxedSampleCount_Total+DemuxedSampleCount_Current+1==IgnoreSamplesAfter)
5600 DemuxedSampleCount_Current++; //Avoid rounding issues (sometimes it remains only 1 sample)
5601 }
5602 #endif //MEDIAINFO_DEMUX
5603 }
5604 else if (Demux_UnpacketizeContainer && !IndexTables.empty() && IndexTables[0].EditUnitByteCount)
5605 {
5606 //Calculating the byte count not included in seek information (partition, index...)
5607 int64u StreamOffset_Offset;
5608 if (!Partitions.empty())
5609 {
5610 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<File_Offset+Buffer_Offset-Header_Size)
5611 Partitions_Pos++;
5612 if (Partitions_Pos && (Partitions_Pos==Partitions.size() || Partitions[Partitions_Pos].StreamOffset!=File_Offset+Buffer_Offset-Header_Size))
5613 Partitions_Pos--; //This is the previous item
5614 StreamOffset_Offset=Partitions[Partitions_Pos].StreamOffset-Partitions[Partitions_Pos].BodyOffset+Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5615 }
5616 else
5617 StreamOffset_Offset=0;
5618
5619 int64u Position=0;
5620 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
5621 {
5622 if (IndexTables[Pos].IndexDuration && File_Offset+Buffer_Offset>=StreamOffset_Offset+Buffer_Header_Size+Position+IndexTables[Pos].IndexDuration*IndexTables[Pos].EditUnitByteCount) //Considering IndexDuration==0 as unlimited
5623 Position+=IndexTables[Pos].EditUnitByteCount*IndexTables[Pos].IndexDuration;
5624 else
5625 {
5626 Element_Size=IndexTables[Pos].EditUnitByteCount;
5627 if (File_Offset+Buffer_Offset+Element_Size>Buffer_End)
5628 {
5629 Element_Size=Buffer_End-(File_Offset+Buffer_Offset);
5630 break; //There is a problem
5631 }
5632
5633 if (Buffer_Offset+Element_Size>Buffer_Size)
5634 {
5635 //Hints
5636 if (File_Buffer_Size_Hint_Pointer)
5637 {
5638 size_t Buffer_Size_Target=(size_t)(Buffer_Offset+Element_Size-Buffer_Size+24); //+24 for next packet header
5639 if (Buffer_Size_Target<128*1024)
5640 Buffer_Size_Target=128*1024;
5641 //if ((*File_Buffer_Size_Hint_Pointer)<Buffer_Size_Target)
5642 (*File_Buffer_Size_Hint_Pointer)=Buffer_Size_Target;
5643 }
5644
5645 return false;
5646 }
5647 break;
5648 }
5649 }
5650
5651 if (Buffer_Offset+(size_t)Element_Size>Buffer_Size)
5652 Element_Size=Buffer_Size-Buffer_Offset; //There is a problem
5653 }
5654 else if (Demux_UnpacketizeContainer && !IndexTables.empty() && !IndexTables[0].Entries.empty())
5655 {
5656 //Calculating the byte count not included in seek information (partition, index...)
5657 int64u StreamOffset_Offset;
5658 if (!Partitions.empty())
5659 {
5660 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<File_Offset+Buffer_Offset-Header_Size)
5661 Partitions_Pos++;
5662 if (Partitions_Pos && (Partitions_Pos==Partitions.size() || Partitions[Partitions_Pos].StreamOffset!=File_Offset+Buffer_Offset-Header_Size))
5663 Partitions_Pos--; //This is the previous item
5664 StreamOffset_Offset=Partitions[Partitions_Pos].StreamOffset-Partitions[Partitions_Pos].BodyOffset+Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5665 }
5666 else
5667 StreamOffset_Offset=0;
5668
5669 int64u StreamOffset=File_Offset+Buffer_Offset-StreamOffset_Offset;
5670 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
5671 {
5672 //Searching the right index
5673 if (!IndexTables[Pos].Entries.empty() && StreamOffset>=IndexTables[Pos].Entries[0].StreamOffset+(IndexTables[Pos].IndexStartPosition)*SDTI_SizePerFrame && (Pos+1>=IndexTables.size() || StreamOffset<IndexTables[Pos+1].Entries[0].StreamOffset+(IndexTables[Pos+1].IndexStartPosition)*SDTI_SizePerFrame))
5674 {
5675 //Searching the frame pos
5676 for (size_t EntryPos=0; EntryPos<IndexTables[Pos].Entries.size(); EntryPos++)
5677 {
5678 //Testing coherency
5679 int64u Entry0_StreamOffset=0; //For coherency checking
5680 int64u Entry_StreamOffset=IndexTables[Pos].Entries[EntryPos].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos)*SDTI_SizePerFrame;
5681 int64u Entry1_StreamOffset=File_Size; //For coherency checking
5682 if (EntryPos==0 && Pos && !IndexTables[Pos-1].Entries.empty())
5683 Entry0_StreamOffset=IndexTables[Pos-1].Entries[IndexTables[Pos-1].Entries.size()-1].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos-1)*SDTI_SizePerFrame;
5684 else if (EntryPos)
5685 Entry0_StreamOffset=IndexTables[Pos].Entries[EntryPos-1].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos-1)*SDTI_SizePerFrame;
5686 if (EntryPos+1<IndexTables[Pos].Entries.size())
5687 Entry1_StreamOffset=IndexTables[Pos].Entries[EntryPos+1].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos+1)*SDTI_SizePerFrame;
5688 else if (Pos+1<IndexTables.size() && !IndexTables[Pos+1].Entries.empty())
5689 Entry1_StreamOffset=IndexTables[Pos+1].Entries[0].StreamOffset+(IndexTables[Pos].IndexStartPosition+EntryPos+1)*SDTI_SizePerFrame;
5690
5691 if (Entry0_StreamOffset>Entry_StreamOffset || Entry_StreamOffset>Entry1_StreamOffset)
5692 break; //Problem
5693
5694 if (StreamOffset>=Entry_StreamOffset && StreamOffset<Entry1_StreamOffset)
5695 {
5696 Element_Size=StreamOffset_Offset+Buffer_Header_Size+Entry1_StreamOffset-(File_Offset+Buffer_Offset);
5697 if (File_Offset+Buffer_Offset+Element_Size>Buffer_End)
5698 {
5699 Element_Size=Buffer_End-(File_Offset+Buffer_Offset);
5700 break; //There is a problem
5701 }
5702
5703 if (Buffer_Offset+Element_Size>Buffer_Size)
5704 {
5705 //Hints
5706 if (File_Buffer_Size_Hint_Pointer)
5707 {
5708 size_t Buffer_Size_Target=(size_t)(Buffer_Offset+Element_Size-Buffer_Size+24); //+24 for next packet header
5709 if (Buffer_Size_Target<128*1024)
5710 Buffer_Size_Target=128*1024;
5711 //if ((*File_Buffer_Size_Hint_Pointer)<Buffer_Size_Target)
5712 (*File_Buffer_Size_Hint_Pointer)=Buffer_Size_Target;
5713 }
5714
5715 return false;
5716 }
5717 break;
5718 }
5719 }
5720 }
5721 }
5722 }
5723 else
5724 #endif //MEDIAINFO_DEMUX
5725 if (File_Offset+Buffer_Size<=Buffer_End)
5726 Element_Size=Buffer_Size-Buffer_Offset; //All the buffer is used
5727 else
5728 Element_Size=Buffer_End-(File_Offset+Buffer_Offset);
5729
5730 Element_Begin0();
5731 Data_Parse();
5732 Buffer_Offset+=(size_t)Element_Size;
5733 Element_Size-=Element_Offset;
5734 Element_Offset=0;
5735 Element_End0();
5736
5737 if (Buffer_End && (File_Offset+Buffer_Offset+Element_Size>=Buffer_End || File_GoTo!=(int64u)-1) )
5738 {
5739 Buffer_Begin=(int64u)-1;
5740 Buffer_End=0;
5741 Buffer_End_Unlimited=false;
5742 Buffer_Header_Size=0;
5743 MustSynchronize=true;
5744 }
5745
5746 if (Buffer_Offset>=Buffer_Size)
5747 return false;
5748
5749 #if MEDIAINFO_DEMUX
5750 if (Config->Demux_EventWasSent)
5751 return false;
5752 #endif //MEDIAINFO_DEMUX
5753 }
5754
5755 return true;
5756 }
5757
5758 //---------------------------------------------------------------------------
Header_Parse()5759 void File_Mxf::Header_Parse()
5760 {
5761 //Parsing
5762 int64u Length;
5763 Get_UL(Code, "Code", NULL);
5764 Get_BER(Length, "Length");
5765 if (Element_IsWaitingForMoreData())
5766 return;
5767
5768 if (Length==0
5769 && ((int32u)Code.hi)==Elements::GenericContainer_Aaf2
5770 && (((int32u)(Code.lo>>32))==Elements::GenericContainer_Aaf3 || ((int32u)(Code.lo>>32))==Elements::GenericContainer_Avid3)
5771 && Retrieve(Stream_General, 0, General_Format_Settings).find(__T(" / Incomplete"))!=string::npos
5772 )
5773 {
5774 if (Buffer_Offset+Element_Offset+4>Buffer_Size)
5775 {
5776 Element_WaitForMoreData();
5777 return;
5778 }
5779
5780 if (BigEndian2int32u(Buffer+Buffer_Offset+(size_t)Element_Offset)!=0x060E2B34)
5781 {
5782 Buffer_End_Unlimited=true;
5783 Length=File_Size-(File_Offset+Buffer_Offset+Element_Offset);
5784 }
5785 }
5786
5787 if (Config->File_IsGrowing && File_Offset+Buffer_Offset+Element_Offset+Length>File_Size)
5788 {
5789 Element_WaitForMoreData();
5790 return;
5791 }
5792
5793 if (Length==0 && Essences.empty() && Retrieve(Stream_General, 0, General_Format_Settings).find(__T(" / Incomplete"))!=string::npos)
5794 {
5795 if (Buffer_Offset+Element_Offset+4>Buffer_Size)
5796 {
5797 Element_WaitForMoreData();
5798 return;
5799 }
5800
5801 if (BigEndian2int32u(Buffer+Buffer_Offset+(size_t)Element_Offset)!=0x060E2B34)
5802 {
5803 Buffer_End_Unlimited=true;
5804 Length=File_Size-(File_Offset+Buffer_Offset+Element_Offset);
5805 }
5806 }
5807
5808 if (Config->File_IsGrowing && File_Offset+Buffer_Offset+Element_Offset+Length>File_Size)
5809 {
5810 Element_WaitForMoreData();
5811 return;
5812 }
5813
5814 //Filling
5815 int32u Code_Compare1=Code.hi>>32;
5816 int32u Code_Compare2=(int32u)Code.hi;
5817 int32u Code_Compare3=Code.lo>>32;
5818 int32u Code_Compare4=(int32u)Code.lo;
5819 if (Code_Compare1==Elements::Filler011
5820 && (Code_Compare2&0xFFFFFF00)==(Elements::Filler012&0xFFFFFF00)
5821 && Code_Compare3==Elements::Filler013)
5822 DataMustAlwaysBeComplete=false;
5823 if (Partitions_IsCalculatingHeaderByteCount)
5824 {
5825 if (!(Code_Compare1==Elements::Filler011
5826 && (Code_Compare2&0xFFFFFF00)==(Elements::Filler012&0xFFFFFF00)
5827 && Code_Compare3==Elements::Filler013))
5828 {
5829 Partitions_IsCalculatingHeaderByteCount=false;
5830 if (Partitions_Pos<Partitions.size())
5831 Partitions[Partitions_Pos].PartitionPackByteCount=File_Offset+Buffer_Offset-Partitions[Partitions_Pos].StreamOffset;
5832 }
5833 }
5834 if (Partitions_IsCalculatingSdtiByteCount)
5835 {
5836 if (!((Code_Compare1==Elements::SDTI_SystemMetadataPack1
5837 && (Code_Compare2&0xFF00FFFF)==(Elements::SDTI_SystemMetadataPack2&0xFF00FFFF) //Independent of Category
5838 && Code_Compare3==Elements::SDTI_SystemMetadataPack3
5839 && (Code_Compare4&0xFFFF0000)==(Elements::SDTI_SystemMetadataPack4&0xFFFF0000))
5840 || ((Code_Compare1==Elements::Filler011
5841 && (Code_Compare2&0xFFFFFF00)==(Elements::Filler012&0xFFFFFF00)
5842 && Code_Compare3==Elements::Filler013))))
5843 {
5844 if (Partitions_Pos<Partitions.size() && !SDTI_IsInIndexStreamOffset)
5845 SDTI_SizePerFrame=File_Offset+Buffer_Offset-(Partitions[Partitions_Pos].StreamOffset+Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount);
5846 Partitions_IsCalculatingSdtiByteCount=false;
5847 }
5848 }
5849
5850 #if MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
5851 if (!Demux_HeaderParsed && !Partitions.empty() && Partitions[Partitions.size()-1].StreamOffset+Partitions[Partitions.size()-1].PartitionPackByteCount+Partitions[Partitions.size()-1].HeaderByteCount+Partitions[Partitions.size()-1].IndexByteCount==File_Offset+Buffer_Offset)
5852 {
5853 Demux_HeaderParsed=true;
5854
5855 //Testing locators
5856 Locators_CleanUp();
5857
5858 if (Config->File_IgnoreEditsBefore && !Config->File_IsDetectingDuration_Get() && Config->Event_CallBackFunction_IsSet()) //Only if demux packet may be requested
5859 Open_Buffer_Seek(3, 0, (int64u)-1); //Forcing seek to Config->File_IgnoreEditsBefore
5860 if (Config->NextPacket_Get() && Config->Event_CallBackFunction_IsSet())
5861 {
5862 if (Locators.empty())
5863 {
5864 Config->Demux_EventWasSent=true; //First set is to indicate the user that header is parsed
5865 return;
5866 }
5867 }
5868 }
5869 #endif //MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
5870
5871 if (Buffer_Offset+Element_Offset+Length>(size_t)-1 || Buffer_Offset+(size_t)(Element_Offset+Length)>Buffer_Size) //Not complete
5872 {
5873 if (Length>File_Size/2) //Divided by 2 for testing if this is a big chunk = Clip based and not frames.
5874 {
5875 //Calculating the byte count not included in seek information (partition, index...)
5876 int64u StreamOffset_Offset;
5877 if (!Partitions.empty())
5878 {
5879 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<File_Offset+Buffer_Offset-Header_Size)
5880 Partitions_Pos++;
5881 if (Partitions_Pos && (Partitions_Pos==Partitions.size() || Partitions[Partitions_Pos].StreamOffset!=File_Offset+Buffer_Offset-Header_Size))
5882 Partitions_Pos--; //This is the previous item
5883 StreamOffset_Offset=Partitions[Partitions_Pos].StreamOffset-Partitions[Partitions_Pos].BodyOffset+Partitions[Partitions_Pos].PartitionPackByteCount+Partitions[Partitions_Pos].HeaderByteCount+Partitions[Partitions_Pos].IndexByteCount;
5884 }
5885 else
5886 StreamOffset_Offset=0;
5887
5888 if (StreamOffset_Offset<=File_Offset+Buffer_Offset
5889 && !Partitions_IsFooter
5890 && !(Code_Compare1==Elements::OpenIncompleteHeaderPartition1 //Skipping any kind of Partition
5891 && Code_Compare2==Elements::OpenIncompleteHeaderPartition2
5892 && Code_Compare3==Elements::OpenIncompleteHeaderPartition3)
5893 && !(Code_Compare1==Elements::IndexTableSegment1 //Skipping any kind of IndexTableSegment
5894 && Code_Compare2==Elements::IndexTableSegment2
5895 && Code_Compare3==Elements::IndexTableSegment3))
5896 {
5897 Buffer_Begin=File_Offset+Buffer_Offset+Element_Offset;
5898 Buffer_End=Buffer_Begin+Length;
5899 Buffer_Header_Size=Element_Offset;
5900 MustSynchronize=false;
5901 Length=0;
5902 #if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
5903 Clip_Begin=Buffer_Begin;
5904 Clip_End=Buffer_End;
5905 Clip_Header_Size=Buffer_Header_Size;
5906 Clip_Code=Code;
5907 #endif //MEDIAINFO_DEMUX || MEDIAINFO_SEEK
5908 }
5909 }
5910
5911 if (Buffer_Begin==(int64u)-1)
5912 {
5913 if (Length<=File_Size/2) //Divided by 2 for testing if this is a big chunk = Clip based and not frames.))
5914 {
5915 if (File_Buffer_Size_Hint_Pointer)
5916 {
5917 int64u Buffer_Size_Target=(size_t)(Buffer_Offset+Element_Offset+Length-Buffer_Size+24); //+24 for next packet header
5918
5919 if (Buffer_Size_Target<128*1024)
5920 Buffer_Size_Target=128*1024;
5921 //if ((*File_Buffer_Size_Hint_Pointer)<Buffer_Size_Target)
5922 (*File_Buffer_Size_Hint_Pointer)=(size_t)Buffer_Size_Target;
5923 }
5924
5925
5926 Element_WaitForMoreData();
5927 return;
5928 }
5929 }
5930 }
5931
5932 #if MEDIAINFO_TRACE
5933 Header_Fill_Code(0, Ztring::ToZtring(Code.hi, 16)+Ztring::ToZtring(Code.lo, 16));
5934 #else //MEDIAINFO_TRACE
5935 Header_Fill_Code(0);
5936 #endif //MEDIAINFO_TRACE
5937 Header_Fill_Size(Element_Offset+Length);
5938 }
5939
5940 //---------------------------------------------------------------------------
Data_Parse()5941 void File_Mxf::Data_Parse()
5942 {
5943 //Clearing
5944 InstanceUID=0;
5945
5946 //Parsing
5947 int32u Code_Compare1=Code.hi>>32;
5948 int32u Code_Compare2=(int32u)Code.hi;
5949 int32u Code_Compare3=Code.lo>>32;
5950 int32u Code_Compare4=(int32u)Code.lo;
5951 #undef ELEMENT
5952 #define ELEMENT(_ELEMENT, _NAME) \
5953 else if (Code_Compare1==Elements::_ELEMENT##1 \
5954 && Code_Compare2==Elements::_ELEMENT##2 \
5955 && Code_Compare3==Elements::_ELEMENT##3 \
5956 && Code_Compare4==Elements::_ELEMENT##4) \
5957 { \
5958 if (!Element_IsComplete_Get()) \
5959 { \
5960 if (Buffer_End==0) \
5961 { \
5962 Element_WaitForMoreData(); \
5963 return; \
5964 } \
5965 Skip_XX(Element_Size, "Data"); \
5966 } \
5967 Element_Name(_NAME); \
5968 switch (Code_Compare2>>24) \
5969 { \
5970 case 0x01 : _ELEMENT(); break; \
5971 case 0x02 : switch ((int8u)(Code_Compare2>>16)) \
5972 { \
5973 case 0x05 : _ELEMENT(); break; \
5974 case 0x43 : _ELEMENT(); break; \
5975 case 0x53 : \
5976 while(Element_Offset<Element_Size) \
5977 { \
5978 Element_Begin0(); \
5979 Element_Begin1("Header"); \
5980 Get_B2 (Code2, "Code"); \
5981 Get_B2 (Length2, "Length"); \
5982 Element_End0(); \
5983 Element_Name(Ztring().From_CC2(Code2)); \
5984 \
5985 int64u End=Element_Offset+Length2; \
5986 _ELEMENT(); \
5987 if (Element_Offset<End) \
5988 Skip_XX(End-Element_Offset, "Unknown"); \
5989 \
5990 Element_End0(); \
5991 } \
5992 break; \
5993 case 0x63 : _ELEMENT(); break; \
5994 default : Skip_XX(Element_Size, "Unknown"); \
5995 } \
5996 } \
5997 } \
5998
5999 //Parsing
6000 if (0) {}
6001 ELEMENT(Filler01, "Filler")
6002 ELEMENT(Filler02, "Padding")
6003 ELEMENT(TerminatingFiller, "Terminating Filler")
6004 ELEMENT(XmlDocumentText, "XML Document Text")
6005 ELEMENT(SubDescriptors, "Sub Descriptors")
6006 ELEMENT(LensUnitMetadata, "Lens Unit Metadata")
6007 ELEMENT(CameraUnitMetadata, "Camera Unit Metadata")
6008 ELEMENT(UserDefinedAcquisitionMetadata, "User Defined Acquisition Metadata")
6009 ELEMENT(DMFiller, "Descriptive Metadata Filler")
6010 ELEMENT(Sequence, "Sequence")
6011 ELEMENT(SourceClip, "Source Clip")
6012 ELEMENT(TimecodeComponent, "Timecode Component")
6013 ELEMENT(ContentStorage, "Content Storage")
6014 ELEMENT(EssenceContainerData, "Essence Container Data")
6015 ELEMENT(GenericPictureEssenceDescriptor, "Generic Picture Essence Descriptor")
6016 ELEMENT(CDCIEssenceDescriptor, "CDCI Essence Descriptor")
6017 ELEMENT(RGBAEssenceDescriptor, "RGBA Essence Descriptor")
6018 ELEMENT(Preface, "Preface")
6019 ELEMENT(Identification, "Identification")
6020 ELEMENT(NetworkLocator, "Network Locator")
6021 ELEMENT(TextLocator, "Text Locator")
6022 ELEMENT(StereoscopicPictureSubDescriptor, "Stereoscopic Picture Sub Descriptor")
6023 ELEMENT(MaterialPackage, "Material Package")
6024 ELEMENT(SourcePackage, "Source Package")
6025 ELEMENT(EventTrack, "Event track")
6026 ELEMENT(StaticTrack, "Static Track")
6027 ELEMENT(TimelineTrack, "Timeline Track")
6028 ELEMENT(DMSegment, "Descriptive Metadata Segment")
6029 ELEMENT(GenericSoundEssenceDescriptor, "Generic Sound Essence Descriptor")
6030 ELEMENT(GenericDataEssenceDescriptor, "Generic Data Essence Descriptor")
6031 ELEMENT(MultipleDescriptor, "Multiple Descriptor")
6032 ELEMENT(DMSourceClip, "DM Source Clip")
6033 ELEMENT(AES3PCMDescriptor, "AES3 Descriptor")
6034 ELEMENT(WaveAudioDescriptor, "Wave Audio Descriptor")
6035 ELEMENT(MPEG2VideoDescriptor, "MPEG-2 Video Descriptor")
6036 ELEMENT(JPEG2000PictureSubDescriptor, "JPEG 2000 Picture Sub Descriptor")
6037 ELEMENT(VbiPacketsDescriptor, "VBI Descriptor")
6038 ELEMENT(AncPacketsDescriptor, "ANC Packets Descriptor")
6039 ELEMENT(MpegAudioDescriptor, "MPEG Audio Descriptor")
6040 ELEMENT(PackageMarkerObject, "DM Source Clip")
6041 ELEMENT(ApplicationPlugInObject, "Application Plug-In Object")
6042 ELEMENT(ApplicationReferencedObject, "Application Referenced Object")
6043 ELEMENT(MCALabelSubDescriptor, "MCA Label Sub-Descriptor")
6044 ELEMENT(TimedTextDescriptor, "Timed Text Descriptor")
6045 ELEMENT(TimedTextResourceSubDescriptor, "Timed Text Resource Sub-Descriptor")
6046 ELEMENT(ContainerConstraintsSubDescriptor, "Container Constraints Sub-Descriptor")
6047 ELEMENT(Mpeg4VisualSubDescriptor, "MPEG-4 Visual Sub-Descriptor")
6048 ELEMENT(AudioChannelLabelSubDescriptor, "Audio Channel Label Sub-Descriptor")
6049 ELEMENT(SoundfieldGroupLabelSubDescriptor, "Soundfield Group Label Sub-Descriptor")
6050 ELEMENT(GroupOfSoundfieldGroupsLabelSubDescriptor, "Group Of Soundfield Groups Label Sub-Descriptor")
6051 ELEMENT(AVCSubDescriptor, "AVC Sub-Descriptor")
6052 ELEMENT(IABEssenceDescriptor, "IAB Essence Descriptor")
6053 ELEMENT(IABSoundfieldLabelSubDescriptor, "IAB Soundfield Label SubDescriptor")
6054 ELEMENT(OpenIncompleteHeaderPartition, "Open and Incomplete Header Partition Pack")
6055 ELEMENT(ClosedIncompleteHeaderPartition, "Closed and Incomplete Header Partition Pack")
6056 ELEMENT(OpenCompleteHeaderPartition, "Open and Complete Header Partition Pack")
6057 ELEMENT(ClosedCompleteHeaderPartition, "Closed and Complete Header Partition Pack")
6058 ELEMENT(OpenIncompleteBodyPartition, "Open and Incomplete Body Partition Pack")
6059 ELEMENT(ClosedIncompleteBodyPartition, "Closed and Incomplete Body Partition Pack")
6060 ELEMENT(OpenCompleteBodyPartition, "Open and Complete Body Partition Pack")
6061 ELEMENT(ClosedCompleteBodyPartition, "Closed and Complete Body Partition Pack")
6062 ELEMENT(GenericStreamPartition, "Generic Stream Partition")
6063 ELEMENT(OpenIncompleteFooterPartition, "Open and Incomplete Footer Partition Pack")
6064 ELEMENT(ClosedIncompleteFooterPartition, "Closed and Incomplete Footer Partition Pack")
6065 ELEMENT(OpenCompleteFooterPartition, "Open and Complete Footer Partition Pack")
6066 ELEMENT(ClosedCompleteFooterPartition, "Closed and Complete Footer Partition Pack")
6067 ELEMENT(Primer, "Primer")
6068 ELEMENT(IndexTableSegment, "Index Table (Segment)")
6069 ELEMENT(RandomIndexPack, "Random Index Pack")
6070 ELEMENT(SDTI_SystemMetadataPack, "SDTI System Metadata Pack")
6071 else if (Code_Compare1==Elements::SDTI_SystemMetadataPack1
6072 && ((Code_Compare2)&0xFF00FFFF)==(Elements::SDTI_SystemMetadataPack2&0xFF00FFFF)
6073 && Code_Compare3==Elements::SDTI_SystemMetadataPack3
6074 && ((Code_Compare4)&0xFFFF0000)==(Elements::SDTI_SystemMetadataPack4&0xFFFF0000))
6075 {
6076 Code_Compare4&=0xFFFFFF00; //Remove MetaData Block Count
6077 if (0) {}
6078 ELEMENT(SDTI_PackageMetadataSet, "SDTI Package Metadata Set")
6079 ELEMENT(SDTI_PictureMetadataSet, "SDTI Picture Metadata Set")
6080 ELEMENT(SDTI_SoundMetadataSet, "SDTI Sound Metadata Set")
6081 ELEMENT(SDTI_DataMetadataSet, "SDTI Data Metadata Set")
6082 ELEMENT(SDTI_ControlMetadataSet, "SDTI Control Metadata Set")
6083 }
6084 else if (Code_Compare1==Elements::SystemScheme11
6085 && Code_Compare2==Elements::SystemScheme12
6086 && Code_Compare3==Elements::SystemScheme13
6087 && ((Code_Compare4)&0xFFFF0000)==(Elements::SystemScheme14&0xFFFF0000))
6088 {
6089 Element_Code=Code.lo;
6090 Code_Compare4&=0xFFFF0000; //Remove Metadata or Control Element Identifier + Element Number
6091 if (0) {}
6092 ELEMENT(SystemScheme1, "SystemScheme1")
6093 }
6094 ELEMENT(AS11_AAF_Core, "AS-11 core metadata framework")
6095 ELEMENT(AS11_AAF_Segmentation, "AS-11 segmentation metadata framework")
6096 ELEMENT(AS11_AAF_UKDPP, "AS-11 UK DPP metadata framework")
6097 ELEMENT(DMScheme1, "Descriptive Metadata Scheme 1") //SMPTE 380M
6098 ELEMENT(Application04_01_04_01_01, "Application04_01_04_01_01")
6099 ELEMENT(Application04_01_04_02_01, "Application04_01_04_02_01")
6100 ELEMENT(Application05_09_01, "Application05_09_01")
6101 ELEMENT(Dolby_PHDRMetadataTrackSubDescriptor, "Dolby PHDRMetadataTrackSubDescriptor")
6102 ELEMENT(Omneon_010201010100, "Omneon .01.02.01.01.01.00")
6103 ELEMENT(Omneon_010201020100, "Omneon .01.02.01.02.01.00")
6104 else if (Code_Compare1==Elements::GenericContainer_Aaf1
6105 && ((Code_Compare2)&0xFFFFFF00)==(Elements::GenericContainer_Aaf2&0xFFFFFF00)
6106 && (Code_Compare3==Elements::GenericContainer_Aaf3
6107 || Code_Compare3==Elements::GenericContainer_Avid3
6108 || Code_Compare3==Elements::Dolby_PHDRImageMetadataItem3
6109 || Code_Compare3==Elements::GenericContainer_Sony3))
6110 {
6111 Element_Name(Mxf_EssenceElement(Code));
6112
6113 //Config
6114 if (!Essences_FirstEssence_Parsed)
6115 {
6116 Streams_Finish_Preface_ForTimeCode(Preface_Current); //Configuring DTS_Delay
6117
6118 #if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
6119 //Searching single descriptor if it is the only valid descriptor
6120 descriptors::iterator SingleDescriptor=Descriptors.end();
6121 for (descriptors::iterator SingleDescriptor_Temp=Descriptors.begin(); SingleDescriptor_Temp!=Descriptors.end(); ++SingleDescriptor_Temp)
6122 if (SingleDescriptor_Temp->second.StreamKind!=Stream_Max)
6123 {
6124 if (SingleDescriptor!=Descriptors.end())
6125 {
6126 SingleDescriptor=Descriptors.end();
6127 break; // 2 or more descriptors, can not be used
6128 }
6129 SingleDescriptor=SingleDescriptor_Temp;
6130 }
6131
6132 if (SingleDescriptor!=Descriptors.end() && SingleDescriptor->second.StreamKind==Stream_Audio)
6133 {
6134 //Configuring bitrate is not available in descriptor
6135 if (SingleDescriptor->second.ByteRate==(int32u)-1)
6136 {
6137 std::map<std::string, Ztring>::const_iterator i=Descriptors.begin()->second.Infos.find("SamplingRate");
6138 if (i != Descriptors.begin()->second.Infos.end())
6139 {
6140 int32u SamplingRate=i->second.To_int32u();
6141
6142 if (SingleDescriptor->second.BlockAlign != (int16u)-1)
6143 SingleDescriptor->second.ByteRate = SamplingRate*SingleDescriptor->second.BlockAlign;
6144 else if (SingleDescriptor->second.QuantizationBits != (int8u)-1)
6145 SingleDescriptor->second.ByteRate = SamplingRate*SingleDescriptor->second.QuantizationBits / 8;
6146 }
6147 }
6148 }
6149
6150 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
6151 {
6152 //Configuring EditRate if needed (e.g. audio at 48000 Hz)
6153 if (Descriptor->second.SampleRate>1000)
6154 {
6155 float64 EditRate_FromTrack=DBL_MAX;
6156 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
6157 if (Track->second.EditRate && EditRate_FromTrack>Track->second.EditRate)
6158 EditRate_FromTrack=Track->second.EditRate;
6159 if (EditRate_FromTrack>1000)
6160 EditRate_FromTrack=Demux_Rate; //Default value;
6161 Descriptor->second.SampleRate=EditRate_FromTrack;
6162 DemuxedSampleCount_Total=Config->File_IgnoreEditsBefore;
6163 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
6164 if (Track->second.EditRate>EditRate_FromTrack)
6165 {
6166 Track->second.EditRate_Real=Track->second.EditRate;
6167 Track->second.EditRate=EditRate_FromTrack;
6168 }
6169 }
6170 }
6171 #endif //MEDIAINFO_DEMUX || MEDIAINFO_SEEK
6172
6173 Essences_FirstEssence_Parsed=true;
6174 }
6175
6176 if (IsParsingEnd)
6177 {
6178 NextRandomIndexPack();
6179 return;
6180 }
6181
6182 essences::iterator Essence=Essences.find(Code_Compare4);
6183 if (Essence==Essences.end())
6184 Essence=Essences.insert(make_pair(Code_Compare4,essence())).first;
6185
6186 #if MEDIAINFO_TRACE
6187 if (Trace_Activated)
6188 {
6189 if (Essence->second.Trace_Count<MaxCountSameElementInTrace)
6190 Essence->second.Trace_Count++;
6191 else
6192 Element_Set_Remove_Children_IfNoErrors();
6193 }
6194 #endif // MEDIAINFO_TRACE
6195
6196 if (Essence->second.Parsers.empty())
6197 {
6198 //Searching single descriptor if it is the only valid descriptor
6199 descriptors::iterator SingleDescriptor=Descriptors.end();
6200 for (descriptors::iterator SingleDescriptor_Temp=Descriptors.begin(); SingleDescriptor_Temp!=Descriptors.end(); ++SingleDescriptor_Temp)
6201 if (SingleDescriptor_Temp->second.StreamKind!=Stream_Max || SingleDescriptor_Temp->second.LinkedTrackID!=(int32u)-1)
6202 {
6203 if (SingleDescriptor!=Descriptors.end())
6204 {
6205 SingleDescriptor=Descriptors.end();
6206 break; // 2 or more descriptors, can not be used
6207 }
6208 SingleDescriptor=SingleDescriptor_Temp;
6209 }
6210
6211 //Format_Settings_Wrapping
6212 if (SingleDescriptor!=Descriptors.end())
6213 {
6214 std::map<std::string, Ztring>::iterator i=SingleDescriptor->second.Infos.find("Format_Settings_Wrapping");
6215 if ((i==SingleDescriptor->second.Infos.end() || i->second.empty()) && (Buffer_End?(Buffer_End-Buffer_Begin):Element_Size)>File_Size/2) //Divided by 2 for testing if this is a big chunk = Clip based and not frames.
6216 {
6217 if (i==SingleDescriptor->second.Infos.end())
6218 SingleDescriptor->second.Infos["Format_Settings_Wrapping"]=__T("Clip");
6219 else
6220 i->second=__T("Clip"); //By default, not sure about it, should be from descriptor
6221 }
6222 }
6223
6224 //Searching the corresponding Track (for TrackID)
6225 if (!Essence->second.TrackID_WasLookedFor)
6226 {
6227 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
6228 if (Track->second.TrackNumber==Code_Compare4)
6229 Essence->second.TrackID=Track->second.TrackID;
6230 #if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
6231 if (Essence->second.TrackID==(int32u)-1 && !Duration_Detected && !Config->File_IsDetectingDuration_Get())
6232 {
6233 DetectDuration(); //In one file (*-009.mxf), the TrackNumber is known only at the end of the file (Open and incomplete header/footer)
6234 for (tracks::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
6235 if (Track->second.TrackNumber==Code_Compare4)
6236 Essence->second.TrackID=Track->second.TrackID;
6237 }
6238 #endif //MEDIAINFO_DEMUX || MEDIAINFO_SEEK
6239
6240 // Fallback in case TrackID is not detected, forcing TrackID and TrackNumber
6241 if (Essence->second.TrackID==(int32u)-1 && SingleDescriptor!=Descriptors.end())
6242 {
6243 Essence->second.TrackID=SingleDescriptor->second.LinkedTrackID;
6244
6245 prefaces::iterator Preface=Prefaces.find(Preface_Current);
6246 if (Preface!=Prefaces.end())
6247 {
6248 contentstorages::iterator ContentStorage=ContentStorages.find(Preface->second.ContentStorage);
6249 if (ContentStorage!=ContentStorages.end())
6250 {
6251 for (size_t Pos=0; Pos<ContentStorage->second.Packages.size(); Pos++)
6252 {
6253 packages::iterator Package=Packages.find(ContentStorage->second.Packages[Pos]);
6254 if (Package!=Packages.end() && Package->second.IsSourcePackage)
6255 {
6256 for (size_t Pos=0; Pos<Package->second.Tracks.size(); Pos++)
6257 {
6258 tracks::iterator Track=Tracks.find(Package->second.Tracks[Pos]);
6259 if (Track!=Tracks.end())
6260 {
6261 if (Track->second.TrackNumber==0 && Track->second.TrackID==Essence->second.TrackID)
6262 {
6263 Track->second.TrackNumber=Essence->first;
6264 Essence->second.Track_Number_IsMappedToTrack=true;
6265 }
6266 }
6267 }
6268 }
6269 }
6270 }
6271 }
6272 }
6273
6274 Essence->second.TrackID_WasLookedFor=true;
6275 }
6276
6277 //Searching the corresponding Descriptor
6278 bool DescriptorFound=false;
6279 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
6280 if (Descriptor==SingleDescriptor || (Descriptor->second.LinkedTrackID==Essence->second.TrackID && Descriptor->second.LinkedTrackID!=(int32u)-1))
6281 {
6282 DescriptorFound=true;
6283
6284 Essence->second.StreamPos_Initial=Essence->second.StreamPos=Code_Compare4&0x000000FF;
6285
6286 if (Descriptor->second.StreamKind==Stream_Audio)
6287 {
6288 std::map<std::string, Ztring>::iterator i=Descriptor->second.Infos.find("Format_Settings_Endianness");
6289 if (i==Descriptor->second.Infos.end())
6290 {
6291 Ztring Format;
6292 Format.From_UTF8(Mxf_EssenceCompression(Descriptor->second.EssenceCompression));
6293 if (Format.empty())
6294 Format.From_UTF8(Mxf_EssenceContainer(Descriptor->second.EssenceContainer));
6295 if (Format.find(__T("PCM"))==0)
6296 Descriptor->second.Infos["Format_Settings_Endianness"]=__T("Little");
6297 }
6298 }
6299
6300 ChooseParser(Essence, Descriptor); //Searching by the descriptor
6301 if (Essence->second.Parsers.empty())
6302 ChooseParser__FromEssence(Essence, Descriptor); //Searching by the track identifier
6303
6304 #ifdef MEDIAINFO_VC3_YES
6305 if (Ztring().From_UTF8(Mxf_EssenceContainer(Descriptor->second.EssenceContainer))==__T("VC-3"))
6306 ((File_Vc3*)(*(Essence->second.Parsers.begin())))->FrameRate=Descriptor->second.SampleRate;
6307 #endif //MEDIAINFO_VC3_YES
6308 break;
6309 }
6310 if (!DescriptorFound)
6311 Streams_Count++; //This stream was not yet counted
6312
6313 //Searching by the track identifier
6314 if (Essence->second.Parsers.empty())
6315 ChooseParser__FromEssence(Essence, Descriptors.end());
6316
6317 //Check of Essence used as a reference for frame count
6318 if (Essences_UsedForFrameCount==(int32u)-1)
6319 Essences_UsedForFrameCount=Essence->first;
6320
6321 //Demux
6322 #if MEDIAINFO_DEMUX
6323 //Configuration
6324 if (!IsSub) //Updating for MXF only if MXF is not embedded in another container
6325 {
6326 Essence->second.Frame_Count_NotParsedIncluded=Frame_Count_NotParsedIncluded;
6327 if (Essence->second.Frame_Count_NotParsedIncluded!=(int64u)-1 && Essence->second.Frame_Count_NotParsedIncluded && Essence->first!=Essences_UsedForFrameCount)
6328 Essence->second.Frame_Count_NotParsedIncluded--; //Info is from the first essence parsed, and 1 frame is already parsed
6329 Essence->second.FrameInfo.DTS=FrameInfo.DTS;
6330 if (Essence->second.FrameInfo.DTS!=(int64u)-1 && FrameInfo.DUR!=(int64u)-1 && Frame_Count_NotParsedIncluded && Essence->first!=Essences_UsedForFrameCount)
6331 Essence->second.FrameInfo.DTS-=FrameInfo.DUR; //Info is from the first essence parsed, and 1 frame is already parsed
6332 if (!Tracks.empty() && Tracks.begin()->second.EditRate) //TODO: use the corresponding track instead of the first one
6333 Essence->second.FrameInfo.DUR=float64_int64s(1000000000/Tracks.begin()->second.EditRate);
6334 else if (!IndexTables.empty() && IndexTables[0].IndexEditRate)
6335 Essence->second.FrameInfo.DUR=float64_int64s(1000000000/IndexTables[0].IndexEditRate);
6336 #if MEDIAINFO_DEMUX
6337 if (Buffer_End && Demux_UnpacketizeContainer && Essences.size()==1 && !Essences.begin()->second.Parsers.empty() && !(*(Essences.begin()->second.Parsers.begin()))->Demux_UnpacketizeContainer)
6338 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
6339 {
6340 (*Parser)->Demux_Level=2; //Container
6341 (*Parser)->Demux_UnpacketizeContainer=true;
6342 }
6343 #endif //MEDIAINFO_DEMUX
6344 }
6345 if (Essence->second.TrackID!=(int32u)-1)
6346 Element_Code=Essence->second.TrackID;
6347 else
6348 Element_Code=Code.lo;
6349 #endif //MEDIAINFO_DEMUX
6350
6351 if (Essence->second.Parsers.empty())
6352 {
6353 if (Streams_Count>0)
6354 Streams_Count--;
6355 }
6356 else
6357 {
6358 Element_Code=Essence->second.TrackID;
6359 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
6360 {
6361 Open_Buffer_Init(*Parser);
6362 if ((*Parser)->Status[IsFinished])
6363 if (Streams_Count>0)
6364 Streams_Count--;
6365 }
6366 }
6367
6368 if ((Code_Compare4&0x000000FF)==0x00000000)
6369 StreamPos_StartAtZero.set(Essence->second.StreamKind);
6370
6371 //Stream size is sometime easy to find
6372 if ((Buffer_End?(Buffer_End-Buffer_Begin):Element_TotalSize_Get())>=File_Size*0.98) //let imagine: if element size is 98% of file size, this is the only one element in the file
6373 {
6374 Essence->second.Stream_Size=Buffer_End?(Buffer_End-Buffer_Begin):Element_TotalSize_Get();
6375 }
6376
6377 //Compute stream bit rate if there is only one stream
6378 int64u Stream_Size;
6379 if (Essence->second.Stream_Size!=(int64u)-1)
6380 Stream_Size=Essence->second.Stream_Size;
6381 else
6382 Stream_Size=File_Size; //TODO: find a way to remove header/footer correctly
6383 if (Stream_Size!=(int64u)-1)
6384 {
6385 //Searching single descriptor if it is the only valid descriptor
6386 descriptors::iterator SingleDescriptor=Descriptors.end();
6387 for (descriptors::iterator SingleDescriptor_Temp=Descriptors.begin(); SingleDescriptor_Temp!=Descriptors.end(); ++SingleDescriptor_Temp)
6388 if (SingleDescriptor_Temp->second.StreamKind!=Stream_Max)
6389 {
6390 if (SingleDescriptor!=Descriptors.end())
6391 {
6392 SingleDescriptor=Descriptors.end();
6393 break; // 2 or more descriptors, can not be used
6394 }
6395 SingleDescriptor=SingleDescriptor_Temp;
6396 }
6397
6398 if (SingleDescriptor!=Descriptors.end())
6399 {
6400 if (SingleDescriptor->second.ByteRate!=(int32u)-1)
6401 for (parsers::iterator Parser=Essence->second.Parsers.begin(); Parser!=Essence->second.Parsers.end(); ++Parser)
6402 (*Parser)->Stream_BitRateFromContainer=SingleDescriptor->second.ByteRate*8;
6403 else if (SingleDescriptor->second.Infos["Duration"].To_float64())
6404 for (parsers::iterator Parser=Essences.begin()->second.Parsers.begin(); Parser!=Essences.begin()->second.Parsers.end(); ++Parser)
6405 (*Parser)->Stream_BitRateFromContainer=((float64)Stream_Size)*8/(SingleDescriptor->second.Infos["Duration"].To_float64()/1000);
6406 }
6407 }
6408 }
6409
6410 //Frame info is specific to the container, and it is not updated
6411 const frame_info FrameInfo_Temp=FrameInfo;
6412 int64u Frame_Count_NotParsedIncluded_Temp=Frame_Count_NotParsedIncluded;
6413 if (!IsSub) //Updating for MXF only if MXF is not embedded in another container
6414 {
6415 FrameInfo=frame_info();
6416 Frame_Count_NotParsedIncluded=(int64u)-1;
6417 }
6418
6419 //Demux
6420 #if MEDIAINFO_DEMUX
6421 if (Essence->second.TrackID!=(int32u)-1)
6422 Element_Code=Essence->second.TrackID;
6423 else
6424 Element_Code=Code.lo;
6425 Demux_Level=(!Essence->second.Parsers.empty() && ((*(Essence->second.Parsers.begin()))->Demux_UnpacketizeContainer || (*(Essence->second.Parsers.begin()))->Demux_Level==2))?4:2; //Intermediate (D-10 Audio) / Container
6426 if (!IsSub) //Updating for MXF only if MXF is not embedded in another container
6427 {
6428 FrameInfo=Essence->second.FrameInfo;
6429 Frame_Count_NotParsedIncluded=Essence->second.Frame_Count_NotParsedIncluded;
6430 }
6431 Demux_random_access=true;
6432 Demux(Buffer+Buffer_Offset, (size_t)Element_Size, ContentType_MainStream);
6433 #endif //MEDIAINFO_DEMUX
6434
6435 if (!Essence->second.Parsers.empty() && !(*(Essence->second.Parsers.begin()))->Status[IsFinished])
6436 {
6437 if ((Code_Compare4&0xFF00FF00)==0x17000100 || (Code_Compare4&0xFF00FF00)==0x17000200)
6438 {
6439 if (Element_Size)
6440 {
6441 parsers::iterator Parser=Essence->second.Parsers.begin();
6442
6443 //Ancillary, SMPTE ST 436
6444 int16u Count;
6445 Get_B2 (Count, "Number of Lines");
6446 if (Count*14>Element_Size)
6447 {
6448 (*Parser)->Finish();
6449 Skip_XX(Element_Size-2, "Unknown");
6450 Count=0;
6451 }
6452 for (int16u Pos=0; Pos<Count; Pos++)
6453 {
6454 Element_Begin1("Line");
6455 int32u ArrayCount, ArrayLength;
6456 int16u LineNumber, SampleCount;
6457 Get_B2 (LineNumber, "Line Number"); Element_Info1(LineNumber);
6458 Skip_B1( "Wrapping Type");
6459 Skip_B1( "Payload Sample Coding");
6460 Get_B2 (SampleCount, "Payload Sample Count");
6461 Get_B4 (ArrayCount, "Payload Array Count");
6462 Get_B4 (ArrayLength, "Payload Array Length");
6463
6464 if (Essence->second.Frame_Count_NotParsedIncluded!=(int64u)-1)
6465 (*Parser)->Frame_Count_NotParsedIncluded=Essence->second.Frame_Count_NotParsedIncluded;
6466 if (Essence->second.FrameInfo.DTS!=(int64u)-1)
6467 (*Parser)->FrameInfo.DTS=Essence->second.FrameInfo.DTS;
6468 if (Essence->second.FrameInfo.PTS!=(int64u)-1)
6469 (*Parser)->FrameInfo.PTS=Essence->second.FrameInfo.PTS;
6470 if (Essence->second.FrameInfo.DUR!=(int64u)-1)
6471 (*Parser)->FrameInfo.DUR=Essence->second.FrameInfo.DUR;
6472 #if defined(MEDIAINFO_ANCILLARY_YES)
6473 if ((*Parser)->ParserName=="Ancillary")
6474 ((File_Ancillary*)(*Parser))->LineNumber=LineNumber;
6475 if ((*Parser)->ParserName=="Ancillary" && (((File_Ancillary*)(*Parser))->FrameRate==0 || ((File_Ancillary*)(*Parser))->AspectRatio==0))
6476 {
6477 //Configuring with video info
6478 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
6479 if (Descriptor->second.StreamKind==Stream_Video)
6480 {
6481 ((File_Ancillary*)(*Parser))->HasBFrames=Descriptor->second.HasBFrames;
6482 ((File_Ancillary*)(*Parser))->AspectRatio=Descriptor->second.DisplayAspectRatio;
6483 ((File_Ancillary*)(*Parser))->FrameRate=Descriptor->second.SampleRate;
6484 break;
6485 }
6486 }
6487 #endif //defined(MEDIAINFO_ANCILLARY_YES)
6488 int64u Parsing_Size=SampleCount;
6489 int64u Array_Size=ArrayCount*ArrayLength;
6490 if (Element_Offset+Parsing_Size>Element_Size)
6491 Parsing_Size=Element_Size-Element_Offset; // There is a problem
6492 if (Parsing_Size>Array_Size)
6493 Parsing_Size=Array_Size; // There is a problem
6494 (*Parser)->Frame_Count=Frame_Count;
6495 (*Parser)->Frame_Count_NotParsedIncluded=Frame_Count_NotParsedIncluded;
6496 Open_Buffer_Continue((*Parser), Buffer+Buffer_Offset+(size_t)(Element_Offset), Parsing_Size);
6497 if ((Code_Compare4&0xFF00FF00)==0x17000100 && LineNumber==21 && (*Parser)->Count_Get(Stream_Text)==0)
6498 {
6499 (*Parser)->Accept();
6500 (*Parser)->Stream_Prepare(Stream_Text);
6501 (*Parser)->Fill(Stream_Text, StreamPos_Last, Text_Format, "EIA-608");
6502 (*Parser)->Fill(Stream_Text, StreamPos_Last, Text_MuxingMode, "VBI / Line 21");
6503 }
6504 Element_Offset+=Parsing_Size;
6505 if (Parsing_Size<Array_Size)
6506 Skip_XX(Array_Size-Parsing_Size, "Padding");
6507 Element_End0();
6508 }
6509 if (IsSub)
6510 Frame_Count++;
6511 }
6512 }
6513 else
6514 {
6515 for (size_t Pos=0; Pos<Essence->second.Parsers.size(); Pos++)
6516 {
6517 //Parsing
6518 if (IsSub)
6519 {
6520 if (Frame_Count_NotParsedIncluded!=(int64u)-1)
6521 Essence->second.Parsers[Pos]->Frame_Count_NotParsedIncluded=Frame_Count_NotParsedIncluded;
6522 if (FrameInfo.DTS!=(int64u)-1)
6523 Essence->second.Parsers[Pos]->FrameInfo.DTS=FrameInfo.DTS;
6524 if (FrameInfo.PTS!=(int64u)-1)
6525 Essence->second.Parsers[Pos]->FrameInfo.PTS=FrameInfo.PTS;
6526 if (FrameInfo.DUR!=(int64u)-1)
6527 Essence->second.Parsers[Pos]->FrameInfo.DUR=FrameInfo.DUR;
6528 }
6529 else
6530 {
6531 if (Essence->second.Frame_Count_NotParsedIncluded!=(int64u)-1)
6532 Essence->second.Parsers[Pos]->Frame_Count_NotParsedIncluded=Essence->second.Frame_Count_NotParsedIncluded;
6533 if (Essence->second.FrameInfo.DTS!=(int64u)-1)
6534 Essence->second.Parsers[Pos]->FrameInfo.DTS=Essence->second.FrameInfo.DTS;
6535 if (Essence->second.FrameInfo.PTS!=(int64u)-1)
6536 Essence->second.Parsers[Pos]->FrameInfo.PTS=Essence->second.FrameInfo.PTS;
6537 if (Essence->second.FrameInfo.DUR!=(int64u)-1)
6538 Essence->second.Parsers[Pos]->FrameInfo.DUR=Essence->second.FrameInfo.DUR;
6539 }
6540 Open_Buffer_Continue(Essence->second.Parsers[Pos], Buffer+Buffer_Offset, (size_t)Element_Size);
6541 #if MEDIAINFO_DEMUX
6542 if (Demux_Level==4 && Config->Demux_EventWasSent && Essence->second.StreamKind==Stream_Video && Essence->second.Parsers[Pos]->ParserIDs[StreamIDs_Size]==MediaInfo_Parser_Jpeg) // Only File_Jpeg. TODO: limit to File_Jpeg instead of video streams
6543 {
6544 Demux_CurrentParser=Essence->second.Parsers[Pos];
6545 Demux_CurrentEssence=Essence;
6546 }
6547 #endif //MEDIAINFO_DEMUX
6548 switch (Essence->second.Parsers[Pos]->Field_Count_InThisBlock)
6549 {
6550 case 1 : Essence->second.Field_Count_InThisBlock_1++; break;
6551 case 2 : Essence->second.Field_Count_InThisBlock_2++; break;
6552 default: ;
6553 }
6554
6555 //Multiple parsers
6556 if (Essence->second.Parsers.size()>1)
6557 {
6558 if (!Essence->second.Parsers[Pos]->Status[IsAccepted] && Essence->second.Parsers[Pos]->Status[IsFinished])
6559 {
6560 delete *(Essence->second.Parsers.begin()+Pos);
6561 Essence->second.Parsers.erase(Essence->second.Parsers.begin()+Pos);
6562 Pos--;
6563 }
6564 else if (Essence->second.Parsers.size()>1 && Essence->second.Parsers[Pos]->Status[IsAccepted])
6565 {
6566 File__Analyze* Parser=Essence->second.Parsers[Pos];
6567 for (size_t Pos2=0; Pos2<Essence->second.Parsers.size(); Pos2++)
6568 {
6569 if (Pos2!=Pos)
6570 delete *(Essence->second.Parsers.begin()+Pos2);
6571 }
6572 Essence->second.Parsers.clear();
6573 Essence->second.Parsers.push_back(Parser);
6574 }
6575 }
6576
6577 if (!Status[IsAccepted] && !Essence->second.Parsers.empty() && Essence->second.Parsers[0]->Status[IsAccepted])
6578 Accept();
6579 }
6580
6581 Element_Offset=Element_Size;
6582 }
6583
6584 if (Essence->second.Parsers.size()==1 && Essence->second.Parsers[0]->Status[IsAccepted] && Essence->second.Frame_Count_NotParsedIncluded==(int64u)-1)
6585 {
6586 Essence->second.FrameInfo.DTS=Essence->second.Parsers[0]->FrameInfo.DTS;
6587 Essence->second.FrameInfo.PTS=Essence->second.Parsers[0]->FrameInfo.PTS;
6588 Essence->second.FrameInfo.DUR=Essence->second.Parsers[0]->FrameInfo.DUR;
6589 }
6590 else if (Buffer_End)
6591 {
6592 Essence->second.Frame_Count_NotParsedIncluded=(int64u)-1;
6593 Essence->second.FrameInfo=frame_info();
6594 }
6595 else
6596 {
6597 if (Essence->second.Frame_Count_NotParsedIncluded!=(int64u)-1)
6598 Essence->second.Frame_Count_NotParsedIncluded++;
6599 if (Essence->second.FrameInfo.DTS!=(int64u)-1 && Essence->second.FrameInfo.DUR!=(int64u)-1)
6600 Essence->second.FrameInfo.DTS+=Essence->second.FrameInfo.DUR;
6601 if (Essence->second.FrameInfo.PTS!=(int64u)-1 && Essence->second.FrameInfo.DUR!=(int64u)-1)
6602 Essence->second.FrameInfo.PTS+=Essence->second.FrameInfo.DUR;
6603 }
6604
6605 //Disabling this Streams
6606 if (!Essence->second.IsFilled && Essence->second.Parsers.size()==1 && Essence->second.Parsers[0]->Status[IsFilled])
6607 {
6608 if (Streams_Count>0)
6609 Streams_Count--;
6610 Essence->second.IsFilled=true;
6611 if (Config->ParseSpeed<1.0 && IsSub)
6612 {
6613 Fill();
6614 Open_Buffer_Unsynch();
6615 Finish();
6616 }
6617 }
6618 }
6619 else
6620 Skip_XX(Element_Size, "Data");
6621
6622 //Frame info is specific to the container, and it is not updated
6623 if (Essence->first==Essences_UsedForFrameCount)
6624 {
6625 FrameInfo=Essence->second.FrameInfo;
6626 Frame_Count_NotParsedIncluded=Essence->second.Frame_Count_NotParsedIncluded;
6627 }
6628 else
6629 {
6630 FrameInfo=FrameInfo_Temp;
6631 Frame_Count_NotParsedIncluded=Frame_Count_NotParsedIncluded_Temp;
6632 }
6633
6634 //Ignore tail
6635 #if MEDIAINFO_DEMUX
6636 if (DemuxedSampleCount_Total!=(int64u)-1 && DemuxedSampleCount_Current!=(int64u)-1)
6637 {
6638 DemuxedSampleCount_Total+=DemuxedSampleCount_Current;
6639 Frame_Count_NotParsedIncluded=DemuxedSampleCount_Total;
6640 }
6641 #endif //MEDIAINFO_DEMUX
6642 if (Config->ParseSpeed>=1.0 && Frame_Count_NotParsedIncluded!=(int64u)-1 && Config->File_IgnoreEditsAfter!=(int64u)-1)
6643 {
6644 descriptors::iterator SingleDescriptor=Descriptors.end();
6645 for (descriptors::iterator SingleDescriptor_Temp=Descriptors.begin(); SingleDescriptor_Temp!=Descriptors.end(); ++SingleDescriptor_Temp)
6646 if (SingleDescriptor_Temp->second.StreamKind!=Stream_Max)
6647 {
6648 if (SingleDescriptor!=Descriptors.end())
6649 {
6650 SingleDescriptor=Descriptors.end();
6651 break; // 2 or more descriptors, can not be used
6652 }
6653 SingleDescriptor=SingleDescriptor_Temp;
6654 }
6655
6656 int64u RealSampleRate=(SingleDescriptor==Descriptors.end() || SingleDescriptor->second.StreamKind!=Stream_Audio)?((int64u)Config->File_EditRate):SingleDescriptor->second.Infos["SamplingRate"].To_int64u();
6657 int64u IgnoreSamplesAfter;
6658 if (!RealSampleRate || RealSampleRate==Config->File_EditRate)
6659 IgnoreSamplesAfter=Config->File_IgnoreEditsAfter;
6660 else
6661 IgnoreSamplesAfter=float64_int64s(((float64)Config->File_IgnoreEditsAfter)/Config->File_EditRate*RealSampleRate);
6662 if (Frame_Count_NotParsedIncluded>=IgnoreSamplesAfter)
6663 {
6664 if (PartitionMetadata_FooterPartition!=(int64u)-1 && PartitionMetadata_FooterPartition>=File_Offset+Buffer_Offset+Element_Size)
6665 GoTo(PartitionMetadata_FooterPartition);
6666 else
6667 GoToFromEnd(0);
6668 }
6669 }
6670 #if MEDIAINFO_DEMUX
6671 if (DemuxedSampleCount_Total!=(int64u)-1)
6672 {
6673 Frame_Count_NotParsedIncluded=(int64u)-1;
6674 }
6675 #endif //MEDIAINFO_DEMUX
6676 }
6677 else
6678 Skip_XX(Element_Size, "Unknown");
6679
6680 if (Buffer_End && (File_Offset+Buffer_Offset+Element_Size>=Buffer_End || File_GoTo!=(int64u)-1) )
6681 {
6682 Buffer_Begin=(int64u)-1;
6683 Buffer_End=0;
6684 Buffer_End_Unlimited=false;
6685 Buffer_Header_Size=0;
6686 MustSynchronize=true;
6687 }
6688
6689 if ((!IsParsingEnd && IsParsingMiddle_MaxOffset==(int64u)-1 && Config->ParseSpeed<1.0)
6690 && ((!IsSub && File_Offset>=Buffer_PaddingBytes+0x4000000) //TODO: 64 MB by default (security), should be changed
6691 || (Streams_Count==0 && !Descriptors.empty())))
6692 {
6693 Fill();
6694
6695 IsParsingEnd=true;
6696 if (PartitionMetadata_FooterPartition!=(int64u)-1 && PartitionMetadata_FooterPartition>File_Offset+Buffer_Offset+(size_t)Element_Size)
6697 {
6698 if (PartitionMetadata_FooterPartition+17<=File_Size)
6699 {
6700 GoTo(PartitionMetadata_FooterPartition);
6701 IsCheckingFooterPartitionAddress=true;
6702 }
6703 else
6704 {
6705 GoToFromEnd(4); //For random access table
6706 FooterPartitionAddress_Jumped=true;
6707 }
6708 }
6709 else
6710 {
6711 GoToFromEnd(4); //For random access table
6712 FooterPartitionAddress_Jumped=true;
6713 }
6714 Open_Buffer_Unsynch();
6715 }
6716
6717 if (File_Offset+Buffer_Offset+Element_Size>=RandomIndexPacks_MaxOffset)
6718 NextRandomIndexPack();
6719 }
6720
6721 //***************************************************************************
6722 // Elements
6723 //***************************************************************************
6724
6725 #undef ELEMENT
6726 #define ELEMENT(_CODE, _CALL, _NAME) \
6727 case 0x##_CODE : { \
6728 Element_Name(_NAME); \
6729 int64u Element_Size_Save=Element_Size; \
6730 Element_Size=Element_Offset+Length2; \
6731 _CALL(); \
6732 Element_Offset=Element_Size; \
6733 Element_Size=Element_Size_Save; \
6734 } \
6735 break; \
6736
6737 #define ELEMENT_UUID(_ELEMENT, _NAME) \
6738 else if (Code_Compare1==Elements::_ELEMENT##1 \
6739 && (Code_Compare2&0xFFFFFF00)==(Elements::_ELEMENT##2&0xFFFFFF00) \
6740 && Code_Compare3==Elements::_ELEMENT##3 \
6741 && Code_Compare4==Elements::_ELEMENT##4) \
6742 { \
6743 Element_Name(_NAME); \
6744 int64u Element_Size_Save=Element_Size; \
6745 Element_Size=Element_Offset+Length2; \
6746 _ELEMENT(); \
6747 Element_Offset=Element_Size; \
6748 Element_Size=Element_Size_Save; \
6749 }
6750
6751 //---------------------------------------------------------------------------
AES3PCMDescriptor()6752 void File_Mxf::AES3PCMDescriptor()
6753 {
6754 Descriptors[InstanceUID].IsAes3Descriptor=true;
6755
6756 switch(Code2)
6757 {
6758 ELEMENT(3D08, AES3PCMDescriptor_AuxBitsMode, "Use of Auxiliary Bits")
6759 ELEMENT(3D0D, AES3PCMDescriptor_Emphasis, "Emphasis")
6760 ELEMENT(3D0F, AES3PCMDescriptor_BlockStartOffset, "Position of first Z preamble in essence stream")
6761 ELEMENT(3D10, AES3PCMDescriptor_ChannelStatusMode, "Enumerated mode of carriage of channel status data")
6762 ELEMENT(3D11, AES3PCMDescriptor_FixedChannelStatusData, "Fixed data pattern for channel status data")
6763 ELEMENT(3D12, AES3PCMDescriptor_UserDataMode, "Mode of carriage of user data")
6764 ELEMENT(3D13, AES3PCMDescriptor_FixedUserData, "Fixed data pattern for user data")
6765 default: WaveAudioDescriptor();
6766 }
6767 }
6768
6769 //---------------------------------------------------------------------------
CDCIEssenceDescriptor()6770 void File_Mxf::CDCIEssenceDescriptor()
6771 {
6772 switch(Code2)
6773 {
6774 ELEMENT(3301, CDCIEssenceDescriptor_ComponentDepth, "Active bits per sample")
6775 ELEMENT(3302, CDCIEssenceDescriptor_HorizontalSubsampling, "Horizontal colour subsampling")
6776 ELEMENT(3303, CDCIEssenceDescriptor_ColorSiting, "Color siting")
6777 ELEMENT(3304, CDCIEssenceDescriptor_BlackRefLevel, "Black refernece level")
6778 ELEMENT(3305, CDCIEssenceDescriptor_WhiteReflevel, "White reference level")
6779 ELEMENT(3306, CDCIEssenceDescriptor_ColorRange, "Color range")
6780 ELEMENT(3307, CDCIEssenceDescriptor_PaddingBits, "Bits to round up each pixel to stored size")
6781 ELEMENT(3308, CDCIEssenceDescriptor_VerticalSubsampling,"Vertical colour subsampling")
6782 ELEMENT(3309, CDCIEssenceDescriptor_AlphaSampleDepth, "Bits per alpha sample")
6783 ELEMENT(330B, CDCIEssenceDescriptor_ReversedByteOrder, "Luma followed by Chroma")
6784 default:
6785 {
6786 std::map<int16u, int128u>::iterator Primer_Value = Primer_Values.find(Code2);
6787 if (Primer_Value != Primer_Values.end())
6788 {
6789 int32u Code_Compare1 = Primer_Value->second.hi >> 32;
6790 int32u Code_Compare2 = (int32u)Primer_Value->second.hi;
6791 int32u Code_Compare3 = Primer_Value->second.lo >> 32;
6792 int32u Code_Compare4 = (int32u)Primer_Value->second.lo;
6793 if (0);
6794 ELEMENT_UUID(SubDescriptors, "Sub Descriptors")
6795 }
6796 }
6797 }
6798
6799 GenericPictureEssenceDescriptor();
6800
6801 if (Descriptors[InstanceUID].Infos.find("ColorSpace")==Descriptors[InstanceUID].Infos.end())
6802 Descriptor_Fill("ColorSpace", "YUV");
6803 }
6804
6805 //---------------------------------------------------------------------------
OpenIncompleteHeaderPartition()6806 void File_Mxf::OpenIncompleteHeaderPartition()
6807 {
6808 //Parsing
6809 PartitionMetadata();
6810 }
6811
6812 //---------------------------------------------------------------------------
ClosedIncompleteHeaderPartition()6813 void File_Mxf::ClosedIncompleteHeaderPartition()
6814 {
6815 //Parsing
6816 PartitionMetadata();
6817 }
6818
6819 //---------------------------------------------------------------------------
OpenCompleteHeaderPartition()6820 void File_Mxf::OpenCompleteHeaderPartition()
6821 {
6822 //Parsing
6823 PartitionMetadata();
6824 }
6825
6826 //---------------------------------------------------------------------------
ClosedCompleteHeaderPartition()6827 void File_Mxf::ClosedCompleteHeaderPartition()
6828 {
6829 //Parsing
6830 PartitionMetadata();
6831 }
6832
6833 //---------------------------------------------------------------------------
OpenIncompleteBodyPartition()6834 void File_Mxf::OpenIncompleteBodyPartition()
6835 {
6836 //Parsing
6837 PartitionMetadata();
6838
6839 #if MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6840 if (!Demux_HeaderParsed)
6841 {
6842 Demux_HeaderParsed=true;
6843
6844 //Testing locators
6845 Locators_CleanUp();
6846
6847 if (Config->File_IgnoreEditsBefore && !Config->File_IsDetectingDuration_Get() && Config->Event_CallBackFunction_IsSet()) //Only if demux packet may be requested
6848 Open_Buffer_Seek(3, 0, (int64u)-1); //Forcing seek to Config->File_IgnoreEditsBefore
6849 if (Config->NextPacket_Get() && Config->Event_CallBackFunction_IsSet())
6850 {
6851 if (Locators.empty())
6852 {
6853 Config->Demux_EventWasSent=true; //First set is to indicate the user that header is parsed
6854 return;
6855 }
6856 }
6857 }
6858 #endif //MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6859 }
6860
6861 //---------------------------------------------------------------------------
ClosedIncompleteBodyPartition()6862 void File_Mxf::ClosedIncompleteBodyPartition()
6863 {
6864 //Parsing
6865 PartitionMetadata();
6866
6867 #if MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6868 if (!Demux_HeaderParsed)
6869 {
6870 Demux_HeaderParsed=true;
6871
6872 //Testing locators
6873 Locators_CleanUp();
6874
6875 if (Config->File_IgnoreEditsBefore && !Config->File_IsDetectingDuration_Get() && Config->Event_CallBackFunction_IsSet()) //Only if demux packet may be requested
6876 Open_Buffer_Seek(3, 0, (int64u)-1); //Forcing seek to Config->File_IgnoreEditsBefore
6877 if (Config->NextPacket_Get() && Config->Event_CallBackFunction_IsSet())
6878 {
6879 if (Locators.empty())
6880 {
6881 Config->Demux_EventWasSent=true; //First set is to indicate the user that header is parsed
6882 return;
6883 }
6884 }
6885 }
6886 #endif //MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6887 }
6888
6889 //---------------------------------------------------------------------------
OpenCompleteBodyPartition()6890 void File_Mxf::OpenCompleteBodyPartition()
6891 {
6892 //Parsing
6893 PartitionMetadata();
6894
6895 #if MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6896 if (!Demux_HeaderParsed)
6897 {
6898 Demux_HeaderParsed=true;
6899
6900 //Testing locators
6901 Locators_CleanUp();
6902
6903 if (Config->File_IgnoreEditsBefore && !Config->File_IsDetectingDuration_Get() && Config->Event_CallBackFunction_IsSet()) //Only if demux packet may be requested
6904 Open_Buffer_Seek(3, 0, (int64u)-1); //Forcing seek to Config->File_IgnoreEditsBefore
6905 if (Config->NextPacket_Get() && Config->Event_CallBackFunction_IsSet())
6906 {
6907 if (Locators.empty())
6908 {
6909 Config->Demux_EventWasSent=true; //First set is to indicate the user that header is parsed
6910 return;
6911 }
6912 }
6913 }
6914 #endif //MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6915 }
6916
6917 //---------------------------------------------------------------------------
ClosedCompleteBodyPartition()6918 void File_Mxf::ClosedCompleteBodyPartition()
6919 {
6920 //Parsing
6921 PartitionMetadata();
6922
6923 #if MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6924 if (!Demux_HeaderParsed)
6925 {
6926 Demux_HeaderParsed=true;
6927
6928 //Testing locators
6929 Locators_CleanUp();
6930
6931 if (Config->File_IgnoreEditsBefore && !Config->File_IsDetectingDuration_Get() && Config->Event_CallBackFunction_IsSet()) //Only if demux packet may be requested
6932 Open_Buffer_Seek(3, 0, (int64u)-1); //Forcing seek to Config->File_IgnoreEditsBefore
6933 if (Config->NextPacket_Get() && Config->Event_CallBackFunction_IsSet())
6934 {
6935 if (Locators.empty())
6936 {
6937 Config->Demux_EventWasSent=true; //First set is to indicate the user that header is parsed
6938 return;
6939 }
6940 }
6941 }
6942 #endif //MEDIAINFO_NEXTPACKET && MEDIAINFO_DEMUX
6943 }
6944
6945 //---------------------------------------------------------------------------
GenericStreamPartition()6946 void File_Mxf::GenericStreamPartition()
6947 {
6948 //Parsing
6949 PartitionMetadata();
6950 }
6951
6952 //---------------------------------------------------------------------------
OpenIncompleteFooterPartition()6953 void File_Mxf::OpenIncompleteFooterPartition()
6954 {
6955 //Parsing
6956 PartitionMetadata();
6957 }
6958
6959 //---------------------------------------------------------------------------
ClosedIncompleteFooterPartition()6960 void File_Mxf::ClosedIncompleteFooterPartition()
6961 {
6962 //Parsing
6963 PartitionMetadata();
6964 }
6965
6966 //---------------------------------------------------------------------------
OpenCompleteFooterPartition()6967 void File_Mxf::OpenCompleteFooterPartition()
6968 {
6969 //Parsing
6970 PartitionMetadata();
6971 }
6972
6973 //---------------------------------------------------------------------------
ClosedCompleteFooterPartition()6974 void File_Mxf::ClosedCompleteFooterPartition()
6975 {
6976 //Parsing
6977 PartitionMetadata();
6978 }
6979
6980 //---------------------------------------------------------------------------
ContentStorage()6981 void File_Mxf::ContentStorage()
6982 {
6983 switch(Code2)
6984 {
6985 ELEMENT(1901, ContentStorage_Packages, "Packages")
6986 ELEMENT(1902, ContentStorage_EssenceContainerData, "EssenceContainerData")
6987 default: GenerationInterchangeObject();
6988 }
6989
6990 if (Code2==0x3C0A && InstanceUID==Prefaces[Preface_Current].ContentStorage) //InstanceIUD
6991 {
6992 Element_Level--;
6993 Element_Info1("Valid from Preface");
6994 Element_Level++;
6995 }
6996 }
6997
6998 //---------------------------------------------------------------------------
DMSegment()6999 void File_Mxf::DMSegment()
7000 {
7001 switch(Code2)
7002 {
7003 ELEMENT(0202, DMSegment_Duration, "Duration")
7004 ELEMENT(6101, DMSegment_DMFramework, "DM Framework")
7005 ELEMENT(6102, DMSegment_TrackIDs, "Track IDs")
7006 default: StructuralComponent();
7007 }
7008 }
7009
7010 //---------------------------------------------------------------------------
EssenceContainerData()7011 void File_Mxf::EssenceContainerData()
7012 {
7013 switch(Code2)
7014 {
7015 ELEMENT(2701, EssenceContainerData_LinkedPackageUID, "LinkedPackageUID")
7016 ELEMENT(3F06, EssenceContainerData_IndexSID, "IndexSID")
7017 ELEMENT(3F07, EssenceContainerData_BodySID, "BodySID")
7018 default: GenerationInterchangeObject();
7019 }
7020 }
7021
7022 //---------------------------------------------------------------------------
EventTrack()7023 void File_Mxf::EventTrack()
7024 {
7025 switch(Code2)
7026 {
7027 ELEMENT(4901, EventTrack_EventEditRate, "Edit Rate of Event Track")
7028 ELEMENT(4902, EventTrack_EventOrigin, "Offset used to resolved timeline references to this event track")
7029 default: GenericTrack();
7030 }
7031 }
7032
7033 //---------------------------------------------------------------------------
FileDescriptor()7034 void File_Mxf::FileDescriptor()
7035 {
7036 switch(Code2)
7037 {
7038 ELEMENT(3001, FileDescriptor_SampleRate, "SampleRate")
7039 ELEMENT(3002, FileDescriptor_ContainerDuration, "ContainerDuration")
7040 ELEMENT(3004, FileDescriptor_EssenceContainer, "EssenceContainer")
7041 ELEMENT(3005, FileDescriptor_Codec, "Codec")
7042 ELEMENT(3006, FileDescriptor_LinkedTrackID, "LinkedTrackID")
7043 default: GenericDescriptor();
7044 }
7045 }
7046
7047 //---------------------------------------------------------------------------
Identification()7048 void File_Mxf::Identification()
7049 {
7050 switch(Code2)
7051 {
7052 ELEMENT(3C01, Identification_CompanyName, "CompanyName")
7053 ELEMENT(3C02, Identification_ProductName, "ProductName")
7054 ELEMENT(3C03, Identification_ProductVersion, "ProductVersion")
7055 ELEMENT(3C04, Identification_VersionString, "VersionString")
7056 ELEMENT(3C05, Identification_ProductUID, "ProductUID")
7057 ELEMENT(3C06, Identification_ModificationDate , "ModificationDate")
7058 ELEMENT(3C07, Identification_ToolkitVersion, "ToolkitVersion")
7059 ELEMENT(3C08, Identification_Platform, "Platform")
7060 ELEMENT(3C09, Identification_ThisGenerationUID, "ThisGenerationUID")
7061 default: InterchangeObject();
7062 }
7063 }
7064
7065 //---------------------------------------------------------------------------
IndexTableSegment()7066 void File_Mxf::IndexTableSegment()
7067 {
7068 if (Element_Offset==4)
7069 {
7070 #if MEDIAINFO_DEMUX || MEDIAINFO_SEEK
7071 //Testing if already parsed
7072 for (size_t Pos=0; Pos<IndexTables.size(); Pos++)
7073 if (File_Offset+Buffer_Offset-Header_Size==IndexTables[Pos].StreamOffset)
7074 {
7075 Element_Offset=Element_Size;
7076 return;
7077 }
7078
7079 IndexTables.push_back(indextable());
7080 IndexTables[IndexTables.size()-1].StreamOffset=File_Offset+Buffer_Offset-Header_Size;
7081 #endif //MEDIAINFO_DEMUX || MEDIAINFO_SEEK
7082 }
7083
7084 switch(Code2)
7085 {
7086 ELEMENT(3F05, IndexTableSegment_EditUnitByteCount, "Edit Unit Byte Count")
7087 ELEMENT(3F06, IndexTableSegment_IndexSID, "IndexSID")
7088 ELEMENT(3F07, IndexTableSegment_BodySID, "BodySID")
7089 ELEMENT(3F08, IndexTableSegment_SliceCount, "Slice Count")
7090 ELEMENT(3F09, IndexTableSegment_DeltaEntryArray, "Delta Entry Array")
7091 ELEMENT(3F0A, IndexTableSegment_IndexEntryArray, "Index Entry Array")
7092 ELEMENT(3F0B, IndexTableSegment_IndexEditRate, "Index Edit Rate")
7093 ELEMENT(3F0C, IndexTableSegment_IndexStartPosition, "Index Start Position")
7094 ELEMENT(3F0D, IndexTableSegment_IndexDuration, "Index Duration")
7095 ELEMENT(3F0E, IndexTableSegment_PosTableCount, "PosTableCount")
7096 ELEMENT(8002, IndexTableSegment_8002, "8002?")
7097 default: InterchangeObject();
7098 }
7099
7100 if (Code2==0x3C0A) //InstanceIUD
7101 {
7102 IndexTable_NSL=0;
7103 IndexTable_NPE=0;
7104 }
7105 }
7106
7107 //---------------------------------------------------------------------------
GenericDescriptor()7108 void File_Mxf::GenericDescriptor()
7109 {
7110 switch(Code2)
7111 {
7112 ELEMENT(2F01, GenericDescriptor_Locators, "Locators")
7113 default: GenerationInterchangeObject();
7114 }
7115 }
7116
7117 //---------------------------------------------------------------------------
JPEG2000PictureSubDescriptor()7118 void File_Mxf::JPEG2000PictureSubDescriptor()
7119 {
7120 {
7121 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7122 if (Primer_Value!=Primer_Values.end())
7123 {
7124 int32u Code_Compare1=Primer_Value->second.hi>>32;
7125 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7126 int32u Code_Compare3=Primer_Value->second.lo>>32;
7127 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7128 if(0);
7129 ELEMENT_UUID(JPEG2000PictureSubDescriptor_Rsiz, "Rsiz - Decoder capabilities")
7130 ELEMENT_UUID(JPEG2000PictureSubDescriptor_Xsiz, "Xsiz - Width")
7131 ELEMENT_UUID(JPEG2000PictureSubDescriptor_Ysiz, "Ysiz - Height")
7132 ELEMENT_UUID(JPEG2000PictureSubDescriptor_XOsiz, "XOsiz - Horizontal offset")
7133 ELEMENT_UUID(JPEG2000PictureSubDescriptor_YOsiz, "YOsiz - Vertical offset")
7134 ELEMENT_UUID(JPEG2000PictureSubDescriptor_XTsiz, "XTsiz - Width of one reference tile")
7135 ELEMENT_UUID(JPEG2000PictureSubDescriptor_YTsiz, "YTsiz - Height of one reference tile")
7136 ELEMENT_UUID(JPEG2000PictureSubDescriptor_XTOsiz, "XTOsiz - Horizontal offset of the first tile")
7137 ELEMENT_UUID(JPEG2000PictureSubDescriptor_YTOsiz, "YTOsiz - Vertical offset of the first tile")
7138 ELEMENT_UUID(JPEG2000PictureSubDescriptor_Csiz, "Csiz - Number of components in the picture")
7139 ELEMENT_UUID(JPEG2000PictureSubDescriptor_PictureComponentSizing, "Picture Component Sizing")
7140 ELEMENT_UUID(JPEG2000PictureSubDescriptor_CodingStyleDefault, "Coding Style Default")
7141 ELEMENT_UUID(JPEG2000PictureSubDescriptor_QuantizationDefault, "Quantization Default")
7142 }
7143 }
7144
7145 GenerationInterchangeObject();
7146 }
7147
7148 //---------------------------------------------------------------------------
GenerationInterchangeObject()7149 void File_Mxf::GenerationInterchangeObject()
7150 {
7151 //Parsing
7152 switch(Code2)
7153 {
7154 ELEMENT(0102, GenerationInterchangeObject_GenerationUID, "GenerationUID")
7155 default: InterchangeObject();
7156 }
7157 }
7158
7159 //---------------------------------------------------------------------------
GenericPackage()7160 void File_Mxf::GenericPackage()
7161 {
7162 switch(Code2)
7163 {
7164 ELEMENT(4401, GenericPackage_PackageUID, "PackageUID")
7165 ELEMENT(4402, GenericPackage_Name, "Name")
7166 ELEMENT(4403, GenericPackage_Tracks, "Tracks")
7167 ELEMENT(4404, GenericPackage_PackageModifiedDate, "PackageModifiedDate")
7168 ELEMENT(4405, GenericPackage_PackageCreationDate, "PackageCreationDate")
7169 default: GenerationInterchangeObject();
7170 }
7171 }
7172
7173 //---------------------------------------------------------------------------
GenericPictureEssenceDescriptor()7174 void File_Mxf::GenericPictureEssenceDescriptor()
7175 {
7176 switch(Code2)
7177 {
7178 ELEMENT(3201, GenericPictureEssenceDescriptor_PictureEssenceCoding, "Identifier of the Picture Compression Scheme")
7179 ELEMENT(3202, GenericPictureEssenceDescriptor_StoredHeight, "Vertical Field Size")
7180 ELEMENT(3203, GenericPictureEssenceDescriptor_StoredWidth, "Horizontal Size")
7181 ELEMENT(3204, GenericPictureEssenceDescriptor_SampledHeight, "Sampled height supplied to codec")
7182 ELEMENT(3205, GenericPictureEssenceDescriptor_SampledWidth, "Sampled width supplied to codec")
7183 ELEMENT(3206, GenericPictureEssenceDescriptor_SampledXOffset, "Offset from sampled to stored width")
7184 ELEMENT(3207, GenericPictureEssenceDescriptor_SampledYOffset, "Offset from sampled to stored height")
7185 ELEMENT(3208, GenericPictureEssenceDescriptor_DisplayHeight, "Displayed Height placed in Production Aperture")
7186 ELEMENT(3209, GenericPictureEssenceDescriptor_DisplayWidth, "Displayed Width placed in Production Aperture")
7187 ELEMENT(320A, GenericPictureEssenceDescriptor_DisplayXOffset,"Horizontal offset from the of the picture as displayed")
7188 ELEMENT(320B, GenericPictureEssenceDescriptor_DisplayYOffset,"Vertical offset of the picture as displayed")
7189 ELEMENT(320C, GenericPictureEssenceDescriptor_FrameLayout, "Interlace or Progressive layout")
7190 ELEMENT(320D, GenericPictureEssenceDescriptor_VideoLineMap, "First active line in each field")
7191 ELEMENT(320E, GenericPictureEssenceDescriptor_AspectRatio, "Aspect ratio")
7192 ELEMENT(320F, GenericPictureEssenceDescriptor_AlphaTransparency, "Is Alpha Inverted")
7193 ELEMENT(3210, GenericPictureEssenceDescriptor_TransferCharacteristic, "Transfer Characteristic")
7194 ELEMENT(3211, GenericPictureEssenceDescriptor_ImageAlignmentOffset, "Byte Boundary alignment required for Low Level Essence Storage")
7195 ELEMENT(3212, GenericPictureEssenceDescriptor_FieldDominance,"Number of the field which is considered temporally to come first")
7196 ELEMENT(3213, GenericPictureEssenceDescriptor_ImageStartOffset, "Unused bytes before start of stored data")
7197 ELEMENT(3214, GenericPictureEssenceDescriptor_ImageEndOffset,"Unused bytes before start of stored data")
7198 ELEMENT(3215, GenericPictureEssenceDescriptor_SignalStandard, "Underlying signal standard")
7199 ELEMENT(3216, GenericPictureEssenceDescriptor_StoredF2Offset, "Topness Adjustment for stored picture")
7200 ELEMENT(3217, GenericPictureEssenceDescriptor_DisplayF2Offset, "Topness Adjustment for Displayed Picture")
7201 ELEMENT(3218, GenericPictureEssenceDescriptor_ActiveFormatDescriptor, "Specifies the intended framing of the content within the displayed image")
7202 ELEMENT(3219, GenericPictureEssenceDescriptor_ColorPrimaries, "Color Primaries")
7203 ELEMENT(321A, GenericPictureEssenceDescriptor_CodingEquations, "Coding Equations")
7204 default:
7205 {
7206 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7207 if (Primer_Value!=Primer_Values.end())
7208 {
7209 int32u Code_Compare1=Primer_Value->second.hi>>32;
7210 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7211 int32u Code_Compare3=Primer_Value->second.lo>>32;
7212 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7213 if(0);
7214 ELEMENT_UUID(MasteringDisplayPrimaries, "Mastering Display Primaries")
7215 ELEMENT_UUID(MasteringDisplayWhitePointChromaticity, "Mastering Display White Point Chromaticity")
7216 ELEMENT_UUID(MasteringDisplayMaximumLuminance, "Mastering Display Maximum Luminance")
7217 ELEMENT_UUID(MasteringDisplayMinimumLuminance, "Mastering Display Minimum Luminance")
7218 }
7219 }
7220 }
7221
7222 FileDescriptor();
7223
7224 if (Descriptors[InstanceUID].StreamKind==Stream_Max)
7225 {
7226 Descriptors[InstanceUID].StreamKind=Stream_Video;
7227 if (Streams_Count==(size_t)-1)
7228 Streams_Count=0;
7229 Streams_Count++;
7230 }
7231 }
7232
7233 //---------------------------------------------------------------------------
GenericSoundEssenceDescriptor()7234 void File_Mxf::GenericSoundEssenceDescriptor()
7235 {
7236 //Parsing
7237 switch(Code2)
7238 {
7239 ELEMENT(3D01, GenericSoundEssenceDescriptor_QuantizationBits, "QuantizationBits")
7240 ELEMENT(3D02, GenericSoundEssenceDescriptor_Locked , "Locked")
7241 ELEMENT(3D03, GenericSoundEssenceDescriptor_AudioSamplingRate, "AudioSamplingRate")
7242 ELEMENT(3D04, GenericSoundEssenceDescriptor_AudioRefLevel, "AudioRefLevel")
7243 ELEMENT(3D05, GenericSoundEssenceDescriptor_ElectroSpatialFormulation, "ElectroSpatialFormulation")
7244 ELEMENT(3D06, GenericSoundEssenceDescriptor_SoundEssenceCompression, "SoundEssenceCompression")
7245 ELEMENT(3D07, GenericSoundEssenceDescriptor_ChannelCount, "ChannelCount")
7246 ELEMENT(3D0C, GenericSoundEssenceDescriptor_DialNorm, "DialNorm")
7247 default: FileDescriptor();
7248 }
7249
7250 if (Descriptors[InstanceUID].StreamKind==Stream_Max)
7251 {
7252 Descriptors[InstanceUID].StreamKind=Stream_Audio;
7253 if (Streams_Count==(size_t)-1)
7254 Streams_Count=0;
7255 Streams_Count++;
7256 }
7257 }
7258
7259 //---------------------------------------------------------------------------
GenericDataEssenceDescriptor()7260 void File_Mxf::GenericDataEssenceDescriptor()
7261 {
7262 //Parsing
7263 switch(Code2)
7264 {
7265 ELEMENT(3E01, GenericDataEssenceDescriptor_DataEssenceCoding, "DataEssenceCoding")
7266 default: FileDescriptor();
7267 }
7268 }
7269
7270 //---------------------------------------------------------------------------
GenericTrack()7271 void File_Mxf::GenericTrack()
7272 {
7273 //Parsing
7274 switch(Code2)
7275 {
7276 ELEMENT(4801, GenericTrack_TrackID, "TrackID")
7277 ELEMENT(4802, GenericTrack_TrackName, "TrackName")
7278 ELEMENT(4803, GenericTrack_Sequence, "Sequence")
7279 ELEMENT(4804, GenericTrack_TrackNumber, "TrackNumber")
7280 default: GenerationInterchangeObject();
7281 }
7282 }
7283
7284 //---------------------------------------------------------------------------
InterchangeObject()7285 void File_Mxf::InterchangeObject()
7286 {
7287 //Parsing
7288 switch(Code2)
7289 {
7290 ELEMENT(3C0A, InterchangeObject_InstanceUID, "InstanceUID")
7291 default: ;
7292 }
7293 }
7294
7295 //---------------------------------------------------------------------------
MaterialPackage()7296 void File_Mxf::MaterialPackage()
7297 {
7298 GenericPackage();
7299
7300 if (Code2==0x3C0A)
7301 {
7302 if (InstanceUID==Prefaces[Preface_Current].PrimaryPackage) //InstanceIUD
7303 {
7304 Element_Level--;
7305 Element_Info1("Primary package");
7306 Element_Level++;
7307 }
7308 for (contentstorages::iterator ContentStorage=ContentStorages.begin(); ContentStorage!=ContentStorages.end(); ++ContentStorage)
7309 {
7310 for (size_t Pos=0; Pos<ContentStorage->second.Packages.size(); Pos++)
7311 if (InstanceUID==ContentStorage->second.Packages[Pos])
7312 {
7313 Element_Level--;
7314 Element_Info1("Valid from Content storage");
7315 Element_Level++;
7316 }
7317 }
7318 }
7319 }
7320
7321 //---------------------------------------------------------------------------
MPEG2VideoDescriptor()7322 void File_Mxf::MPEG2VideoDescriptor()
7323 {
7324 Descriptors[InstanceUID].HasMPEG2VideoDescriptor=true;
7325
7326 {
7327 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7328 if (Primer_Value!=Primer_Values.end())
7329 {
7330 int32u Code_Compare1=Primer_Value->second.hi>>32;
7331 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7332 int32u Code_Compare3=Primer_Value->second.lo>>32;
7333 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7334 if(0);
7335 ELEMENT_UUID(MPEG2VideoDescriptor_SingleSequence, "Single sequence")
7336 ELEMENT_UUID(MPEG2VideoDescriptor_ConstantBFrames, "Number of B frames always constant")
7337 ELEMENT_UUID(MPEG2VideoDescriptor_CodedContentType, "Coded content type")
7338 ELEMENT_UUID(MPEG2VideoDescriptor_LowDelay, "Low delay")
7339 ELEMENT_UUID(MPEG2VideoDescriptor_ClosedGOP, "Closed GOP")
7340 ELEMENT_UUID(MPEG2VideoDescriptor_IdenticalGOP, "Identical GOP")
7341 ELEMENT_UUID(MPEG2VideoDescriptor_MaxGOP, "Maximum occurring spacing between I frames")
7342 ELEMENT_UUID(MPEG2VideoDescriptor_BPictureCount, "Maximum number of B pictures between P or I frames")
7343 ELEMENT_UUID(MPEG2VideoDescriptor_ProfileAndLevel, "Profile and level")
7344 ELEMENT_UUID(MPEG2VideoDescriptor_BitRate, "Maximum bit rate")
7345 }
7346 }
7347
7348 CDCIEssenceDescriptor();
7349 }
7350
7351 //---------------------------------------------------------------------------
MultipleDescriptor()7352 void File_Mxf::MultipleDescriptor()
7353 {
7354 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
7355 Descriptors[InstanceUID].Type=descriptor::type_Mutiple;
7356
7357 switch(Code2)
7358 {
7359 ELEMENT(3F01, MultipleDescriptor_FileDescriptors, "FileDescriptors")
7360 default:;
7361 /*
7362 //TODO: check when MPEG-4 Visual subdescriptor, it disabled stream info merge
7363 {
7364 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7365 if (Primer_Value!=Primer_Values.end())
7366 {
7367 int32u Code_Compare1=Primer_Value->second.hi>>32;
7368 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7369 int32u Code_Compare3=Primer_Value->second.lo>>32;
7370 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7371 if(0);
7372 ELEMENT_UUID(SubDescriptors, "Sub Descriptors")
7373 }
7374 }
7375 */
7376 }
7377
7378 FileDescriptor();
7379 }
7380
7381 //---------------------------------------------------------------------------
DMSourceClip()7382 void File_Mxf::DMSourceClip()
7383 {
7384 InterchangeObject();
7385 }
7386
7387 //---------------------------------------------------------------------------
NetworkLocator()7388 void File_Mxf::NetworkLocator()
7389 {
7390 switch(Code2)
7391 {
7392 ELEMENT(4001, NetworkLocator_URLString, "A URL indicating where the essence may be found.")
7393 default: GenerationInterchangeObject();
7394 }
7395
7396 if (Code2==0x3C0A)
7397 {
7398 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
7399 {
7400 for (size_t Pos=0; Pos<Descriptor->second.Locators.size(); Pos++)
7401 if (InstanceUID==Descriptor->second.Locators[Pos])
7402 {
7403 Element_Level--;
7404 Element_Info1("Valid from Descriptor");
7405 Element_Level++;
7406 }
7407 }
7408 }
7409 }
7410
7411 //---------------------------------------------------------------------------
Preface()7412 void File_Mxf::Preface()
7413 {
7414 switch(Code2)
7415 {
7416 ELEMENT(3B02, Preface_LastModifiedDate, "LastModifiedDate")
7417 ELEMENT(3B03, Preface_ContentStorage, "ContentStorage")
7418 ELEMENT(3B05, Preface_Version, "Version")
7419 ELEMENT(3B06, Preface_Identifications, "Identifications")
7420 ELEMENT(3B07, Preface_ObjectModelVersion, "ObjectModelVersion")
7421 ELEMENT(3B08, Preface_PrimaryPackage, "PrimaryPackage")
7422 ELEMENT(3B09, Preface_OperationalPattern, "OperationalPattern")
7423 ELEMENT(3B0A, Preface_EssenceContainers, "EssenceContainers")
7424 ELEMENT(3B0B, Preface_DMSchemes, "DMSchemes")
7425 default: GenerationInterchangeObject();
7426 }
7427
7428 if (Code2==0x3C0A) //InstanceIUD
7429 {
7430 Preface_Current=InstanceUID;
7431 }
7432 }
7433
7434 //---------------------------------------------------------------------------
Primer()7435 void File_Mxf::Primer()
7436 {
7437 //Parsing
7438 if (Vector(2+16)==(int32u)-1)
7439 return;
7440 while (Element_Offset<Element_Size)
7441 {
7442 Element_Begin1("LocalTagEntryBatch");
7443 int16u LocalTag;
7444 int128u UID;
7445 Get_B2 (LocalTag, "LocalTag"); Element_Info1(Ztring().From_CC2(LocalTag));
7446 Get_UL (UID, "UID", NULL); Element_Info1(Ztring().From_UUID(UID));
7447 Element_End0();
7448
7449 FILLING_BEGIN();
7450 if (LocalTag>=0x8000) //user defined
7451 Primer_Values[LocalTag]=UID;
7452 FILLING_END();
7453 }
7454 }
7455
7456 //---------------------------------------------------------------------------
RGBAEssenceDescriptor()7457 void File_Mxf::RGBAEssenceDescriptor()
7458 {
7459 Descriptors[InstanceUID].Type=descriptor::Type_RGBA;
7460
7461 switch(Code2)
7462 {
7463 ELEMENT(3401, RGBAEssenceDescriptor_PixelLayout, "Pixel Layout")
7464 ELEMENT(3403, RGBAEssenceDescriptor_Palette, "Palette")
7465 ELEMENT(3404, RGBAEssenceDescriptor_PaletteLayout, "Palette Layout")
7466 ELEMENT(3405, RGBAEssenceDescriptor_ScanningDirection, "Enumerated Scanning Direction")
7467 ELEMENT(3406, RGBAEssenceDescriptor_ComponentMaxRef, "Maximum value for RGB components")
7468 ELEMENT(3407, RGBAEssenceDescriptor_ComponentMinRef, "Minimum value for RGB components")
7469 ELEMENT(3408, RGBAEssenceDescriptor_AlphaMaxRef, "Maximum value for alpha component")
7470 ELEMENT(3409, RGBAEssenceDescriptor_AlphaMinRef, "Minimum value for alpha component")
7471 default:
7472 {
7473 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7474 if (Primer_Value!=Primer_Values.end())
7475 {
7476 int32u Code_Compare1=Primer_Value->second.hi>>32;
7477 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7478 int32u Code_Compare3=Primer_Value->second.lo>>32;
7479 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7480 if(0);
7481 ELEMENT_UUID(SubDescriptors, "Sub Descriptors")
7482 }
7483 }
7484 }
7485
7486 GenericPictureEssenceDescriptor();
7487
7488 if (Descriptors[InstanceUID].Infos.find("ColorSpace")==Descriptors[InstanceUID].Infos.end())
7489 Descriptor_Fill("ColorSpace", "RGB");
7490 }
7491
7492 //---------------------------------------------------------------------------
RandomIndexPack()7493 void File_Mxf::RandomIndexPack()
7494 {
7495 //Parsing
7496 while (Element_Offset+4<Element_Size)
7497 {
7498 Element_Begin1("PartitionArray");
7499 randomindexpack RandomIndexPack;
7500 Get_B4 (RandomIndexPack.BodySID, "BodySID"); Element_Info1(RandomIndexPack.BodySID);
7501 Get_B8 (RandomIndexPack.ByteOffset, "ByteOffset"); Element_Info1(Ztring::ToZtring(RandomIndexPack.ByteOffset, 16));
7502 Element_End0();
7503
7504 FILLING_BEGIN();
7505 if (!RandomIndexPacks_AlreadyParsed && PartitionPack_AlreadyParsed.find(RandomIndexPack.ByteOffset)==PartitionPack_AlreadyParsed.end())
7506 RandomIndexPacks.push_back(RandomIndexPack);
7507 if (!RandomIndexPacks_AlreadyParsed && ExtraMetadata_SID.find(RandomIndexPack.BodySID)!=ExtraMetadata_SID.end() && RandomIndexPack.ByteOffset<ExtraMetadata_Offset)
7508 ExtraMetadata_Offset=RandomIndexPack.ByteOffset;
7509 FILLING_END();
7510 }
7511 Skip_B4( "Length");
7512
7513 FILLING_BEGIN();
7514 if (Config->ParseSpeed<1.0 && !RandomIndexPacks_AlreadyParsed && !RandomIndexPacks.empty() && Config->File_Mxf_ParseIndex_Get())
7515 {
7516 IsParsingEnd=true;
7517 GoTo(RandomIndexPacks[0].ByteOffset);
7518 RandomIndexPacks.erase(RandomIndexPacks.begin());
7519 Open_Buffer_Unsynch();
7520
7521 //Hints
7522 if (File_Buffer_Size_Hint_Pointer)
7523 (*File_Buffer_Size_Hint_Pointer)=64*1024;
7524 }
7525 else if (!RandomIndexPacks_AlreadyParsed && !Partitions_IsFooter && !RandomIndexPacks.empty() && (!RandomIndexPacks[RandomIndexPacks.size()-1].BodySID || File_Offset+Buffer_Offset-Header_Size-RandomIndexPacks[RandomIndexPacks.size()-1].ByteOffset<16*1024*1024)) // If footer was not parsed but is available
7526 {
7527 GoTo(RandomIndexPacks[RandomIndexPacks.size()-1].ByteOffset);
7528 }
7529 RandomIndexPacks_AlreadyParsed=true;
7530 FILLING_END();
7531 }
7532
7533 //---------------------------------------------------------------------------
DMFiller()7534 void File_Mxf::DMFiller()
7535 {
7536 switch(Code2)
7537 {
7538 ELEMENT(0202, DMSegment_Duration, "Duration")
7539 default: StructuralComponent();
7540 }
7541
7542 FILLING_BEGIN();
7543 DMSegments[InstanceUID].IsAs11SegmentFiller=true;
7544 FILLING_END();
7545 }
7546
7547 //---------------------------------------------------------------------------
Sequence()7548 void File_Mxf::Sequence()
7549 {
7550 switch(Code2)
7551 {
7552 ELEMENT(1001, Sequence_StructuralComponents, "StructuralComponents")
7553 default: StructuralComponent();
7554 }
7555
7556 if (Code2==0x3C0A)
7557 {
7558 for (std::map<int128u, track>::iterator Track=Tracks.begin(); Track!=Tracks.end(); ++Track)
7559 {
7560 if (InstanceUID==Track->second.Sequence)
7561 {
7562 Element_Level--;
7563 Element_Info1("Valid from track");
7564 Element_Level++;
7565 }
7566 }
7567 }
7568 }
7569
7570 //---------------------------------------------------------------------------
SourceClip()7571 void File_Mxf::SourceClip()
7572 {
7573 switch(Code2)
7574 {
7575 ELEMENT(1101, SourceClip_SourcePackageID, "SourcePackageID")
7576 ELEMENT(1102, SourceClip_SourceTrackID, "SourceTrackID")
7577 ELEMENT(1201, SourceClip_StartPosition, "StartPosition")
7578 default: StructuralComponent();
7579 }
7580 }
7581
7582 //---------------------------------------------------------------------------
SourcePackage()7583 void File_Mxf::SourcePackage()
7584 {
7585 switch(Code2)
7586 {
7587 //SourcePackage
7588 ELEMENT(4701, SourcePackage_Descriptor, "Descriptor")
7589 default: GenericPackage();
7590 Packages[InstanceUID].IsSourcePackage=true;
7591 }
7592 }
7593
7594 //---------------------------------------------------------------------------
StaticTrack()7595 void File_Mxf::StaticTrack()
7596 {
7597 GenericTrack();
7598 }
7599
7600 //---------------------------------------------------------------------------
7601 //SMPTE 405M
SystemScheme1()7602 void File_Mxf::SystemScheme1()
7603 {
7604 systemschemes::iterator SystemScheme=SystemSchemes.find(Element_Code&0xFFFF);
7605 if (SystemScheme==SystemSchemes.end())
7606 {
7607 SystemSchemes[Element_Code&0xFFFF].IsTimeCode=false;
7608 }
7609
7610 switch(Code2)
7611 {
7612 #if MEDIAINFO_TRACE
7613 ELEMENT(0101, SystemScheme1_FrameCount, "Frame Count")
7614 #endif //MEDIAINFO_TRACE
7615 ELEMENT(0102, SystemScheme1_TimeCodeArray, "Time Code Array")
7616 #if MEDIAINFO_TRACE
7617 ELEMENT(0103, SystemScheme1_ClipIDArray, "Clip ID Array")
7618 ELEMENT(0104, SystemScheme1_ExtendedClipIDArray, "Extended Clip ID Array")
7619 ELEMENT(0105, SystemScheme1_VideoIndexArray, "Video Index Array")
7620 ELEMENT(0106, SystemScheme1_KLVMetadataSequence, "KLV Metadata Sequence")
7621 ELEMENT(3001, SystemScheme1_SampleRate, "Sample Rate")
7622 ELEMENT(4804, SystemScheme1_EssenceTrackNumber, "Essence Track Number")
7623 ELEMENT(6801, SystemScheme1_EssenceTrackNumberBatch, "Essence TrackNumber Batch")
7624 ELEMENT(6803, SystemScheme1_ContentPackageIndexArray, "Content Package Index Array")
7625 #endif //MEDIAINFO_TRACE
7626 default: InterchangeObject();
7627 }
7628 }
7629
7630 //---------------------------------------------------------------------------
7631 //
AS11_AAF_Core()7632 void File_Mxf::AS11_AAF_Core()
7633 {
7634 {
7635 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7636 if (Primer_Value!=Primer_Values.end())
7637 {
7638 int32u Code_Compare1=Primer_Value->second.hi>>32;
7639 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7640 int32u Code_Compare3=Primer_Value->second.lo>>32;
7641 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7642 if(0);
7643 ELEMENT_UUID(AS11_Core_SeriesTitle, "Series Title")
7644 ELEMENT_UUID(AS11_Core_ProgrammeTitle, "Programme Title")
7645 ELEMENT_UUID(AS11_Core_EpisodeTitleNumber, "Episode Title Number")
7646 ELEMENT_UUID(AS11_Core_ShimName, "Shim Name")
7647 ELEMENT_UUID(AS11_Core_AudioTrackLayout, "Audio Track Layout")
7648 ELEMENT_UUID(AS11_Core_PrimaryAudioLanguage, "Primary Audio Language")
7649 ELEMENT_UUID(AS11_Core_ClosedCaptionsPresent, "Closed Captions Present")
7650 ELEMENT_UUID(AS11_Core_ClosedCaptionsType, "Closed Captions Type")
7651 ELEMENT_UUID(AS11_Core_ClosedCaptionsLanguage, "Closed Captions Language")
7652 ELEMENT_UUID(AS11_Core_ShimVersion, "Shim Version")
7653 }
7654 }
7655
7656 StructuralComponent();
7657
7658 if (Code2==0x3C0A) //InstanceIUD
7659 AS11s[InstanceUID].Type=as11::Type_Core;
7660 }
7661
7662 //---------------------------------------------------------------------------
7663 //
AS11_AAF_Segmentation()7664 void File_Mxf::AS11_AAF_Segmentation()
7665 {
7666 {
7667 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7668 if (Primer_Value!=Primer_Values.end())
7669 {
7670 int32u Code_Compare1=Primer_Value->second.hi>>32;
7671 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7672 int32u Code_Compare3=Primer_Value->second.lo>>32;
7673 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7674 if(0);
7675 ELEMENT_UUID(AS11_Segment_PartNumber, "Part Number")
7676 ELEMENT_UUID(AS11_Segment_PartTotal, "Part Total")
7677 }
7678 }
7679
7680 StructuralComponent();
7681
7682 if (Code2==0x3C0A) //InstanceIUD
7683 AS11s[InstanceUID].Type=as11::Type_Segmentation;
7684 }
7685
7686 //---------------------------------------------------------------------------
7687 //
AS11_AAF_UKDPP()7688 void File_Mxf::AS11_AAF_UKDPP()
7689 {
7690 {
7691 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7692 if (Primer_Value!=Primer_Values.end())
7693 {
7694 int32u Code_Compare1=Primer_Value->second.hi>>32;
7695 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7696 int32u Code_Compare3=Primer_Value->second.lo>>32;
7697 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7698 if(0);
7699 ELEMENT_UUID(AS11_UKDPP_ProductionNumber, "Production Number")
7700 ELEMENT_UUID(AS11_UKDPP_Synopsis, "Synopsis")
7701 ELEMENT_UUID(AS11_UKDPP_Originator, "Originator")
7702 ELEMENT_UUID(AS11_UKDPP_CopyrightYear, "Copyright Year")
7703 ELEMENT_UUID(AS11_UKDPP_OtherIdentifier, "Other Identifier")
7704 ELEMENT_UUID(AS11_UKDPP_OtherIdentifierType, "Other Identifier Type")
7705 ELEMENT_UUID(AS11_UKDPP_Genre, "Genre")
7706 ELEMENT_UUID(AS11_UKDPP_Distributor, "Distributor")
7707 ELEMENT_UUID(AS11_UKDPP_PictureRatio, "Picture Ratio")
7708 ELEMENT_UUID(AS11_UKDPP_3D, "3D")
7709 ELEMENT_UUID(AS11_UKDPP_3DType, "3D Type")
7710 ELEMENT_UUID(AS11_UKDPP_ProductPlacement, "Product Placement")
7711 ELEMENT_UUID(AS11_UKDPP_FpaPass, "FPA Pass")
7712 ELEMENT_UUID(AS11_UKDPP_FpaManufacturer, "FPA Manufacturer")
7713 ELEMENT_UUID(AS11_UKDPP_FpaVersion, "FPA Version")
7714 ELEMENT_UUID(AS11_UKDPP_VideoComments, "Video Comments")
7715 ELEMENT_UUID(AS11_UKDPP_SecondaryAudioLanguage, "Secondary Audio Language")
7716 ELEMENT_UUID(AS11_UKDPP_TertiaryAudioLanguage, "Tertiary Audio Language")
7717 ELEMENT_UUID(AS11_UKDPP_AudioLoudnessStandard, "Audio Loudness Standard")
7718 ELEMENT_UUID(AS11_UKDPP_AudioComments, "Audio Comments")
7719 ELEMENT_UUID(AS11_UKDPP_LineUpStart, "Line Up Start")
7720 ELEMENT_UUID(AS11_UKDPP_IdentClockStart, "Ident Clock Start")
7721 ELEMENT_UUID(AS11_UKDPP_TotalNumberOfParts, "Total Number Of Parts")
7722 ELEMENT_UUID(AS11_UKDPP_TotalProgrammeDuration, "Total Programme Duration")
7723 ELEMENT_UUID(AS11_UKDPP_AudioDescriptionPresent, "Audio Description Present")
7724 ELEMENT_UUID(AS11_UKDPP_AudioDescriptionType, "Audio Description Type")
7725 ELEMENT_UUID(AS11_UKDPP_OpenCaptionsPresent, "Open Captions Present")
7726 ELEMENT_UUID(AS11_UKDPP_OpenCaptionsType, "Open Captions Type")
7727 ELEMENT_UUID(AS11_UKDPP_OpenCaptionsLanguage, "Open Captions Language")
7728 ELEMENT_UUID(AS11_UKDPP_SigningPresent, "Signing Present")
7729 ELEMENT_UUID(AS11_UKDPP_SignLanguage, "Sign Language")
7730 ELEMENT_UUID(AS11_UKDPP_CompletionDate, "Completion Date")
7731 ELEMENT_UUID(AS11_UKDPP_TextlessElementsExist, "Textless Elements Exist")
7732 ELEMENT_UUID(AS11_UKDPP_ProgrammeHasText, "Programme Has Text")
7733 ELEMENT_UUID(AS11_UKDPP_ProgrammeTextLanguage, "Programme Text Language")
7734 ELEMENT_UUID(AS11_UKDPP_ContactEmail, "Contact Email")
7735 ELEMENT_UUID(AS11_UKDPP_ContactTelephoneNumber, "Contact Telephone Number")
7736 }
7737 }
7738
7739 StructuralComponent();
7740
7741 if (Code2==0x3C0A) //InstanceIUD
7742 AS11s[InstanceUID].Type=as11::Type_UKDPP;
7743 }
7744
7745 //---------------------------------------------------------------------------
7746 //SMPTE 380M
DMScheme1()7747 void File_Mxf::DMScheme1()
7748 {
7749 {
7750 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7751 if (Primer_Value!=Primer_Values.end())
7752 {
7753 int32u Code_Compare1=Primer_Value->second.hi>>32;
7754 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7755 int32u Code_Compare3=Primer_Value->second.lo>>32;
7756 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7757 if(0);
7758 ELEMENT_UUID(PrimaryExtendedSpokenLanguage, "Primary Extended Spoken Language")
7759 ELEMENT_UUID(SecondaryExtendedSpokenLanguage, "Secondary Extended Spoken Language")
7760 ELEMENT_UUID(OriginalExtendedSpokenLanguage, "Original Extended Spoken Language")
7761 ELEMENT_UUID(SecondaryOriginalExtendedSpokenLanguage, "Secondary Original Extended Spoken Language")
7762 }
7763 }
7764
7765 InterchangeObject();
7766 }
7767
7768 //---------------------------------------------------------------------------
7769 //
Application04_01_04_01_01()7770 void File_Mxf::Application04_01_04_01_01()
7771 {
7772 {
7773 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7774 if (Primer_Value!=Primer_Values.end())
7775 {
7776 int32u Code_Compare1=Primer_Value->second.hi>>32;
7777 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7778 int32u Code_Compare3=Primer_Value->second.lo>>32;
7779 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7780 if(0);
7781 ELEMENT_UUID(PrimaryExtendedSpokenLanguage, "Primary Extended Spoken Language")
7782 ELEMENT_UUID(SecondaryExtendedSpokenLanguage, "Secondary Extended Spoken Language")
7783 ELEMENT_UUID(OriginalExtendedSpokenLanguage, "Original Extended Spoken Language")
7784 ELEMENT_UUID(SecondaryOriginalExtendedSpokenLanguage, "Secondary Original Extended Spoken Language")
7785 }
7786 }
7787
7788 InterchangeObject();
7789 }
7790
7791 //---------------------------------------------------------------------------
7792 //
Application04_01_04_02_01()7793 void File_Mxf::Application04_01_04_02_01()
7794 {
7795 {
7796 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7797 if (Primer_Value!=Primer_Values.end())
7798 {
7799 int32u Code_Compare1=Primer_Value->second.hi>>32;
7800 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7801 int32u Code_Compare3=Primer_Value->second.lo>>32;
7802 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7803 if(0);
7804 ELEMENT_UUID(PrimaryExtendedSpokenLanguage, "Primary Extended Spoken Language")
7805 ELEMENT_UUID(SecondaryExtendedSpokenLanguage, "Secondary Extended Spoken Language")
7806 ELEMENT_UUID(OriginalExtendedSpokenLanguage, "Original Extended Spoken Language")
7807 ELEMENT_UUID(SecondaryOriginalExtendedSpokenLanguage, "Secondary Original Extended Spoken Language")
7808 ELEMENT_UUID(Application_08_BodySID, "BodySID?")
7809 }
7810 }
7811
7812 InterchangeObject();
7813 }
7814
7815
7816 //---------------------------------------------------------------------------
7817 //
Application_08_BodySID()7818 void File_Mxf::Application_08_BodySID()
7819 {
7820 //Parsing
7821 int32u Data;
7822 Get_B4 (Data, "Data"); Element_Info1(Data);
7823
7824 FILLING_BEGIN();
7825 ExtraMetadata_SID.insert(Data);
7826 FILLING_END();
7827 }
7828
7829 //---------------------------------------------------------------------------
7830 //
Application05_09_01()7831 void File_Mxf::Application05_09_01()
7832 {
7833 //Parsing - Dolby Vision Metadata
7834 File_DolbyVisionMetadata* DolbyVisionMetadata_New=new File_DolbyVisionMetadata;
7835 Open_Buffer_Init(DolbyVisionMetadata_New);
7836 Open_Buffer_Continue(DolbyVisionMetadata_New);
7837 if (DolbyVisionMetadata_New->Status[IsAccepted])
7838 {
7839 delete DolbyVisionMetadata;
7840 DolbyVisionMetadata=DolbyVisionMetadata_New;
7841 }
7842 Element_Offset=0;
7843
7844 //Parsing - ADM
7845 #if defined(MEDIAINFO_ADM_YES)
7846 File_Adm* Adm_New=new File_Adm;
7847 Open_Buffer_Init(Adm_New);
7848 Open_Buffer_Continue(Adm_New);
7849 if (Adm_New->Status[IsAccepted])
7850 {
7851 delete Adm;
7852 Adm=Adm_New;
7853 }
7854 Element_Offset=0;
7855 #endif
7856
7857 //Parsing - Dolby Audio Metadata
7858 File_DolbyAudioMetadata* DolbyAudioMetadata_New=new File_DolbyAudioMetadata;
7859 DolbyAudioMetadata_New->IsXML=true;
7860 Open_Buffer_Init(DolbyAudioMetadata_New);
7861 Open_Buffer_Continue(DolbyAudioMetadata_New);
7862 if (DolbyAudioMetadata_New->Status[IsAccepted])
7863 {
7864 delete DolbyAudioMetadata;
7865 DolbyAudioMetadata=DolbyAudioMetadata_New;
7866 }
7867 Element_Offset=0;
7868
7869 Skip_String(Element_Size, "Data");
7870 Element_Show();
7871 }
7872
7873 //---------------------------------------------------------------------------
StructuralComponent()7874 void File_Mxf::StructuralComponent()
7875 {
7876 switch(Code2)
7877 {
7878 ELEMENT(0201, StructuralComponent_DataDefinition, "DataDefinition")
7879 ELEMENT(0202, StructuralComponent_Duration, "Duration")
7880 default: GenerationInterchangeObject();
7881 }
7882 }
7883
7884 //---------------------------------------------------------------------------
TextLocator()7885 void File_Mxf::TextLocator()
7886 {
7887 switch(Code2)
7888 {
7889 ELEMENT(4101, TextLocator_LocatorName, "Human-readable locator text string for manual location of essence")
7890 default: GenerationInterchangeObject();
7891 }
7892 }
7893
7894 //---------------------------------------------------------------------------
StereoscopicPictureSubDescriptor()7895 void File_Mxf::StereoscopicPictureSubDescriptor()
7896 {
7897 StereoscopicPictureSubDescriptor_IsPresent=true;
7898
7899 //switch(Code2)
7900 //{
7901 // default:
7902 GenerationInterchangeObject();
7903 //}
7904 }
7905
7906 //---------------------------------------------------------------------------
TimecodeComponent()7907 void File_Mxf::TimecodeComponent()
7908 {
7909 if (Element_Offset==4)
7910 {
7911 MxfTimeCodeForDelay=mxftimecode();
7912 DTS_Delay=0;
7913 FrameInfo.DTS=0;
7914 }
7915
7916 switch(Code2)
7917 {
7918 ELEMENT(1501, TimecodeComponent_StartTimecode, "StartTimecode")
7919 ELEMENT(1502, TimecodeComponent_RoundedTimecodeBase, "RoundedTimecodeBase")
7920 ELEMENT(1503, TimecodeComponent_DropFrame, "DropFrame")
7921 default: StructuralComponent();
7922 }
7923 }
7924
7925 //---------------------------------------------------------------------------
WaveAudioDescriptor()7926 void File_Mxf::WaveAudioDescriptor()
7927 {
7928 switch(Code2)
7929 {
7930 ELEMENT(3D09, WaveAudioDescriptor_AvgBps, "Average Bytes per second")
7931 ELEMENT(3D0A, WaveAudioDescriptor_BlockAlign, "Sample Block alignment")
7932 ELEMENT(3D0B, WaveAudioDescriptor_SequenceOffset, "Frame number of first essence")
7933 ELEMENT(3D29, WaveAudioDescriptor_PeakEnvelopeVersion, "Peak envelope version information")
7934 ELEMENT(3D2A, WaveAudioDescriptor_PeakEnvelopeFormat, "Format of a peak point")
7935 ELEMENT(3D2B, WaveAudioDescriptor_PointsPerPeakValue, "Number of peak points per peak value")
7936 ELEMENT(3D2C, WaveAudioDescriptor_PeakEnvelopeBlockSize,"Number of audio samples used to generate each peak frame")
7937 ELEMENT(3D2D, WaveAudioDescriptor_PeakChannels, "Number of peak channels")
7938 ELEMENT(3D2E, WaveAudioDescriptor_PeakFrames, "Number of peak frames")
7939 ELEMENT(3D2F, WaveAudioDescriptor_PeakOfPeaksPosition, "Offset to the first audio sample whose absolute value is the maximum value of the entire audio file")
7940 ELEMENT(3D30, WaveAudioDescriptor_PeakEnvelopeTimestamp,"Time stamp of the creation of the peak data")
7941 ELEMENT(3D31, WaveAudioDescriptor_PeakEnvelopeData , "Peak envelope data")
7942 ELEMENT(3D32, WaveAudioDescriptor_ChannelAssignment, "Channel assignment")
7943 default:
7944 {
7945 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
7946 if (Primer_Value!=Primer_Values.end())
7947 {
7948 int32u Code_Compare1=Primer_Value->second.hi>>32;
7949 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
7950 int32u Code_Compare3=Primer_Value->second.lo>>32;
7951 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
7952 if(0);
7953 ELEMENT_UUID(SubDescriptors, "Sub Descriptors")
7954 }
7955 }
7956 }
7957
7958 GenericSoundEssenceDescriptor();
7959 }
7960
7961 //---------------------------------------------------------------------------
VbiPacketsDescriptor()7962 void File_Mxf::VbiPacketsDescriptor()
7963 {
7964 //switch(Code2)
7965 //{
7966 // default:
7967 GenericDataEssenceDescriptor();
7968 //}
7969
7970 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
7971 {
7972 Descriptors[InstanceUID].Type=descriptor::Type_AncPackets;
7973 if (Streams_Count==(size_t)-1)
7974 Streams_Count=0;
7975 Streams_Count++;
7976 }
7977 }
7978
7979 //---------------------------------------------------------------------------
AncPacketsDescriptor()7980 void File_Mxf::AncPacketsDescriptor()
7981 {
7982 //switch(Code2)
7983 //{
7984 // default:
7985 GenericDataEssenceDescriptor();
7986 //}
7987
7988 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
7989 {
7990 Descriptors[InstanceUID].Type=descriptor::Type_AncPackets;
7991 if (Streams_Count==(size_t)-1)
7992 Streams_Count=0;
7993 Streams_Count++;
7994 }
7995 }
7996
7997 //---------------------------------------------------------------------------
MpegAudioDescriptor()7998 void File_Mxf::MpegAudioDescriptor()
7999 {
8000 {
8001 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8002 if (Primer_Value!=Primer_Values.end())
8003 {
8004 int32u Code_Compare1=Primer_Value->second.hi>>32;
8005 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
8006 int32u Code_Compare3=Primer_Value->second.lo>>32;
8007 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
8008 if(0);
8009 ELEMENT_UUID(MpegAudioDescriptor_BitRate, "Bit Rate")
8010 }
8011 }
8012
8013 //switch(Code2)
8014 //{
8015 // default: GenericSoundEssenceDescriptor();
8016 //}
8017 }
8018
8019 //---------------------------------------------------------------------------
PackageMarkerObject()8020 void File_Mxf::PackageMarkerObject()
8021 {
8022 //switch(Code2)
8023 //{
8024 // default:
8025 GenerationInterchangeObject();
8026 //}
8027 }
8028
8029 //---------------------------------------------------------------------------
ApplicationPlugInObject()8030 void File_Mxf::ApplicationPlugInObject()
8031 {
8032 //switch(Code2)
8033 //{
8034 // default:
8035 GenerationInterchangeObject();
8036 //}
8037 }
8038
8039 //---------------------------------------------------------------------------
ApplicationReferencedObject()8040 void File_Mxf::ApplicationReferencedObject()
8041 {
8042 //switch(Code2)
8043 //{
8044 // default:
8045 GenerationInterchangeObject();
8046 //}
8047 }
8048
8049 //---------------------------------------------------------------------------
MCALabelSubDescriptor()8050 void File_Mxf::MCALabelSubDescriptor()
8051 {
8052 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
8053 Descriptors[InstanceUID].Type=descriptor::Type_MCALabelSubDescriptor;
8054
8055 {
8056 // Not a short code
8057 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8058 if (Primer_Value!=Primer_Values.end())
8059 {
8060 int32u Code_Compare1=Primer_Value->second.hi>>32;
8061 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
8062 int32u Code_Compare3=Primer_Value->second.lo>>32;
8063 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
8064 if(0);
8065 ELEMENT_UUID(MCAChannelID, "MCA Channel ID")
8066 ELEMENT_UUID(MCALabelDictionaryID, "MCA Label Dictionary ID")
8067 ELEMENT_UUID(MCATagSymbol, "MCA Tag Symbol")
8068 ELEMENT_UUID(MCATagName, "MCA Tag Name")
8069 ELEMENT_UUID(GroupOfSoundfieldGroupsLinkID, "Group Of Soundfield Groups Link ID")
8070 ELEMENT_UUID(MCALinkID, "MCA Link ID")
8071 ELEMENT_UUID(SoundfieldGroupLinkID, "Soundfield Group Link ID")
8072 ELEMENT_UUID(MCAPartitionKind, "MCA Partition Kind")
8073 ELEMENT_UUID(MCAPartitionNumber, "MCA Partition Number")
8074 ELEMENT_UUID(MCATitle, "MCA Title")
8075 ELEMENT_UUID(MCATitleVersion, "MCA Title Version")
8076 ELEMENT_UUID(MCATitleSubVersion, "MCA Title Sub-version")
8077 ELEMENT_UUID(MCAEpisode, "MCA Episode")
8078 ELEMENT_UUID(MCAAudioContentKind, "MCA Audio Content Kind")
8079 ELEMENT_UUID(MCAAudioElementKind, "MCA Audio Element Kind")
8080 ELEMENT_UUID(RFC5646AudioLanguageCode, "Secondary Original Extended Spoken Language")
8081 }
8082 }
8083
8084 //switch(Code2)
8085 //{
8086 // default:
8087 GenerationInterchangeObject();
8088 //}
8089 }
8090
8091 //---------------------------------------------------------------------------
TimedTextDescriptor()8092 void File_Mxf::TimedTextDescriptor()
8093 {
8094 {
8095 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8096 if (Primer_Value!=Primer_Values.end())
8097 {
8098 int32u Code_Compare1=Primer_Value->second.hi>>32;
8099 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
8100 int32u Code_Compare3=Primer_Value->second.lo>>32;
8101 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
8102 if(0);
8103 ELEMENT_UUID(ResourceID, "Resource ID")
8104 ELEMENT_UUID(NamespaceURI, "Namespace URI")
8105 ELEMENT_UUID(UCSEncoding, "UCS Encoding")
8106 }
8107 }
8108
8109 //switch(Code2)
8110 //{
8111 // default:
8112 GenericDataEssenceDescriptor();
8113 //}
8114
8115 if (Descriptors[InstanceUID].StreamKind==Stream_Max)
8116 {
8117 Descriptors[InstanceUID].StreamKind=Stream_Text;
8118 if (Streams_Count==(size_t)-1)
8119 Streams_Count=0;
8120 Streams_Count++;
8121 }
8122 }
8123
8124 //---------------------------------------------------------------------------
TimedTextResourceSubDescriptor()8125 void File_Mxf::TimedTextResourceSubDescriptor()
8126 {
8127 //switch(Code2)
8128 //{
8129 // default:
8130 GenerationInterchangeObject();
8131 //}
8132 }
8133
8134 //---------------------------------------------------------------------------
ContainerConstraintsSubDescriptor()8135 void File_Mxf::ContainerConstraintsSubDescriptor()
8136 {
8137 //switch(Code2)
8138 //{
8139 // default:
8140 GenerationInterchangeObject();
8141 //}
8142 }
8143
8144 //---------------------------------------------------------------------------
Mpeg4VisualSubDescriptor()8145 void File_Mxf::Mpeg4VisualSubDescriptor()
8146 {
8147 if (Code2>=0x8000)
8148 {
8149 // Not a short code
8150 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8151 if (Primer_Value!=Primer_Values.end())
8152 {
8153 int32u Code_Compare1=Primer_Value->second.hi>>32;
8154 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
8155 int32u Code_Compare3=Primer_Value->second.lo>>32;
8156 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
8157 if(0);
8158 ELEMENT_UUID(Mpeg4VisualDescriptor_SingleSequence, "Single sequence")
8159 ELEMENT_UUID(Mpeg4VisualDescriptor_ConstantBFrames, "Number of B frames always constant")
8160 ELEMENT_UUID(Mpeg4VisualDescriptor_CodedContentType, "Coded content type")
8161 ELEMENT_UUID(Mpeg4VisualDescriptor_LowDelay, "Low delay")
8162 ELEMENT_UUID(Mpeg4VisualDescriptor_ClosedGOP, "Closed GOP")
8163 ELEMENT_UUID(Mpeg4VisualDescriptor_IdenticalGOP, "Identical GOP")
8164 ELEMENT_UUID(Mpeg4VisualDescriptor_MaxGOP, "Maximum occurring spacing between I frames")
8165 ELEMENT_UUID(Mpeg4VisualDescriptor_BPictureCount, "Maximum number of B pictures between P or I frames")
8166 ELEMENT_UUID(Mpeg4VisualDescriptor_ProfileAndLevel, "Profile and level")
8167 ELEMENT_UUID(Mpeg4VisualDescriptor_BitRate, "Maximum bit rate")
8168 }
8169 }
8170
8171 //switch(Code2)
8172 //{
8173 // default:
8174 GenerationInterchangeObject();
8175 //}
8176 }
8177
8178 //---------------------------------------------------------------------------
ResourceID()8179 void File_Mxf::ResourceID()
8180 {
8181 //Parsing
8182 Info_UUID(Data, "UUID"); Element_Info1(Ztring().From_UUID(Data));
8183 }
8184
8185 //---------------------------------------------------------------------------
NamespaceURI()8186 void File_Mxf::NamespaceURI()
8187 {
8188 //Parsing
8189 Info_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8190 }
8191
8192 //---------------------------------------------------------------------------
UCSEncoding()8193 void File_Mxf::UCSEncoding()
8194 {
8195 //Parsing
8196 Info_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8197 }
8198
8199 //---------------------------------------------------------------------------
AudioChannelLabelSubDescriptor()8200 void File_Mxf::AudioChannelLabelSubDescriptor()
8201 {
8202 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
8203 Descriptors[InstanceUID].Type=descriptor::Type_AudioChannelLabelSubDescriptor;
8204
8205 //switch(Code2)
8206 //{
8207 // default:
8208 MCALabelSubDescriptor();
8209 //}
8210 }
8211
8212 //---------------------------------------------------------------------------
SoundfieldGroupLabelSubDescriptor()8213 void File_Mxf::SoundfieldGroupLabelSubDescriptor()
8214 {
8215 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
8216 Descriptors[InstanceUID].Type=descriptor::Type_SoundfieldGroupLabelSubDescriptor;
8217
8218 //switch(Code2)
8219 //{
8220 // default:
8221 MCALabelSubDescriptor();
8222 //}
8223 }
8224
8225 //---------------------------------------------------------------------------
GroupOfSoundfieldGroupsLabelSubDescriptor()8226 void File_Mxf::GroupOfSoundfieldGroupsLabelSubDescriptor()
8227 {
8228 if (Descriptors[InstanceUID].Type==descriptor::Type_Unknown)
8229 Descriptors[InstanceUID].Type=descriptor::Type_GroupOfSoundfieldGroupsLabelSubDescriptor;
8230
8231 if (Code2>=0x8000)
8232 {
8233 // Not a short code
8234 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8235 if (Primer_Value!=Primer_Values.end())
8236 {
8237 MCALabelSubDescriptor();
8238
8239 return;
8240 }
8241 }
8242
8243 //switch(Code2)
8244 //{
8245 // default:
8246 MCALabelSubDescriptor();
8247 //}
8248 }
8249
8250 //---------------------------------------------------------------------------
AVCSubDescriptor()8251 void File_Mxf::AVCSubDescriptor()
8252 {
8253 {
8254 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8255 if (Primer_Value!=Primer_Values.end())
8256 {
8257 int32u Code_Compare1=Primer_Value->second.hi>>32;
8258 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
8259 int32u Code_Compare3=Primer_Value->second.lo>>32;
8260 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
8261 if(0);
8262 ELEMENT_UUID(AVCDescriptor_ConstantBFrames, "Number of B frames always constant")
8263 ELEMENT_UUID(AVCDescriptor_CodedContentType, "Coded content type")
8264 ELEMENT_UUID(AVCDescriptor_ClosedGOP, "Closed GOP")
8265 ELEMENT_UUID(AVCDescriptor_IdenticalGOP, "Identical GOP")
8266 ELEMENT_UUID(AVCDescriptor_MaxGOP, "Maximum occurring spacing between I frames")
8267 ELEMENT_UUID(AVCDescriptor_BPictureCount, "Maximum number of B pictures between P or I frames")
8268 ELEMENT_UUID(AVCDescriptor_Profile, "Profile")
8269 ELEMENT_UUID(AVCDescriptor_MaximumBitRate, "Maximum bit rate")
8270 ELEMENT_UUID(AVCDescriptor_ProfileConstraint, "Profile Constraint")
8271 ELEMENT_UUID(AVCDescriptor_Level, "Level")
8272 ELEMENT_UUID(AVCDescriptor_DecodingDelay, "Decoding delay")
8273 ELEMENT_UUID(AVCDescriptor_MaximumRefFrames, "Maximum reference frames")
8274 ELEMENT_UUID(AVCDescriptor_SequenceParameterSetFlag, "Sequence parameter set flag")
8275 ELEMENT_UUID(AVCDescriptor_PictureParameterSetFlag, "Picture parameter set flag")
8276 ELEMENT_UUID(AVCDescriptor_AverageBitRate, "Average bit rate")
8277 }
8278 }
8279
8280 //switch(Code2)
8281 //{
8282 // default:
8283 GenerationInterchangeObject();
8284 //}
8285 }
8286
8287 //---------------------------------------------------------------------------
IABEssenceDescriptor()8288 void File_Mxf::IABEssenceDescriptor()
8289 {
8290 //switch(Code2)
8291 //{
8292 // default:
8293 GenericSoundEssenceDescriptor();
8294 //}
8295 }
8296
8297 //---------------------------------------------------------------------------
IABSoundfieldLabelSubDescriptor()8298 void File_Mxf::IABSoundfieldLabelSubDescriptor()
8299 {
8300 //switch(Code2)
8301 //{
8302 // default:
8303 MCALabelSubDescriptor();
8304 //}
8305 }
8306
8307 //---------------------------------------------------------------------------
MCAChannelID()8308 void File_Mxf::MCAChannelID()
8309 {
8310 if (Length2==4)
8311 {
8312 Info_B4(Value, "Value"); Element_Info1(Value);
8313 }
8314 else
8315 Skip_XX(Length2, "Data");
8316 }
8317
8318 //---------------------------------------------------------------------------
MCALabelDictionaryID()8319 void File_Mxf::MCALabelDictionaryID()
8320 {
8321 //Parsing
8322 int128u Value;
8323 Get_UL (Value, "Value", NULL); Element_Info1(Ztring().From_UUID(Value));
8324
8325 FILLING_BEGIN();
8326 Descriptors[InstanceUID].MCALabelDictionaryID=Value;
8327 FILLING_END();
8328 }
8329
8330 //---------------------------------------------------------------------------
MCATagSymbol()8331 void File_Mxf::MCATagSymbol()
8332 {
8333 //Parsing
8334 Ztring Value;
8335 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8336
8337 FILLING_BEGIN();
8338 Descriptors[InstanceUID].MCATagSymbol=Value;
8339 FILLING_END();
8340 }
8341
8342 //---------------------------------------------------------------------------
MCATagName()8343 void File_Mxf::MCATagName()
8344 {
8345 //Parsing
8346 Ztring Value;
8347 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8348
8349 FILLING_BEGIN();
8350 Descriptors[InstanceUID].MCATagName=Value;
8351 FILLING_END();
8352 }
8353
8354 //---------------------------------------------------------------------------
GroupOfSoundfieldGroupsLinkID()8355 void File_Mxf::GroupOfSoundfieldGroupsLinkID()
8356 {
8357 if (Length2==0)
8358 return;
8359
8360 //Parsing
8361 if (Vector(16)==(int32u)-1)
8362 return;
8363 while (Element_Offset<Element_Size)
8364 {
8365 int128u Data;
8366 Get_UUID(Data, "Value");
8367 }
8368 }
8369
8370 //---------------------------------------------------------------------------
MCALinkID()8371 void File_Mxf::MCALinkID()
8372 {
8373 //Parsing
8374 int128u Value;
8375 Get_UUID (Value, "Value"); Element_Info1(Ztring().From_UUID(Value));
8376
8377 FILLING_BEGIN();
8378 Descriptors[InstanceUID].MCALinkID=Value;
8379 FILLING_END();
8380 }
8381
8382 //---------------------------------------------------------------------------
SoundfieldGroupLinkID()8383 void File_Mxf::SoundfieldGroupLinkID()
8384 {
8385 //Parsing
8386 int128u Value;
8387 Get_UUID (Value, "Value"); Element_Info1(Ztring().From_UUID(Value));
8388
8389 FILLING_BEGIN();
8390 Descriptors[InstanceUID].SoundfieldGroupLinkID=Value;
8391 FILLING_END();
8392 }
8393
8394 //---------------------------------------------------------------------------
MCAPartitionKind()8395 void File_Mxf::MCAPartitionKind()
8396 {
8397 //Parsing
8398 Ztring Value;
8399 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8400
8401 FILLING_BEGIN();
8402 Descriptors[InstanceUID].MCAPartitionKind=Value;
8403 FILLING_END();
8404 }
8405
8406 //---------------------------------------------------------------------------
MCAPartitionNumber()8407 void File_Mxf::MCAPartitionNumber()
8408 {
8409 //Parsing
8410 Ztring Value;
8411 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8412
8413 FILLING_BEGIN();
8414 Descriptors[InstanceUID].MCAPartitionNumber=Value;
8415 FILLING_END();
8416 }
8417
8418 //---------------------------------------------------------------------------
MCATitle()8419 void File_Mxf::MCATitle()
8420 {
8421 //Parsing
8422 Ztring Value;
8423 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8424
8425 FILLING_BEGIN();
8426 Descriptors[InstanceUID].MCATitle=Value;
8427 FILLING_END();
8428 }
8429
8430 //---------------------------------------------------------------------------
MCATitleVersion()8431 void File_Mxf::MCATitleVersion()
8432 {
8433 //Parsing
8434 Ztring Value;
8435 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8436
8437 FILLING_BEGIN();
8438 Descriptors[InstanceUID].MCATitleVersion=Value;
8439 FILLING_END();
8440 }
8441
8442 //---------------------------------------------------------------------------
MCATitleSubVersion()8443 void File_Mxf::MCATitleSubVersion()
8444 {
8445 //Parsing
8446 Ztring Value;
8447 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8448
8449 FILLING_BEGIN();
8450 Descriptors[InstanceUID].MCATitleSubVersion=Value;
8451 FILLING_END();
8452 }
8453
8454 //---------------------------------------------------------------------------
MCAEpisode()8455 void File_Mxf::MCAEpisode()
8456 {
8457 //Parsing
8458 Ztring Value;
8459 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8460
8461 FILLING_BEGIN();
8462 Descriptors[InstanceUID].MCAEpisode=Value;
8463 FILLING_END();
8464 }
8465
8466 //---------------------------------------------------------------------------
MCAAudioContentKind()8467 void File_Mxf::MCAAudioContentKind()
8468 {
8469 //Parsing
8470 Ztring Value;
8471 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8472
8473 FILLING_BEGIN();
8474 Descriptors[InstanceUID].MCAAudioContentKind=Value;
8475 FILLING_END();
8476 }
8477
8478 //---------------------------------------------------------------------------
MCAAudioElementKind()8479 void File_Mxf::MCAAudioElementKind()
8480 {
8481 //Parsing
8482 Ztring Value;
8483 Get_UTF16B (Length2, Value, "Value"); Element_Info1(Value);
8484
8485 FILLING_BEGIN();
8486 Descriptors[InstanceUID].MCAAudioElementKind=Value;
8487 FILLING_END();
8488 }
8489
8490 //---------------------------------------------------------------------------
Filler()8491 void File_Mxf::Filler()
8492 {
8493 #if MEDIAINFO_TRACE
8494 if (Trace_Activated)
8495 {
8496 if (Padding_Trace_Count<MaxCountSameElementInTrace || (IsParsingMiddle_MaxOffset==(int64u)-1 && Partitions_IsFooter))
8497 {
8498 if (!Essences.empty()) //Only after first essence data or in footer
8499 Padding_Trace_Count++;
8500 }
8501 else
8502 {
8503 Element_Set_Remove_Children_IfNoErrors();
8504 Element_Begin0(); //TODO: Element_Set_Remove_Children_IfNoErrors does not work if there is not sub-element
8505 Element_End0();
8506 }
8507 }
8508 #endif // MEDIAINFO_TRACE
8509
8510 Skip_XX(Element_Size, "Junk");
8511
8512 Buffer_PaddingBytes+=Element_Size;
8513 DataMustAlwaysBeComplete=true;
8514 }
8515
8516 //---------------------------------------------------------------------------
TerminatingFiller()8517 void File_Mxf::TerminatingFiller()
8518 {
8519 #if MEDIAINFO_TRACE
8520 if (Trace_Activated)
8521 {
8522 if (Padding_Trace_Count<MaxCountSameElementInTrace || Partitions_IsFooter)
8523 {
8524 if (!Essences.empty()) //Only after first essence data or in footer
8525 Padding_Trace_Count++;
8526 }
8527 else
8528 {
8529 Element_Set_Remove_Children_IfNoErrors();
8530 Element_Begin0(); //TODO: Element_Set_Remove_Children_IfNoErrors does not work if there is not sub-element
8531 Element_End0();
8532 }
8533 }
8534 #endif // MEDIAINFO_TRACE
8535
8536 Skip_XX(Element_Size, "Junk");
8537
8538 Buffer_PaddingBytes+=Element_Size;
8539 }
8540
8541 //---------------------------------------------------------------------------
XmlDocumentText()8542 void File_Mxf::XmlDocumentText()
8543 {
8544 Skip_XX(Element_Size, "XML data");
8545 }
8546
8547 //---------------------------------------------------------------------------
SubDescriptors()8548 void File_Mxf::SubDescriptors()
8549 {
8550 Descriptors[InstanceUID].SubDescriptors.clear();
8551
8552 //Parsing
8553 if (Vector(16)==(int32u)-1)
8554 return;
8555 while (Element_Offset<Element_Size)
8556 {
8557 int128u Data;
8558 Get_UUID(Data, "Sub Descriptor");
8559
8560 FILLING_BEGIN();
8561 Descriptors[InstanceUID].SubDescriptors.push_back(Data);
8562 FILLING_END();
8563 }
8564 }
8565
8566 //---------------------------------------------------------------------------
LensUnitMetadata()8567 void File_Mxf::LensUnitMetadata()
8568 {
8569 if (AcquisitionMetadataLists.empty())
8570 AcquisitionMetadataLists.resize(0x10000);
8571
8572 switch(Code2)
8573 {
8574 ELEMENT(8000, LensUnitMetadata_IrisFNumber, "Iris (F)")
8575 ELEMENT(8001, LensUnitMetadata_FocusPositionFromImagePlane, "Focus Position (Image Plane)")
8576 ELEMENT(8002, LensUnitMetadata_FocusPositionFromFrontLensVertex, "Focus Position (Front Lens Vertex)")
8577 ELEMENT(8003, LensUnitMetadata_MacroSetting, "Macro Setting")
8578 ELEMENT(8004, LensUnitMetadata_LensZoom35mmStillCameraEquivalent, "LensZoom (35mm Still Camera Equivalent")
8579 ELEMENT(8005, LensUnitMetadata_LensZoomActualFocalLength, "LensZoom (Actual Focal Length)")
8580 ELEMENT(8006, LensUnitMetadata_OpticalExtenderMagnification, "Optical Extender Magnification")
8581 ELEMENT(8007, LensUnitMetadata_LensAttributes, "Lens Attributes")
8582 ELEMENT(8008, LensUnitMetadata_IrisTNumber, "Iris (T)")
8583 ELEMENT(8009, LensUnitMetadata_IrisRingPosition, "Iris Ring Position")
8584 ELEMENT(800A, LensUnitMetadata_FocusRingPosition, "Focus Ring Position")
8585 ELEMENT(800B, LensUnitMetadata_ZoomRingPosition, "Zoom Ring Position")
8586 default:
8587 GenerationInterchangeObject();
8588 }
8589 }
8590
8591 //---------------------------------------------------------------------------
CameraUnitMetadata()8592 void File_Mxf::CameraUnitMetadata()
8593 {
8594 if (AcquisitionMetadataLists.empty())
8595 AcquisitionMetadataLists.resize(0x10000);
8596
8597 switch(Code2)
8598 {
8599 ELEMENT(3210, CameraUnitMetadata_CaptureGammaEquation, "Capture Gamma Equation")
8600 ELEMENT(8100, CameraUnitMetadata_AutoExposureMode, "AutoExposure Mode")
8601 ELEMENT(8101, CameraUnitMetadata_AutoFocusSensingAreaSetting, "Auto Focus Sensing Area Setting")
8602 ELEMENT(8102, CameraUnitMetadata_ColorCorrectionFilterWheelSetting, "Color Correction Filter Wheel Setting")
8603 ELEMENT(8103, CameraUnitMetadata_NeutralDensityFilterWheelSetting, "Neutral Density Filter Wheel Setting")
8604 ELEMENT(8104, CameraUnitMetadata_ImageSensorDimensionEffectiveWidth,"Imager Dimension (Effective Width)")
8605 ELEMENT(8105, CameraUnitMetadata_ImageSensorDimensionEffectiveHeight,"Imager Dimension (Effective Height)")
8606 ELEMENT(8106, CameraUnitMetadata_CaptureFrameRate, "Capture Frame Rate")
8607 ELEMENT(8107, CameraUnitMetadata_ImageSensorReadoutMode, "Image Sensor Readout Mode")
8608 ELEMENT(8108, CameraUnitMetadata_ShutterSpeed_Angle, "Shutter Speed (Angle)")
8609 ELEMENT(8109, CameraUnitMetadata_ShutterSpeed_Time, "Shutter Speed (Time)")
8610 ELEMENT(810A, CameraUnitMetadata_CameraMasterGainAdjustment, "Camera Master Gain Adjustment")
8611 ELEMENT(810B, CameraUnitMetadata_ISOSensitivity, "ISO Sensitivity")
8612 ELEMENT(810C, CameraUnitMetadata_ElectricalExtenderMagnification, "Electrical Extender Magnification")
8613 ELEMENT(810D, CameraUnitMetadata_AutoWhiteBalanceMode, "Auto White Balance Mode")
8614 ELEMENT(810E, CameraUnitMetadata_WhiteBalance, "White Balance")
8615 ELEMENT(810F, CameraUnitMetadata_CameraMasterBlackLevel, "Camera Master BlackLevel")
8616 ELEMENT(8110, CameraUnitMetadata_CameraKneePoint, "Camera Knee Point")
8617 ELEMENT(8111, CameraUnitMetadata_CameraKneeSlope, "Camera Knee Slope")
8618 ELEMENT(8112, CameraUnitMetadata_CameraLuminanceDynamicRange, "Camera Luminance Dynamic Range")
8619 ELEMENT(8113, CameraUnitMetadata_CameraSettingFileURI, "Camera Setting File URI")
8620 ELEMENT(8114, CameraUnitMetadata_CameraAttributes, "Camera Attributes")
8621 ELEMENT(8115, CameraUnitMetadata_ExposureIndexofPhotoMeter, "Exposure Index of Photo Meter")
8622 ELEMENT(8116, CameraUnitMetadata_GammaForCDL, "Gamma for CDL")
8623 ELEMENT(8117, CameraUnitMetadata_ASC_CDL_V12, "ASC CDL V1.2")
8624 ELEMENT(8118, CameraUnitMetadata_ColorMatrix, "ColorMatrix")
8625 default:
8626 GenerationInterchangeObject();
8627 }
8628 }
8629
8630 //---------------------------------------------------------------------------
UserDefinedAcquisitionMetadata()8631 void File_Mxf::UserDefinedAcquisitionMetadata()
8632 {
8633 if (AcquisitionMetadataLists.empty())
8634 {
8635 AcquisitionMetadataLists.resize(0x10000);
8636 AcquisitionMetadata_Sony_CalibrationType = (int8u)-1;
8637 }
8638
8639 switch(Code2)
8640 {
8641 ELEMENT(E000, UserDefinedAcquisitionMetadata_UdamSetIdentifier, "UDAM Set Identifier")
8642 default:
8643 if (UserDefinedAcquisitionMetadata_UdamSetIdentifier_IsSony)
8644 switch(Code2)
8645 {
8646 ELEMENT(8007, LensUnitMetadata_LensAttributes, "Lens Attributes")
8647 ELEMENT(E101, UserDefinedAcquisitionMetadata_Sony_E101, "Effective Marker Coverage")
8648 ELEMENT(E102, UserDefinedAcquisitionMetadata_Sony_E102, "Effective Marker Aspect Ratio")
8649 ELEMENT(E103, UserDefinedAcquisitionMetadata_Sony_E103, "Camera Process Discrimination Code")
8650 ELEMENT(E104, UserDefinedAcquisitionMetadata_Sony_E104, "Rotary Shutter Mode")
8651 ELEMENT(E105, UserDefinedAcquisitionMetadata_Sony_E105, "Raw Black Code Value")
8652 ELEMENT(E106, UserDefinedAcquisitionMetadata_Sony_E106, "Raw Gray Code Value")
8653 ELEMENT(E107, UserDefinedAcquisitionMetadata_Sony_E107, "Raw White Code Value")
8654 ELEMENT(E109, UserDefinedAcquisitionMetadata_Sony_E109, "Monitoring Descriptions")
8655 ELEMENT(E10B, UserDefinedAcquisitionMetadata_Sony_E10B, "Monitoring Base Curve")
8656 ELEMENT(E201, UserDefinedAcquisitionMetadata_Sony_E201, "Cooke Protocol Binary Metadata")
8657 ELEMENT(E202, UserDefinedAcquisitionMetadata_Sony_E202, "Cooke Protocol User Metadata")
8658 ELEMENT(E203, UserDefinedAcquisitionMetadata_Sony_E203, "Cooke Protocol Calibration Type")
8659 default:
8660 GenerationInterchangeObject();
8661 }
8662 else
8663 GenerationInterchangeObject();
8664 }
8665 }
8666
8667 //---------------------------------------------------------------------------
SDTI_SystemMetadataPack()8668 void File_Mxf::SDTI_SystemMetadataPack() //SMPTE 385M + 326M
8669 {
8670 #if MEDIAINFO_TRACE
8671 if (Trace_Activated)
8672 {
8673 if (SDTI_SystemMetadataPack_Trace_Count<MaxCountSameElementInTrace)
8674 SDTI_SystemMetadataPack_Trace_Count++;
8675 else
8676 Element_Set_Remove_Children_IfNoErrors();
8677 }
8678 #endif // MEDIAINFO_TRACE
8679
8680 //Info for SDTI in Index StreamOffset
8681 if (!SDTI_IsPresent)
8682 {
8683 if (!Partitions.empty() && File_Offset+Buffer_Offset<Partitions[Partitions_Pos].StreamOffset+Partitions[Partitions_Pos].BodyOffset)
8684 SDTI_IsInIndexStreamOffset=false;
8685
8686 SDTI_IsPresent=true;
8687 }
8688
8689 //Parsing
8690 int8u SMB, CPR_Rate, Format;
8691 bool SMB_UL_Present, SMB_CreationTimeStamp, SMB_UserTimeStamp, CPR_DropFrame;
8692 Get_B1 (SMB, "System Metadata Bitmap");
8693 Skip_Flags(SMB, 7, "FEC Active");
8694 Get_Flags (SMB, 6, SMB_UL_Present, "SMPTE Label");
8695 Get_Flags (SMB, 5, SMB_CreationTimeStamp, "Creation Date/Time");
8696 Get_Flags (SMB, 4, SMB_UserTimeStamp, "User Date/Time");
8697 Skip_Flags(SMB, 3, "Picture item");
8698 Skip_Flags(SMB, 2, "Sound item");
8699 Skip_Flags(SMB, 1, "Data item");
8700 Skip_Flags(SMB, 0, "Control item");
8701 BS_Begin();
8702 Element_Begin1("Content Package Rate");
8703 Skip_S1(2, "Reserved");
8704 Get_S1 (5, CPR_Rate, "Package Rate"); //See SMPTE 326M
8705 Get_SB ( CPR_DropFrame, "1.001 Flag");
8706 Element_End0();
8707 Element_Begin1("Content Package Type");
8708 Skip_S1(3, "Stream Status");
8709 Skip_SB( "Sub-package flag");
8710 Skip_SB( "Transfer Mode");
8711 Skip_S1(3, "Timing Mode");
8712 Element_End0();
8713 BS_End();
8714 Skip_B2( "channel handle");
8715 Skip_B2( "continuity count");
8716
8717 //Some computing
8718 int8u FrameRate;
8719 int8u RepetitionMaxCount;
8720 switch (CPR_Rate) //See SMPTE 326M
8721 {
8722 case 0x01 : FrameRate=24; RepetitionMaxCount=0; break;
8723 case 0x02 : FrameRate=25; RepetitionMaxCount=0; break;
8724 case 0x03 : FrameRate=30; RepetitionMaxCount=0; break;
8725 case 0x04 : FrameRate=48; RepetitionMaxCount=1; break;
8726 case 0x05 : FrameRate=50; RepetitionMaxCount=1; break;
8727 case 0x06 : FrameRate=60; RepetitionMaxCount=1; break;
8728 case 0x07 : FrameRate=72; RepetitionMaxCount=2; break;
8729 case 0x08 : FrameRate=75; RepetitionMaxCount=2; break;
8730 case 0x09 : FrameRate=90; RepetitionMaxCount=2; break;
8731 case 0x0A : FrameRate=96; RepetitionMaxCount=3; break;
8732 case 0x0B : FrameRate=100; RepetitionMaxCount=3; break;
8733 case 0x0C : FrameRate=120; RepetitionMaxCount=3; break;
8734 default : FrameRate=0; RepetitionMaxCount=0; break;
8735 }
8736
8737 //Parsing
8738 if (SMB_UL_Present)
8739 Skip_UL( "SMPTE Universal label");
8740 if (SMB_CreationTimeStamp)
8741 {
8742 Get_B1 (Format, "Format"); //0x81=timecode, 0x82=date-timecode
8743 Skip_B8( "Time stamp");
8744 Skip_B8( "Zero");
8745 }
8746 else
8747 Skip_XX(17, "Junk");
8748 if (SMB_UserTimeStamp)
8749 {
8750 Get_B1 (Format, "Format"); //0x81=timecode, 0x82=date-timecode, SMPTE 331M
8751 Element_Begin1("TimeCode");
8752 int8u Frames_Units, Frames_Tens, Seconds_Units, Seconds_Tens, Minutes_Units, Minutes_Tens, Hours_Units, Hours_Tens;
8753 bool DropFrame;
8754 BS_Begin();
8755
8756 Skip_SB( "CF - Color fame");
8757 Get_SB ( DropFrame, "DP - Drop frame");
8758 Get_S1 (2, Frames_Tens, "Frames (Tens)");
8759 Get_S1 (4, Frames_Units, "Frames (Units)");
8760
8761 Skip_SB( "FP - Field Phase / BGF0");
8762 Get_S1 (3, Seconds_Tens, "Seconds (Tens)");
8763 Get_S1 (4, Seconds_Units, "Seconds (Units)");
8764
8765 Skip_SB( "BGF0 / BGF2");
8766 Get_S1 (3, Minutes_Tens, "Minutes (Tens)");
8767 Get_S1 (4, Minutes_Units, "Minutes (Units)");
8768
8769 Skip_SB( "BGF2 / Field Phase");
8770 Skip_SB( "BGF1");
8771 Get_S1 (2, Hours_Tens, "Hours (Tens)");
8772 Get_S1 (4, Hours_Units, "Hours (Units)");
8773
8774 Skip_S1(4, "BG2");
8775 Skip_S1(4, "BG1");
8776
8777 Skip_S1(4, "BG4");
8778 Skip_S1(4, "BG3");
8779
8780 Skip_S1(4, "BG6");
8781 Skip_S1(4, "BG5");
8782
8783 Skip_S1(4, "BG8");
8784 Skip_S1(4, "BG7");
8785
8786 BS_End();
8787
8788 //TimeCode
8789 TimeCode TimeCode_Current( Hours_Tens *10+Hours_Units,
8790 Minutes_Tens*10+Minutes_Units,
8791 Seconds_Tens*10+Seconds_Units,
8792 Frames_Tens *10+Frames_Units,
8793 FrameRate/(RepetitionMaxCount+1),
8794 DropFrame,
8795 RepetitionMaxCount?true:false);
8796 if (RepetitionMaxCount)
8797 {
8798 if (SDTI_TimeCode_Previous.IsValid() && TimeCode_Current==SDTI_TimeCode_Previous)
8799 {
8800 SDTI_TimeCode_RepetitionCount++;
8801 TimeCode_Current++;
8802 if (!SDTI_TimeCode_StartTimecode.IsValid() && SDTI_TimeCode_RepetitionCount>=RepetitionMaxCount)
8803 SDTI_TimeCode_StartTimecode=SDTI_TimeCode_Previous; //The first time code was the first one of the repetition sequence
8804 }
8805 else
8806 {
8807 if (!SDTI_TimeCode_StartTimecode.IsValid() && SDTI_TimeCode_Previous.IsValid())
8808 {
8809 SDTI_TimeCode_StartTimecode=SDTI_TimeCode_Previous;
8810 while(SDTI_TimeCode_RepetitionCount<RepetitionMaxCount)
8811 {
8812 SDTI_TimeCode_StartTimecode++;
8813 SDTI_TimeCode_RepetitionCount++;
8814 }
8815 }
8816 SDTI_TimeCode_RepetitionCount=0;
8817 SDTI_TimeCode_Previous=TimeCode_Current;
8818 }
8819 }
8820 else if (!SDTI_TimeCode_StartTimecode.IsValid())
8821 SDTI_TimeCode_StartTimecode=TimeCode_Current;
8822
8823 Element_Info1(Ztring().From_UTF8(TimeCode_Current.ToString().c_str()));
8824 Element_Level--;
8825 Element_Info1(Ztring().From_UTF8(TimeCode_Current.ToString().c_str()));
8826 Element_Level++;
8827
8828 Element_End0();
8829
8830 Skip_B8( "Zero");
8831 }
8832 else
8833 Skip_XX(17, "Junk");
8834
8835 //Filling
8836 if (SDTI_SizePerFrame==0)
8837 Partitions_IsCalculatingSdtiByteCount=true;
8838
8839 FILLING_BEGIN_PRECISE();
8840 if (!Status[IsAccepted])
8841 Accept();
8842 FILLING_END();
8843 }
8844
8845 //---------------------------------------------------------------------------
SDTI_PackageMetadataSet()8846 void File_Mxf::SDTI_PackageMetadataSet()
8847 {
8848 #if MEDIAINFO_TRACE
8849 if (Trace_Activated)
8850 {
8851 if (SDTI_PackageMetadataSet_Trace_Count<MaxCountSameElementInTrace)
8852 SDTI_PackageMetadataSet_Trace_Count++;
8853 else
8854 Element_Set_Remove_Children_IfNoErrors();
8855 }
8856 #endif // MEDIAINFO_TRACE
8857
8858 while (Element_Offset<Element_Size)
8859 {
8860 //Parsing
8861 Element_Begin1("Item");
8862 int128u Tag;
8863 int16u Length;
8864 int8u Type;
8865 Get_B1 (Type, "Type");
8866 Get_B2 (Length, "Length");
8867 int64u End=Element_Offset+Length;
8868 Get_UL (Tag, "Tag", NULL); //TODO: check 10-byte UL with out_imx.mxf
8869 switch (Type)
8870 {
8871 case 0x83 : //UMID
8872 {
8873 Skip_UMID( );
8874 if (Element_Offset<End)
8875 Skip_UL ( "Zeroes");
8876 }
8877 break;
8878 case 0x88 : //KLV Metadata
8879 {
8880 while (Element_Offset<End)
8881 {
8882 int64u Length;
8883 Get_BER(Length, "Length");
8884 switch ((Tag.lo>>16)&0xFF)
8885 {
8886 case 0x00 : Skip_UTF8(Length,"Data"); break;
8887 case 0x01 : Skip_UTF16L(Length,"Data"); break;
8888 default : Skip_XX(Length, "Data");
8889 }
8890 }
8891 }
8892 break;
8893 default : Skip_XX(Length, "Unknown");
8894 }
8895 Element_End0();
8896 }
8897
8898 //Filling
8899 if (SDTI_SizePerFrame==0)
8900 Partitions_IsCalculatingSdtiByteCount=true;
8901
8902 FILLING_BEGIN_PRECISE();
8903 if (!Status[IsAccepted])
8904 Accept();
8905 FILLING_END();
8906 }
8907
8908 //---------------------------------------------------------------------------
SDTI_PictureMetadataSet()8909 void File_Mxf::SDTI_PictureMetadataSet()
8910 {
8911 Skip_XX(Element_Size, "Data");
8912
8913 //Filling
8914 if (SDTI_SizePerFrame==0)
8915 Partitions_IsCalculatingSdtiByteCount=true;
8916 }
8917
8918 //---------------------------------------------------------------------------
SDTI_SoundMetadataSet()8919 void File_Mxf::SDTI_SoundMetadataSet()
8920 {
8921 Skip_XX(Element_Size, "Data");
8922
8923 //Filling
8924 if (SDTI_SizePerFrame==0)
8925 Partitions_IsCalculatingSdtiByteCount=true;
8926 }
8927
8928 //---------------------------------------------------------------------------
SDTI_DataMetadataSet()8929 void File_Mxf::SDTI_DataMetadataSet()
8930 {
8931 Skip_XX(Element_Size, "Data");
8932
8933 //Filling
8934 if (SDTI_SizePerFrame==0)
8935 Partitions_IsCalculatingSdtiByteCount=true;
8936 }
8937
8938 //---------------------------------------------------------------------------
SDTI_ControlMetadataSet()8939 void File_Mxf::SDTI_ControlMetadataSet()
8940 {
8941 Skip_XX(Element_Size, "Data");
8942
8943 //Filling
8944 if (SDTI_SizePerFrame==0)
8945 Partitions_IsCalculatingSdtiByteCount=true;
8946 }
8947
8948 //---------------------------------------------------------------------------
Dolby_PHDRImageMetadataItem()8949 void File_Mxf::Dolby_PHDRImageMetadataItem()
8950 {
8951 //Parsing
8952 Skip_String(Element_Size, "Data");
8953 }
8954
8955 //---------------------------------------------------------------------------
Dolby_PHDRMetadataTrackSubDescriptor()8956 void File_Mxf::Dolby_PHDRMetadataTrackSubDescriptor()
8957 {
8958 {
8959 std::map<int16u, int128u>::iterator Primer_Value=Primer_Values.find(Code2);
8960 if (Primer_Value!=Primer_Values.end())
8961 {
8962 int32u Code_Compare1=Primer_Value->second.hi>>32;
8963 int32u Code_Compare2=(int32u)Primer_Value->second.hi;
8964 int32u Code_Compare3=Primer_Value->second.lo>>32;
8965 int32u Code_Compare4=(int32u)Primer_Value->second.lo;
8966 if(0);
8967 ELEMENT_UUID(Dolby_DataDefinition, "Dolby Data Definition")
8968 ELEMENT_UUID(Dolby_SourceTrackID, "Dolby Source Track ID")
8969 ELEMENT_UUID(Dolby_SimplePayloadSID, "Dolby Simple Payload SID")
8970 }
8971 }
8972
8973 if (Descriptors[InstanceUID].StreamKind==Stream_Max)
8974 {
8975 Descriptors[InstanceUID].StreamKind=Stream_Other;
8976 if (Streams_Count==(size_t)-1)
8977 Streams_Count=0;
8978 Streams_Count++;
8979 }
8980 }
8981
8982 //---------------------------------------------------------------------------
Omneon_010201010100()8983 void File_Mxf::Omneon_010201010100()
8984 {
8985 //Parsing
8986 switch(Code2)
8987 {
8988 ELEMENT(8001, Omneon_010201010100_8001, "Omneon .80.01")
8989 ELEMENT(8003, Omneon_010201010100_8003, "Omneon .80.03")
8990 default: GenerationInterchangeObject();
8991 }
8992 }
8993
8994 //---------------------------------------------------------------------------
Omneon_010201020100()8995 void File_Mxf::Omneon_010201020100()
8996 {
8997 //Parsing
8998 switch(Code2)
8999 {
9000 ELEMENT(8002, Omneon_010201020100_8002, "Omneon .80.02")
9001 ELEMENT(8003, Omneon_010201020100_8003, "Omneon .80.03")
9002 ELEMENT(8004, Omneon_010201020100_8004, "Omneon .80.04")
9003 ELEMENT(8005, Omneon_010201020100_8005, "Omneon .80.05")
9004 ELEMENT(8006, Omneon_010201020100_8006, "Omneon .80.06")
9005 default: GenerationInterchangeObject();
9006 }
9007 }
9008
9009 //---------------------------------------------------------------------------
TimelineTrack()9010 void File_Mxf::TimelineTrack()
9011 {
9012 //Parsing
9013 switch(Code2)
9014 {
9015 ELEMENT(4B01, Track_EditRate, "EditRate")
9016 ELEMENT(4B02, Track_Origin, "Origin")
9017 default: GenericTrack();
9018 }
9019
9020 if (Code2==0x3C0A)
9021 {
9022 for (packages::iterator Package=Packages.begin(); Package!=Packages.end(); ++Package)
9023 {
9024 if (Package->first==Prefaces[Preface_Current].PrimaryPackage) //InstanceIUD
9025 {
9026 Element_Level--;
9027 Element_Info1("Primary package");
9028 Element_Level++;
9029 }
9030 for (size_t Pos=0; Pos<Package->second.Tracks.size(); Pos++)
9031 if (InstanceUID==Package->second.Tracks[Pos])
9032 {
9033 Element_Level--;
9034 Element_Info1("Valid from Package");
9035 Element_Level++;
9036 }
9037 }
9038 }
9039 }
9040
9041 //***************************************************************************
9042 // Base
9043 //***************************************************************************
9044
9045 //---------------------------------------------------------------------------
9046 // 0x3D08
AES3PCMDescriptor_AuxBitsMode()9047 void File_Mxf::AES3PCMDescriptor_AuxBitsMode()
9048 {
9049 //Parsing
9050 Info_B1(Data, "Data"); Element_Info1(Data);
9051 }
9052
9053 //---------------------------------------------------------------------------
9054 // 0x3D0D
AES3PCMDescriptor_Emphasis()9055 void File_Mxf::AES3PCMDescriptor_Emphasis()
9056 {
9057 //Parsing
9058 Info_B1(Data, "Data"); Element_Info1(Data);
9059 }
9060
9061 //---------------------------------------------------------------------------
9062 // 0x3D0F
AES3PCMDescriptor_BlockStartOffset()9063 void File_Mxf::AES3PCMDescriptor_BlockStartOffset()
9064 {
9065 //Parsing
9066 Info_B2(Data, "Data"); Element_Info1(Data);
9067 }
9068
9069 //---------------------------------------------------------------------------
9070 // 0x3D10
AES3PCMDescriptor_ChannelStatusMode()9071 void File_Mxf::AES3PCMDescriptor_ChannelStatusMode()
9072 {
9073 //Parsing
9074 Skip_XX(Length2, "Batch");
9075 }
9076
9077 //---------------------------------------------------------------------------
9078 // 0x3D11
AES3PCMDescriptor_FixedChannelStatusData()9079 void File_Mxf::AES3PCMDescriptor_FixedChannelStatusData()
9080 {
9081 //Parsing
9082 Skip_XX(Length2, "Data");
9083 }
9084
9085 //---------------------------------------------------------------------------
9086 // 0x3D12
AES3PCMDescriptor_UserDataMode()9087 void File_Mxf::AES3PCMDescriptor_UserDataMode()
9088 {
9089 //Parsing
9090 Skip_XX(Length2, "Data");
9091 }
9092
9093 //---------------------------------------------------------------------------
9094 // 0x3D13
AES3PCMDescriptor_FixedUserData()9095 void File_Mxf::AES3PCMDescriptor_FixedUserData()
9096 {
9097 //Parsing
9098 Skip_XX(Length2, "Data");
9099 }
9100
9101 //---------------------------------------------------------------------------
9102 // 0x3301
CDCIEssenceDescriptor_ComponentDepth()9103 void File_Mxf::CDCIEssenceDescriptor_ComponentDepth()
9104 {
9105 //Parsing
9106 int32u Data;
9107 Get_B4 (Data, "Data"); Element_Info1(Data);
9108
9109 FILLING_BEGIN();
9110 if (Data)
9111 Descriptor_Fill("BitDepth", Ztring().From_Number(Data));
9112 FILLING_END();
9113 }
9114
9115 //---------------------------------------------------------------------------
9116 // 0x3302
CDCIEssenceDescriptor_HorizontalSubsampling()9117 void File_Mxf::CDCIEssenceDescriptor_HorizontalSubsampling()
9118 {
9119 //Parsing
9120 int32u Data;
9121 Get_B4 (Data, "Data"); Element_Info1(Data);
9122
9123 FILLING_BEGIN();
9124 Descriptors[InstanceUID].SubSampling_Horizontal=Data;
9125 Subsampling_Compute(Descriptors.find(InstanceUID));
9126 FILLING_END();
9127 }
9128
9129 //---------------------------------------------------------------------------
9130 // 0x3303
CDCIEssenceDescriptor_ColorSiting()9131 void File_Mxf::CDCIEssenceDescriptor_ColorSiting()
9132 {
9133 //Parsing
9134 Info_B1(Data, "Data"); Element_Info1(Data);
9135 }
9136
9137 //---------------------------------------------------------------------------
9138 // 0x3304
CDCIEssenceDescriptor_BlackRefLevel()9139 void File_Mxf::CDCIEssenceDescriptor_BlackRefLevel()
9140 {
9141 //Parsing
9142 int32u Data;
9143 Get_B4 (Data, "Data"); Element_Info1(Data);
9144
9145 FILLING_BEGIN();
9146 if (Descriptors[InstanceUID].MinRefLevel==(int32u)-1)
9147 Descriptors[InstanceUID].MinRefLevel=Data;
9148 ColorLevels_Compute(Descriptors.find(InstanceUID));
9149 FILLING_END();
9150 }
9151
9152 //---------------------------------------------------------------------------
9153 // 0x3305
CDCIEssenceDescriptor_WhiteReflevel()9154 void File_Mxf::CDCIEssenceDescriptor_WhiteReflevel()
9155 {
9156 //Parsing
9157 int32u Data;
9158 Get_B4 (Data, "Data"); Element_Info1(Data);
9159
9160 FILLING_BEGIN();
9161 if (Descriptors[InstanceUID].MaxRefLevel==(int32u)-1)
9162 Descriptors[InstanceUID].MaxRefLevel=Data;
9163 ColorLevels_Compute(Descriptors.find(InstanceUID));
9164 FILLING_END();
9165 }
9166
9167 //---------------------------------------------------------------------------
9168 // 0x3306
CDCIEssenceDescriptor_ColorRange()9169 void File_Mxf::CDCIEssenceDescriptor_ColorRange()
9170 {
9171 //Parsing
9172 int32u Data;
9173 Get_B4 (Data, "Data"); Element_Info1(Data);
9174
9175 FILLING_BEGIN();
9176 if (Descriptors[InstanceUID].ColorRange==(int32u)-1)
9177 Descriptors[InstanceUID].ColorRange=Data;
9178 ColorLevels_Compute(Descriptors.find(InstanceUID));
9179 FILLING_END();
9180 }
9181
9182 //---------------------------------------------------------------------------
9183 // 0x3307
CDCIEssenceDescriptor_PaddingBits()9184 void File_Mxf::CDCIEssenceDescriptor_PaddingBits()
9185 {
9186 //Parsing
9187 Info_B2(Data, "Data"); Element_Info1(Data);
9188 }
9189
9190 //---------------------------------------------------------------------------
9191 // 0x3308
CDCIEssenceDescriptor_VerticalSubsampling()9192 void File_Mxf::CDCIEssenceDescriptor_VerticalSubsampling()
9193 {
9194 //Parsing
9195 int32u Data;
9196 Get_B4 (Data, "Data"); Element_Info1(Data);
9197
9198 FILLING_BEGIN();
9199 Descriptors[InstanceUID].SubSampling_Vertical=Data;
9200 Subsampling_Compute(Descriptors.find(InstanceUID));
9201 FILLING_END();
9202 }
9203
9204 //---------------------------------------------------------------------------
9205 // 0x3309
CDCIEssenceDescriptor_AlphaSampleDepth()9206 void File_Mxf::CDCIEssenceDescriptor_AlphaSampleDepth()
9207 {
9208 //Parsing
9209 Info_B4(Data, "Data"); Element_Info1(Data);
9210 }
9211
9212 //---------------------------------------------------------------------------
9213 // 0x330B
CDCIEssenceDescriptor_ReversedByteOrder()9214 void File_Mxf::CDCIEssenceDescriptor_ReversedByteOrder()
9215 {
9216 //Parsing
9217 Info_B1(Data, "Data"); Element_Info1(Data);
9218 }
9219
9220 //---------------------------------------------------------------------------
9221 // 0x1901
ContentStorage_Packages()9222 void File_Mxf::ContentStorage_Packages()
9223 {
9224 ContentStorages[InstanceUID].Packages.clear();
9225
9226 //Parsing
9227 if (Vector(16)==(int32u)-1)
9228 return;
9229 while (Element_Offset<Element_Size)
9230 {
9231 int128u Data;
9232 Get_UUID(Data, "Package");
9233
9234 FILLING_BEGIN();
9235 Element_Info1C((Data==Prefaces[Preface_Current].PrimaryPackage), "Primary package");
9236 ContentStorages[InstanceUID].Packages.push_back(Data);
9237 FILLING_END();
9238 }
9239 }
9240
9241 //---------------------------------------------------------------------------
9242 // 0x1902
ContentStorage_EssenceContainerData()9243 void File_Mxf::ContentStorage_EssenceContainerData()
9244 {
9245 //Parsing
9246 if (Vector(16)==(int32u)-1)
9247 return;
9248 while (Element_Offset<Element_Size)
9249 {
9250 Skip_UUID( "EssenceContainer");
9251 }
9252 }
9253
9254 //---------------------------------------------------------------------------
9255 // 0x0202
DMSegment_Duration()9256 void File_Mxf::DMSegment_Duration()
9257 {
9258 //Parsing
9259 int64u Data;
9260 Get_B8 (Data, "Data"); Element_Info1(Data); //units of edit rate
9261
9262 FILLING_BEGIN();
9263 DMSegments[InstanceUID].Duration=Data;
9264 FILLING_END();
9265 }
9266
9267 //---------------------------------------------------------------------------
9268 // 0x6101
DMSegment_DMFramework()9269 void File_Mxf::DMSegment_DMFramework()
9270 {
9271 //Parsing
9272 int128u Data;
9273 Get_UUID(Data, "DM Framework"); Element_Info1(Ztring().From_UUID(Data));
9274
9275 FILLING_BEGIN();
9276 DMSegments[InstanceUID].Framework=Data;
9277 FILLING_END();
9278 }
9279
9280 //---------------------------------------------------------------------------
9281 // 0x6101
DMSegment_TrackIDs()9282 void File_Mxf::DMSegment_TrackIDs()
9283 {
9284 //Parsing
9285 if (Vector(4)==(int32u)-1)
9286 return;
9287 while (Element_Offset<Element_Size)
9288 {
9289 int32u Data;
9290 Get_B4 (Data, "Track ID");
9291
9292 FILLING_BEGIN();
9293 DMSegments[InstanceUID].TrackIDs.push_back(Data);
9294 FILLING_END();
9295 }
9296 }
9297
9298 //---------------------------------------------------------------------------
9299 // 0x2701
EssenceContainerData_LinkedPackageUID()9300 void File_Mxf::EssenceContainerData_LinkedPackageUID()
9301 {
9302 //Parsing
9303 Skip_UMID();
9304 }
9305
9306 //---------------------------------------------------------------------------
9307 // 0x3F06
EssenceContainerData_IndexSID()9308 void File_Mxf::EssenceContainerData_IndexSID()
9309 {
9310 //Parsing
9311 Info_B4(Data, "Data"); Element_Info1(Data);
9312 }
9313
9314 //---------------------------------------------------------------------------
9315 // 0x3F07
EssenceContainerData_BodySID()9316 void File_Mxf::EssenceContainerData_BodySID()
9317 {
9318 //Parsing
9319 Info_B4(Data, "Data"); Element_Info1(Data);
9320 }
9321
9322 //---------------------------------------------------------------------------
9323 // 0x4901
EventTrack_EventEditRate()9324 void File_Mxf::EventTrack_EventEditRate()
9325 {
9326 //Parsing
9327 Info_Rational();
9328 }
9329
9330 //---------------------------------------------------------------------------
9331 // 0x4902
EventTrack_EventOrigin()9332 void File_Mxf::EventTrack_EventOrigin()
9333 {
9334 //Parsing
9335 Info_B8(Data, "Data"); Element_Info1(Data);
9336 }
9337
9338 //---------------------------------------------------------------------------
9339 // 0x3001
FileDescriptor_SampleRate()9340 void File_Mxf::FileDescriptor_SampleRate()
9341 {
9342 //Parsing
9343 Get_Rational(Descriptors[InstanceUID].SampleRate); Element_Info1(Descriptors[InstanceUID].SampleRate);
9344
9345 FILLING_BEGIN();
9346 if (Descriptors[InstanceUID].SampleRate && Descriptors[InstanceUID].Duration!=(int64u)-1)
9347 Descriptor_Fill("Duration", Ztring().From_Number(Descriptors[InstanceUID].Duration/Descriptors[InstanceUID].SampleRate*1000, 0));
9348 FILLING_END();
9349 }
9350
9351 //---------------------------------------------------------------------------
9352 // 0x3002
FileDescriptor_ContainerDuration()9353 void File_Mxf::FileDescriptor_ContainerDuration()
9354 {
9355 //Parsing
9356 int64u Data;
9357 Get_B8 (Data, "Data"); Element_Info1(Data);
9358
9359 FILLING_BEGIN();
9360 if (Data)
9361 {
9362 Descriptors[InstanceUID].Duration=Data;
9363 if (Descriptors[InstanceUID].SampleRate && Descriptors[InstanceUID].Duration!=(int64u)-1)
9364 Descriptors[InstanceUID].Infos["Duration"].From_Number(Descriptors[InstanceUID].Duration/Descriptors[InstanceUID].SampleRate*1000, 0);
9365 }
9366 FILLING_END();
9367 }
9368
9369 //---------------------------------------------------------------------------
9370 // 0x3004
FileDescriptor_EssenceContainer()9371 void File_Mxf::FileDescriptor_EssenceContainer()
9372 {
9373 //Parsing
9374 int128u EssenceContainer;
9375 Get_UL (EssenceContainer, "EssenceContainer", Mxf_EssenceContainer); Element_Info1(Mxf_EssenceContainer(EssenceContainer));
9376
9377 FILLING_BEGIN();
9378 int8u Code6=(int8u)((EssenceContainer.lo&0x0000000000FF0000LL)>>16);
9379 int8u Code7=(int8u)((EssenceContainer.lo&0x000000000000FF00LL)>> 8);
9380 int8u Code8=(int8u)((EssenceContainer.lo&0x00000000000000FFLL) );
9381
9382 Descriptors[InstanceUID].EssenceContainer=EssenceContainer;
9383 Descriptor_Fill("Format_Settings_Wrapping", Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
9384
9385 if (!DataMustAlwaysBeComplete && Descriptors[InstanceUID].Infos["Format_Settings_Wrapping"].find(__T("Frame"))!=string::npos)
9386 DataMustAlwaysBeComplete=true;
9387 FILLING_END();
9388 }
9389
9390 //---------------------------------------------------------------------------
9391 // 0x3005
FileDescriptor_Codec()9392 void File_Mxf::FileDescriptor_Codec()
9393 {
9394 //Parsing
9395 Skip_UL( "UUID");
9396 }
9397
9398 //---------------------------------------------------------------------------
9399 // 0x3006
FileDescriptor_LinkedTrackID()9400 void File_Mxf::FileDescriptor_LinkedTrackID()
9401 {
9402 //Parsing
9403 int32u Data;
9404 Get_B4 (Data, "Data"); Element_Info1(Data);
9405
9406 FILLING_BEGIN();
9407 if (Descriptors[InstanceUID].LinkedTrackID==(int32u)-1)
9408 Descriptors[InstanceUID].LinkedTrackID=Data;
9409 FILLING_END();
9410 }
9411
9412 //---------------------------------------------------------------------------
9413 // 0x3C0A
InterchangeObject_InstanceUID()9414 void File_Mxf::InterchangeObject_InstanceUID()
9415 {
9416 //Parsing
9417 Get_UUID(InstanceUID, "UUID"); Element_Info1(Ztring().From_UUID(InstanceUID));
9418
9419 FILLING_BEGIN();
9420 //Putting the right UID for already parsed items
9421 prefaces::iterator Preface=Prefaces.find(0);
9422 if (Preface!=Prefaces.end())
9423 {
9424 Prefaces[InstanceUID]=Preface->second;
9425 Prefaces.erase(Preface);
9426 }
9427 identifications::iterator Identification=Identifications.find(0);
9428 if (Identification!=Identifications.end())
9429 {
9430 Identifications[InstanceUID]=Identification->second;
9431 Identifications.erase(Identification);
9432 }
9433 contentstorages::iterator ContentStorage=ContentStorages.find(0);
9434 if (ContentStorage!=ContentStorages.end())
9435 {
9436 ContentStorages[InstanceUID]=ContentStorage->second;
9437 ContentStorages.erase(ContentStorage);
9438 }
9439 packages::iterator Package=Packages.find(0);
9440 if (Package!=Packages.end())
9441 {
9442 Packages[InstanceUID]=Package->second;
9443 Packages.erase(Package);
9444 }
9445 tracks::iterator Track=Tracks.find(0);
9446 if (Track!=Tracks.end())
9447 {
9448 Tracks[InstanceUID]=Track->second;
9449 Tracks.erase(Track);
9450 }
9451 descriptors::iterator Descriptor=Descriptors.find(0);
9452 if (Descriptor!=Descriptors.end())
9453 {
9454 descriptors::iterator Descriptor_Previous=Descriptors.find(InstanceUID);
9455 if (Descriptor_Previous!=Descriptors.end())
9456 {
9457 //Merging
9458 Descriptor->second.Infos.insert(Descriptor_Previous->second.Infos.begin(), Descriptor_Previous->second.Infos.end()); //TODO: better implementation
9459 }
9460 for (std::map<std::string, Ztring>::iterator Info = Descriptor->second.Infos.begin(); Info != Descriptor->second.Infos.end(); ++Info) //Note: can not be mapped directly because there are some tests done in Descriptor_Fill
9461 Descriptor_Fill(Info->first.c_str(), Info->second);
9462 std::map<std::string, Ztring> Infos_Temp=Descriptors[InstanceUID].Infos; //Quick method for copying the whole descriptor without erasing the modifications made by Descriptor_Fill(). TODO: a better method in order to be more generic
9463 Descriptors[InstanceUID]=Descriptor->second;
9464 Descriptors[InstanceUID].Infos=Infos_Temp;
9465 Descriptors.erase(Descriptor);
9466 }
9467 locators::iterator Locator=Locators.find(0);
9468 if (Locator!=Locators.end())
9469 {
9470 Locators[InstanceUID]=Locator->second;
9471 Locators.erase(Locator);
9472 }
9473 components::iterator Component=Components.find(0);
9474 if (Component!=Components.end())
9475 {
9476 Components[InstanceUID].Update(Component->second);
9477 Components.erase(Component);
9478 }
9479 dmsegments::iterator DMSegment=DMSegments.find(0);
9480 if (DMSegment!=DMSegments.end())
9481 {
9482 DMSegments[InstanceUID]=DMSegment->second;
9483 DMSegments.erase(DMSegment);
9484 }
9485 as11s::iterator AS11=AS11s.find(0);
9486 if (AS11!=AS11s.end())
9487 {
9488 AS11s[InstanceUID]=AS11->second;
9489 AS11s.erase(AS11);
9490 }
9491 FILLING_END();
9492 }
9493
9494 //---------------------------------------------------------------------------
9495 // 0x0102
GenerationInterchangeObject_GenerationUID()9496 void File_Mxf::GenerationInterchangeObject_GenerationUID()
9497 {
9498 //Parsing
9499 Skip_UUID( "UUID");
9500 }
9501
9502 //---------------------------------------------------------------------------
9503 // 0x2F01
GenericDescriptor_Locators()9504 void File_Mxf::GenericDescriptor_Locators()
9505 {
9506 Descriptors[InstanceUID].Locators.clear();
9507
9508 //Parsing
9509 if (Vector(16)==(int32u)-1)
9510 return;
9511 while (Element_Offset<Element_Size)
9512 {
9513 Element_Begin1("Locator");
9514 int128u UUID;
9515 Get_UUID(UUID, "UUID");
9516
9517 FILLING_BEGIN();
9518 Descriptors[InstanceUID].Locators.push_back(UUID);
9519 FILLING_END();
9520
9521 Element_End0();
9522 }
9523 }
9524
9525 //---------------------------------------------------------------------------
9526 // 0x4401
GenericPackage_PackageUID()9527 void File_Mxf::GenericPackage_PackageUID()
9528 {
9529 //Parsing
9530 int256u Data;
9531 Get_UMID (Data, "PackageUID");
9532
9533 FILLING_BEGIN();
9534 Packages[InstanceUID].PackageUID=Data;
9535 FILLING_END();
9536 }
9537
9538 //---------------------------------------------------------------------------
9539 // 0x4402
GenericPackage_Name()9540 void File_Mxf::GenericPackage_Name()
9541 {
9542 //Parsing
9543 Ztring Data;
9544 Get_UTF16B(Length2, Data, "Data"); Element_Info1(Data);
9545
9546 FILLING_BEGIN();
9547 if (Essences.empty() && Data!=Retrieve(Stream_General, 0, General_PackageName))
9548 Fill(Stream_General, 0, General_PackageName, Data);
9549 FILLING_END();
9550 }
9551
9552 //---------------------------------------------------------------------------
9553 // 0x4403
GenericPackage_Tracks()9554 void File_Mxf::GenericPackage_Tracks()
9555 {
9556 //Parsing
9557 if (Vector(16)==(int32u)-1)
9558 return;
9559 while (Element_Offset<Element_Size)
9560 {
9561 int128u Data;
9562 Get_UUID(Data, "Track");
9563
9564 FILLING_BEGIN();
9565 Packages[InstanceUID].Tracks.push_back(Data);
9566 FILLING_END();
9567 }
9568 }
9569
9570 //---------------------------------------------------------------------------
9571 // 0x4404
GenericPackage_PackageModifiedDate()9572 void File_Mxf::GenericPackage_PackageModifiedDate()
9573 {
9574 //Parsing
9575 Info_Timestamp();
9576 }
9577
9578 //---------------------------------------------------------------------------
9579 // 0x4405
GenericPackage_PackageCreationDate()9580 void File_Mxf::GenericPackage_PackageCreationDate()
9581 {
9582 //Parsing
9583 Info_Timestamp();
9584 }
9585
9586 //---------------------------------------------------------------------------
9587 // 0x3201
GenericPictureEssenceDescriptor_PictureEssenceCoding()9588 void File_Mxf::GenericPictureEssenceDescriptor_PictureEssenceCoding()
9589 {
9590 //Parsing
9591 int128u Data;
9592 Get_UL(Data, "Data", Mxf_EssenceCompression); Element_Info1(Mxf_EssenceCompression(Data));
9593
9594 FILLING_BEGIN();
9595 Descriptors[InstanceUID].EssenceCompression=Data;
9596 Descriptors[InstanceUID].StreamKind=Stream_Video;
9597 Descriptor_Fill("Format", Mxf_EssenceCompression(Data));
9598 Descriptor_Fill("Format_Version", Mxf_EssenceCompression_Version(Data));
9599 Descriptor_Fill("Format_Profile", Mxf_EssenceCompression_Profile(Data));
9600 FILLING_END();
9601 }
9602
9603 //---------------------------------------------------------------------------
9604 // 0x3202
GenericPictureEssenceDescriptor_StoredHeight()9605 void File_Mxf::GenericPictureEssenceDescriptor_StoredHeight()
9606 {
9607 //Parsing
9608 int32u Data;
9609 Get_B4 (Data, "Data"); Element_Info1(Data);
9610
9611 FILLING_BEGIN();
9612 if (Descriptors[InstanceUID].Height==(int32u)-1)
9613 {
9614 if (Descriptors[InstanceUID].Is_Interlaced())
9615 Data*=2; //This is per field
9616 if (Descriptors[InstanceUID].Height==(int32u)-1)
9617 Descriptors[InstanceUID].Height=Data;
9618 }
9619 FILLING_END();
9620 }
9621
9622 //---------------------------------------------------------------------------
9623 // 0x3203
GenericPictureEssenceDescriptor_StoredWidth()9624 void File_Mxf::GenericPictureEssenceDescriptor_StoredWidth()
9625 {
9626 //Parsing
9627 int32u Data;
9628 Get_B4 (Data, "Data"); Element_Info1(Data);
9629
9630 FILLING_BEGIN();
9631 if (Descriptors[InstanceUID].Width==(int32u)-1)
9632 {
9633 Descriptors[InstanceUID].Width=Data;
9634 }
9635 FILLING_END();
9636 }
9637
9638 //---------------------------------------------------------------------------
9639 // 0x3204
GenericPictureEssenceDescriptor_SampledHeight()9640 void File_Mxf::GenericPictureEssenceDescriptor_SampledHeight()
9641 {
9642 //Parsing
9643 int32u Data;
9644 Get_B4 (Data, "Data"); Element_Info1(Data);
9645
9646 FILLING_BEGIN();
9647 if (Descriptors[InstanceUID].Is_Interlaced())
9648 Data*=2; //This is per field
9649 Descriptors[InstanceUID].Height=Data;
9650 FILLING_END();
9651 }
9652
9653 //---------------------------------------------------------------------------
9654 // 0x3205
GenericPictureEssenceDescriptor_SampledWidth()9655 void File_Mxf::GenericPictureEssenceDescriptor_SampledWidth()
9656 {
9657 //Parsing
9658 int32u Data;
9659 Get_B4 (Data, "Data"); Element_Info1(Data);
9660
9661 FILLING_BEGIN();
9662 Descriptors[InstanceUID].Width=Data;
9663 FILLING_END();
9664 }
9665
9666 //---------------------------------------------------------------------------
9667 // 0x3206
GenericPictureEssenceDescriptor_SampledXOffset()9668 void File_Mxf::GenericPictureEssenceDescriptor_SampledXOffset()
9669 {
9670 //Parsing
9671 Info_B4(Data, "Data"); Element_Info1(Data);
9672 }
9673
9674 //---------------------------------------------------------------------------
9675 // 0x3207
GenericPictureEssenceDescriptor_SampledYOffset()9676 void File_Mxf::GenericPictureEssenceDescriptor_SampledYOffset()
9677 {
9678 //Parsing
9679 Info_B4(Data, "Data"); Element_Info1(Data);
9680 }
9681
9682 //---------------------------------------------------------------------------
9683 // 0x3208
GenericPictureEssenceDescriptor_DisplayHeight()9684 void File_Mxf::GenericPictureEssenceDescriptor_DisplayHeight()
9685 {
9686 //Parsing
9687 int32u Data;
9688 Get_B4 (Data, "Data"); Element_Info1(Data);
9689
9690 FILLING_BEGIN();
9691 if (Descriptors[InstanceUID].Is_Interlaced())
9692 Data*=2; //This is per field
9693 Descriptors[InstanceUID].Height_Display=Data;
9694 FILLING_END();
9695 }
9696
9697 //---------------------------------------------------------------------------
9698 // 0x3209
GenericPictureEssenceDescriptor_DisplayWidth()9699 void File_Mxf::GenericPictureEssenceDescriptor_DisplayWidth()
9700 {
9701 //Parsing
9702 int32u Data;
9703 Get_B4 (Data, "Data"); Element_Info1(Data);
9704
9705 FILLING_BEGIN();
9706 Descriptors[InstanceUID].Width_Display=Data;
9707 FILLING_END();
9708 }
9709
9710 //---------------------------------------------------------------------------
9711 // 0x320A
GenericPictureEssenceDescriptor_DisplayXOffset()9712 void File_Mxf::GenericPictureEssenceDescriptor_DisplayXOffset()
9713 {
9714 //Parsing
9715 int32u Data;
9716 Get_B4 (Data, "Data"); Element_Info1(Data);
9717
9718 FILLING_BEGIN();
9719 Descriptors[InstanceUID].Width_Display_Offset=Data;
9720 FILLING_END();
9721 }
9722
9723 //---------------------------------------------------------------------------
9724 // 0x320B
GenericPictureEssenceDescriptor_DisplayYOffset()9725 void File_Mxf::GenericPictureEssenceDescriptor_DisplayYOffset()
9726 {
9727 //Parsing
9728 int32u Data;
9729 Get_B4 (Data, "Data"); Element_Info1(Data);
9730
9731 FILLING_BEGIN();
9732 if (Descriptors[InstanceUID].Is_Interlaced())
9733 Data*=2; //This is per field
9734 Descriptors[InstanceUID].Height_Display_Offset=Data;
9735 FILLING_END();
9736 }
9737
9738 //---------------------------------------------------------------------------
9739 // 0x320C
GenericPictureEssenceDescriptor_FrameLayout()9740 void File_Mxf::GenericPictureEssenceDescriptor_FrameLayout()
9741 {
9742 //Parsing
9743 int8u Data;
9744 Get_B1 (Data, "Data"); Element_Info1(Data); Param_Info1(Mxf_FrameLayout(Data)); Element_Info1(Mxf_FrameLayout(Data));
9745
9746 FILLING_BEGIN();
9747 if (Descriptors[InstanceUID].ScanType.empty())
9748 {
9749 if (Descriptors[InstanceUID].Height!=(int32u)-1) Descriptors[InstanceUID].Height*=Mxf_FrameLayout_Multiplier(Data);
9750 if (Descriptors[InstanceUID].Height_Display!=(int32u)-1) Descriptors[InstanceUID].Height_Display*=Mxf_FrameLayout_Multiplier(Data);
9751 if (Descriptors[InstanceUID].Height_Display_Offset!=(int32u)-1) Descriptors[InstanceUID].Height_Display_Offset*=Mxf_FrameLayout_Multiplier(Data);
9752 }
9753 Descriptors[InstanceUID].ScanType.From_UTF8(Mxf_FrameLayout_ScanType(Data));
9754 FILLING_END();
9755 }
9756
9757 //---------------------------------------------------------------------------
9758 // 0x320D
GenericPictureEssenceDescriptor_VideoLineMap()9759 void File_Mxf::GenericPictureEssenceDescriptor_VideoLineMap()
9760 {
9761 int64u VideoLineMapEntries_Total=0;
9762 bool VideoLineMapEntry_IsZero=false;
9763
9764 //Parsing
9765 if (Vector(4)==(int32u)-1)
9766 return;
9767 while (Element_Offset<Element_Size)
9768 {
9769 int32u VideoLineMapEntry;
9770 Get_B4 (VideoLineMapEntry, "VideoLineMapEntry");
9771
9772 if (VideoLineMapEntry)
9773 VideoLineMapEntries_Total+=VideoLineMapEntry;
9774 else
9775 VideoLineMapEntry_IsZero=true;
9776 }
9777
9778 FILLING_BEGIN();
9779 // Cryptic formula:
9780 // odd odd field 2 upper
9781 // odd even field 1 upper
9782 // even odd field 1 upper
9783 // even even field 2 upper
9784 if (Length2==8+2*4 && !VideoLineMapEntry_IsZero) //2 values
9785 Descriptors[InstanceUID].FieldTopness=(VideoLineMapEntries_Total%2)?1:2;
9786 FILLING_END();
9787 }
9788
9789 //---------------------------------------------------------------------------
9790 // 0x320E
GenericPictureEssenceDescriptor_AspectRatio()9791 void File_Mxf::GenericPictureEssenceDescriptor_AspectRatio()
9792 {
9793 //Parsing
9794 float64 Data;
9795 Get_Rational(Data);
9796
9797 FILLING_BEGIN();
9798 if (Data)
9799 {
9800 Descriptors[InstanceUID].DisplayAspectRatio=Data;
9801 Descriptor_Fill("DisplayAspectRatio", Ztring().From_Number(Data, 3));
9802 }
9803 FILLING_END();
9804 }
9805
9806 //---------------------------------------------------------------------------
9807 // 0x320F
GenericPictureEssenceDescriptor_AlphaTransparency()9808 void File_Mxf::GenericPictureEssenceDescriptor_AlphaTransparency()
9809 {
9810 //Parsing
9811 Info_B1(Data, "Data"); Element_Info1(Data);
9812 }
9813
9814 //---------------------------------------------------------------------------
9815 // 0x3210
GenericPictureEssenceDescriptor_TransferCharacteristic()9816 void File_Mxf::GenericPictureEssenceDescriptor_TransferCharacteristic()
9817 {
9818 //Parsing
9819 int128u Data;
9820 Get_UL(Data, "Data", Mxf_TransferCharacteristic); Element_Info1(Mxf_TransferCharacteristic(Data));
9821
9822 FILLING_BEGIN();
9823 Descriptor_Fill("transfer_characteristics", Mxf_TransferCharacteristic(Data));
9824 FILLING_END();
9825 }
9826
9827 //---------------------------------------------------------------------------
9828 // 0x3211
GenericPictureEssenceDescriptor_ImageAlignmentOffset()9829 void File_Mxf::GenericPictureEssenceDescriptor_ImageAlignmentOffset()
9830 {
9831 //Parsing
9832 Info_B4(Data, "Data"); Element_Info1(Data);
9833 }
9834
9835 //---------------------------------------------------------------------------
9836 // 0x3212
GenericPictureEssenceDescriptor_FieldDominance()9837 void File_Mxf::GenericPictureEssenceDescriptor_FieldDominance()
9838 {
9839 //Parsing
9840 int8u Data;
9841 Get_B1 (Data, "Data"); Element_Info1(Data);
9842
9843 FILLING_BEGIN();
9844 Descriptors[InstanceUID].FieldDominance=Data;
9845 FILLING_END();
9846 //Parsing
9847 }
9848
9849 //---------------------------------------------------------------------------
9850 // 0x3213
GenericPictureEssenceDescriptor_ImageStartOffset()9851 void File_Mxf::GenericPictureEssenceDescriptor_ImageStartOffset()
9852 {
9853 //Parsing
9854 Info_B4(Data, "Data"); Element_Info1(Data);
9855 }
9856
9857 //---------------------------------------------------------------------------
9858 // 0x3214
GenericPictureEssenceDescriptor_ImageEndOffset()9859 void File_Mxf::GenericPictureEssenceDescriptor_ImageEndOffset()
9860 {
9861 //Parsing
9862 Info_B4(Data, "Data"); Element_Info1(Data);
9863 }
9864
9865 //---------------------------------------------------------------------------
9866 // 0x3215
GenericPictureEssenceDescriptor_SignalStandard()9867 void File_Mxf::GenericPictureEssenceDescriptor_SignalStandard()
9868 {
9869 //Parsing
9870 Info_B1(Data, "Data"); Element_Info1(Data);
9871 }
9872
9873 //---------------------------------------------------------------------------
9874 // 0x3216
GenericPictureEssenceDescriptor_StoredF2Offset()9875 void File_Mxf::GenericPictureEssenceDescriptor_StoredF2Offset()
9876 {
9877 //Parsing
9878 Info_B4(Data, "Data"); Element_Info1(Data);
9879 }
9880
9881 //---------------------------------------------------------------------------
9882 // 0x3217
GenericPictureEssenceDescriptor_DisplayF2Offset()9883 void File_Mxf::GenericPictureEssenceDescriptor_DisplayF2Offset()
9884 {
9885 //Parsing
9886 Info_B4(Data, "Data"); Element_Info1(Data);
9887 }
9888
9889 //---------------------------------------------------------------------------
9890 // 0x3218
GenericPictureEssenceDescriptor_ActiveFormatDescriptor()9891 void File_Mxf::GenericPictureEssenceDescriptor_ActiveFormatDescriptor()
9892 {
9893 //Parsing
9894 int8u Data;
9895 bool Is1dot3=Retrieve(Stream_General, 0, General_Format_Version).To_float32()>=1.3?true:false;
9896 if (!Is1dot3 && Element_Size && Buffer[(size_t)(Buffer_Offset+Element_Offset)]&0x60)
9897 Is1dot3=true;
9898
9899 BS_Begin();
9900 if (Is1dot3)
9901 {
9902 Skip_SB( "Reserved");
9903 Get_S1 (4, Data, "Data"); Element_Info1C((Data<16), AfdBarData_active_format[Data]);
9904 Skip_SB( "AR");
9905 Skip_S1(2, "Reserved");
9906 }
9907 else
9908 {
9909 Skip_S1(3, "Reserved");
9910 Get_S1 (4, Data, "Data"); Element_Info1C((Data<16), AfdBarData_active_format[Data]);
9911 Skip_SB( "AR");
9912 }
9913 BS_End();
9914
9915 FILLING_BEGIN();
9916 Descriptors[InstanceUID].ActiveFormat=Data;
9917 FILLING_END();
9918 }
9919
9920 //---------------------------------------------------------------------------
9921 // 0x3219
GenericPictureEssenceDescriptor_ColorPrimaries()9922 void File_Mxf::GenericPictureEssenceDescriptor_ColorPrimaries()
9923 {
9924 //Parsing
9925 int128u Data;
9926 Get_UL(Data, "Data", Mxf_ColorPrimaries); Element_Info1(Mxf_ColorPrimaries(Data));
9927
9928 FILLING_BEGIN();
9929 Descriptor_Fill("colour_primaries", Mxf_ColorPrimaries(Data));
9930 FILLING_END();
9931 }
9932
9933 //---------------------------------------------------------------------------
9934 // 0x321A
GenericPictureEssenceDescriptor_CodingEquations()9935 void File_Mxf::GenericPictureEssenceDescriptor_CodingEquations()
9936 {
9937 //Parsing
9938 int128u Data;
9939 Get_UL(Data, "Data", Mxf_CodingEquations); Element_Info1(Mxf_CodingEquations(Data));
9940
9941 FILLING_BEGIN();
9942 Descriptor_Fill("matrix_coefficients", Mxf_CodingEquations(Data));
9943 FILLING_END();
9944 }
9945
9946 //---------------------------------------------------------------------------
9947 //
MasteringDisplayPrimaries()9948 void File_Mxf::MasteringDisplayPrimaries()
9949 {
9950 //Parsing
9951 int16u x[3];
9952 int16u y[3];
9953 for (size_t c = 0; c < 3; c++)
9954 {
9955 Get_B2(x[c], "display_primaries_x");
9956 Get_B2(y[c], "display_primaries_y");
9957 }
9958
9959 FILLING_BEGIN();
9960 ZtringList MasteringDisplay_ColorPrimaries;
9961 for (size_t c = 0; c < 3; c++)
9962 {
9963 MasteringDisplay_ColorPrimaries.push_back(Ztring::ToZtring(x[c]));
9964 MasteringDisplay_ColorPrimaries.push_back(Ztring::ToZtring(y[c]));
9965 }
9966 Descriptor_Fill("MasteringDisplay_Primaries", MasteringDisplay_ColorPrimaries.Read());
9967 FILLING_END();
9968 }
9969
9970 //---------------------------------------------------------------------------
9971 //
MasteringDisplayWhitePointChromaticity()9972 void File_Mxf::MasteringDisplayWhitePointChromaticity()
9973 {
9974 int16u x;
9975 int16u y;
9976 Get_B2(x, "white_point_x");
9977 Get_B2(y, "white_point_y");
9978
9979 FILLING_BEGIN();
9980 ZtringList MasteringDisplay_WhitePointChromaticity;
9981 MasteringDisplay_WhitePointChromaticity.push_back(Ztring::ToZtring(x));
9982 MasteringDisplay_WhitePointChromaticity.push_back(Ztring::ToZtring(y));
9983 Descriptor_Fill("MasteringDisplay_WhitePointChromaticity", MasteringDisplay_WhitePointChromaticity.Read());
9984 FILLING_END();
9985 }
9986
9987 //---------------------------------------------------------------------------
9988 //
MasteringDisplayMaximumLuminance()9989 void File_Mxf::MasteringDisplayMaximumLuminance()
9990 {
9991 //Parsing
9992 int32u max;
9993 Get_B4 (max, "Data");
9994
9995 FILLING_BEGIN();
9996 Descriptor_Fill("MasteringDisplay_Luminance_Max", Ztring::ToZtring(max));
9997 FILLING_END();
9998 }
9999
10000 //---------------------------------------------------------------------------
10001 //
MasteringDisplayMinimumLuminance()10002 void File_Mxf::MasteringDisplayMinimumLuminance()
10003 {
10004 //Parsing
10005 int32u min;
10006 Get_B4 (min, "Data");
10007
10008 FILLING_BEGIN();
10009 Descriptor_Fill("MasteringDisplay_Luminance_Min", Ztring::ToZtring(min));
10010 FILLING_END();
10011 }
10012
10013 //---------------------------------------------------------------------------
10014 // 0x3D01
GenericSoundEssenceDescriptor_QuantizationBits()10015 void File_Mxf::GenericSoundEssenceDescriptor_QuantizationBits()
10016 {
10017 //Parsing
10018 int32u Data;
10019 Get_B4 (Data, "Data"); Element_Info1(Data);
10020
10021 FILLING_BEGIN();
10022 if (Data)
10023 {
10024 Descriptor_Fill("BitDepth", Ztring().From_Number(Data));
10025 Descriptors[InstanceUID].QuantizationBits=Data;
10026 }
10027 FILLING_END();
10028 }
10029
10030 //---------------------------------------------------------------------------
10031 // 0x3D02
GenericSoundEssenceDescriptor_Locked()10032 void File_Mxf::GenericSoundEssenceDescriptor_Locked()
10033 {
10034 //Parsing
10035 int8u Data;
10036 Get_B1 (Data, "Data"); Element_Info1(Data?"Yes":"No");
10037
10038 FILLING_BEGIN();
10039 Descriptor_Fill("Locked", Data?"Yes":"No");
10040 FILLING_END();
10041 }
10042
10043 //---------------------------------------------------------------------------
10044 // 0x3D03
GenericSoundEssenceDescriptor_AudioSamplingRate()10045 void File_Mxf::GenericSoundEssenceDescriptor_AudioSamplingRate()
10046 {
10047 //Parsing
10048 float64 Data;
10049 Get_Rational(Data); Element_Info1(Data);
10050
10051 FILLING_BEGIN();
10052 Descriptor_Fill("SamplingRate", Ztring().From_Number(Data, 0));
10053 FILLING_END();
10054 }
10055
10056 //---------------------------------------------------------------------------
10057 // 0x3D04
GenericSoundEssenceDescriptor_AudioRefLevel()10058 void File_Mxf::GenericSoundEssenceDescriptor_AudioRefLevel()
10059 {
10060 //Parsing
10061 Info_B1(Data, "Data"); Element_Info2(Data, " dB");
10062 }
10063
10064 //---------------------------------------------------------------------------
10065 // 0x3D05
GenericSoundEssenceDescriptor_ElectroSpatialFormulation()10066 void File_Mxf::GenericSoundEssenceDescriptor_ElectroSpatialFormulation()
10067 {
10068 //Parsing
10069 Info_B1(Data, "Data"); Element_Info1(Data); //Enum
10070 }
10071
10072 //---------------------------------------------------------------------------
10073 // 0x3D06
GenericSoundEssenceDescriptor_SoundEssenceCompression()10074 void File_Mxf::GenericSoundEssenceDescriptor_SoundEssenceCompression()
10075 {
10076 //Parsing
10077 int128u Data;
10078 Get_UL(Data, "Data", Mxf_EssenceCompression); Element_Info1(Mxf_EssenceCompression(Data));
10079
10080 FILLING_BEGIN();
10081 Descriptors[InstanceUID].EssenceCompression=Data;
10082 Descriptors[InstanceUID].StreamKind=Stream_Audio;
10083 Descriptor_Fill("Format", Mxf_EssenceCompression(Data));
10084 Descriptor_Fill("Format_Version", Mxf_EssenceCompression_Version(Data));
10085 if ((Data.lo&0xFFFFFFFFFF000000LL)==0x040202017e000000LL)
10086 Descriptor_Fill("Format_Settings_Endianness", "Big");
10087 FILLING_END();
10088 }
10089
10090 //---------------------------------------------------------------------------
10091 // 0x3D07
GenericSoundEssenceDescriptor_ChannelCount()10092 void File_Mxf::GenericSoundEssenceDescriptor_ChannelCount()
10093 {
10094 //Parsing
10095 int32u Value;
10096 Get_B4 (Value, "Value"); Element_Info1(Value);
10097
10098 FILLING_BEGIN();
10099 if (Value)
10100 {
10101 Descriptors[InstanceUID].ChannelCount=Value;
10102 Descriptor_Fill("Channel(s)", Ztring().From_Number(Value));
10103 }
10104 FILLING_END();
10105 }
10106
10107 //---------------------------------------------------------------------------
10108 // 0x3D0C
GenericSoundEssenceDescriptor_DialNorm()10109 void File_Mxf::GenericSoundEssenceDescriptor_DialNorm()
10110 {
10111 //Parsing
10112 Info_B1(Data, "Data"); Element_Info2(Data, " dB");
10113 }
10114
10115 //---------------------------------------------------------------------------
10116 // 0x3E01
GenericDataEssenceDescriptor_DataEssenceCoding()10117 void File_Mxf::GenericDataEssenceDescriptor_DataEssenceCoding()
10118 {
10119 //Parsing
10120 Skip_UL( "UUID");
10121 }
10122
10123 //---------------------------------------------------------------------------
10124 // 0x4801
GenericTrack_TrackID()10125 void File_Mxf::GenericTrack_TrackID()
10126 {
10127 //Parsing
10128 int32u Data;
10129 Get_B4 (Data, "Data"); Element_Info1(Data);
10130
10131 FILLING_BEGIN();
10132 if (Tracks[InstanceUID].TrackID==(int32u)-1)
10133 Tracks[InstanceUID].TrackID=Data;
10134 FILLING_END();
10135 }
10136
10137 //---------------------------------------------------------------------------
10138 // 0x4802
GenericTrack_TrackName()10139 void File_Mxf::GenericTrack_TrackName()
10140 {
10141 //Parsing
10142 Ztring Data;
10143 Get_UTF16B (Length2, Data, "Data"); Element_Info1(Data);
10144
10145 FILLING_BEGIN();
10146 Tracks[InstanceUID].TrackName=Data;
10147 FILLING_END();
10148 }
10149
10150 //---------------------------------------------------------------------------
10151 // 0x4803
GenericTrack_Sequence()10152 void File_Mxf::GenericTrack_Sequence()
10153 {
10154 //Parsing
10155 int128u Data;
10156 Get_UUID(Data, "Data"); Element_Info1(uint128toString(Data, 16));
10157
10158 FILLING_BEGIN();
10159 Tracks[InstanceUID].Sequence=Data;
10160 FILLING_END();
10161 }
10162
10163 //---------------------------------------------------------------------------
10164 // 0x4804
GenericTrack_TrackNumber()10165 void File_Mxf::GenericTrack_TrackNumber()
10166 {
10167 //Parsing
10168 int32u Data;
10169 Get_B4 (Data, "Data"); Element_Info1(Ztring::ToZtring(Data, 16));
10170
10171 FILLING_BEGIN();
10172 if (Tracks[InstanceUID].TrackNumber==(int32u)-1 || Data) // In some cases, TrackNumber is 0 for all track and we have replaced with the right value during the parsing
10173 Tracks[InstanceUID].TrackNumber=Data;
10174 Track_Number_IsAvailable=true;
10175 FILLING_END();
10176 }
10177
10178 //---------------------------------------------------------------------------
10179 // 0x3C01
Identification_CompanyName()10180 void File_Mxf::Identification_CompanyName()
10181 {
10182 //Parsing
10183 Ztring Data;
10184 Get_UTF16B(Length2, Data, "Data"); Element_Info1(Data);
10185
10186 FILLING_BEGIN();
10187 Identifications[InstanceUID].CompanyName=Data;
10188 FILLING_END();
10189 }
10190
10191 //---------------------------------------------------------------------------
10192 // 0x3C02
Identification_ProductName()10193 void File_Mxf::Identification_ProductName()
10194 {
10195 //Parsing
10196 Ztring Data;
10197 Get_UTF16B(Length2, Data, "Data"); Element_Info1(Data);
10198
10199 FILLING_BEGIN();
10200 Identifications[InstanceUID].ProductName=Data;
10201 FILLING_END();
10202 }
10203
10204 //---------------------------------------------------------------------------
10205 // 0x3C03
Identification_ProductVersion()10206 void File_Mxf::Identification_ProductVersion()
10207 {
10208 //Parsing
10209 int16u Major, Minor, Patch, Build, Release;
10210 Get_B2 (Major, "Major");
10211 Get_B2 (Minor, "Minor");
10212 Get_B2 (Patch, "Patch");
10213 Get_B2 (Build, "Build");
10214 Get_B2 (Release, "Release");
10215 Ztring Version=Ztring::ToZtring(Major)+__T('.')
10216 +Ztring::ToZtring(Minor)+__T('.')
10217 +Ztring::ToZtring(Patch)+__T('.')
10218 +Ztring::ToZtring(Build)+__T('.')
10219 +Ztring::ToZtring(Release) ;
10220 Element_Info1(Version);
10221
10222 FILLING_BEGIN();
10223 if (Major || Minor || Patch || Build || Release)
10224 Identifications[InstanceUID].ProductVersion=Version;
10225 FILLING_END();
10226 }
10227
10228 //---------------------------------------------------------------------------
10229 // 0x3C04
Identification_VersionString()10230 void File_Mxf::Identification_VersionString()
10231 {
10232 //Parsing
10233 Ztring Data;
10234 Get_UTF16B(Length2, Data, "Data"); Element_Info1(Data);
10235
10236 FILLING_BEGIN();
10237 Identifications[InstanceUID].VersionString=Data;
10238 FILLING_END();
10239 }
10240
10241 //---------------------------------------------------------------------------
10242 // 0x3C05
Identification_ProductUID()10243 void File_Mxf::Identification_ProductUID()
10244 {
10245 //Parsing
10246 Skip_UUID( "UUID");
10247 }
10248
10249 //---------------------------------------------------------------------------
10250 // 0x3C06
Identification_ModificationDate()10251 void File_Mxf::Identification_ModificationDate()
10252 {
10253 //Parsing
10254 Info_Timestamp();
10255 }
10256
10257 //---------------------------------------------------------------------------
10258 // 0x3C07
Identification_ToolkitVersion()10259 void File_Mxf::Identification_ToolkitVersion()
10260 {
10261 //Parsing
10262 int16u Major, Minor, Patch, Build, Release;
10263 Get_B2 (Major, "Major");
10264 Get_B2 (Minor, "Minor");
10265 Get_B2 (Patch, "Patch");
10266 Get_B2 (Build, "Build");
10267 if (Element_Size-Element_Offset==1)
10268 {
10269 int8u t;
10270 Get_B1 (t, "Release"); Param_Error("Identification ToolkitVersion is 9 byte long (should be 10)");
10271 Release=t;
10272 }
10273 else
10274 Get_B2 (Release, "Release");
10275 Ztring Version=Ztring::ToZtring(Major)+__T('.')
10276 +Ztring::ToZtring(Minor)+__T('.')
10277 +Ztring::ToZtring(Patch)+__T('.')
10278 +Ztring::ToZtring(Build)+__T('.')
10279 +Ztring::ToZtring(Release) ;
10280 Element_Info1(Version);
10281
10282 FILLING_BEGIN();
10283 if (Major || Minor || Patch || Build || Release)
10284 Identifications[InstanceUID].ToolkitVersion=Version;
10285 FILLING_END();
10286 }
10287
10288 //---------------------------------------------------------------------------
10289 // 0x3C08
Identification_Platform()10290 void File_Mxf::Identification_Platform()
10291 {
10292 //Parsing
10293 Ztring Data;
10294 Get_UTF16B(Length2, Data, "Data"); Element_Info1(Data);
10295
10296 FILLING_BEGIN();
10297 if (Data!=__T("Unknown"))
10298 Identifications[InstanceUID].Platform=Data;
10299 FILLING_END();
10300 }
10301
10302 //---------------------------------------------------------------------------
10303 // 0x3C09
Identification_ThisGenerationUID()10304 void File_Mxf::Identification_ThisGenerationUID()
10305 {
10306 //Parsing
10307 Skip_UUID( "UUID");
10308 }
10309
10310 //---------------------------------------------------------------------------
10311 // 0x3F05
IndexTableSegment_EditUnitByteCount()10312 void File_Mxf::IndexTableSegment_EditUnitByteCount()
10313 {
10314 //Parsing
10315 int32u Data;
10316 Get_B4(Data, "Data"); Element_Info1(Data);
10317
10318 FILLING_BEGIN();
10319 #if MEDIAINFO_SEEK
10320 IndexTables[IndexTables.size()-1].EditUnitByteCount=Data;
10321 #endif //MEDIAINFO_SEEK
10322 FILLING_END();
10323 }
10324
10325 //---------------------------------------------------------------------------
10326 // 0x3F06
IndexTableSegment_IndexSID()10327 void File_Mxf::IndexTableSegment_IndexSID()
10328 {
10329 //Parsing
10330 Info_B4(Data, "Data"); Element_Info1(Data);
10331 }
10332
10333 //---------------------------------------------------------------------------
10334 // 0x3F07
IndexTableSegment_BodySID()10335 void File_Mxf::IndexTableSegment_BodySID()
10336 {
10337 //Parsing
10338 Info_B4(Data, "Data"); Element_Info1(Data);
10339 }
10340
10341 //---------------------------------------------------------------------------
10342 // 0x3F08
IndexTableSegment_SliceCount()10343 void File_Mxf::IndexTableSegment_SliceCount()
10344 {
10345 //Parsing
10346 int8u Data;
10347 Get_B1(Data, "Data"); Element_Info1(Data);
10348
10349 FILLING_BEGIN();
10350 IndexTable_NSL=Data;
10351 FILLING_END();
10352 }
10353
10354 //---------------------------------------------------------------------------
10355 // 0x3F09
IndexTableSegment_DeltaEntryArray()10356 void File_Mxf::IndexTableSegment_DeltaEntryArray()
10357 {
10358 //Parsing
10359 int32u NDE, Length;
10360 Get_B4(NDE, "NDE");
10361 Get_B4(Length, "Length");
10362 for (int32u Pos=0; Pos<NDE; Pos++)
10363 {
10364 Element_Begin1("Delta Entry");
10365 Skip_B1( "PosTableIndex");
10366 Skip_B1( "Slice");
10367 Skip_B4( "Element Delta");
10368 Element_End0();
10369 }
10370 }
10371
10372 //---------------------------------------------------------------------------
10373 // 0x3F0A
IndexTableSegment_IndexEntryArray()10374 void File_Mxf::IndexTableSegment_IndexEntryArray()
10375 {
10376 //Parsing
10377 int32u NIE, Length;
10378 Get_B4(NIE, "NIE");
10379 Get_B4(Length, "Length");
10380 for (int32u Pos=0; Pos<NIE; Pos++)
10381 {
10382 #if MEDIAINFO_SEEK
10383 indextable::entry Entry;
10384 int64u Stream_Offset;
10385 bool forward_rediction_flag, backward_prediction_flag;
10386 #endif //MEDIAINFO_SEEK
10387 int8u Flags;
10388 Element_Begin1("Index Entry");
10389 Skip_B1( "Temporal Offset");
10390 Skip_B1( "Key-Frame Offset");
10391 Get_B1 (Flags, "Flags");
10392 Skip_Flags(Flags, 7, "Random Access");
10393 Skip_Flags(Flags, 6, "Sequence Header");
10394 #if MEDIAINFO_SEEK
10395 Get_Flags (Flags, 5, forward_rediction_flag, "forward prediction flag");
10396 Get_Flags (Flags, 4, backward_prediction_flag, "backward prediction flag");
10397 #else //MEDIAINFO_SEEK
10398 Skip_Flags(Flags, 5, "forward prediction flag");
10399 Skip_Flags(Flags, 4, "backward prediction flag");
10400 #endif //MEDIAINFO_SEEK
10401 #if MEDIAINFO_SEEK
10402 Get_B8 (Stream_Offset, "Stream Offset");
10403 Entry.StreamOffset=Stream_Offset;
10404 Entry.Type=(forward_rediction_flag?1:0)*2+(backward_prediction_flag?1:0);
10405 IndexTables[IndexTables.size()-1].Entries.push_back(Entry);
10406 #else //MEDIAINFO_SEEK
10407 Skip_B8( "Stream Offset");
10408 #endif //MEDIAINFO_SEEK
10409 for (int32u NSL_Pos=0; NSL_Pos<IndexTable_NSL; NSL_Pos++)
10410 Skip_B4( "SliceOffset");
10411 for (int32u NPE_Pos=0; NPE_Pos<IndexTable_NPE; NPE_Pos++)
10412 Skip_B4( "PosTable");
10413 Element_End0();
10414 }
10415 }
10416
10417 //---------------------------------------------------------------------------
10418 // 0x3F0B
IndexTableSegment_IndexEditRate()10419 void File_Mxf::IndexTableSegment_IndexEditRate()
10420 {
10421 //Parsing
10422 float64 Data;
10423 Get_Rational(Data);
10424
10425 FILLING_BEGIN();
10426 #if MEDIAINFO_SEEK
10427 IndexTables[IndexTables.size()-1].IndexEditRate=Data;
10428 #endif //MEDIAINFO_SEEK
10429 FILLING_END();
10430 }
10431
10432 //---------------------------------------------------------------------------
10433 // 0x3F0C
IndexTableSegment_IndexStartPosition()10434 void File_Mxf::IndexTableSegment_IndexStartPosition()
10435 {
10436 //Parsing
10437 int64u Data;
10438 Get_B8 (Data, "Data"); Element_Info1(Data);
10439
10440 FILLING_BEGIN();
10441 #if MEDIAINFO_SEEK
10442 IndexTables[IndexTables.size()-1].IndexStartPosition=Data;
10443
10444 //Integrity test (in one file, I have 2 indexes with IndexStartPosition=0, the first one is weird (only one frame), or the same index is repeated
10445 //Integrity test (in one file, I have 2 indexes with IndexStartPosition=0, the second one is weird (only one frame), or the same index is repeated
10446 for (size_t Pos=0; Pos<IndexTables.size()-1; Pos++)
10447 if (IndexTables[Pos].IndexStartPosition==Data)
10448 {
10449 if (IndexTables[Pos].IndexDuration==1 && Pos!=IndexTables.size()-1)
10450 IndexTables.erase(IndexTables.begin()+Pos);
10451 else
10452 {
10453 //Removed in order to get all indexes, even the duplicated ones (in order to check duplicated index in the footer)
10454 //IndexTables.erase(IndexTables.begin()+IndexTables.size()-1);
10455 //Element_Offset=Element_Size;
10456 }
10457
10458 return;
10459 }
10460 #endif //MEDIAINFO_SEEK
10461 FILLING_END();
10462 }
10463
10464 //---------------------------------------------------------------------------
10465 // 0x3F0D
IndexTableSegment_IndexDuration()10466 void File_Mxf::IndexTableSegment_IndexDuration()
10467 {
10468 //Parsing
10469 int64u Data;
10470 Get_B8 (Data, "Data"); Element_Info1(Data);
10471
10472 FILLING_BEGIN();
10473 #if MEDIAINFO_SEEK
10474 IndexTables[IndexTables.size()-1].IndexDuration=Data;
10475 #endif //MEDIAINFO_SEEK
10476 FILLING_END();
10477 }
10478
10479 //---------------------------------------------------------------------------
10480 // 0x3F0E
IndexTableSegment_PosTableCount()10481 void File_Mxf::IndexTableSegment_PosTableCount()
10482 {
10483 //Parsing
10484 int8u Data;
10485 Get_B1(Data, "Data"); Element_Info1(Data);
10486
10487 FILLING_BEGIN();
10488 IndexTable_NPE=Data;
10489 FILLING_END();
10490 }
10491
10492 //---------------------------------------------------------------------------
10493 // 0x8002
IndexTableSegment_8002()10494 void File_Mxf::IndexTableSegment_8002()
10495 {
10496 //Parsing
10497 Info_B8(Data, "Data"); Element_Info1(Data);
10498 }
10499
10500 //---------------------------------------------------------------------------
10501 // 0x8001
JPEG2000PictureSubDescriptor_Rsiz()10502 void File_Mxf::JPEG2000PictureSubDescriptor_Rsiz()
10503 {
10504 #if MEDIAINFO_ADVANCED
10505 //Parsing
10506 int16u Data;
10507 Get_B2 (Data, "Data"); Element_Info1(Data);
10508
10509 FILLING_BEGIN();
10510 Descriptors[InstanceUID].Jpeg2000_Rsiz=Data;
10511 FILLING_END();
10512 #else //MEDIAINFO_ADVANCED
10513 Info_B2(Data, "Data"); Element_Info1(Data);
10514 #endif //MEDIAINFO_ADVANCED
10515 }
10516
10517 //---------------------------------------------------------------------------
10518 // 0x8002
JPEG2000PictureSubDescriptor_Xsiz()10519 void File_Mxf::JPEG2000PictureSubDescriptor_Xsiz()
10520 {
10521 //Parsing
10522 Info_B4(Data, "Data"); Element_Info1(Data);
10523 }
10524
10525 //---------------------------------------------------------------------------
10526 // 0x8003
JPEG2000PictureSubDescriptor_Ysiz()10527 void File_Mxf::JPEG2000PictureSubDescriptor_Ysiz()
10528 {
10529 //Parsing
10530 Info_B4(Data, "Data"); Element_Info1(Data);
10531 }
10532
10533 //---------------------------------------------------------------------------
10534 // 0x8004
JPEG2000PictureSubDescriptor_XOsiz()10535 void File_Mxf::JPEG2000PictureSubDescriptor_XOsiz()
10536 {
10537 //Parsing
10538 Info_B4(Data, "Data"); Element_Info1(Data);
10539 }
10540
10541 //---------------------------------------------------------------------------
10542 // 0x8005
JPEG2000PictureSubDescriptor_YOsiz()10543 void File_Mxf::JPEG2000PictureSubDescriptor_YOsiz()
10544 {
10545 //Parsing
10546 Info_B4(Data, "Data"); Element_Info1(Data);
10547 }
10548
10549 //---------------------------------------------------------------------------
10550 // 0x8006
JPEG2000PictureSubDescriptor_XTsiz()10551 void File_Mxf::JPEG2000PictureSubDescriptor_XTsiz()
10552 {
10553 //Parsing
10554 Info_B4(Data, "Data"); Element_Info1(Data);
10555 }
10556
10557 //---------------------------------------------------------------------------
10558 // 0x8007
JPEG2000PictureSubDescriptor_YTsiz()10559 void File_Mxf::JPEG2000PictureSubDescriptor_YTsiz()
10560 {
10561 //Parsing
10562 Info_B4(Data, "Data"); Element_Info1(Data);
10563 }
10564
10565 //---------------------------------------------------------------------------
10566 // 0x8008
JPEG2000PictureSubDescriptor_XTOsiz()10567 void File_Mxf::JPEG2000PictureSubDescriptor_XTOsiz()
10568 {
10569 //Parsing
10570 Info_B4(Data, "Data"); Element_Info1(Data);
10571 }
10572
10573 //---------------------------------------------------------------------------
10574 // 0x8009
JPEG2000PictureSubDescriptor_YTOsiz()10575 void File_Mxf::JPEG2000PictureSubDescriptor_YTOsiz()
10576 {
10577 //Parsing
10578 Info_B4(Data, "Data"); Element_Info1(Data);
10579 }
10580
10581 //---------------------------------------------------------------------------
10582 // 0x800A
JPEG2000PictureSubDescriptor_Csiz()10583 void File_Mxf::JPEG2000PictureSubDescriptor_Csiz()
10584 {
10585 //Parsing
10586 int16u Data;
10587 Get_B2 (Data, "Data"); Element_Info1(Data);
10588
10589 FILLING_BEGIN()
10590 Descriptor_Fill("ComponentCount", Ztring::ToZtring(Data));
10591 FILLING_END()
10592
10593 }
10594
10595 //---------------------------------------------------------------------------
10596 // 0x800B
JPEG2000PictureSubDescriptor_PictureComponentSizing()10597 void File_Mxf::JPEG2000PictureSubDescriptor_PictureComponentSizing()
10598 {
10599 //Parsing
10600 if (Vector(3)==(int32u)-1)
10601 return;
10602 while (Element_Offset<Element_Size)
10603 {
10604 Element_Begin1("PictureComponentSize");
10605 Info_B1(Ssiz, "Component sample precision"); Element_Info1(Ssiz);
10606 Info_B1(XRsiz, "Horizontal separation of a sample"); Element_Info1(XRsiz);
10607 Info_B1(YRsiz, "Vertical separation of a sample"); Element_Info1(YRsiz);
10608 Element_End0();
10609 }
10610 }
10611
10612 //---------------------------------------------------------------------------
10613 //
JPEG2000PictureSubDescriptor_CodingStyleDefault()10614 void File_Mxf::JPEG2000PictureSubDescriptor_CodingStyleDefault()
10615 {
10616 Skip_XX(Length2, "Data");
10617 }
10618
10619 //---------------------------------------------------------------------------
10620 //
JPEG2000PictureSubDescriptor_QuantizationDefault()10621 void File_Mxf::JPEG2000PictureSubDescriptor_QuantizationDefault()
10622 {
10623 Skip_XX(Length2, "Data");
10624 }
10625
10626 //---------------------------------------------------------------------------
10627 //
MpegAudioDescriptor_BitRate()10628 void File_Mxf::MpegAudioDescriptor_BitRate()
10629 {
10630 Skip_B4( "Data");
10631 }
10632
10633 //---------------------------------------------------------------------------
10634 // 0x3B02
Preface_LastModifiedDate()10635 void File_Mxf::Preface_LastModifiedDate()
10636 {
10637 //Parsing
10638 Ztring Value;
10639 Get_Timestamp(Value); Element_Info1(Value);
10640
10641 FILLING_BEGIN();
10642 Fill(Stream_General, 0, General_Encoded_Date, Value, true);
10643 FILLING_END();
10644 }
10645
10646 //---------------------------------------------------------------------------
10647 // 0x
PrimaryExtendedSpokenLanguage()10648 void File_Mxf::PrimaryExtendedSpokenLanguage()
10649 {
10650 //Parsing
10651 Ztring Data;
10652 Get_UTF8 (Length2, Data, "Data"); Element_Info1(Data);
10653
10654 FILLING_BEGIN();
10655 DMScheme1s[InstanceUID].PrimaryExtendedSpokenLanguage=Data;
10656 FILLING_END();
10657 }
10658
10659 //---------------------------------------------------------------------------
10660 // 0x
SecondaryExtendedSpokenLanguage()10661 void File_Mxf::SecondaryExtendedSpokenLanguage()
10662 {
10663 //Parsing
10664 Info_UTF8(Length2, Data, "Data"); Element_Info1(Data);
10665 }
10666
10667 //---------------------------------------------------------------------------
10668 // 0x
OriginalExtendedSpokenLanguage()10669 void File_Mxf::OriginalExtendedSpokenLanguage()
10670 {
10671 //Parsing
10672 Info_UTF8(Length2, Data, "Data"); Element_Info1(Data);
10673 }
10674
10675 //---------------------------------------------------------------------------
10676 // 0x
SecondaryOriginalExtendedSpokenLanguage()10677 void File_Mxf::SecondaryOriginalExtendedSpokenLanguage()
10678 {
10679 //Parsing
10680 Info_UTF8(Length2, Data, "Data"); Element_Info1(Data);
10681 }
10682
10683 //---------------------------------------------------------------------------
10684 // 0x
RFC5646AudioLanguageCode()10685 void File_Mxf::RFC5646AudioLanguageCode()
10686 {
10687 bool SizeIsPresent=false;
10688 if (Length2>=4)
10689 {
10690 int32u Size;
10691 Peek_B4(Size);
10692 if (Size==((int32u)Length2)-4)
10693 {
10694 SizeIsPresent=true;
10695 Skip_B4( "Value size");
10696 }
10697 }
10698
10699 //Parsing
10700 Ztring Value;
10701 Get_UTF8 (Length2-(SizeIsPresent?4:0), Value, "Value"); Element_Info1(Value);
10702
10703 FILLING_BEGIN();
10704 Descriptor_Fill("Language", Value);
10705 FILLING_END();
10706 }
10707
10708 //---------------------------------------------------------------------------
10709 // 0x
MPEG2VideoDescriptor_SingleSequence()10710 void File_Mxf::MPEG2VideoDescriptor_SingleSequence()
10711 {
10712 //Parsing
10713 Info_B1(Data, "Data"); Element_Info1(Data?"Yes":"No");
10714 }
10715
10716 //---------------------------------------------------------------------------
10717 // 0x
MPEG2VideoDescriptor_ConstantBFrames()10718 void File_Mxf::MPEG2VideoDescriptor_ConstantBFrames()
10719 {
10720 //Parsing
10721 Info_B1(Data, "Data"); Element_Info1(Data?"Yes":"No");
10722 }
10723
10724 //---------------------------------------------------------------------------
10725 // 0x
MPEG2VideoDescriptor_CodedContentType()10726 void File_Mxf::MPEG2VideoDescriptor_CodedContentType()
10727 {
10728 //Parsing
10729 int8u Data;
10730 Get_B1 (Data, "Data"); Element_Info1(Mxf_MPEG2_CodedContentType(Data));
10731
10732 FILLING_BEGIN();
10733 descriptor& desc_item = Descriptors[InstanceUID];
10734 if (desc_item.ScanType.empty())
10735 {
10736 if (Data==2)
10737 {
10738 if (desc_item.Height!=(int32u)-1) desc_item.Height*=2;
10739 if (desc_item.Height_Display!=(int32u)-1) desc_item.Height_Display*=2;
10740 if (desc_item.Height_Display_Offset!=(int32u)-1) desc_item.Height_Display_Offset*=2;
10741 }
10742 desc_item.ScanType.From_UTF8(Mxf_MPEG2_CodedContentType(Data));
10743 }
10744 FILLING_END();
10745 }
10746
10747 //---------------------------------------------------------------------------
10748 // 0x
MPEG2VideoDescriptor_LowDelay()10749 void File_Mxf::MPEG2VideoDescriptor_LowDelay()
10750 {
10751 //Parsing
10752 Info_B1(Data, "Data"); Element_Info1(Data?"Yes":"No");
10753 }
10754
10755 //---------------------------------------------------------------------------
10756 // 0x
MPEG2VideoDescriptor_ClosedGOP()10757 void File_Mxf::MPEG2VideoDescriptor_ClosedGOP()
10758 {
10759 //Parsing
10760 Info_B1(Data, "Data"); Element_Info1(Data?"Yes":"No");
10761 }
10762
10763 //---------------------------------------------------------------------------
10764 // 0x
MPEG2VideoDescriptor_IdenticalGOP()10765 void File_Mxf::MPEG2VideoDescriptor_IdenticalGOP()
10766 {
10767 //Parsing
10768 Info_B1(Data, "Data"); Element_Info1(Data?"Yes":"No");
10769 }
10770
10771 //---------------------------------------------------------------------------
10772 // 0x
MPEG2VideoDescriptor_MaxGOP()10773 void File_Mxf::MPEG2VideoDescriptor_MaxGOP()
10774 {
10775 //Parsing
10776 int16u Data;
10777 Get_B2 (Data, "Data"); Element_Info1(Data);
10778
10779 FILLING_BEGIN();
10780 if (Data==1)
10781 Descriptors[InstanceUID].Infos["Format_Settings_GOP"]=__T("N=1");
10782 FILLING_END();
10783 }
10784
10785 //---------------------------------------------------------------------------
10786 // 0x
MPEG2VideoDescriptor_BPictureCount()10787 void File_Mxf::MPEG2VideoDescriptor_BPictureCount()
10788 {
10789 //Parsing
10790 int16u Data;
10791 Get_B2 (Data, "Data"); Element_Info1(Data);
10792
10793 FILLING_BEGIN();
10794 Descriptors[InstanceUID].HasBFrames=Data?true:false;
10795 FILLING_END();
10796 }
10797
10798 //---------------------------------------------------------------------------
10799 // 0x
MPEG2VideoDescriptor_ProfileAndLevel()10800 void File_Mxf::MPEG2VideoDescriptor_ProfileAndLevel()
10801 {
10802 //Parsing
10803 int8u profile_and_level_indication_profile, profile_and_level_indication_level;
10804 BS_Begin();
10805 Skip_SB( "profile_and_level_indication_escape");
10806 Get_S1 ( 3, profile_and_level_indication_profile, "profile_and_level_indication_profile"); Param_Info1(Mpegv_profile_and_level_indication_profile[profile_and_level_indication_profile]);
10807 Get_S1 ( 4, profile_and_level_indication_level, "profile_and_level_indication_level"); Param_Info1(Mpegv_profile_and_level_indication_level[profile_and_level_indication_level]);
10808 BS_End();
10809
10810 FILLING_BEGIN();
10811 if (profile_and_level_indication_profile && profile_and_level_indication_level)
10812 Descriptor_Fill("Format_Profile", Ztring().From_UTF8(Mpegv_profile_and_level_indication_profile[profile_and_level_indication_profile])+__T("@")+Ztring().From_UTF8(Mpegv_profile_and_level_indication_level[profile_and_level_indication_level]));
10813 FILLING_END();
10814 }
10815
10816 //---------------------------------------------------------------------------
10817 // 0x
Mpeg4VisualDescriptor_ProfileAndLevel()10818 void File_Mxf::Mpeg4VisualDescriptor_ProfileAndLevel()
10819 {
10820 //Parsing
10821 int8u profile_and_level_indication;
10822 Get_B1 (profile_and_level_indication, "profile_and_level_indication"); Param_Info1(Mpeg4v_Profile_Level(profile_and_level_indication)); Element_Info1(Mpeg4v_Profile_Level(profile_and_level_indication));
10823
10824 FILLING_BEGIN();
10825 if (profile_and_level_indication)
10826 Descriptor_Fill("Format_Profile", Mpeg4v_Profile_Level(profile_and_level_indication));
10827 FILLING_END();
10828 }
10829
10830 //---------------------------------------------------------------------------
10831 // 0x
AVCDescriptor_Profile()10832 void File_Mxf::AVCDescriptor_Profile()
10833 {
10834 //Parsing
10835 int8u profile_idc;
10836 Get_B1 (profile_idc, "profile_idc"); Element_Info1(Avc_profile_idc(profile_idc));
10837
10838 FILLING_BEGIN();
10839 if (profile_idc)
10840 Descriptor_Fill("Format_Profile", Avc_profile_idc(profile_idc));
10841 FILLING_END();
10842 }
10843
10844 //---------------------------------------------------------------------------
10845 // 0x
MPEG2VideoDescriptor_BitRate()10846 void File_Mxf::MPEG2VideoDescriptor_BitRate()
10847 {
10848 //Parsing
10849 int32u Data;
10850 Get_B4 (Data, "Data"); Element_Info1(Data);
10851
10852 FILLING_BEGIN();
10853 Descriptor_Fill("BitRate", Ztring().From_Number(Data));
10854 FILLING_END();
10855 }
10856
10857 //---------------------------------------------------------------------------
10858 // 0x
AVCDescriptor_MaximumBitRate()10859 void File_Mxf::AVCDescriptor_MaximumBitRate()
10860 {
10861 //Parsing
10862 int32u Data;
10863 Get_B4 (Data, "Data"); Element_Info1(Data);
10864
10865 FILLING_BEGIN();
10866 Descriptor_Fill("BitRate_Maximum", Ztring().From_Number(Data));
10867 FILLING_END();
10868 }
10869
10870 //---------------------------------------------------------------------------
10871 // 0x
AVCDescriptor_ProfileConstraint()10872 void File_Mxf::AVCDescriptor_ProfileConstraint()
10873 {
10874 //Parsing
10875 BS_Begin();
10876 bool constraint_set3_flag;
10877 Element_Begin1("constraints");
10878 Skip_SB( "constraint_set0_flag");
10879 Skip_SB( "constraint_set1_flag");
10880 Skip_SB( "constraint_set2_flag");
10881 Get_SB (constraint_set3_flag, "constraint_set3_flag");
10882 Skip_SB( "constraint_set4_flag");
10883 Skip_SB( "constraint_set5_flag");
10884 Skip_BS(2, "reserved_zero_2bits");
10885 Element_End0();
10886 BS_End();
10887
10888 FILLING_BEGIN();
10889 Descriptor_Fill("Temp_AVC_constraint_set3_flag", Ztring::ToZtring(constraint_set3_flag?1:0));
10890 FILLING_END();
10891 }
10892
10893 //---------------------------------------------------------------------------
10894 // 0x
AVCDescriptor_Level()10895 void File_Mxf::AVCDescriptor_Level()
10896 {
10897 //Parsing
10898 int8u level_idc;
10899 Get_B1 (level_idc, "level_idc"); Element_Info1(Ztring().From_Number(((float)level_idc)/10, (level_idc%10)?1:0));
10900
10901 FILLING_BEGIN();
10902 if (level_idc)
10903 Descriptor_Fill("Temp_AVC_Format_Level", Ztring().From_Number(((float)level_idc)/10, (level_idc%10)?1:0));
10904 FILLING_END();
10905 }
10906
10907 //---------------------------------------------------------------------------
10908 // 0x
AVCDescriptor_DecodingDelay()10909 void File_Mxf::AVCDescriptor_DecodingDelay()
10910 {
10911 //Parsing
10912 Info_B1(Data, "Data"); Element_Info1(Data==0xFF?"":(Data?"Yes":"No"));
10913 }
10914
10915 //---------------------------------------------------------------------------
10916 // 0x
AVCDescriptor_MaximumRefFrames()10917 void File_Mxf::AVCDescriptor_MaximumRefFrames()
10918 {
10919 //Parsing
10920 Info_B1(Data, "max_num_ref_frames"); Element_Info1(Data);
10921 }
10922
10923 //---------------------------------------------------------------------------
10924 // 0x
AVCDescriptor_SequenceParameterSetFlag()10925 void File_Mxf::AVCDescriptor_SequenceParameterSetFlag()
10926 {
10927 //Parsing
10928 BS_Begin();
10929 Info_SB( Constancy, "Constancy");
10930 Info_BS(3, Location, "In-band location"); Element_Info1(Mxf_AVC_SequenceParameterSetFlag_Constancy(Constancy));
10931 Skip_BS(4, "reserved"); Element_Info1(Mxf_AVC_SequenceParameterSetFlag_Constancy(Location));
10932 BS_End();
10933 }
10934
10935 //---------------------------------------------------------------------------
10936 // 0x
AVCDescriptor_PictureParameterSetFlag()10937 void File_Mxf::AVCDescriptor_PictureParameterSetFlag()
10938 {
10939 //Parsing
10940 BS_Begin();
10941 Info_SB( Constancy, "Constancy");
10942 Info_BS(3, Location, "In-band location"); Element_Info1(Mxf_AVC_SequenceParameterSetFlag_Constancy(Constancy));
10943 Skip_BS(4, "reserved"); Element_Info1(Mxf_AVC_SequenceParameterSetFlag_Constancy(Location));
10944 BS_End();
10945 }
10946
10947 //---------------------------------------------------------------------------
10948 // 0x
AVCDescriptor_AverageBitRate()10949 void File_Mxf::AVCDescriptor_AverageBitRate()
10950 {
10951 //Parsing
10952 int32u Data;
10953 Get_B4 (Data, "Data");
10954
10955 FILLING_BEGIN();
10956 Descriptor_Fill("BitRate", Ztring().From_Number(Data));
10957 FILLING_END();
10958 }
10959
10960 //---------------------------------------------------------------------------
10961 // 0x4001
NetworkLocator_URLString()10962 void File_Mxf::NetworkLocator_URLString()
10963 {
10964 //Parsing
10965 Ztring Data;
10966 Get_UTF16B(Length2, Data, "Essence Locator"); Element_Info1(Data);
10967
10968 FILLING_BEGIN();
10969 Locators[InstanceUID].EssenceLocator=Data;
10970 FILLING_END();
10971 }
10972
10973 //---------------------------------------------------------------------------
10974 // 0x3F01
MultipleDescriptor_FileDescriptors()10975 void File_Mxf::MultipleDescriptor_FileDescriptors()
10976 {
10977 Descriptors[InstanceUID].SubDescriptors.clear();
10978
10979 //Parsing
10980 if (Vector(16)==(int32u)-1)
10981 return;
10982 size_t StreamOrder=0;
10983 while (Element_Offset<Element_Size)
10984 {
10985 //Parsing
10986 int128u Data;
10987 Get_UUID(Data, "UUID");
10988
10989 FILLING_BEGIN();
10990 Descriptors[InstanceUID].SubDescriptors.push_back(Data);
10991 Descriptors[Data].Infos["StreamOrder"].From_Number(StreamOrder);
10992 StreamOrder++;
10993 FILLING_END();
10994 }
10995 }
10996
10997 //---------------------------------------------------------------------------
PartitionMetadata()10998 void File_Mxf::PartitionMetadata()
10999 {
11000 //Parsing
11001 int64u PreviousPartition, FooterPartition, HeaderByteCount, IndexByteCount, BodyOffset;
11002 int32u IndexSID;
11003 int32u KAGSize;
11004 int16u MajorVersion, MinorVersion;
11005 Get_B2 (MajorVersion, "MajorVersion");
11006 Get_B2 (MinorVersion, "MinorVersion");
11007 Get_B4 (KAGSize, "KAGSize");
11008 Skip_B8( "ThisPartition");
11009 Get_B8 (PreviousPartition, "PreviousPartition");
11010 Get_B8 (FooterPartition, "FooterPartition");
11011 Get_B8 (HeaderByteCount, "HeaderByteCount");
11012 Get_B8 (IndexByteCount, "IndexByteCount");
11013 Get_B4 (IndexSID, "IndexSID");
11014 Get_B8 (BodyOffset, "BodyOffset");
11015 Skip_B4( "BodySID");
11016 Get_UL (OperationalPattern, "OperationalPattern", Mxf_OperationalPattern);
11017
11018 Element_Begin1("EssenceContainers"); //Vector
11019 if (Vector(16)==(int32u)-1)
11020 {
11021 Element_End0();
11022 return;
11023 }
11024 int32u Count=(Element_Size-Element_Offset)/16;
11025 while (Element_Offset<Element_Size)
11026 {
11027 int128u EssenceContainer;
11028 Get_UL (EssenceContainer, "EssenceContainer", Mxf_EssenceContainer);
11029 if (Count==1)
11030 EssenceContainer_FromPartitionMetadata=EssenceContainer;
11031 }
11032 Element_End0();
11033
11034 FILLING_BEGIN_PRECISE();
11035 if (!Status[IsAccepted])
11036 Accept();
11037 FILLING_END();
11038
11039 PartitionPack_Parsed=true;
11040 Partitions_IsFooter=(Code.lo&0x00FF0000)==0x00040000;
11041 if (PreviousPartition!=File_Offset+Buffer_Offset-Header_Size)
11042 PartitionMetadata_PreviousPartition=PreviousPartition;
11043 if (FooterPartition)
11044 PartitionMetadata_FooterPartition=FooterPartition;
11045 bool AlreadyParsed=false;
11046 for (size_t Pos=0; Pos<Partitions.size(); Pos++)
11047 if (Partitions[Pos].StreamOffset==File_Offset+Buffer_Offset-Header_Size)
11048 AlreadyParsed=true;
11049 if (!AlreadyParsed)
11050 {
11051 partition Partition;
11052 Partition.StreamOffset=File_Offset+Buffer_Offset-Header_Size;
11053 Partition.FooterPartition=FooterPartition;
11054 Partition.HeaderByteCount=HeaderByteCount;
11055 Partition.IndexByteCount=IndexByteCount;
11056 Partition.BodyOffset=BodyOffset;
11057 Partitions_Pos=0;
11058 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset<Partition.StreamOffset)
11059 Partitions_Pos++;
11060 Partitions.insert(Partitions.begin()+Partitions_Pos, Partition);
11061 Partitions_IsCalculatingHeaderByteCount=true;
11062 }
11063
11064 Fill(Stream_General, 0, General_Format_Version, Ztring::ToZtring(MajorVersion)+__T('.')+Ztring::ToZtring(MinorVersion), true);
11065
11066 if ((Code.lo&0xFF0000)==0x020000) //If Header Partition Pack
11067 switch ((Code.lo>>8)&0xFF)
11068 {
11069 case 0x01 : Fill(Stream_General, 0, General_Format_Settings, "Open / Incomplete" , Unlimited, true, true);
11070 if (Config->ParseSpeed>=1.0)
11071 {
11072 Config->File_IsGrowing=true;
11073 HeaderPartition_IsOpen=true;
11074 #if MEDIAINFO_HASH
11075 delete Hash; Hash=NULL;
11076 #endif //MEDIAINFO_HASH
11077 }
11078 break;
11079 case 0x02 : Fill(Stream_General, 0, General_Format_Settings, "Closed / Incomplete", Unlimited, true, true);
11080 break;
11081 case 0x03 : Fill(Stream_General, 0, General_Format_Settings, "Open / Complete" , Unlimited, true, true);
11082 if (Config->ParseSpeed>=1.0)
11083 {
11084 Config->File_IsGrowing=true;
11085 HeaderPartition_IsOpen=true;
11086 #if MEDIAINFO_HASH
11087 delete Hash; Hash=NULL;
11088 #endif //MEDIAINFO_HASH
11089 }
11090 break;
11091 case 0x04 : Fill(Stream_General, 0, General_Format_Settings, "Closed / Complete" , Unlimited, true, true);
11092 break;
11093 default : ;
11094 }
11095
11096 if ((Code.lo&0xFF0000)==0x030000 && (Code.lo&0x00FF00)<=0x000400) //If Body Partition Pack
11097 {
11098 if (IsParsingEnd)
11099 {
11100 //Parsing only index
11101 RandomIndexPacks_MaxOffset=File_Offset+Buffer_Offset+Element_Size+HeaderByteCount+IndexByteCount;
11102
11103 //Hints
11104 if (File_Buffer_Size_Hint_Pointer && Buffer_Offset+Element_Size+HeaderByteCount+IndexByteCount>=Buffer_Size)
11105 {
11106 size_t Buffer_Size_Target=(size_t)(Buffer_Offset+Element_Size+HeaderByteCount+IndexByteCount-Buffer_Size);
11107 if (Buffer_Size_Target<128*1024)
11108 Buffer_Size_Target=128*1024;
11109 //if ((*File_Buffer_Size_Hint_Pointer)<Buffer_Size_Target)
11110 (*File_Buffer_Size_Hint_Pointer)=Buffer_Size_Target;
11111 }
11112 }
11113 }
11114
11115 if ((Code.lo&0xFF0000)==0x040000) //If Footer Partition Pack
11116 {
11117 switch ((Code.lo>>8)&0xFF)
11118 {
11119 case 0x02 :
11120 case 0x04 :
11121 Config->File_IsGrowing=false;
11122 break;
11123 default : ;
11124 }
11125
11126 #if MEDIAINFO_ADVANCED
11127 if (Footer_Position==(int64u)-1)
11128 Footer_Position=File_Offset+Buffer_Offset-Header_Size;
11129 #endif //MEDIAINFO_ADVANCED
11130
11131 #if MEDIAINFO_ADVANCED
11132 //IsTruncated
11133 bool IsTruncated;
11134 if (!Trusted_Get())
11135 IsTruncated=true;
11136 else
11137 {
11138 int32u KAGSize_Corrected=KAGSize;
11139 if (!KAGSize || KAGSize>=File_Size) // Checking incoherent behaviors
11140 KAGSize_Corrected=1;
11141 int64u Element_Size_WithPadding=Element_Offset;
11142 if (Element_Size_WithPadding%KAGSize_Corrected)
11143 {
11144 Element_Size_WithPadding-=Element_Size_WithPadding%KAGSize_Corrected;
11145 Element_Size_WithPadding+=KAGSize_Corrected;
11146 }
11147
11148 if (File_Offset+Buffer_Offset-Header_Size+Element_Size_WithPadding+HeaderByteCount+IndexByteCount > File_Size)
11149 IsTruncated=true;
11150 else
11151 IsTruncated=false;
11152 }
11153 if (IsTruncated)
11154 Fill(Stream_General, 0, "IsTruncated", "Yes", Unlimited, true, true);
11155 #endif //MEDIAINFO_ADVANCED
11156 }
11157
11158 PartitionPack_AlreadyParsed.insert(File_Offset+Buffer_Offset-Header_Size);
11159 }
11160
11161 //---------------------------------------------------------------------------
11162 // 0x3B03
Preface_ContentStorage()11163 void File_Mxf::Preface_ContentStorage()
11164 {
11165 //Parsing
11166 int128u Data;
11167 Get_UUID(Data, "Data"); Element_Info1(Ztring().From_UUID(Data));
11168
11169 FILLING_BEGIN();
11170 Prefaces[Preface_Current].ContentStorage=Data;
11171 FILLING_END();
11172 }
11173
11174 //---------------------------------------------------------------------------
11175 // 0x3B05
Preface_Version()11176 void File_Mxf::Preface_Version()
11177 {
11178 //Parsing
11179 Info_B1(Major, "Major"); //1
11180 Info_B1(Minor, "Minor"); //2
11181 Element_Info1(Ztring::ToZtring(Major)+__T('.')+Ztring::ToZtring(Minor));
11182 }
11183
11184 //---------------------------------------------------------------------------
11185 // 0x3B06
Preface_Identifications()11186 void File_Mxf::Preface_Identifications()
11187 {
11188 //Parsing
11189 if (Vector(16)==(int32u)-1)
11190 return;
11191 while (Element_Offset<Element_Size)
11192 {
11193 Element_Begin1("Identification");
11194 int128u Data;
11195 Get_UUID(Data, "UUID"); Element_Info1(Ztring().From_UUID(Data));
11196 Element_End0();
11197
11198 FILLING_BEGIN();
11199 Prefaces[Preface_Current].Identifications.push_back(Data);
11200 FILLING_END();
11201 }
11202 }
11203
11204 //---------------------------------------------------------------------------
11205 // 0x3B07
Preface_ObjectModelVersion()11206 void File_Mxf::Preface_ObjectModelVersion()
11207 {
11208 //Parsing
11209 Skip_B4( "Data");
11210 }
11211
11212 //---------------------------------------------------------------------------
11213 // 0x3B08
Preface_PrimaryPackage()11214 void File_Mxf::Preface_PrimaryPackage()
11215 {
11216 //Parsing
11217 int128u Data;
11218 Get_UUID(Data, "Data");
11219
11220 FILLING_BEGIN();
11221 Prefaces[Preface_Current].PrimaryPackage=Data;
11222 FILLING_END();
11223 }
11224
11225 //---------------------------------------------------------------------------
11226 // 0x3B09
Preface_OperationalPattern()11227 void File_Mxf::Preface_OperationalPattern()
11228 {
11229 //Parsing
11230 Get_UL (OperationalPattern, "UUID", Mxf_OperationalPattern); Element_Info1(Mxf_OperationalPattern(OperationalPattern));
11231 }
11232
11233 //---------------------------------------------------------------------------
11234 // 0x3B0A
Preface_EssenceContainers()11235 void File_Mxf::Preface_EssenceContainers()
11236 {
11237 //Parsing
11238 if (Vector(16)==(int32u)-1)
11239 return;
11240 while (Element_Offset<Element_Size)
11241 {
11242 Info_UL(EssenceContainer, "EssenceContainer", Mxf_EssenceContainer);
11243 }
11244 }
11245
11246 //---------------------------------------------------------------------------
11247 // 0x3B0B
Preface_DMSchemes()11248 void File_Mxf::Preface_DMSchemes()
11249 {
11250 //Parsing
11251 int32u Length;
11252 if ((Length=Vector())==(int32u)-1)
11253 return;
11254 while (Element_Offset<Element_Size)
11255 if (Length==16)
11256 {
11257 Info_UL(Data, "DMScheme", NULL); Element_Info1(Ztring().From_UUID(Data));
11258 }
11259 else
11260 Skip_XX(Length, "DMScheme");
11261 }
11262
11263 //---------------------------------------------------------------------------
11264 // 0x3401
RGBAEssenceDescriptor_PixelLayout()11265 void File_Mxf::RGBAEssenceDescriptor_PixelLayout()
11266 {
11267 //Parsing
11268 Info_B4(Data, "Data"); Element_Info1(Data);
11269 }
11270
11271 //---------------------------------------------------------------------------
11272 // 0x3403
RGBAEssenceDescriptor_Palette()11273 void File_Mxf::RGBAEssenceDescriptor_Palette()
11274 {
11275 //Parsing
11276 Info_B4(Data, "Data"); Element_Info1(Data);
11277 }
11278
11279 //---------------------------------------------------------------------------
11280 // 0x3404
RGBAEssenceDescriptor_PaletteLayout()11281 void File_Mxf::RGBAEssenceDescriptor_PaletteLayout()
11282 {
11283 //Parsing
11284 Info_B4(Data, "Data"); Element_Info1(Data);
11285 }
11286
11287 //---------------------------------------------------------------------------
11288 // 0x3405
RGBAEssenceDescriptor_ScanningDirection()11289 void File_Mxf::RGBAEssenceDescriptor_ScanningDirection()
11290 {
11291 //Parsing
11292 Info_B1(Data, "Data"); Element_Info1(Data);
11293 }
11294
11295 //---------------------------------------------------------------------------
11296 // 0x3406
RGBAEssenceDescriptor_ComponentMaxRef()11297 void File_Mxf::RGBAEssenceDescriptor_ComponentMaxRef()
11298 {
11299 //Parsing
11300 int32u Data;
11301 Get_B4 (Data, "Data"); Element_Info1(Data);
11302
11303 FILLING_BEGIN();
11304 if (Descriptors[InstanceUID].MaxRefLevel==(int32u)-1)
11305 Descriptors[InstanceUID].MaxRefLevel=Data;
11306 ColorLevels_Compute(Descriptors.find(InstanceUID));
11307 FILLING_END();
11308 }
11309
11310 //---------------------------------------------------------------------------
11311 // 0x3407
RGBAEssenceDescriptor_ComponentMinRef()11312 void File_Mxf::RGBAEssenceDescriptor_ComponentMinRef()
11313 {
11314 //Parsing
11315 int32u Data;
11316 Get_B4 (Data, "Data"); Element_Info1(Data);
11317
11318 FILLING_BEGIN();
11319 if (Descriptors[InstanceUID].MinRefLevel==(int32u)-1)
11320 Descriptors[InstanceUID].MinRefLevel=Data;
11321 ColorLevels_Compute(Descriptors.find(InstanceUID));
11322 FILLING_END();
11323 }
11324
11325 //---------------------------------------------------------------------------
11326 // 0x3408
RGBAEssenceDescriptor_AlphaMaxRef()11327 void File_Mxf::RGBAEssenceDescriptor_AlphaMaxRef()
11328 {
11329 //Parsing
11330 Info_B4(Data, "Data"); Element_Info1(Data);
11331 }
11332
11333 //---------------------------------------------------------------------------
11334 // 0x3409
RGBAEssenceDescriptor_AlphaMinRef()11335 void File_Mxf::RGBAEssenceDescriptor_AlphaMinRef()
11336 {
11337 //Parsing
11338 Info_B4(Data, "Data"); Element_Info1(Data);
11339 }
11340
11341 //---------------------------------------------------------------------------
11342 // 0x1001
Sequence_StructuralComponents()11343 void File_Mxf::Sequence_StructuralComponents()
11344 {
11345 Components[InstanceUID].StructuralComponents.clear();
11346
11347 //Parsing
11348 if (Vector(16)==(int32u)-1)
11349 return;
11350 while (Element_Offset<Element_Size)
11351 {
11352 int128u Data;
11353 Get_UUID (Data, "StructuralComponent");
11354
11355 FILLING_BEGIN();
11356 Components[InstanceUID].StructuralComponents.push_back(Data);
11357 FILLING_END();
11358 }
11359 }
11360
11361 //---------------------------------------------------------------------------
11362 // 0x1101
SourceClip_SourcePackageID()11363 void File_Mxf::SourceClip_SourcePackageID()
11364 {
11365 //Parsing
11366 int256u Data;
11367 Get_UMID(Data, "SourcePackageID");
11368
11369 FILLING_BEGIN();
11370 Components[InstanceUID].SourcePackageID=Data;
11371 FILLING_END();
11372 }
11373
11374 //---------------------------------------------------------------------------
11375 // 0x1102
SourceClip_SourceTrackID()11376 void File_Mxf::SourceClip_SourceTrackID()
11377 {
11378 //Parsing
11379 int32u Data;
11380 Get_B4 (Data, "SourceTrackID"); Element_Info1(Data);
11381
11382 FILLING_BEGIN();
11383 if (Components[InstanceUID].SourceTrackID==(int32u)-1)
11384 Components[InstanceUID].SourceTrackID=Data;
11385 FILLING_END();
11386 }
11387
11388 //---------------------------------------------------------------------------
11389 // 0x1201
SourceClip_StartPosition()11390 void File_Mxf::SourceClip_StartPosition()
11391 {
11392 //Parsing
11393 Info_B8(Data, "StartPosition"); Element_Info1(Data); //units of edit rate
11394 }
11395
11396 //---------------------------------------------------------------------------
11397 // 0x4701
SourcePackage_Descriptor()11398 void File_Mxf::SourcePackage_Descriptor()
11399 {
11400 //Parsing
11401 int128u Data;
11402 Get_UUID(Data, "Data"); Element_Info1(Ztring().From_UUID(Data));
11403
11404 FILLING_BEGIN();
11405 Packages[InstanceUID].Descriptor=Data;
11406 FILLING_END();
11407 }
11408
11409 //---------------------------------------------------------------------------
11410 // 0x0201
StructuralComponent_DataDefinition()11411 void File_Mxf::StructuralComponent_DataDefinition()
11412 {
11413 //Parsing
11414 Info_UL(Data, "Data", Mxf_Sequence_DataDefinition); Element_Info1(Mxf_Sequence_DataDefinition(Data));
11415 }
11416
11417 //---------------------------------------------------------------------------
11418 // 0x0202
StructuralComponent_Duration()11419 void File_Mxf::StructuralComponent_Duration()
11420 {
11421 //Parsing
11422 int64u Data;
11423 Get_B8 (Data, "Data"); Element_Info1(Data); //units of edit rate
11424
11425 FILLING_BEGIN();
11426 if (Data!=0xFFFFFFFFFFFFFFFFLL)
11427 Components[InstanceUID].Duration=Data;
11428 FILLING_END();
11429 }
11430
11431 //---------------------------------------------------------------------------
11432 // 0x0101
SystemScheme1_FrameCount()11433 void File_Mxf::SystemScheme1_FrameCount()
11434 {
11435 //Parsing
11436 Skip_B4( "Value");
11437 }
11438
11439 //---------------------------------------------------------------------------
11440 // 0x0102
SystemScheme1_TimeCodeArray()11441 void File_Mxf::SystemScheme1_TimeCodeArray()
11442 {
11443 //Parsing
11444 if (Vector(8)==(int32u)-1)
11445 return;
11446 while (Element_Offset<Element_Size)
11447 {
11448 Element_Begin1("TimeCode");
11449 int8u Frames_Units, Frames_Tens, Seconds_Units, Seconds_Tens, Minutes_Units, Minutes_Tens, Hours_Units, Hours_Tens;
11450 bool DropFrame;
11451 BS_Begin();
11452
11453 Skip_SB( "CF - Color fame");
11454 Get_SB ( DropFrame, "DP - Drop frame");
11455 Get_S1 (2, Frames_Tens, "Frames (Tens)");
11456 Get_S1 (4, Frames_Units, "Frames (Units)");
11457
11458 Skip_SB( "FP - Field Phase / BGF0");
11459 Get_S1 (3, Seconds_Tens, "Seconds (Tens)");
11460 Get_S1 (4, Seconds_Units, "Seconds (Units)");
11461
11462 Skip_SB( "BGF0 / BGF2");
11463 Get_S1 (3, Minutes_Tens, "Minutes (Tens)");
11464 Get_S1 (4, Minutes_Units, "Minutes (Units)");
11465
11466 Skip_SB( "BGF2 / Field Phase");
11467 Skip_SB( "BGF1");
11468 Get_S1 (2, Hours_Tens, "Hours (Tens)");
11469 Get_S1 (4, Hours_Units, "Hours (Units)");
11470
11471 Skip_S1(4, "BG2");
11472 Skip_S1(4, "BG1");
11473
11474 Skip_S1(4, "BG4");
11475 Skip_S1(4, "BG3");
11476
11477 Skip_S1(4, "BG6");
11478 Skip_S1(4, "BG5");
11479
11480 Skip_S1(4, "BG8");
11481 Skip_S1(4, "BG7");
11482
11483 BS_End();
11484
11485 int64u TimeCode=(int64u)(Hours_Tens *10*60*60*1000
11486 + Hours_Units *60*60*1000
11487 + Minutes_Tens *10*60*1000
11488 + Minutes_Units *60*1000
11489 + Seconds_Tens *10*1000
11490 + Seconds_Units *1000
11491 + (SystemScheme1_FrameRateFromDescriptor?float64_int32s((Frames_Tens*10+Frames_Units)*1000/(float64)SystemScheme1_FrameRateFromDescriptor):0));
11492
11493 Element_Info1(Ztring().Duration_From_Milliseconds(TimeCode));
11494
11495 Element_End0();
11496
11497 //TimeCode
11498 if (SystemScheme1_TimeCodeArray_StartTimecode_ms==(int64u)-1 && !IsParsingEnd && IsParsingMiddle_MaxOffset==(int64u)-1)
11499 {
11500 SystemScheme1_TimeCodeArray_StartTimecode_ms=TimeCode;
11501
11502 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Hours_Tens);
11503 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Hours_Units);
11504 SystemScheme1_TimeCodeArray_StartTimecode+=':';
11505 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Minutes_Tens);
11506 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Minutes_Units);
11507 SystemScheme1_TimeCodeArray_StartTimecode+=':';
11508 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Seconds_Tens);
11509 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Seconds_Units);
11510 SystemScheme1_TimeCodeArray_StartTimecode+=DropFrame?';':':';
11511 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Frames_Tens);
11512 SystemScheme1_TimeCodeArray_StartTimecode+=('0'+Frames_Units);
11513 }
11514 }
11515
11516 SystemSchemes[Element_Code&0xFFFF].IsTimeCode=true;
11517 }
11518
11519 //---------------------------------------------------------------------------
11520 // 0x0103
SystemScheme1_ClipIDArray()11521 void File_Mxf::SystemScheme1_ClipIDArray()
11522 {
11523 //Parsing
11524 if (Vector(32)==(int32u)-1)
11525 return;
11526 while (Element_Offset<Element_Size)
11527 {
11528 Skip_UMID( );
11529 }
11530 }
11531
11532 //---------------------------------------------------------------------------
11533 // 0x0104
SystemScheme1_ExtendedClipIDArray()11534 void File_Mxf::SystemScheme1_ExtendedClipIDArray()
11535 {
11536 //Parsing
11537 if (Vector(64)==(int32u)-1)
11538 return;
11539 while (Element_Offset<Element_Size)
11540 {
11541 Skip_UMID( ); //ExtUMID (ToDo: merge)
11542 Skip_UMID( );
11543 }
11544 }
11545
11546 //---------------------------------------------------------------------------
11547 // 0x0105
SystemScheme1_VideoIndexArray()11548 void File_Mxf::SystemScheme1_VideoIndexArray()
11549 {
11550 //Parsing
11551 int32u Length;
11552 if ((Length=Vector())==(int32u)-1)
11553 return;
11554 while (Element_Offset<Element_Size)
11555 {
11556 Skip_XX(Length, "Video Index");
11557 }
11558 }
11559
11560 //---------------------------------------------------------------------------
11561 // 0x0106
SystemScheme1_KLVMetadataSequence()11562 void File_Mxf::SystemScheme1_KLVMetadataSequence()
11563 {
11564 Skip_XX(Element_Size, "KLV");
11565 }
11566
11567 //---------------------------------------------------------------------------
11568 // 0x3001
SystemScheme1_SampleRate()11569 void File_Mxf::SystemScheme1_SampleRate()
11570 {
11571 //Parsing
11572 Skip_B8( "Value");
11573 }
11574
11575 //---------------------------------------------------------------------------
11576 // 0x4804
SystemScheme1_EssenceTrackNumber()11577 void File_Mxf::SystemScheme1_EssenceTrackNumber()
11578 {
11579 //Parsing
11580 Skip_B4( "Value");
11581 }
11582
11583 //---------------------------------------------------------------------------
11584 // 0x6801
SystemScheme1_EssenceTrackNumberBatch()11585 void File_Mxf::SystemScheme1_EssenceTrackNumberBatch()
11586 {
11587 //Parsing
11588 if (Vector(4)==(int32u)-1)
11589 return;
11590 while (Element_Offset<Element_Size)
11591 {
11592 Skip_B4( "Track Number");
11593 }
11594 }
11595
11596 //---------------------------------------------------------------------------
11597 // 0x6803
SystemScheme1_ContentPackageIndexArray()11598 void File_Mxf::SystemScheme1_ContentPackageIndexArray()
11599 {
11600 //Parsing
11601 int32u Length;
11602 if ((Length=Vector())==(int32u)-1)
11603 return;
11604 while (Element_Offset<Element_Size)
11605 {
11606 Skip_XX(Length, "Index Entry");
11607 }
11608 }
11609
11610 //---------------------------------------------------------------------------
11611 // 0x4101
TextLocator_LocatorName()11612 void File_Mxf::TextLocator_LocatorName()
11613 {
11614 //Parsing
11615 Ztring Data;
11616 Get_UTF16B (Length2, Data, "Data"); Element_Info1(Data);
11617
11618 FILLING_BEGIN();
11619 Locators[InstanceUID].EssenceLocator=Data;
11620 Locators[InstanceUID].IsTextLocator=true;
11621 FILLING_END();
11622 }
11623
11624 //---------------------------------------------------------------------------
11625 // 0x1501
TimecodeComponent_StartTimecode()11626 void File_Mxf::TimecodeComponent_StartTimecode()
11627 {
11628 //Parsing
11629 int64u Data;
11630 Get_B8 (Data, "Data"); Element_Info1(Data);
11631
11632 FILLING_BEGIN();
11633 if (Data!=(int64u)-1)
11634 {
11635 MxfTimeCodeForDelay.StartTimecode=Data;
11636 if (MxfTimeCodeForDelay.RoundedTimecodeBase)
11637 {
11638 DTS_Delay=((float64)MxfTimeCodeForDelay.StartTimecode)/MxfTimeCodeForDelay.RoundedTimecodeBase;
11639 if (MxfTimeCodeForDelay.DropFrame)
11640 {
11641 DTS_Delay*=1001;
11642 DTS_Delay/=1000;
11643 }
11644 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000);
11645 #if MEDIAINFO_DEMUX
11646 Config->Demux_Offset_DTS_FromStream=FrameInfo.DTS;
11647 #endif //MEDIAINFO_DEMUX
11648 }
11649 }
11650
11651 Components[InstanceUID].MxfTimeCode.StartTimecode=Data;
11652 FILLING_END();
11653 }
11654
11655 //---------------------------------------------------------------------------
11656 // 0x1502
TimecodeComponent_RoundedTimecodeBase()11657 void File_Mxf::TimecodeComponent_RoundedTimecodeBase()
11658 {
11659 //Parsing
11660 int16u Data;
11661 Get_B2 (Data, "Data"); Element_Info1(Data);
11662
11663 FILLING_BEGIN();
11664 if (Data && Data!=(int16u)-1)
11665 {
11666 MxfTimeCodeForDelay.RoundedTimecodeBase=Data;
11667 if (MxfTimeCodeForDelay.StartTimecode!=(int64u)-1)
11668 {
11669 DTS_Delay=((float64)MxfTimeCodeForDelay.StartTimecode)/MxfTimeCodeForDelay.RoundedTimecodeBase;
11670 if (MxfTimeCodeForDelay.DropFrame)
11671 {
11672 DTS_Delay*=1001;
11673 DTS_Delay/=1000;
11674 }
11675 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000);
11676 #if MEDIAINFO_DEMUX
11677 Config->Demux_Offset_DTS_FromStream=FrameInfo.DTS;
11678 #endif //MEDIAINFO_DEMUX
11679 }
11680 }
11681
11682 Components[InstanceUID].MxfTimeCode.RoundedTimecodeBase=Data;
11683 FILLING_END();
11684 }
11685
11686 //---------------------------------------------------------------------------
11687 // 0x1503
TimecodeComponent_DropFrame()11688 void File_Mxf::TimecodeComponent_DropFrame()
11689 {
11690 //Parsing
11691 int8u Data;
11692 Get_B1 (Data, "Data"); Element_Info1(Data);
11693
11694 FILLING_BEGIN();
11695 if (Data!=(int8u)-1 && Data)
11696 {
11697 MxfTimeCodeForDelay.DropFrame=true;
11698 if (DTS_Delay)
11699 {
11700 DTS_Delay*=1001;
11701 DTS_Delay/=1000;
11702 }
11703 FrameInfo.DTS=float64_int64s(DTS_Delay*1000000000);
11704 #if MEDIAINFO_DEMUX
11705 Config->Demux_Offset_DTS_FromStream=FrameInfo.DTS;
11706 #endif //MEDIAINFO_DEMUX
11707 }
11708
11709 Components[InstanceUID].MxfTimeCode.DropFrame=Data?true:false;
11710 FILLING_END();
11711 }
11712
11713 //---------------------------------------------------------------------------
11714 // 0x4B01
Track_EditRate()11715 void File_Mxf::Track_EditRate()
11716 {
11717 //Parsing
11718 float64 Data;
11719 Get_Rational(Data); Element_Info1(Data);
11720
11721 FILLING_BEGIN();
11722 Tracks[InstanceUID].EditRate=Data;
11723 FILLING_END();
11724 }
11725
11726 //---------------------------------------------------------------------------
11727 // 0x4B02
Track_Origin()11728 void File_Mxf::Track_Origin()
11729 {
11730 //Parsing
11731 int64u Data;
11732 Get_B8 (Data, "Data"); Element_Info1(Data); //Note: Origin is signed but there is no signed Get_* in MediaInfo
11733
11734 FILLING_BEGIN();
11735 Tracks[InstanceUID].Origin=(int64s)Data; //Origin is signed
11736 FILLING_END();
11737 }
11738
11739 //---------------------------------------------------------------------------
11740 // 0x3D09
WaveAudioDescriptor_AvgBps()11741 void File_Mxf::WaveAudioDescriptor_AvgBps()
11742 {
11743 //Parsing
11744 int32u Data;
11745 Get_B4 (Data, "Data"); Element_Info1(Data);
11746
11747 FILLING_BEGIN();
11748 Descriptor_Fill("BitRate", Ztring().From_Number(Data*8));
11749 Descriptors[InstanceUID].ByteRate=Data;
11750 FILLING_END();
11751 }
11752
11753 //---------------------------------------------------------------------------
11754 // 0x3D0A
WaveAudioDescriptor_BlockAlign()11755 void File_Mxf::WaveAudioDescriptor_BlockAlign()
11756 {
11757 //Parsing
11758 int16u Data;
11759 Get_B2 (Data, "Data"); Element_Info1(Data);
11760
11761 FILLING_BEGIN();
11762 Descriptors[InstanceUID].BlockAlign=Data;
11763 FILLING_END();
11764 }
11765
11766 //---------------------------------------------------------------------------
11767 // 0x3D0B
WaveAudioDescriptor_SequenceOffset()11768 void File_Mxf::WaveAudioDescriptor_SequenceOffset()
11769 {
11770 //Parsing
11771 Info_B1(Data, "Data"); Element_Info1(Data);
11772 }
11773
11774 //---------------------------------------------------------------------------
11775 // 0x3D29
WaveAudioDescriptor_PeakEnvelopeVersion()11776 void File_Mxf::WaveAudioDescriptor_PeakEnvelopeVersion()
11777 {
11778 //Parsing
11779 Info_B4(Data, "Data"); Element_Info1(Data);
11780 }
11781
11782 //---------------------------------------------------------------------------
11783 // 0x3D2A
WaveAudioDescriptor_PeakEnvelopeFormat()11784 void File_Mxf::WaveAudioDescriptor_PeakEnvelopeFormat()
11785 {
11786 //Parsing
11787 Info_B4(Data, "Data"); Element_Info1(Data);
11788 }
11789
11790 //---------------------------------------------------------------------------
11791 // 0x3D2B
WaveAudioDescriptor_PointsPerPeakValue()11792 void File_Mxf::WaveAudioDescriptor_PointsPerPeakValue()
11793 {
11794 //Parsing
11795 Info_B4(Data, "Data"); Element_Info1(Data);
11796 }
11797
11798 //---------------------------------------------------------------------------
11799 // 0x3D2C
WaveAudioDescriptor_PeakEnvelopeBlockSize()11800 void File_Mxf::WaveAudioDescriptor_PeakEnvelopeBlockSize()
11801 {
11802 //Parsing
11803 Info_B4(Data, "Data"); Element_Info1(Data);
11804 }
11805
11806 //---------------------------------------------------------------------------
11807 // 0x3D2D
WaveAudioDescriptor_PeakChannels()11808 void File_Mxf::WaveAudioDescriptor_PeakChannels()
11809 {
11810 //Parsing
11811 Info_B4(Data, "Data"); Element_Info1(Data);
11812 }
11813
11814 //---------------------------------------------------------------------------
11815 // 0x3D2E
WaveAudioDescriptor_PeakFrames()11816 void File_Mxf::WaveAudioDescriptor_PeakFrames()
11817 {
11818 //Parsing
11819 Info_B4(Data, "Data"); Element_Info1(Data);
11820 }
11821
11822 //---------------------------------------------------------------------------
11823 // 0x3D2F
WaveAudioDescriptor_PeakOfPeaksPosition()11824 void File_Mxf::WaveAudioDescriptor_PeakOfPeaksPosition()
11825 {
11826 //Parsing
11827 Info_B8(Data, "Data"); Element_Info1(Data);
11828 }
11829
11830 //---------------------------------------------------------------------------
11831 // 0x3D30
WaveAudioDescriptor_PeakEnvelopeTimestamp()11832 void File_Mxf::WaveAudioDescriptor_PeakEnvelopeTimestamp()
11833 {
11834 //Parsing
11835 Info_Timestamp();
11836 }
11837
11838 //---------------------------------------------------------------------------
11839 // 0x3D31
WaveAudioDescriptor_PeakEnvelopeData()11840 void File_Mxf::WaveAudioDescriptor_PeakEnvelopeData()
11841 {
11842 //Parsing
11843 Skip_XX(Length2, "Data");
11844 }
11845
11846 //---------------------------------------------------------------------------
11847 // 0x3D32
WaveAudioDescriptor_ChannelAssignment()11848 void File_Mxf::WaveAudioDescriptor_ChannelAssignment()
11849 {
11850 //Parsing
11851 int128u Value;
11852 Get_UL (Value, "Value", Mxf_ChannelAssignment_ChannelLayout); Element_Info1(Mxf_ChannelAssignment_ChannelLayout(Value, Descriptors[InstanceUID].ChannelCount));
11853
11854 FILLING_BEGIN();
11855 Descriptors[InstanceUID].ChannelAssignment=Value;
11856
11857 //Descriptors[InstanceUID].Infos["ChannelLayout"]=Mxf_ChannelAssignment_ChannelLayout(Value, Descriptors[InstanceUID].ChannelCount);
11858 //Ztring ChannelLayoutID;
11859 //ChannelLayoutID.From_Number(Value.lo, 16);
11860 //if (ChannelLayoutID.size()<16)
11861 // ChannelLayoutID.insert(0, 16-ChannelLayoutID.size(), __T('0'));
11862 //Descriptors[InstanceUID].Infos["ChannelLayoutID"]=ChannelLayoutID;
11863 //Descriptors[InstanceUID].Infos["ChannelPositions"]=Mxf_ChannelAssignment_ChannelPositions(Value, Descriptors[InstanceUID].ChannelCount);
11864 //if (Descriptors[InstanceUID].Infos["ChannelPositions"].empty())
11865 // Descriptors[InstanceUID].Infos["ChannelPositions"]=ChannelLayoutID;
11866 //Descriptors[InstanceUID].Infos["ChannelPositions/String2"]=Mxf_ChannelAssignment_ChannelPositions2(Value, Descriptors[InstanceUID].ChannelCount);
11867 FILLING_END();
11868 }
11869
11870 //---------------------------------------------------------------------------
11871 //
LensUnitMetadata_IrisFNumber()11872 void File_Mxf::LensUnitMetadata_IrisFNumber()
11873 {
11874 //Parsing
11875 int16u Value;
11876 Get_B2(Value, "Value");
11877
11878 FILLING_BEGIN();
11879 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(std::pow(2, 8*(1-(float(Value)/0x10000))), 6).To_UTF8());
11880 FILLING_END();
11881 }
11882
11883 //---------------------------------------------------------------------------
11884 // Big Endian - float 16 bits
11885 // TODO: remove it when Linux version of ZenLib is updated
BigEndian2float16lens(const char * Liste)11886 float32 BigEndian2float16lens(const char* Liste)
11887 {
11888 //exponent 4 bit
11889 //significand 12 bit
11890
11891 //Retrieving data
11892 int16u Integer=BigEndian2int16s(Liste);
11893
11894 //Retrieving elements
11895 int Exponent=(Integer>>12)&0x0F;
11896 if (Exponent>=8)
11897 Exponent=-(((~Exponent)&0x7)+1);
11898 int32u Mantissa= Integer&0x0FFF;
11899
11900 //Some computing
11901 float64 Answer=((float64)Mantissa)*std::pow((float64)10, Exponent);
11902
11903 return (float32)Answer;
11904 }
BigEndian2float16lens(const int8u * List)11905 inline float32 BigEndian2float16lens(const int8u* List) {return BigEndian2float16lens((const char*)List);}
11906
11907 //---------------------------------------------------------------------------
11908 //
LensUnitMetadata_FocusPositionFromImagePlane()11909 void File_Mxf::LensUnitMetadata_FocusPositionFromImagePlane()
11910 {
11911 //Parsing
11912 float32 Value;
11913 Value=BigEndian2float16lens(Buffer+Buffer_Offset+(size_t)Element_Offset);
11914 Skip_B2( "Value");
11915
11916 FILLING_BEGIN();
11917 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value, 3).To_UTF8());
11918 FILLING_END();
11919 }
11920
11921 //---------------------------------------------------------------------------
11922 //
LensUnitMetadata_FocusPositionFromFrontLensVertex()11923 void File_Mxf::LensUnitMetadata_FocusPositionFromFrontLensVertex()
11924 {
11925 //Parsing
11926 float32 Value;
11927 Value=BigEndian2float16lens(Buffer+Buffer_Offset+(size_t)Element_Offset);
11928 Skip_B2( "Value");
11929
11930 FILLING_BEGIN();
11931 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value, 3).To_UTF8());
11932 FILLING_END();
11933 }
11934
11935 //---------------------------------------------------------------------------
11936 //
LensUnitMetadata_MacroSetting()11937 void File_Mxf::LensUnitMetadata_MacroSetting()
11938 {
11939 //Parsing
11940 int8u Value;
11941 Get_B1(Value, "Value");
11942
11943 FILLING_BEGIN();
11944 AcquisitionMetadata_Add(Code2, Value?"On":"Off");
11945 FILLING_END();
11946 }
11947
11948 //---------------------------------------------------------------------------
11949 //
LensUnitMetadata_LensZoom35mmStillCameraEquivalent()11950 void File_Mxf::LensUnitMetadata_LensZoom35mmStillCameraEquivalent()
11951 {
11952 //Parsing
11953 float32 Value;
11954 Value=BigEndian2float16lens(Buffer+Buffer_Offset+(size_t)Element_Offset);
11955 Skip_B2( "Value");
11956
11957 FILLING_BEGIN();
11958 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value*1000, 3).To_UTF8());
11959 FILLING_END();
11960 }
11961
11962 //---------------------------------------------------------------------------
11963 //
LensUnitMetadata_LensZoomActualFocalLength()11964 void File_Mxf::LensUnitMetadata_LensZoomActualFocalLength()
11965 {
11966 //Parsing
11967 float32 Value;
11968 Value=BigEndian2float16lens(Buffer+Buffer_Offset+(size_t)Element_Offset);
11969 Skip_B2( "Value");
11970
11971 FILLING_BEGIN();
11972 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value * 1000, 3).To_UTF8());
11973 FILLING_END();
11974 }
11975
11976 //---------------------------------------------------------------------------
11977 //
LensUnitMetadata_OpticalExtenderMagnification()11978 void File_Mxf::LensUnitMetadata_OpticalExtenderMagnification()
11979 {
11980 //Parsing
11981 int16u Value;
11982 Get_B2(Value, "Value");
11983
11984 FILLING_BEGIN();
11985 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
11986 FILLING_END();
11987 }
11988
11989 //---------------------------------------------------------------------------
11990 //
LensUnitMetadata_LensAttributes()11991 void File_Mxf::LensUnitMetadata_LensAttributes()
11992 {
11993 //Parsing
11994 Ztring Value;
11995 Get_UTF8(Length2, Value, "Value");
11996
11997 FILLING_BEGIN();
11998 AcquisitionMetadata_Add(Code2, Value.To_UTF8());
11999 FILLING_END();
12000 }
12001
12002 //---------------------------------------------------------------------------
12003 //
LensUnitMetadata_IrisTNumber()12004 void File_Mxf::LensUnitMetadata_IrisTNumber()
12005 {
12006 //Parsing
12007 int16u Value;
12008 Get_B2(Value, "Value");
12009
12010 FILLING_BEGIN();
12011 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(std::pow(2, 8*(1-(float(Value)/0x10000))), 6).To_UTF8());
12012 FILLING_END();
12013 }
12014
12015 //---------------------------------------------------------------------------
12016 //
LensUnitMetadata_IrisRingPosition()12017 void File_Mxf::LensUnitMetadata_IrisRingPosition()
12018 {
12019 //Parsing
12020 int16u Value;
12021 Get_B2(Value, "Value");
12022
12023 FILLING_BEGIN();
12024 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float)Value)/65536*100, 4).To_UTF8());
12025 FILLING_END();
12026 }
12027
12028 //---------------------------------------------------------------------------
12029 //
LensUnitMetadata_FocusRingPosition()12030 void File_Mxf::LensUnitMetadata_FocusRingPosition()
12031 {
12032 //Parsing
12033 int16u Value;
12034 Get_B2(Value, "Value");
12035
12036 FILLING_BEGIN();
12037 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float)Value)/65536*100, 4).To_UTF8());
12038 FILLING_END();
12039 }
12040
12041 //---------------------------------------------------------------------------
12042 //
LensUnitMetadata_ZoomRingPosition()12043 void File_Mxf::LensUnitMetadata_ZoomRingPosition()
12044 {
12045 //Parsing
12046 int16u Value;
12047 Get_B2(Value, "Value");
12048
12049 FILLING_BEGIN();
12050 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float)Value)/65536*100, 4).To_UTF8());
12051 FILLING_END();
12052 }
12053
12054 //---------------------------------------------------------------------------
12055 //
CameraUnitMetadata_CaptureGammaEquation()12056 void File_Mxf::CameraUnitMetadata_CaptureGammaEquation()
12057 {
12058 //Parsing
12059 int128u Value;
12060 Get_UUID(Value, "Value");
12061
12062 FILLING_BEGIN();
12063 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_CaptureGammaEquation(Value));
12064 FILLING_END();
12065 }
12066
12067 //---------------------------------------------------------------------------
12068 //
CameraUnitMetadata_AutoExposureMode()12069 void File_Mxf::CameraUnitMetadata_AutoExposureMode()
12070 {
12071 //Parsing
12072 int128u Value;
12073 Get_UUID(Value, "Value");
12074
12075 FILLING_BEGIN();
12076 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_AutoExposureMode(Value));
12077 FILLING_END();
12078 }
12079
12080 //---------------------------------------------------------------------------
12081 //
CameraUnitMetadata_AutoFocusSensingAreaSetting()12082 void File_Mxf::CameraUnitMetadata_AutoFocusSensingAreaSetting()
12083 {
12084 //Parsing
12085 int8u Value;
12086 Get_B1(Value, "Value");
12087
12088 FILLING_BEGIN();
12089 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_AutoFocusSensingAreaSetting(Value));
12090 FILLING_END();
12091 }
12092
12093 //---------------------------------------------------------------------------
12094 //
CameraUnitMetadata_ColorCorrectionFilterWheelSetting()12095 void File_Mxf::CameraUnitMetadata_ColorCorrectionFilterWheelSetting()
12096 {
12097 //Parsing
12098 int8u Value;
12099 Get_B1(Value, "Value");
12100
12101 FILLING_BEGIN();
12102 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_ColorCorrectionFilterWheelSetting(Value));
12103 FILLING_END();
12104 }
12105
12106 //---------------------------------------------------------------------------
12107 //
CameraUnitMetadata_NeutralDensityFilterWheelSetting()12108 void File_Mxf::CameraUnitMetadata_NeutralDensityFilterWheelSetting()
12109 {
12110 //Parsing
12111 int16u Value;
12112 Get_B2(Value, "Value"); Element_Info1(Mxf_CameraUnitMetadata_NeutralDensityFilterWheelSetting(Value).c_str());
12113
12114 FILLING_BEGIN();
12115 if (Value==1)
12116 AcquisitionMetadata_Add(Code2, "Clear");
12117 else
12118 AcquisitionMetadata_Add(Code2, "1/"+Ztring::ToZtring(Value).To_UTF8());
12119 FILLING_END();
12120 }
12121
12122 //---------------------------------------------------------------------------
12123 //
CameraUnitMetadata_ImageSensorDimensionEffectiveWidth()12124 void File_Mxf::CameraUnitMetadata_ImageSensorDimensionEffectiveWidth()
12125 {
12126 //Parsing
12127 int16u Value;
12128 Get_B2(Value, "Value");
12129
12130 FILLING_BEGIN();
12131 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float64)Value)/1000, 3).To_UTF8());
12132 FILLING_END();
12133 }
12134
12135 //---------------------------------------------------------------------------
12136 //
CameraUnitMetadata_ImageSensorDimensionEffectiveHeight()12137 void File_Mxf::CameraUnitMetadata_ImageSensorDimensionEffectiveHeight()
12138 {
12139 //Parsing
12140 int16u Value;
12141 Get_B2(Value, "Value");
12142
12143 FILLING_BEGIN();
12144 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float64)Value)/1000, 3).To_UTF8());
12145 FILLING_END();
12146 }
12147
12148 //---------------------------------------------------------------------------
12149 //
CameraUnitMetadata_CaptureFrameRate()12150 void File_Mxf::CameraUnitMetadata_CaptureFrameRate()
12151 {
12152 //Parsing
12153 float64 Value;
12154 Get_Rational(Value);
12155
12156 FILLING_BEGIN();
12157 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12158 FILLING_END();
12159 }
12160
12161 //---------------------------------------------------------------------------
12162 //
CameraUnitMetadata_ImageSensorReadoutMode()12163 void File_Mxf::CameraUnitMetadata_ImageSensorReadoutMode()
12164 {
12165 //Parsing
12166 int8u Value;
12167 Get_B1(Value, "Value");
12168
12169 FILLING_BEGIN();
12170 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_ImageSensorReadoutMode(Value));
12171 FILLING_END();
12172 }
12173
12174 //---------------------------------------------------------------------------
12175 //
CameraUnitMetadata_ShutterSpeed_Angle()12176 void File_Mxf::CameraUnitMetadata_ShutterSpeed_Angle()
12177 {
12178 //Parsing
12179 int32u Value;
12180 Get_B4(Value, "Value");
12181
12182 FILLING_BEGIN();
12183 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float)Value) / 60, 1).To_UTF8());
12184 FILLING_END();
12185 }
12186
12187 //---------------------------------------------------------------------------
12188 //
CameraUnitMetadata_ShutterSpeed_Time()12189 void File_Mxf::CameraUnitMetadata_ShutterSpeed_Time()
12190 {
12191 //Parsing
12192 int32u Num, Den;
12193 Get_B4(Num, "Num");
12194 Get_B4(Den, "Den");
12195
12196 FILLING_BEGIN();
12197 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Num).To_UTF8()+'/'+Ztring::ToZtring(Den).To_UTF8());
12198 FILLING_END();
12199 }
12200
12201 //---------------------------------------------------------------------------
12202 //
CameraUnitMetadata_CameraMasterGainAdjustment()12203 void File_Mxf::CameraUnitMetadata_CameraMasterGainAdjustment()
12204 {
12205 //Parsing
12206 int16u Value;
12207 Get_B2(Value, "Value");
12208
12209 FILLING_BEGIN();
12210 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float64)Value)/100, 2).To_UTF8());
12211 FILLING_END();
12212 }
12213
12214 //---------------------------------------------------------------------------
12215 //
CameraUnitMetadata_ISOSensitivity()12216 void File_Mxf::CameraUnitMetadata_ISOSensitivity()
12217 {
12218 //Parsing
12219 int16u Value;
12220 Get_B2(Value, "Value");
12221
12222 FILLING_BEGIN();
12223 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12224 FILLING_END();
12225 }
12226
12227 //---------------------------------------------------------------------------
12228 //
CameraUnitMetadata_ElectricalExtenderMagnification()12229 void File_Mxf::CameraUnitMetadata_ElectricalExtenderMagnification()
12230 {
12231 //Parsing
12232 int16u Value;
12233 Get_B2(Value, "Value");
12234
12235 FILLING_BEGIN();
12236 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12237 FILLING_END();
12238 }
12239
12240 //---------------------------------------------------------------------------
12241 //
CameraUnitMetadata_AutoWhiteBalanceMode()12242 void File_Mxf::CameraUnitMetadata_AutoWhiteBalanceMode()
12243 {
12244 //Parsing
12245 int8u Value;
12246 Get_B1(Value, "Value");
12247
12248 FILLING_BEGIN();
12249 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_AutoWhiteBalanceMode(Value));
12250 FILLING_END();
12251 }
12252
12253 //---------------------------------------------------------------------------
12254 //
CameraUnitMetadata_WhiteBalance()12255 void File_Mxf::CameraUnitMetadata_WhiteBalance()
12256 {
12257 //Parsing
12258 int16u Value;
12259 Get_B2(Value, "Value");
12260
12261 FILLING_BEGIN();
12262 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12263 FILLING_END();
12264 }
12265
12266 //---------------------------------------------------------------------------
12267 //
CameraUnitMetadata_CameraMasterBlackLevel()12268 void File_Mxf::CameraUnitMetadata_CameraMasterBlackLevel()
12269 {
12270 //Parsing
12271 int16u Value;
12272 Get_B2(Value, "Value");
12273
12274 FILLING_BEGIN();
12275 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float64)Value)/10, 1).To_UTF8());
12276 FILLING_END();
12277 }
12278
12279 //---------------------------------------------------------------------------
12280 //
CameraUnitMetadata_CameraKneePoint()12281 void File_Mxf::CameraUnitMetadata_CameraKneePoint()
12282 {
12283 //Parsing
12284 int16u Value;
12285 Get_B2(Value, "Value");
12286
12287 FILLING_BEGIN();
12288 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float64)Value)/10, 1).To_UTF8());
12289 FILLING_END();
12290 }
12291
12292 //---------------------------------------------------------------------------
12293 //
CameraUnitMetadata_CameraKneeSlope()12294 void File_Mxf::CameraUnitMetadata_CameraKneeSlope()
12295 {
12296 //Parsing
12297 float64 Value;
12298 Get_Rational(Value);
12299
12300 FILLING_BEGIN();
12301 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value, 3).To_UTF8());
12302 FILLING_END();
12303 }
12304
12305 //---------------------------------------------------------------------------
12306 //
CameraUnitMetadata_CameraLuminanceDynamicRange()12307 void File_Mxf::CameraUnitMetadata_CameraLuminanceDynamicRange()
12308 {
12309 //Parsing
12310 int16u Value;
12311 Get_B2(Value, "Value");
12312
12313 FILLING_BEGIN();
12314 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(((float64)Value)/10, 1).To_UTF8());
12315 FILLING_END();
12316 }
12317
12318 //---------------------------------------------------------------------------
12319 //
CameraUnitMetadata_CameraSettingFileURI()12320 void File_Mxf::CameraUnitMetadata_CameraSettingFileURI()
12321 {
12322 //Parsing
12323 Ztring Value;
12324 Get_UTF8(Length2, Value, "Value");
12325
12326 FILLING_BEGIN();
12327 AcquisitionMetadata_Add(Code2, Value.To_UTF8());
12328 FILLING_END();
12329 }
12330
12331 //---------------------------------------------------------------------------
12332 //
CameraUnitMetadata_CameraAttributes()12333 void File_Mxf::CameraUnitMetadata_CameraAttributes()
12334 {
12335 //Parsing
12336 Ztring Value;
12337 Get_UTF8(Length2, Value, "Value");
12338
12339 FILLING_BEGIN();
12340 AcquisitionMetadata_Add(Code2, Value.To_UTF8());
12341 FILLING_END();
12342 }
12343
12344 //---------------------------------------------------------------------------
12345 //
CameraUnitMetadata_ExposureIndexofPhotoMeter()12346 void File_Mxf::CameraUnitMetadata_ExposureIndexofPhotoMeter()
12347 {
12348 //Parsing
12349 int16u Value;
12350 Get_B2(Value, "Value");
12351
12352 FILLING_BEGIN();
12353 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12354 FILLING_END();
12355 }
12356
12357 //---------------------------------------------------------------------------
12358 //
CameraUnitMetadata_GammaForCDL()12359 void File_Mxf::CameraUnitMetadata_GammaForCDL()
12360 {
12361 //Parsing
12362 int8u Value;
12363 Get_B1(Value, "Value");
12364
12365 FILLING_BEGIN();
12366 AcquisitionMetadata_Add(Code2, Mxf_CameraUnitMetadata_GammaforCDL(Value));
12367 FILLING_END();
12368 }
12369
12370 //---------------------------------------------------------------------------
12371 //
CameraUnitMetadata_ASC_CDL_V12()12372 void File_Mxf::CameraUnitMetadata_ASC_CDL_V12()
12373 {
12374 //Parsing
12375 //Vector
12376 int32u Count, Length;
12377 Get_B4 (Count, "Count");
12378 Get_B4 (Length, "Length");
12379 if (Count!=10 || Length!=2)
12380 {
12381 Skip_XX (Length2-8, "Data");
12382 return;
12383 }
12384 float32 sR, sG, sB, oR, oG, oB, pR, pG, pB, sat;
12385 Get_BF2(sR, "sR");
12386 Get_BF2(sG, "sG");
12387 Get_BF2(sB, "sB");
12388 Get_BF2(oR, "oR");
12389 Get_BF2(oG, "oG");
12390 Get_BF2(oB, "oB");
12391 Get_BF2(pR, "pR");
12392 Get_BF2(pG, "pG");
12393 Get_BF2(pB, "pB");
12394 Get_BF2(sat, "sat");
12395
12396 FILLING_BEGIN();
12397 Ztring ValueS=__T("sR=")+Ztring::ToZtring(sR, 1)+__T(" sG=")+Ztring::ToZtring(sG, 1)+__T(" sB=")+Ztring::ToZtring(sB, 1)+__T(" oR=")+Ztring::ToZtring(oR, 1)+__T(" oG=")+Ztring::ToZtring(oG, 1)+__T(" oB=")+Ztring::ToZtring(oB, 1)+__T(" pR=")+Ztring::ToZtring(pR, 1)+__T(" pG=")+Ztring::ToZtring(pG, 1)+__T(" pB=")+Ztring::ToZtring(pB, 1)+__T(" sat=")+Ztring::ToZtring(sat, 1);
12398 AcquisitionMetadata_Add(Code2, ValueS.To_UTF8());
12399 FILLING_END();
12400 }
12401
12402 //---------------------------------------------------------------------------
12403 //
CameraUnitMetadata_ColorMatrix()12404 void File_Mxf::CameraUnitMetadata_ColorMatrix()
12405 {
12406 //Parsing
12407 //Vector
12408 int32u Count, Length;
12409 Get_B4 (Count, "Count");
12410 Get_B4 (Length, "Length");
12411 if (Count!=9 || Length!=8)
12412 {
12413 Skip_XX (Length2-8, "Data");
12414 return;
12415 }
12416 int32u RR_N, RR_D, GR_N, GR_D, BR_N, BR_D, RG_N, RG_D, GG_N, GG_D, BG_N, BG_D, RB_N, RB_D, GB_N, GB_D, BB_N, BB_D;
12417 Get_B4 (RR_N, "RR Num");
12418 Get_B4 (RR_D, "RR Den");
12419 Get_B4 (GR_N, "GR Num");
12420 Get_B4 (GR_D, "GR Den");
12421 Get_B4 (BR_N, "BR Num");
12422 Get_B4 (BR_D, "BR Den");
12423 Get_B4 (RG_N, "RG Num");
12424 Get_B4 (RG_D, "RG Den");
12425 Get_B4 (GG_N, "GG Num");
12426 Get_B4 (GG_D, "GG Den");
12427 Get_B4 (BG_N, "BG Num");
12428 Get_B4 (BG_D, "BG Den");
12429 Get_B4 (RB_N, "RB Num");
12430 Get_B4 (RB_D, "RB Den");
12431 Get_B4 (GB_N, "GB Num");
12432 Get_B4 (GB_D, "GB Den");
12433 Get_B4 (BB_N, "BB Num");
12434 Get_B4 (BB_D, "BB Den");
12435
12436 FILLING_BEGIN();
12437 Ztring ValueS=__T("RR=")+Ztring::ToZtring(((float)RR_N)/RR_D, 3)+__T(" GR=")+Ztring::ToZtring(((float)GR_N)/GR_D, 3)+__T(" BR=")+Ztring::ToZtring(((float)BR_N)/BR_D, 3)
12438 + __T(" RG=")+Ztring::ToZtring(((float)RG_N)/RG_D, 3)+__T(" GG=")+Ztring::ToZtring(((float)GG_N)/GG_D, 3)+__T(" BG=")+Ztring::ToZtring(((float)BG_N)/BG_D, 3)
12439 + __T(" RB=")+Ztring::ToZtring(((float)RB_N)/RB_D, 3)+__T(" GB=")+Ztring::ToZtring(((float)GB_N)/GB_D, 3)+__T(" BB=")+Ztring::ToZtring(((float)BB_N)/BB_D, 3);
12440 AcquisitionMetadata_Add(Code2, ValueS.To_UTF8());
12441 FILLING_END();
12442 }
12443
12444 //---------------------------------------------------------------------------
12445 //
UserDefinedAcquisitionMetadata_UdamSetIdentifier()12446 void File_Mxf::UserDefinedAcquisitionMetadata_UdamSetIdentifier()
12447 {
12448 //Parsing
12449 int128u Value;
12450 Get_UUID(Value, "Value");
12451
12452 FILLING_BEGIN();
12453 if ((Value.hi==0x966908004678031CLL && Value.lo==0x20500000F0C01181LL)
12454 || (Value.hi==0x966908004678031CLL && Value.lo==0x20500002F0C01181LL)) //Found Sony metadata with 00 or 02, what is the difference?
12455 UserDefinedAcquisitionMetadata_UdamSetIdentifier_IsSony=true;
12456 FILLING_END();
12457 }
12458
12459 //---------------------------------------------------------------------------
12460 //
UserDefinedAcquisitionMetadata_Sony_E101()12461 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E101()
12462 {
12463 //Parsing
12464 int32u Width, Height;
12465 Get_B4 (Width, "Width");
12466 Get_B4 (Height, "Height");
12467
12468 FILLING_BEGIN();
12469 AcquisitionMetadata_Add(Code2, Ztring(Ztring::ToZtring(Width)+__T("x")+Ztring::ToZtring(Height)).To_UTF8());
12470 FILLING_END();
12471 }
12472
12473 //---------------------------------------------------------------------------
12474 //
UserDefinedAcquisitionMetadata_Sony_E102()12475 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E102()
12476 {
12477 //Parsing
12478 int32u Width, Height;
12479 Get_B4 (Width, "Width");
12480 Get_B4 (Height, "Height");
12481
12482 FILLING_BEGIN();
12483 AcquisitionMetadata_Add(Code2, Ztring(Ztring::ToZtring(Width)+__T("x")+Ztring::ToZtring(Height)).To_UTF8());
12484 FILLING_END();
12485 }
12486
12487 //---------------------------------------------------------------------------
12488 //
UserDefinedAcquisitionMetadata_Sony_E103()12489 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E103()
12490 {
12491 //Parsing
12492 int16u Value;
12493 Get_B2(Value, "Value");
12494
12495 FILLING_BEGIN();
12496 AcquisitionMetadata_Add(Code2, Mxf_AcquisitionMetadata_Sony_CameraProcessDiscriminationCode(Value));
12497 FILLING_END();
12498 }
12499
12500 //---------------------------------------------------------------------------
12501 //
UserDefinedAcquisitionMetadata_Sony_E104()12502 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E104()
12503 {
12504 //Parsing
12505 int8u Value;
12506 Get_B1(Value, "Value");
12507
12508 FILLING_BEGIN();
12509 AcquisitionMetadata_Add(Code2, Value?"On":"Off");
12510 FILLING_END();
12511 }
12512
12513 //---------------------------------------------------------------------------
12514 //
UserDefinedAcquisitionMetadata_Sony_E105()12515 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E105()
12516 {
12517 //Parsing
12518 int16u Value;
12519 Get_B2(Value, "Value");
12520
12521 FILLING_BEGIN();
12522 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12523 FILLING_END();
12524 }
12525
12526 //---------------------------------------------------------------------------
12527 //
UserDefinedAcquisitionMetadata_Sony_E106()12528 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E106()
12529 {
12530 //Parsing
12531 int16u Value;
12532 Get_B2(Value, "Value");
12533
12534 FILLING_BEGIN();
12535 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12536 FILLING_END();
12537 }
12538
12539 //---------------------------------------------------------------------------
12540 //
UserDefinedAcquisitionMetadata_Sony_E107()12541 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E107()
12542 {
12543 //Parsing
12544 int16u Value;
12545 Get_B2(Value, "Value");
12546
12547 FILLING_BEGIN();
12548 AcquisitionMetadata_Add(Code2, Ztring::ToZtring(Value).To_UTF8());
12549 FILLING_END();
12550 }
12551
12552 //---------------------------------------------------------------------------
12553 //
UserDefinedAcquisitionMetadata_Sony_E109()12554 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E109()
12555 {
12556 //Parsing
12557 Ztring Value;
12558 Get_UTF8(Length2, Value, "Value");
12559
12560 FILLING_BEGIN();
12561 AcquisitionMetadata_Add(Code2, Value.To_UTF8());
12562 FILLING_END();
12563 }
12564
12565 //---------------------------------------------------------------------------
12566 //
UserDefinedAcquisitionMetadata_Sony_E10B()12567 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E10B()
12568 {
12569 //Parsing
12570 int128u Value;
12571 Get_UUID(Value, "Value");
12572
12573 FILLING_BEGIN();
12574 Ztring ValueS;
12575 ValueS.From_Number(Value.lo, 16);
12576 if (ValueS.size()<16)
12577 ValueS.insert(0, 16-ValueS.size(), __T('0'));
12578 AcquisitionMetadata_Add(Code2, Mxf_AcquisitionMetadata_Sony_MonitoringBaseCurve(Value));
12579 FILLING_END();
12580 }
12581
12582 //---------------------------------------------------------------------------
12583 //
UserDefinedAcquisitionMetadata_Sony_E201()12584 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E201()
12585 {
12586 if (AcquisitionMetadata_Sony_E201_Lists.empty())
12587 AcquisitionMetadata_Sony_E201_Lists.resize(Mxf_AcquisitionMetadata_Sony_E201_ElementCount);
12588
12589 //Parsing
12590 Ztring FocusDistance, ApertureValue, ApertureScale, HyperfocalDistance, NearFocusDistance, FarFocusDistance, EntrancePupilPosition;
12591 string LensSerialNumber;
12592 int16u EffectiveFocaleLength, HorizontalFieldOfView, NormalizedZoomValue;
12593 if (Length2<27)
12594 {
12595 Skip_XX(Length2, "Unknown");
12596 return;
12597 }
12598 int64u End=Element_Offset+Length2;
12599 Skip_C1( "Tag");
12600 BS_Begin();
12601 Element_Begin1("Focus Distance");
12602 {
12603 int8u B1, B2, B3, B4;
12604 Mark_0();
12605 Mark_1();
12606 Get_S1 (6, B1, "1");
12607 Mark_0();
12608 Mark_1();
12609 Get_S1 (6, B2, "2");
12610 Mark_0();
12611 Mark_1();
12612 Get_S1 (6, B3, "3");
12613 Mark_0();
12614 Mark_1();
12615 Get_S1 (6, B4, "4");
12616 int32u Value=(B1<<18)|(B2<<12)|(B3<<6)|B4;
12617 if (Value==0xFFFFFF)
12618 FocusDistance=__T("Infinite");
12619 else
12620 switch (AcquisitionMetadata_Sony_CalibrationType)
12621 {
12622 case 1 : FocusDistance=Ztring::ToZtring(((float)Value)/10, 1); break;
12623 default: FocusDistance=Ztring::ToZtring(Value); break;
12624 }
12625 Element_Info1(FocusDistance);
12626 }
12627 Element_End0();
12628 Element_Begin1("Aperture Value");
12629 {
12630 int8u B1, B2;
12631 Mark_0();
12632 Mark_1();
12633 Get_S1 (6, B1, "1");
12634 Mark_0();
12635 Mark_1();
12636 Get_S1 (6, B2, "2");
12637 int16u Value=(B1<<6)|B2;
12638 ApertureValue.From_Number(((float)Value)/100, 2);
12639 Element_Info1(ApertureValue);
12640 }
12641 Element_End0();
12642 Element_Begin1("Aperture Scale");
12643 {
12644 int8u B1, B2, Fraction;
12645 Mark_1();
12646 Get_S1 (7, B2, "Integer 2");
12647 Mark_1();
12648 Get_S1 (1, B1, "Integer 1");
12649 Mark_0();
12650 Mark_0();
12651 Get_S1 (4, Fraction, "Fraction");
12652 int8u Value=((B1<<7)|B2);
12653 ApertureScale=__T("T ")+Ztring::ToZtring(((float)Value)/10, 2)+__T(" + ")+Ztring::ToZtring(Fraction)+__T("/10");
12654 Element_Info1(ApertureScale);
12655 }
12656 Element_End0();
12657 Element_Begin1("Effective Focale Length");
12658 {
12659 int8u B1, B2;
12660 Mark_0();
12661 Mark_1();
12662 Mark_0();
12663 Mark_0();
12664 Get_S1 (4, B1, "1");
12665 Mark_0();
12666 Mark_1();
12667 Get_S1 (6, B2, "2");
12668 EffectiveFocaleLength=(B1<<6)|B2;
12669 Element_Info2(EffectiveFocaleLength, "mm");
12670 }
12671 Element_End0();
12672 Element_Begin1("Hyperfocal Distance");
12673 {
12674 int8u B1, B2, B3, B4;
12675 Mark_0();
12676 Mark_1();
12677 Get_S1 (6, B1, "1");
12678 Mark_0();
12679 Mark_1();
12680 Get_S1 (6, B2, "2");
12681 Mark_0();
12682 Mark_1();
12683 Get_S1 (6, B3, "3");
12684 Mark_0();
12685 Mark_1();
12686 Get_S1 (6, B4, "4");
12687 int32u Value=(B1<<18)|(B2<<12)|(B3<<6)|B4;
12688 if (Value==0xFFFFFF)
12689 HyperfocalDistance=__T("Infinite");
12690 else
12691 switch (AcquisitionMetadata_Sony_CalibrationType)
12692 {
12693 case 1 : HyperfocalDistance=Ztring::ToZtring(((float)Value)/10, 1); break;
12694 default: HyperfocalDistance=Ztring::ToZtring(Value);
12695 }
12696 Element_Info1(HyperfocalDistance);
12697 }
12698 Element_End0();
12699 Element_Begin1("Near Focus Distance");
12700 {
12701 int8u B1, B2, B3, B4;
12702 Mark_0();
12703 Mark_1();
12704 Get_S1 (6, B1, "1");
12705 Mark_0();
12706 Mark_1();
12707 Get_S1 (6, B2, "2");
12708 Mark_0();
12709 Mark_1();
12710 Get_S1 (6, B3, "3");
12711 Mark_0();
12712 Mark_1();
12713 Get_S1 (6, B4, "4");
12714 int32u Value=(B1<<18)|(B2<<12)|(B3<<6)|B4;
12715 if (Value==0xFFFFFF)
12716 NearFocusDistance=__T("Infinite");
12717 else
12718 switch (AcquisitionMetadata_Sony_CalibrationType)
12719 {
12720 case 1 : NearFocusDistance=Ztring::ToZtring(((float)Value)/10, 1); break;
12721 default: NearFocusDistance=Ztring::ToZtring(Value);
12722 }
12723 Element_Info1(NearFocusDistance);
12724 }
12725 Element_End0();
12726 Element_Begin1("Far Focus Distance");
12727 {
12728 int8u B1, B2, B3, B4;
12729 Mark_0();
12730 Mark_1();
12731 Get_S1 (6, B1, "1");
12732 Mark_0();
12733 Mark_1();
12734 Get_S1 (6, B2, "2");
12735 Mark_0();
12736 Mark_1();
12737 Get_S1 (6, B3, "3");
12738 Mark_0();
12739 Mark_1();
12740 Get_S1 (6, B4, "4");
12741 int32u Value=(B1<<18)|(B2<<12)|(B3<<6)|B4;
12742 if (Value==0xFFFFFF)
12743 FarFocusDistance=__T("Infinite");
12744 else
12745 switch (AcquisitionMetadata_Sony_CalibrationType)
12746 {
12747 case 1 : FarFocusDistance=Ztring::ToZtring(((float)Value)/10, 1); break;
12748 default: FarFocusDistance=Ztring::ToZtring(Value);
12749 }
12750 Element_Info1(FarFocusDistance);
12751 }
12752 Element_End0();
12753 Element_Begin1("Horizontal Field of View");
12754 {
12755 int8u B1, B2;
12756 Mark_0();
12757 Mark_1();
12758 Mark_0();
12759 Get_S1 (5, B1, "1");
12760 Mark_0();
12761 Mark_1();
12762 Get_S1 (6, B2, "2");
12763 HorizontalFieldOfView=(B1<<6)|B2;
12764 Element_Info1(Ztring::ToZtring(((float)HorizontalFieldOfView)/10, 1));
12765 }
12766 Element_End0();
12767 Element_Begin1("Entrance Pupil Position");
12768 {
12769 int8u B1, B2;
12770 bool Minus;
12771 Mark_0();
12772 Mark_1();
12773 Get_SB (Minus, "Minus");
12774 Mark_0();
12775 Get_S1 (4, B1, "1");
12776 Mark_0();
12777 Mark_1();
12778 Get_S1 (6, B2, "2");
12779 int32u Value=(B1<<6)|B2;
12780 switch (AcquisitionMetadata_Sony_CalibrationType)
12781 {
12782 case 1 : EntrancePupilPosition=Ztring::ToZtring(((float)Value)/10, 1); break;
12783 default: EntrancePupilPosition=Ztring::ToZtring(Value);
12784 }
12785 Element_Info1(EntrancePupilPosition);
12786 }
12787 Element_End0();
12788 Element_Begin1("Normalized Zoom Value");
12789 {
12790 int8u B1, B2;
12791 Mark_0();
12792 Mark_1();
12793 Mark_0();
12794 Mark_0();
12795 Get_S1 (4, B1, "1");
12796 Mark_0();
12797 Mark_1();
12798 Get_S1 (6, B2, "2");
12799 NormalizedZoomValue=(B1<<6)|B2;
12800 Element_Info1(Ztring::ToZtring(((float)NormalizedZoomValue)/1000, 3));
12801 }
12802 Element_End0();
12803 BS_End();
12804 Skip_C1( "S");
12805 Get_String(9, LensSerialNumber, "Lens Serial Number");
12806 if (Element_Offset+2<End)
12807 Skip_XX(End-2-Element_Offset, "Unknown");
12808 Skip_C2( "Termination");
12809
12810 FILLING_BEGIN();
12811 // Values are internal MI
12812 AcquisitionMetadata_Sony_E201_Add(0, FocusDistance.To_UTF8());
12813 AcquisitionMetadata_Sony_E201_Add(1, ApertureValue.To_UTF8());
12814 AcquisitionMetadata_Sony_E201_Add(2, ApertureScale.To_UTF8());
12815 AcquisitionMetadata_Sony_E201_Add(3, Ztring::ToZtring(EffectiveFocaleLength).To_UTF8());
12816 AcquisitionMetadata_Sony_E201_Add(4, HyperfocalDistance.To_UTF8());
12817 AcquisitionMetadata_Sony_E201_Add(5, NearFocusDistance.To_UTF8());
12818 AcquisitionMetadata_Sony_E201_Add(6, FarFocusDistance.To_UTF8());
12819 AcquisitionMetadata_Sony_E201_Add(7, Ztring::ToZtring(((float)HorizontalFieldOfView)/10, 1).To_UTF8());
12820 AcquisitionMetadata_Sony_E201_Add(8, EntrancePupilPosition.To_UTF8());
12821 AcquisitionMetadata_Sony_E201_Add(9, Ztring::ToZtring(((float)NormalizedZoomValue)/1000, 3).To_UTF8());
12822 AcquisitionMetadata_Sony_E201_Add(10, LensSerialNumber);
12823 FILLING_END();
12824 }
12825
12826 //---------------------------------------------------------------------------
12827 //
UserDefinedAcquisitionMetadata_Sony_E202()12828 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E202()
12829 {
12830 //Parsing
12831 Ztring Value;
12832 Get_UTF8(Length2, Value, "Value");
12833
12834 FILLING_BEGIN();
12835 AcquisitionMetadata_Add(Code2, Value.To_UTF8());
12836 FILLING_END();
12837 }
12838
12839 //---------------------------------------------------------------------------
12840 //
UserDefinedAcquisitionMetadata_Sony_E203()12841 void File_Mxf::UserDefinedAcquisitionMetadata_Sony_E203()
12842 {
12843 //Parsing
12844 Get_B1(AcquisitionMetadata_Sony_CalibrationType, "Value");
12845
12846 FILLING_BEGIN();
12847 switch(AcquisitionMetadata_Sony_CalibrationType)
12848 {
12849 case 0 : AcquisitionMetadata_Add(Code2, "mm"); break;
12850 case 1 : AcquisitionMetadata_Add(Code2, "in"); break;
12851 default : AcquisitionMetadata_Add(Code2, Ztring::ToZtring(AcquisitionMetadata_Sony_CalibrationType).To_UTF8());
12852 }
12853 FILLING_END();
12854 }
12855
12856 //---------------------------------------------------------------------------
12857 // AAF
AS11_Core_SeriesTitle()12858 void File_Mxf::AS11_Core_SeriesTitle()
12859 {
12860 //Parsing
12861 Ztring Value;
12862 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
12863
12864 FILLING_BEGIN();
12865 AS11s[InstanceUID].SeriesTitle=Value;
12866 FILLING_END();
12867 }
12868
12869 //---------------------------------------------------------------------------
12870 // AAF
AS11_Core_ProgrammeTitle()12871 void File_Mxf::AS11_Core_ProgrammeTitle()
12872 {
12873 //Parsing
12874 Ztring Value;
12875 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
12876
12877 FILLING_BEGIN();
12878 AS11s[InstanceUID].ProgrammeTitle=Value;
12879 FILLING_END();
12880 }
12881
12882 //---------------------------------------------------------------------------
12883 // AAF
AS11_Core_EpisodeTitleNumber()12884 void File_Mxf::AS11_Core_EpisodeTitleNumber()
12885 {
12886 //Parsing
12887 Ztring Value;
12888 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
12889
12890 FILLING_BEGIN();
12891 AS11s[InstanceUID].EpisodeTitleNumber=Value;
12892 FILLING_END();
12893 }
12894
12895 //---------------------------------------------------------------------------
12896 // AAF
AS11_Core_ShimName()12897 void File_Mxf::AS11_Core_ShimName()
12898 {
12899 //Parsing
12900 Ztring Value;
12901 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
12902
12903 FILLING_BEGIN();
12904 AS11s[InstanceUID].ShimName=Value;
12905 FILLING_END();
12906 }
12907
12908 //---------------------------------------------------------------------------
12909 // AAF
AS11_Core_AudioTrackLayout()12910 void File_Mxf::AS11_Core_AudioTrackLayout()
12911 {
12912 //Parsing
12913 int8u Value;
12914 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_AudioTrackLayout_Count, Mxf_AS11_AudioTrackLayout[Value]);
12915
12916 FILLING_BEGIN();
12917 AS11s[InstanceUID].AudioTrackLayout=Value;
12918 FILLING_END();
12919 }
12920
12921 //---------------------------------------------------------------------------
12922 // AAF
AS11_Core_PrimaryAudioLanguage()12923 void File_Mxf::AS11_Core_PrimaryAudioLanguage()
12924 {
12925 //Parsing
12926 Ztring Value;
12927 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
12928
12929 FILLING_BEGIN();
12930 AS11s[InstanceUID].PrimaryAudioLanguage=Value;
12931 FILLING_END();
12932 }
12933
12934 //---------------------------------------------------------------------------
12935 // AAF
AS11_Core_ClosedCaptionsPresent()12936 void File_Mxf::AS11_Core_ClosedCaptionsPresent()
12937 {
12938 int8u Value;
12939 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
12940
12941 FILLING_BEGIN();
12942 AS11s[InstanceUID].ClosedCaptionsPresent=Value;
12943 FILLING_END();
12944 }
12945
12946 //---------------------------------------------------------------------------
12947 // AAF
AS11_Core_ClosedCaptionsType()12948 void File_Mxf::AS11_Core_ClosedCaptionsType()
12949 {
12950 //Parsing
12951 int8u Value;
12952 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_ClosedCaptionType_Count, Mxf_AS11_ClosedCaptionType[Value]);
12953
12954 FILLING_BEGIN();
12955 AS11s[InstanceUID].ClosedCaptionsType=Value;
12956 FILLING_END();
12957 }
12958
12959 //---------------------------------------------------------------------------
12960 // AAF
AS11_Core_ClosedCaptionsLanguage()12961 void File_Mxf::AS11_Core_ClosedCaptionsLanguage()
12962 {
12963 //Parsing
12964 Ztring Value;
12965 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
12966
12967 FILLING_BEGIN();
12968 AS11s[InstanceUID].ClosedCaptionsLanguage=Value;
12969 FILLING_END();
12970 }
12971
12972 //---------------------------------------------------------------------------
12973 // AAF
AS11_Core_ShimVersion()12974 void File_Mxf::AS11_Core_ShimVersion()
12975 {
12976 //Parsing
12977 int8u Major, Minor;
12978 Get_B1 (Major, "Major"); Element_Info1(Major);
12979 Get_B1 (Minor, "Minor"); Element_Info1(Minor);
12980
12981 FILLING_BEGIN();
12982 AS11s[InstanceUID].ShimVersion_Major=Major;
12983 AS11s[InstanceUID].ShimVersion_Minor=Minor;
12984 FILLING_END();
12985 }
12986
12987 //---------------------------------------------------------------------------
12988 // AAF
AS11_Segment_PartNumber()12989 void File_Mxf::AS11_Segment_PartNumber()
12990 {
12991 //Parsing
12992 int16u Value;
12993 Get_B2 (Value, "Value"); Element_Info1(Value);
12994
12995 FILLING_BEGIN();
12996 AS11s[InstanceUID].PartNumber=Value;
12997 FILLING_END();
12998 }
12999
13000 //---------------------------------------------------------------------------
13001 // AAF
AS11_Segment_PartTotal()13002 void File_Mxf::AS11_Segment_PartTotal()
13003 {
13004 //Parsing
13005 int16u Value;
13006 Get_B2 (Value, "Value"); Element_Info1(Value);
13007
13008 FILLING_BEGIN();
13009 AS11s[InstanceUID].PartTotal=Value;
13010 FILLING_END();
13011 }
13012
13013 //---------------------------------------------------------------------------
13014 // DPP .010101010100
AS11_UKDPP_ProductionNumber()13015 void File_Mxf::AS11_UKDPP_ProductionNumber()
13016 {
13017 //Parsing
13018 Ztring Value;
13019 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13020
13021 FILLING_BEGIN();
13022 AS11s[InstanceUID].ProductionNumber=Value;
13023 FILLING_END();
13024 }
13025
13026 //---------------------------------------------------------------------------
13027 // DPP .010101010200
AS11_UKDPP_Synopsis()13028 void File_Mxf::AS11_UKDPP_Synopsis()
13029 {
13030 //Parsing
13031 Ztring Value;
13032 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13033
13034 FILLING_BEGIN();
13035 AS11s[InstanceUID].Synopsis=Value;
13036 FILLING_END();
13037 }
13038
13039 //---------------------------------------------------------------------------
13040 // DPP .010101010300
AS11_UKDPP_Originator()13041 void File_Mxf::AS11_UKDPP_Originator()
13042 {
13043 //Parsing
13044 Ztring Value;
13045 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13046
13047 FILLING_BEGIN();
13048 AS11s[InstanceUID].Originator=Value;
13049 FILLING_END();
13050 }
13051
13052 //---------------------------------------------------------------------------
13053 // DPP .010101010400
AS11_UKDPP_CopyrightYear()13054 void File_Mxf::AS11_UKDPP_CopyrightYear()
13055 {
13056 //Parsing
13057 int16u Value;
13058 Get_B2 (Value, "Value"); Element_Info1(Value);
13059
13060 FILLING_BEGIN();
13061 AS11s[InstanceUID].CopyrightYear=Value;
13062 FILLING_END();
13063 }
13064
13065 //---------------------------------------------------------------------------
13066 // DPP .010101010500
AS11_UKDPP_OtherIdentifier()13067 void File_Mxf::AS11_UKDPP_OtherIdentifier()
13068 {
13069 //Parsing
13070 Ztring Value;
13071 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13072
13073 FILLING_BEGIN();
13074 AS11s[InstanceUID].OtherIdentifier=Value;
13075 FILLING_END();
13076 }
13077
13078 //---------------------------------------------------------------------------
13079 // DPP .010101010600
AS11_UKDPP_OtherIdentifierType()13080 void File_Mxf::AS11_UKDPP_OtherIdentifierType()
13081 {
13082 //Parsing
13083 Ztring Value;
13084 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13085
13086 FILLING_BEGIN();
13087 AS11s[InstanceUID].OtherIdentifierType=Value;
13088 FILLING_END();
13089 }
13090
13091 //---------------------------------------------------------------------------
13092 // DPP .010101010700
AS11_UKDPP_Genre()13093 void File_Mxf::AS11_UKDPP_Genre()
13094 {
13095 //Parsing
13096 Ztring Value;
13097 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13098
13099 FILLING_BEGIN();
13100 AS11s[InstanceUID].Genre=Value;
13101 FILLING_END();
13102 }
13103
13104 //---------------------------------------------------------------------------
13105 // DPP .010101010800
AS11_UKDPP_Distributor()13106 void File_Mxf::AS11_UKDPP_Distributor()
13107 {
13108 //Parsing
13109 Ztring Value;
13110 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13111
13112 FILLING_BEGIN();
13113 AS11s[InstanceUID].Distributor=Value;
13114 FILLING_END();
13115 }
13116
13117 //---------------------------------------------------------------------------
13118 // DPP .010101010900
AS11_UKDPP_PictureRatio()13119 void File_Mxf::AS11_UKDPP_PictureRatio()
13120 {
13121 //Parsing
13122 int32u Numerator, Denominator;
13123 Get_B4 (Numerator, "Numerator");
13124 Get_B4 (Denominator, "Denominator");
13125 Element_Info1(Ztring::ToZtring(Numerator)+__T(':')+Ztring::ToZtring(Denominator));
13126
13127 FILLING_BEGIN();
13128 AS11s[InstanceUID].PictureRatio_N=Numerator;
13129 AS11s[InstanceUID].PictureRatio_D=Denominator;
13130 FILLING_END();
13131 }
13132
13133 //---------------------------------------------------------------------------
13134 // DPP .010101010A00
AS11_UKDPP_3D()13135 void File_Mxf::AS11_UKDPP_3D()
13136 {
13137 int8u Value;
13138 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
13139
13140 FILLING_BEGIN();
13141 AS11s[InstanceUID].ThreeD=Value;
13142 FILLING_END();
13143 }
13144
13145 //---------------------------------------------------------------------------
13146 // DPP .010101010B00
AS11_UKDPP_3DType()13147 void File_Mxf::AS11_UKDPP_3DType()
13148 {
13149 //Parsing
13150 int8u Value;
13151 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_3D_Type_Count, Mxf_AS11_3D_Type[Value]);
13152
13153 FILLING_BEGIN();
13154 if (Value<Mxf_AS11_3D_Type_Count)
13155 AS11s[InstanceUID].ThreeDType=Value;
13156 FILLING_END();
13157 }
13158
13159 //---------------------------------------------------------------------------
13160 // DPP .010101010C00
AS11_UKDPP_ProductPlacement()13161 void File_Mxf::AS11_UKDPP_ProductPlacement()
13162 {
13163 int8u Value;
13164 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
13165
13166 FILLING_BEGIN();
13167 AS11s[InstanceUID].ProductPlacement=Value;
13168 FILLING_END();
13169 }
13170
13171 //---------------------------------------------------------------------------
13172 // DPP .010101010D00
AS11_UKDPP_FpaPass()13173 void File_Mxf::AS11_UKDPP_FpaPass()
13174 {
13175 //Parsing
13176 int8u Value;
13177 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_FpaPass_Count, Mxf_AS11_FpaPass[Value]);
13178
13179 FILLING_BEGIN();
13180 AS11s[InstanceUID].FpaPass=Value;
13181 FILLING_END();
13182 }
13183
13184 //---------------------------------------------------------------------------
13185 // DPP .010101010E00
AS11_UKDPP_FpaManufacturer()13186 void File_Mxf::AS11_UKDPP_FpaManufacturer()
13187 {
13188 //Parsing
13189 Ztring Value;
13190 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13191
13192 FILLING_BEGIN();
13193 AS11s[InstanceUID].FpaManufacturer=Value;
13194 FILLING_END();
13195 }
13196
13197 //---------------------------------------------------------------------------
13198 // DPP .010101010F00
AS11_UKDPP_FpaVersion()13199 void File_Mxf::AS11_UKDPP_FpaVersion()
13200 {
13201 //Parsing
13202 Ztring Value;
13203 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13204
13205 FILLING_BEGIN();
13206 AS11s[InstanceUID].FpaVersion=Value;
13207 FILLING_END();
13208 }
13209
13210 //---------------------------------------------------------------------------
13211 // DPP .010101011000
AS11_UKDPP_VideoComments()13212 void File_Mxf::AS11_UKDPP_VideoComments()
13213 {
13214 //Parsing
13215 Ztring Value;
13216 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13217
13218 FILLING_BEGIN();
13219 AS11s[InstanceUID].VideoComments=Value;
13220 FILLING_END();
13221 }
13222
13223 //---------------------------------------------------------------------------
13224 // DPP .010101011100
AS11_UKDPP_SecondaryAudioLanguage()13225 void File_Mxf::AS11_UKDPP_SecondaryAudioLanguage()
13226 {
13227 //Parsing
13228 Ztring Value;
13229 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13230
13231 FILLING_BEGIN();
13232 AS11s[InstanceUID].SecondaryAudioLanguage=Value;
13233 FILLING_END();
13234 }
13235
13236 //---------------------------------------------------------------------------
AS11_UKDPP_TertiaryAudioLanguage()13237 void File_Mxf::AS11_UKDPP_TertiaryAudioLanguage()
13238 {
13239 //Parsing
13240 Ztring Value;
13241 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13242
13243 FILLING_BEGIN();
13244 AS11s[InstanceUID].TertiaryAudioLanguage=Value;
13245 FILLING_END();
13246 }
13247
13248 //---------------------------------------------------------------------------
13249 // DPP .010101011300
AS11_UKDPP_AudioLoudnessStandard()13250 void File_Mxf::AS11_UKDPP_AudioLoudnessStandard()
13251 {
13252 //Parsing
13253 int8u Value;
13254 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_AudioLoudnessStandard_Count, Mxf_AS11_AudioLoudnessStandard[Value]);
13255
13256 FILLING_BEGIN();
13257 AS11s[InstanceUID].AudioLoudnessStandard=Value;
13258 FILLING_END();
13259 }
13260
13261 //---------------------------------------------------------------------------
13262 // DPP .010101011400
AS11_UKDPP_AudioComments()13263 void File_Mxf::AS11_UKDPP_AudioComments()
13264 {
13265 //Parsing
13266 Ztring Value;
13267 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13268
13269 FILLING_BEGIN();
13270 AS11s[InstanceUID].AudioComments=Value;
13271 FILLING_END();
13272 }
13273
13274 //---------------------------------------------------------------------------
13275 // DPP .010101011500
AS11_UKDPP_LineUpStart()13276 void File_Mxf::AS11_UKDPP_LineUpStart()
13277 {
13278 //Parsing
13279 int64u Value;
13280 Get_B8 (Value, "Value"); Element_Info1(Value);
13281
13282 FILLING_BEGIN();
13283 AS11s[InstanceUID].LineUpStart=Value;
13284 FILLING_END();
13285 }
13286
13287 //---------------------------------------------------------------------------
13288 // DPP .010101011600
AS11_UKDPP_IdentClockStart()13289 void File_Mxf::AS11_UKDPP_IdentClockStart()
13290 {
13291 //Parsing
13292 int64u Value;
13293 Get_B8 (Value, "Value"); Element_Info1(Value);
13294
13295 FILLING_BEGIN();
13296 AS11s[InstanceUID].IdentClockStart=Value;
13297 FILLING_END();
13298 }
13299
13300 //---------------------------------------------------------------------------
13301 // DPP .010101011700
AS11_UKDPP_TotalNumberOfParts()13302 void File_Mxf::AS11_UKDPP_TotalNumberOfParts()
13303 {
13304 //Parsing
13305 int16u Value;
13306 Get_B2 (Value, "Value"); Element_Info1(Value);
13307
13308 FILLING_BEGIN();
13309 AS11s[InstanceUID].TotalNumberOfParts=Value;
13310 FILLING_END();
13311 }
13312
13313 //---------------------------------------------------------------------------
13314 // DPP .010101011800
AS11_UKDPP_TotalProgrammeDuration()13315 void File_Mxf::AS11_UKDPP_TotalProgrammeDuration()
13316 {
13317 //Parsing
13318 int64u Value;
13319 Get_B8 (Value, "Value"); Element_Info1(Value);
13320
13321 FILLING_BEGIN();
13322 AS11s[InstanceUID].TotalProgrammeDuration=Value;
13323 FILLING_END();
13324 }
13325
13326 //---------------------------------------------------------------------------
13327 // DPP .010101011900
AS11_UKDPP_AudioDescriptionPresent()13328 void File_Mxf::AS11_UKDPP_AudioDescriptionPresent()
13329 {
13330 //Parsing
13331 int8u Value;
13332 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
13333
13334 FILLING_BEGIN();
13335 AS11s[InstanceUID].AudioDescriptionPresent=Value;
13336 FILLING_END();
13337 }
13338
13339 //---------------------------------------------------------------------------
13340 // DPP .010101011A00
AS11_UKDPP_AudioDescriptionType()13341 void File_Mxf::AS11_UKDPP_AudioDescriptionType()
13342 {
13343 //Parsing
13344 int8u Value;
13345 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_AudioDescriptionType_Count, Mxf_AS11_AudioDescriptionType[Value]);
13346
13347 FILLING_BEGIN();
13348 AS11s[InstanceUID].AudioDescriptionType=Value;
13349 FILLING_END();
13350 }
13351
13352 //---------------------------------------------------------------------------
13353 // DPP .010101011B00
AS11_UKDPP_OpenCaptionsPresent()13354 void File_Mxf::AS11_UKDPP_OpenCaptionsPresent()
13355 {
13356 //Parsing
13357 int8u Value;
13358 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
13359
13360 FILLING_BEGIN();
13361 AS11s[InstanceUID].OpenCaptionsPresent=Value;
13362 FILLING_END();
13363 }
13364
13365 //---------------------------------------------------------------------------
13366 // DPP .010101011C00
AS11_UKDPP_OpenCaptionsType()13367 void File_Mxf::AS11_UKDPP_OpenCaptionsType()
13368 {
13369 //Parsing
13370 int8u Value;
13371 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_OpenCaptionsType_Count, Mxf_AS11_OpenCaptionsType[Value]);
13372
13373 FILLING_BEGIN();
13374 AS11s[InstanceUID].OpenCaptionsType=Value;
13375 FILLING_END();
13376 }
13377
13378 //---------------------------------------------------------------------------
13379 // DPP .010101011D00
AS11_UKDPP_OpenCaptionsLanguage()13380 void File_Mxf::AS11_UKDPP_OpenCaptionsLanguage()
13381 {
13382 //Parsing
13383 Ztring Value;
13384 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13385
13386 FILLING_BEGIN();
13387 AS11s[InstanceUID].OpenCaptionsLanguage=Value;
13388 FILLING_END();
13389 }
13390
13391 //---------------------------------------------------------------------------
13392 // DPP .010101011E00
AS11_UKDPP_SigningPresent()13393 void File_Mxf::AS11_UKDPP_SigningPresent()
13394 {
13395 //Parsing
13396 int8u Value;
13397 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_SigningPresent_Count, Mxf_AS11_SigningPresent[Value]);
13398
13399 FILLING_BEGIN();
13400 AS11s[InstanceUID].SigningPresent=Value;
13401 FILLING_END();
13402 }
13403
13404 //---------------------------------------------------------------------------
13405 // DPP .010101011F00
AS11_UKDPP_SignLanguage()13406 void File_Mxf::AS11_UKDPP_SignLanguage()
13407 {
13408 //Parsing
13409 int8u Value;
13410 Get_B1 (Value, "Value"); Element_Info1C(Value<Mxf_AS11_SignLanguage_Count, Mxf_AS11_SignLanguage[Value]);
13411
13412 FILLING_BEGIN();
13413 AS11s[InstanceUID].SignLanguage=Value;
13414 FILLING_END();
13415 }
13416
13417 //---------------------------------------------------------------------------
13418 // DPP .010101012000
AS11_UKDPP_CompletionDate()13419 void File_Mxf::AS11_UKDPP_CompletionDate()
13420 {
13421 //Parsing
13422 int64u Value;
13423 Get_B8 (Value, "Value"); Element_Info1(Value); //TODO: Timestamp
13424
13425 FILLING_BEGIN();
13426 AS11s[InstanceUID].CompletionDate=Value;
13427 FILLING_END();
13428 }
13429
13430 //---------------------------------------------------------------------------
13431 // DPP .010101012100
AS11_UKDPP_TextlessElementsExist()13432 void File_Mxf::AS11_UKDPP_TextlessElementsExist()
13433 {
13434 //Parsing
13435 int8u Value;
13436 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
13437
13438 FILLING_BEGIN();
13439 AS11s[InstanceUID].TextlessElementsExist=Value;
13440 FILLING_END();
13441 }
13442
13443 //---------------------------------------------------------------------------
13444 // DPP .010101012200
AS11_UKDPP_ProgrammeHasText()13445 void File_Mxf::AS11_UKDPP_ProgrammeHasText()
13446 {
13447 //Parsing
13448 int8u Value;
13449 Get_B1 (Value, "Value"); Element_Info1(Value?"Yes":"No");
13450
13451 FILLING_BEGIN();
13452 AS11s[InstanceUID].ProgrammeHasText=Value;
13453 FILLING_END();
13454 }
13455
13456 //---------------------------------------------------------------------------
13457 // DPP .010101012300
AS11_UKDPP_ProgrammeTextLanguage()13458 void File_Mxf::AS11_UKDPP_ProgrammeTextLanguage()
13459 {
13460 //Parsing
13461 Ztring Value;
13462 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13463
13464 FILLING_BEGIN();
13465 AS11s[InstanceUID].ProgrammeTextLanguage=Value;
13466 FILLING_END();
13467 }
13468
13469 //---------------------------------------------------------------------------
13470 // DPP .010101012400
AS11_UKDPP_ContactEmail()13471 void File_Mxf::AS11_UKDPP_ContactEmail()
13472 {
13473 //Parsing
13474 Ztring Value;
13475 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13476
13477 FILLING_BEGIN();
13478 AS11s[InstanceUID].ContactEmail=Value;
13479 FILLING_END();
13480 }
13481
13482 //---------------------------------------------------------------------------
13483 // DPP .010101012500
AS11_UKDPP_ContactTelephoneNumber()13484 void File_Mxf::AS11_UKDPP_ContactTelephoneNumber()
13485 {
13486 //Parsing
13487 Ztring Value;
13488 Get_UTF16B(Length2, Value, "Value"); Element_Info1(Value);
13489
13490 FILLING_BEGIN();
13491 AS11s[InstanceUID].ContactTelephoneNumber=Value;
13492 FILLING_END();
13493 }
13494
13495 //---------------------------------------------------------------------------
13496 // 0x8001
Omneon_010201010100_8001()13497 void File_Mxf::Omneon_010201010100_8001()
13498 {
13499 //Parsing
13500 if (Vector(16)==(int32u)-1)
13501 return;
13502 while (Element_Offset<Element_Size)
13503 {
13504 Skip_UUID( "UUID Omneon_010201020100");
13505 }
13506 }
13507
13508 //---------------------------------------------------------------------------
13509 // 0x8001
Omneon_010201010100_8003()13510 void File_Mxf::Omneon_010201010100_8003()
13511 {
13512 //Parsing
13513 if (Vector(16)==(int32u)-1)
13514 return;
13515 while (Element_Offset<Element_Size)
13516 {
13517 Skip_UUID( "UUID Omneon_010201020100");
13518 }
13519 }
13520
13521 //---------------------------------------------------------------------------
13522 // 0x8003
Omneon_010201020100_8002()13523 void File_Mxf::Omneon_010201020100_8002()
13524 {
13525 //Parsing
13526 Skip_UTF16B(Length2, "Content");
13527 }
13528
13529 //---------------------------------------------------------------------------
13530 // 0x8003
Omneon_010201020100_8003()13531 void File_Mxf::Omneon_010201020100_8003()
13532 {
13533 //Parsing
13534 Skip_UTF16B(Length2, "Content");
13535 }
13536
13537 //---------------------------------------------------------------------------
13538 // 0x8004
Omneon_010201020100_8004()13539 void File_Mxf::Omneon_010201020100_8004()
13540 {
13541 //Parsing
13542 Skip_XX(Length2, "Unknown");
13543 }
13544
13545 //---------------------------------------------------------------------------
13546 // 0x8005
Omneon_010201020100_8005()13547 void File_Mxf::Omneon_010201020100_8005()
13548 {
13549 //Parsing
13550 Skip_UTF16B(Length2, "Content");
13551 }
13552
13553 //---------------------------------------------------------------------------
13554 // 0x8006
Omneon_010201020100_8006()13555 void File_Mxf::Omneon_010201020100_8006()
13556 {
13557 //Parsing
13558 Skip_UTF8(Length2, "Content");
13559 }
13560
13561 //---------------------------------------------------------------------------
13562 //
Dolby_DataDefinition()13563 void File_Mxf::Dolby_DataDefinition()
13564 {
13565 //Parsing
13566 Skip_UUID( "Value");
13567 }
13568
13569 //---------------------------------------------------------------------------
13570 //
Dolby_SourceTrackID()13571 void File_Mxf::Dolby_SourceTrackID()
13572 {
13573 //Parsing
13574 int32u Data;
13575 Get_B4 (Data, "Data"); Element_Info1(Data);
13576
13577 FILLING_BEGIN();
13578 if (Descriptors[InstanceUID].LinkedTrackID==(int32u)-1)
13579 Descriptors[InstanceUID].LinkedTrackID=Data;
13580 FILLING_END();
13581 }
13582
13583 //---------------------------------------------------------------------------
13584 //
Dolby_SimplePayloadSID()13585 void File_Mxf::Dolby_SimplePayloadSID()
13586 {
13587 //Parsing
13588 int32u Data;
13589 Get_B4 (Data, "Data"); Element_Info1(Data);
13590
13591 FILLING_BEGIN();
13592 ExtraMetadata_SID.insert(Data);
13593 FILLING_END();
13594 }
13595
13596 //***************************************************************************
13597 // Basic types
13598 //***************************************************************************
13599
13600 //---------------------------------------------------------------------------
Get_Rational(float64 & Value)13601 void File_Mxf::Get_Rational(float64 &Value)
13602 {
13603 //Parsing
13604 int32u N, D;
13605 Get_B4 (N, "Numerator");
13606 Get_B4 (D, "Denominator");
13607 if (D)
13608 Value=((float64)N)/D;
13609 else
13610 Value=0; //Error
13611 }
13612
13613 //---------------------------------------------------------------------------
Skip_Rational()13614 void File_Mxf::Skip_Rational()
13615 {
13616 //Parsing
13617 Skip_B4( "Numerator");
13618 Skip_B4( "Denominator");
13619 }
13620
13621 //---------------------------------------------------------------------------
Info_Rational()13622 void File_Mxf::Info_Rational()
13623 {
13624 //Parsing
13625 Info_B4(N, "Numerator");
13626 Info_B4(D, "Denominator");
13627 Element_Info1C(D, ((float32)N)/D);
13628 }
13629
13630 //---------------------------------------------------------------------------
Get_UL(int128u & Value,const char * Name,const char * (* Param)(int128u))13631 void File_Mxf::Get_UL(int128u &Value, const char* Name, const char* (*Param) (int128u))
13632 {
13633 #ifdef MEDIAINFO_MINIMIZE_SIZE
13634 Skip_UUID();
13635 #else
13636 //Parsing
13637 Element_Begin1(Name);
13638 int64u Value_hi, Value_lo;
13639 int8u Category, Registry, Structure;
13640 Peek_B8(Value_hi);
13641 Skip_B1( "Start (0x06)");
13642 Skip_B1( "Length of the remaining key (0x0E)");
13643 Skip_B1( "ISO, ORG (0x2B)");
13644 Skip_B1( "SMPTE (0x34)");
13645 Get_B1 (Category, "Category"); Param_Info1(Mxf_Category(Category));
13646 Get_B1 (Registry, "Registry"); Param_Info1(Mxf_Registry(Category, Registry));
13647 Get_B1 (Structure, "Structure"); Param_Info1(Mxf_Structure(Category, Registry, Structure));
13648 Skip_B1( "Version");
13649 Peek_B8(Value_lo);
13650 switch (Category)
13651 {
13652 case 0x01 : //Item
13653 {
13654 //switch (Registry)
13655 //{
13656 // default :
13657 {
13658 switch (Structure)
13659 {
13660 case 0x01 : //Standard
13661 Param_Info1("Essence element"); //SMPTE 379M
13662 Info_UL_01xx01_Items();
13663 break;
13664 default :
13665 Skip_B8( "Unknown");
13666 }
13667 }
13668 //}
13669 }
13670 break;
13671 case 0x02 : //Group
13672 {
13673 //switch (Registry)
13674 //{
13675 // default :
13676 {
13677 switch (Structure)
13678 {
13679 case 0x01 :
13680 Info_UL_02xx01_Groups();
13681 break;
13682 default :
13683 Skip_B8( "Unknown");
13684 }
13685 }
13686 //}
13687 }
13688 break;
13689 case 0x04 : //Value
13690 {
13691 switch (Registry)
13692 {
13693 case 0x01 :
13694 {
13695 Param_Info1("Labels");
13696 switch (Structure)
13697 {
13698 case 0x01 :
13699 Info_UL_040101_Values();
13700 break;
13701 default :
13702 Skip_B8( "Unknown");
13703 }
13704 }
13705 break;
13706 default :
13707 Skip_B8( "Unknown");
13708 }
13709 }
13710 break;
13711 default :
13712 Skip_B8( "Unknown");
13713 }
13714
13715
13716 Value.hi=Value_hi;
13717 Value.lo=Value_lo;
13718 Element_Info1C((Param), Param(Value));
13719 Element_End0();
13720 #endif
13721 }
13722
13723 //---------------------------------------------------------------------------
13724 #if MEDIAINFO_TRACE
Info_UL_01xx01_Items()13725 void File_Mxf::Info_UL_01xx01_Items()
13726 {
13727 Info_B1(Code1, "Item Designator");
13728 switch (Code1)
13729 {
13730 case 0x01 :
13731 {
13732 Param_Info1("Identifiers and locators");
13733 Info_B1(Code2, "Code (2)");
13734 switch (Code2)
13735 {
13736 case 0x01 :
13737 {
13738 Param_Info1("GUID");
13739 Info_B1(Code3, "Code (3)");
13740 switch (Code3)
13741 {
13742 case 0x0D :
13743 {
13744 Param_Info1("UMID Mixed");
13745 Info_B1(Code4, "Code (4)");
13746 Info_B1(Code5, "Code (5)");
13747 Info_B1(Code6, "Code (6)");
13748 Info_B1(Code7, "Code (7)");
13749 Info_B1(Code8, "Code (8)");
13750 }
13751 break;
13752 default :
13753 Skip_B5( "Unknown");
13754 }
13755 }
13756 break;
13757 case 0x03 :
13758 {
13759 Param_Info1("Locally Unique Identifiers");
13760 Info_B1(Code3, "Code (3)");
13761 switch (Code3)
13762 {
13763 case 0x06 :
13764 {
13765 Param_Info1("Metadata Identifiers");
13766 Info_B1(Code4, "Code (4)");
13767 switch (Code4)
13768 {
13769 case 0x01 :
13770 {
13771 Param_Info1("Item Designator ID");
13772 Info_B1(Code5, "Code (5)");
13773 //switch (Code5)
13774 //{
13775 // default :
13776 Skip_B3( "Unknown");
13777 //}
13778 }
13779 break;
13780 default :
13781 Skip_B4( "Unknown");
13782 }
13783 }
13784 break;
13785 case 0x07 :
13786 {
13787 Param_Info1("?");
13788 Info_B1(Code4, "Code (4)");
13789 switch (Code4)
13790 {
13791 case 0x01 :
13792 {
13793 Param_Info1("?");
13794 Info_B1(Code5, "Code (5)");
13795 switch (Code5)
13796 {
13797 case 0x01 :
13798 {
13799 Param_Info1("MCA Label Dictionary ID");
13800 Skip_B3( "Reserved");
13801 }
13802 break;
13803 case 0x02 :
13804 {
13805 Param_Info1("MCA Tag Symbol");
13806 Skip_B3( "Reserved");
13807 }
13808 break;
13809 case 0x03 :
13810 {
13811 Param_Info1("MCA Tag Name");
13812 Skip_B3( "Reserved");
13813 }
13814 break;
13815 case 0x04 :
13816 {
13817 Param_Info1("Group Of Soundfield Groups Link ID");
13818 Skip_B3( "Reserved");
13819 }
13820 break;
13821 case 0x05 :
13822 {
13823 Param_Info1("MCA Link ID");
13824 Skip_B3( "Reserved");
13825 }
13826 break;
13827 default :
13828 Skip_B3( "Unknown");
13829 }
13830 }
13831 break;
13832 default :
13833 Skip_B4( "Unknown");
13834 }
13835 }
13836 break;
13837 default :
13838 Skip_B5( "Unknown");
13839 }
13840 }
13841 break;
13842 case 0x05 :
13843 {
13844 Param_Info1("Titles");
13845 Info_B1(Code3, "Code (3)");
13846 switch (Code3)
13847 {
13848 case 0x10 :
13849 {
13850 Param_Info1("MCA Title");
13851 Skip_B5( "Reserved");
13852 }
13853 break;
13854 case 0x11 :
13855 {
13856 Param_Info1("MCA Title Version");
13857 Skip_B5( "Reserved");
13858 }
13859 break;
13860 case 0x12 :
13861 {
13862 Param_Info1("MCA Title Sub-Version");
13863 Skip_B5( "Reserved");
13864 }
13865 break;
13866 case 0x13 :
13867 {
13868 Param_Info1("MCA Episode");
13869 Skip_B5( "Reserved");
13870 }
13871 break;
13872 default :
13873 Skip_B5( "Unknown");
13874 }
13875 }
13876 break;
13877 default :
13878 Skip_B6( "Unknown");
13879 }
13880 }
13881 break;
13882 case 0x03 :
13883 {
13884 Param_Info1("Interpretive");
13885 Info_B1(Code2, "Code (2)");
13886 switch (Code2)
13887 {
13888 case 0x01 :
13889 {
13890 Param_Info1("Fundamental");
13891 Info_B1(Code3, "Code (3)");
13892 switch (Code3)
13893 {
13894 case 0x01 :
13895 {
13896 Param_Info1("Countries and Languages");
13897 Info_B1(Code4, "Code (4)");
13898 switch (Code4)
13899 {
13900 case 0x02 :
13901 {
13902 Param_Info1("Language Codes");
13903 Info_B1(Code5, "Code (5)");
13904 switch (Code5)
13905 {
13906 case 0x03 :
13907 {
13908 Param_Info1("Spoken Language Codes");
13909 Info_B1(Code6, "Code (6)");
13910 switch (Code6)
13911 {
13912 case 0x01 :
13913 {
13914 Param_Info1("Primary Spoken Language Code");
13915 Skip_B2( "Reserved");
13916 }
13917 break;
13918 case 0x02 :
13919 {
13920 Param_Info1("Secondary Spoken Language Code");
13921 Skip_B2( "Reserved");
13922 }
13923 break;
13924 case 0x03 :
13925 {
13926 Param_Info1("Primary Original Language Code");
13927 Skip_B2( "Reserved");
13928 }
13929 break;
13930 case 0x04 :
13931 {
13932 Param_Info1("Secondary Original Language Code");
13933 Skip_B2( "Reserved");
13934 }
13935 break;
13936 case 0x11 :
13937 {
13938 Param_Info1("Primary Extended Spoken Language Code");
13939 Skip_B2( "Reserved");
13940 }
13941 break;
13942 case 0x12 :
13943 {
13944 Param_Info1("Secondary Extended Spoken Language Code");
13945 Skip_B2( "Reserved");
13946 }
13947 break;
13948 case 0x13 :
13949 {
13950 Param_Info1("Original Extended Spoken Primary Language Code");
13951 Skip_B2( "Reserved");
13952 }
13953 break;
13954 case 0x14 :
13955 {
13956 Param_Info1("Secondary Original Extended Spoken Language Code");
13957 Skip_B2( "Reserved");
13958 }
13959 break;
13960 case 0x15 :
13961 {
13962 Param_Info1("RFC 5646 Audio Language Code");
13963 Skip_B2( "Reserved");
13964 }
13965 break;
13966 default :
13967 Skip_B2( "Unknown");
13968 }
13969 }
13970 break;
13971 default :
13972 Skip_B3( "Unknown");
13973 }
13974 }
13975 break;
13976 default :
13977 Skip_B4( "Unknown");
13978 }
13979 }
13980 break;
13981 case 0x02 :
13982 {
13983 Param_Info1("Data Interpretations and Definitions");
13984 Info_B1(Code4, "Code (4)");
13985 switch (Code4)
13986 {
13987 case 0x0A :
13988 {
13989 Param_Info1("Name-Value Construct Interpretations");
13990 Info_B1(Code5, "Code (5)");
13991 switch (Code5)
13992 {
13993 case 0x01 :
13994 case 0x02 :
13995 {
13996 Param_Info1("");
13997 Info_B1(Code6, "Code (6)");
13998 switch (Code6)
13999 {
14000 case 0x00 :
14001 {
14002 Param_Info1("ANSI");
14003 Info_B1(Code7, "Reserved");
14004 Info_B1(Code8, "Reserved");
14005 }
14006 break;
14007 case 0x01 :
14008 {
14009 Param_Info1("UTF-16");
14010 Info_B1(Code7, "Reserved");
14011 Info_B1(Code8, "Reserved");
14012 }
14013 break;
14014 default :
14015 Skip_B2( "Unknown");
14016 }
14017 }
14018 break;
14019 default :
14020 Skip_B3( "Unknown");
14021 }
14022 }
14023 break;
14024 case 0x10 :
14025 {
14026 Param_Info1("KLV Interpretations");
14027 Info_B1(Code5, "Code (5)");
14028 switch (Code5)
14029 {
14030 case 0x01 :
14031 {
14032 Param_Info1("Filler");
14033 Info_B1(Code6, "Reserved");
14034 Info_B1(Code7, "Reserved");
14035 Info_B1(Code8, "Reserved");
14036 }
14037 break;
14038 case 0x05 :
14039 {
14040 Param_Info1("Terminating Filler");
14041 Info_B1(Code6, "Reserved");
14042 Info_B1(Code7, "Reserved");
14043 Info_B1(Code8, "Reserved");
14044 }
14045 break;
14046 default :
14047 Skip_B3( "Unknown");
14048 }
14049 }
14050 break;
14051 case 0x20 :
14052 {
14053 Param_Info1("XML Constructs and Interpretations");
14054 Info_B1(Code5, "Code (5)");
14055 switch (Code5)
14056 {
14057 case 0x01 :
14058 {
14059 Param_Info1("XML Document Text");
14060 Info_B1(Code6, "Reserved");
14061 Info_B1(Code7, "Reserved");
14062 Info_B1(Code8, "Reserved");
14063 }
14064 break;
14065 default :
14066 Skip_B3( "Unknown");
14067 }
14068 }
14069 break;
14070 default :
14071 Skip_B4( "Unknown");
14072 }
14073 }
14074 break;
14075 default :
14076 Skip_B5( "Unknown");
14077 }
14078 }
14079 break;
14080 case 0x02 :
14081 {
14082 Param_Info1("Human Assigned Descriptors");
14083 Info_B1(Code3, "Code (3)");
14084 switch (Code3)
14085 {
14086 case 0x01 :
14087 {
14088 Param_Info1("Categorization");
14089 Info_B1(Code4, "Code (4)");
14090 switch (Code4)
14091 {
14092 case 0x02 :
14093 {
14094 Param_Info1("Cataloging and Indexing");
14095 Info_B1(Code5, "Code (5)");
14096 switch (Code5)
14097 {
14098 case 0x01 :
14099 {
14100 Param_Info1("Catalog Data Status");
14101 Skip_B3( "Reserved");
14102 }
14103 break;
14104 case 0x02 :
14105 {
14106 Param_Info1("Thesaurus Name");
14107 Skip_B3( "Reserved");
14108 }
14109 break;
14110 case 0x03 :
14111 {
14112 Param_Info1("Theme");
14113 Skip_B3( "Reserved");
14114 }
14115 break;
14116 case 0x04 :
14117 {
14118 Param_Info1("Content Classification");
14119 Skip_B3( "Reserved");
14120 }
14121 break;
14122 case 0x05 :
14123 {
14124 Param_Info1("Keywords");
14125 Skip_B3( "Reserved");
14126 }
14127 break;
14128 case 0x06 :
14129 {
14130 Param_Info1("Key Frames");
14131 Skip_B3( "Reserved");
14132 }
14133 break;
14134 case 0x07 :
14135 {
14136 Param_Info1("Key Sounds");
14137 Skip_B3( "Reserved");
14138 }
14139 break;
14140 case 0x08 :
14141 {
14142 Param_Info1("Key Data");
14143 Skip_B3( "Reserved");
14144 }
14145 break;
14146 case 0x09 :
14147 {
14148 Param_Info1("Assigned Category Name");
14149 Skip_B3( "Reserved");
14150 }
14151 break;
14152 case 0x0A :
14153 {
14154 Param_Info1("Assigned Category Value");
14155 Skip_B3( "Reserved");
14156 }
14157 break;
14158 case 0x0B :
14159 {
14160 Param_Info1("Shot List");
14161 Skip_B3( "Reserved");
14162 }
14163 break;
14164 case 0x0C :
14165 {
14166 Param_Info1("Package User Comments");
14167 Skip_B3( "Reserved");
14168 }
14169 break;
14170 case 0x0D :
14171 {
14172 Param_Info1("Cue-In Words");
14173 Skip_B3( "Reserved");
14174 }
14175 break;
14176 case 0x0E :
14177 {
14178 Param_Info1("Cue-Out Words");
14179 Skip_B3( "Reserved");
14180 }
14181 break;
14182 case 0x0F :
14183 {
14184 Param_Info1("Key Frame Sample Count");
14185 Skip_B3( "Reserved");
14186 }
14187 break;
14188 case 0x10 :
14189 {
14190 Param_Info1("Keypoint Kind");
14191 Skip_B3( "Reserved");
14192 }
14193 break;
14194 case 0x11 :
14195 {
14196 Param_Info1("Keypoint Value");
14197 Skip_B3( "Reserved");
14198 }
14199 break;
14200 case 0x15 :
14201 {
14202 Param_Info1("Framework Thesaurus Name");
14203 Skip_B3( "Reserved");
14204 }
14205 break;
14206 case 0x16 :
14207 {
14208 Param_Info1("Component User Comments");
14209 Skip_B3( "Reserved");
14210 }
14211 break;
14212 default :
14213 Skip_B3( "Unknown");
14214 }
14215 }
14216 break;
14217 default :
14218 Skip_B4( "Unknown");
14219 }
14220 }
14221 break;
14222 default :
14223 Skip_B5( "Unknown");
14224 }
14225 }
14226 break;
14227 default :
14228 Skip_B6( "Unknown");
14229 }
14230 }
14231 break;
14232 case 0x04 :
14233 {
14234 Param_Info1("Parametric");
14235 Info_B1(Code2, "Code (2)");
14236 switch (Code2)
14237 {
14238 case 0x01 :
14239 {
14240 Param_Info1("Video and Image Essence Characteristics");
14241 Info_B1(Code3, "Code (3)");
14242 switch (Code3)
14243 {
14244 case 0x02 :
14245 {
14246 Param_Info1("Image Source Characteristics");
14247 Info_B1(Code4, "Code (4)");
14248 switch (Code4)
14249 {
14250 case 0x01 :
14251 {
14252 Param_Info1("Opto-Electronic Formulation");
14253 Info_B1(Code5, "Code (5)");
14254 switch (Code5)
14255 {
14256 case 0x01 :
14257 {
14258 Param_Info1("Transfer Characteristics");
14259 Info_B1(Code6, "Code (6)");
14260 switch (Code6)
14261 {
14262 case 0x01 :
14263 {
14264 Param_Info1("Capture Gamma Equation");
14265 Info_B1(Code7, "Code (7)");
14266 switch (Code7)
14267 {
14268 case 0x00 :
14269 {
14270 Param_Info1("ISO/IEC 646:1991 - ISO 7-Bit Coded Character Set");
14271 }
14272 break;
14273 case 0x01 :
14274 {
14275 Param_Info1("Rational");
14276 }
14277 break;
14278 case 0x02 :
14279 {
14280 Param_Info1("UL");
14281 }
14282 break;
14283 default :
14284 Info_B1(Code8, "Unknown");
14285 }
14286 Info_B1(Code8, "Reserved");
14287 }
14288 break;
14289 default :
14290 Skip_B2( "Unknown");
14291 }
14292 }
14293 break;
14294 default :
14295 Skip_B3( "Unknown");
14296 }
14297 }
14298 break;
14299 default :
14300 Skip_B4( "Unknown");
14301 }
14302 }
14303 break;
14304 case 0x06 :
14305 {
14306 Param_Info1("Digital Video and Image Compression Parameters");
14307 Info_B1(Code4, "Code (4)");
14308 switch (Code4)
14309 {
14310 case 0x03 :
14311 {
14312 Param_Info1("JPEG 2000 Coding Parameters");
14313 Info_B1(Code5, "Code (5)");
14314 switch (Code5)
14315 {
14316 case 0x01 :
14317 {
14318 Param_Info1("Rsiz - Decoder capabilities");
14319 Skip_B3( "Reserved");
14320 }
14321 break;
14322 case 0x02 :
14323 {
14324 Param_Info1("Xsiz - Width");
14325 Skip_B3( "Reserved");
14326 }
14327 break;
14328 case 0x03 :
14329 {
14330 Param_Info1("Ysiz - Height");
14331 Skip_B3( "Reserved");
14332 }
14333 break;
14334 case 0x04 :
14335 {
14336 Param_Info1("XOsiz - Horizontal offset");
14337 Skip_B3( "Reserved");
14338 }
14339 break;
14340 case 0x05 :
14341 {
14342 Param_Info1("YOsiz - Vertical offset");
14343 Skip_B3( "Reserved");
14344 }
14345 break;
14346 case 0x06 :
14347 {
14348 Param_Info1("XTsiz - Width of one reference tile");
14349 Skip_B3( "Reserved");
14350 }
14351 break;
14352 case 0x07 :
14353 {
14354 Param_Info1("YTsiz - Height of one reference tile");
14355 Skip_B3( "Reserved");
14356 }
14357 break;
14358 case 0x08 :
14359 {
14360 Param_Info1("XTOsiz - Horizontal offset of the first tile");
14361 Skip_B3( "Reserved");
14362 }
14363 break;
14364 case 0x09 :
14365 {
14366 Param_Info1("YTOsiz - Vertical offset of the first tile");
14367 Skip_B3( "Reserved");
14368 }
14369 break;
14370 case 0x0A :
14371 {
14372 Param_Info1("Csiz - Number of components in the picture");
14373 Skip_B3( "Reserved");
14374 }
14375 break;
14376 case 0x0B :
14377 {
14378 Param_Info1("Picture Component Sizing");
14379 Skip_B3( "Reserved");
14380 }
14381 break;
14382 case 0x0C :
14383 {
14384 Param_Info1("Coding Style Default");
14385 Skip_B3( "Reserved");
14386 }
14387 break;
14388 case 0x0D :
14389 {
14390 Param_Info1("Quantization Default");
14391 Skip_B3( "Reserved");
14392 }
14393 break;
14394 case 0x0 :
14395 {
14396 Param_Info1("");
14397 Skip_B3( "Reserved");
14398 }
14399 break;
14400 default :
14401 Skip_B3( "Unknown");
14402 }
14403 }
14404 break;
14405 default :
14406 Skip_B4( "Unknown");
14407 }
14408 }
14409 break;
14410 default :
14411 Skip_B5( "Unknown");
14412 }
14413 }
14414 break;
14415 case 0x02 :
14416 {
14417 Param_Info1("Audio Essence Characteristics");
14418 Info_B1(Code3, "Code (3)");
14419 switch (Code3)
14420 {
14421 case 0x01 :
14422 {
14423 Param_Info1("Fundamental Audio Characteristics");
14424 Info_B1(Code4, "Code (4)");
14425 switch (Code4)
14426 {
14427 case 0x01 :
14428 {
14429 Param_Info1("Audio Formulation");
14430 Info_B1(Code5, "Code (5)");
14431 switch (Code5)
14432 {
14433 case 0x01 :
14434 {
14435 Param_Info1("Electrospatial Formulation");
14436 Skip_B3( "Reserved");
14437 }
14438 break;
14439 case 0x02 :
14440 {
14441 Param_Info1("Filtering Applied");
14442 Skip_B3( "Reserved");
14443 }
14444 break;
14445 case 0x03 :
14446 {
14447 Param_Info1("Audio Reference Level");
14448 Skip_B3( "Reserved");
14449 }
14450 break;
14451 case 0x04 :
14452 {
14453 Param_Info1("Channel Count");
14454 Skip_B3( "Reserved");
14455 }
14456 break;
14457 case 0x05 :
14458 {
14459 Param_Info1("Channel Assignment");
14460 Skip_B3( "Reserved");
14461 }
14462 break;
14463 default :
14464 Skip_B3( "Unknown");
14465 }
14466 }
14467 break;
14468 default :
14469 Skip_B4( "Unknown");
14470 }
14471 }
14472 break;
14473 default :
14474 Skip_B5( "Unknown");
14475 }
14476 }
14477 break;
14478 default :
14479 Skip_B6( "Unknown");
14480 }
14481 }
14482 break;
14483 case 0x06 :
14484 {
14485 Param_Info1("Relational");
14486 Info_B1(Code2, "Code (2)");
14487 switch (Code2)
14488 {
14489 case 0x01 :
14490 {
14491 Param_Info1("Essence and Metadata Relationships");
14492 Info_B1(Code3, "Code (3)");
14493 switch (Code3)
14494 {
14495 case 0x01 :
14496 {
14497 Param_Info1("Essence to Essence Relationships");
14498 Info_B1(Code4, "Code (4)");
14499 switch (Code4)
14500 {
14501 case 0x04 :
14502 {
14503 Param_Info1("Object to Object Relationships");
14504 Info_B1(Code5, "Code (5)");
14505 switch (Code5)
14506 {
14507 case 0x06 :
14508 {
14509 Param_Info1("Strong References Arrays");
14510 Info_B1(Code6, "Code (6)");
14511 switch (Code6)
14512 {
14513 case 0x10 :
14514 {
14515 Param_Info1("Sub-descriptors");
14516 Skip_B2( "Reserved");
14517 }
14518 break;
14519 default :
14520 Skip_B2( "Unknown");
14521 }
14522 }
14523 break;
14524 default :
14525 Skip_B3( "Unknown");
14526 }
14527 }
14528 break;
14529 default :
14530 Skip_B4( "Unknown");
14531 }
14532 }
14533 break;
14534 default :
14535 Skip_B5( "Unknown");
14536 }
14537 }
14538 break;
14539 default :
14540 Skip_B6( "Unknown");
14541 }
14542 }
14543 break;
14544 case 0x0D :
14545 {
14546 Param_Info1("User Organisation Registered For Public Use");
14547 Info_B1(Code2, "Organization");
14548 switch (Code2)
14549 {
14550 case 0x01 :
14551 {
14552 Param_Info1("AAF");
14553 Info_B1(Code3, "Application");
14554 switch (Code3)
14555 {
14556 case 0x03 :
14557 {
14558 Param_Info1("MXF Generic Container Keys");
14559 Info_B1(Code4, "Structure Version");
14560 switch (Code4)
14561 {
14562 case 0x01 :
14563 {
14564 Param_Info1("Version 1");
14565 Info_B1(Code5, "Item Type Identifier");
14566 switch (Code5)
14567 {
14568 case 0x05 : Param_Info1("CP Picture (SMPTE 386M)"); break;
14569 case 0x06 : Param_Info1("CP Sound (SMPTE 386M)"); break;
14570 case 0x07 : Param_Info1("CP Data (SMPTE 386M)"); break;
14571 case 0x14 : Param_Info1("MXF in MXF? (To confirm)"); break;
14572 case 0x15 : Param_Info1("GC Picture"); break;
14573 case 0x16 : Param_Info1("GC Sound"); break;
14574 case 0x17 : Param_Info1("GC Data"); break;
14575 case 0x18 : Param_Info1("GC Compound"); break;
14576 default : ;
14577 }
14578 Info_B1(Code6, "Essence Element Count");
14579 Info_B1(Code7, "Essence Element Type");
14580 Info_B1(Code8, "Essence Element Number");
14581 }
14582 break;
14583 default :
14584 Skip_B4( "Unknown");
14585 }
14586 }
14587 break;
14588 default :
14589 Skip_B5( "Unknown");
14590 }
14591 }
14592 break;
14593 default :
14594 Skip_B6( "Unknown");
14595 }
14596 }
14597 break;
14598 case 0x0E :
14599 {
14600 Param_Info1("User Organisation Registered For Private Use");
14601 Info_B1(Code2, "Organization");
14602 switch (Code2)
14603 {
14604 case 0x04 :
14605 {
14606 Param_Info1("Avid");
14607 Info_B1(Code3, "Application");
14608 switch (Code3)
14609 {
14610 case 0x03 :
14611 {
14612 Param_Info1("Container Keys");
14613 Info_B1(Code4, "Structure Version");
14614 switch (Code4)
14615 {
14616 case 0x01 :
14617 {
14618 Param_Info1("Version 1");
14619 Info_B1(Code5, "Item Type Identifier");
14620 switch (Code5)
14621 {
14622 case 0x15 : Param_Info1("Picture"); break;
14623 default : ;
14624 }
14625 Info_B1(Code6, "Essence Element Count");
14626 Info_B1(Code7, "Essence Element Type");
14627 Info_B1(Code8, "Essence Element Number");
14628 }
14629 break;
14630 default :
14631 Skip_B4( "Unknown");
14632 }
14633 }
14634 break;
14635 default :
14636 Skip_B5( "Unknown");
14637 }
14638 }
14639 break;
14640 case 0x06 :
14641 {
14642 Param_Info1("Sony");
14643 Info_B1(Code3, "Application");
14644 switch (Code3)
14645 {
14646 case 0x7F :
14647 {
14648 Param_Info1("?");
14649 Info_B1(Code4, "?");
14650 switch (Code4)
14651 {
14652 case 0x03 :
14653 {
14654 Param_Info1("?");
14655 Info_B1(Code5, "?");
14656 switch (Code5)
14657 {
14658 case 0x15 : Param_Info1("Picture"); break;
14659 default : ;
14660 }
14661 Info_B1(Code6, "Essence Element Count");
14662 Info_B1(Code7, "Essence Element Type");
14663 Info_B1(Code8, "Essence Element Number");
14664 }
14665 break;
14666 default :
14667 Skip_B4( "Unknown");
14668 }
14669 }
14670 break;
14671 default :
14672 Skip_B5( "Unknown");
14673 }
14674 }
14675 break;
14676 default :
14677 Skip_B6( "Unknown");
14678 }
14679 }
14680 break;
14681 default :
14682 Skip_B7( "Unknown");
14683 }
14684 }
14685 #endif //MEDIAINFO_TRACE
14686
14687 //---------------------------------------------------------------------------
14688 #if MEDIAINFO_TRACE
Info_UL_02xx01_Groups()14689 void File_Mxf::Info_UL_02xx01_Groups()
14690 {
14691 Info_B1(Code1, "Item Designator");
14692 switch (Code1)
14693 {
14694 case 0x0D :
14695 {
14696 Param_Info1("User Organisation Registered For Public Use");
14697 Info_B1(Code2, "Organization");
14698 switch (Code2)
14699 {
14700 case 0x01 :
14701 {
14702 Param_Info1("AAF");
14703 Info_B1(Code3, "Application");
14704 switch (Code3)
14705 {
14706 case 0x01 :
14707 {
14708 Param_Info1("Structural Metadata Sets");
14709 Info_B1(Code4, "Structure Version");
14710 switch (Code4)
14711 {
14712 case 0x01 :
14713 {
14714 Param_Info1("Version 1");
14715 Info_B1(Code5, "Structure Kind");
14716 switch (Code5)
14717 {
14718 case 0x01 :
14719 {
14720 Param_Info1("MXF / AAF Association compatible sets & packs");
14721 Info_B1(Code6, "Set Kind (1)"); //See table 17
14722 Info_B1(Code7, "Set Kind (2)"); //See table 17
14723 Info_B1(Code8, "Reserved");
14724 }
14725 break;
14726 default :
14727 Skip_B3( "Unknown");
14728 }
14729 }
14730 break;
14731 default :
14732 Skip_B4( "Unknown");
14733 }
14734 }
14735 break;
14736 case 0x02 :
14737 {
14738 Param_Info1("MXF File Structure");
14739 Info_B1(Code4, "Structure Version");
14740 switch (Code4)
14741 {
14742 case 0x01 :
14743 {
14744 Param_Info1("Version 1");
14745 Info_B1(Code5, "Structure Kind");
14746 switch (Code5)
14747 {
14748 case 0x01 :
14749 {
14750 Param_Info1("MXF File Structure sets & packs");
14751 Info_B1(Code6, "Set / Pack Kind");
14752 switch (Code6)
14753 {
14754 case 0x02 :
14755 {
14756 Param_Info1("Header Partition");
14757 Info_B1(Code7, "Partition Status");
14758 Info_B1(Code8, "Reserved");
14759 }
14760 break;
14761 case 0x03 :
14762 {
14763 Param_Info1("Body Partition");
14764 Info_B1(Code7, "Partition Status");
14765 Info_B1(Code8, "Reserved");
14766 }
14767 break;
14768 case 0x04 :
14769 {
14770 Param_Info1("Footer Partition");
14771 Info_B1(Code7, "Partition Status");
14772 Info_B1(Code8, "Reserved");
14773 }
14774 break;
14775 case 0x05 :
14776 {
14777 Param_Info1("Primer");
14778 Info_B1(Code7, "Version of the Primer Pack");
14779 Info_B1(Code8, "Reserved");
14780 }
14781 break;
14782 case 0x10 :
14783 Param_Info1("Index Table Segment");
14784 Skip_B1( "Version");
14785 Skip_B1( "Reserved");
14786 break;
14787 case 0x11 :
14788 Param_Info1("Random Index Pack");
14789 Skip_B1( "Version");
14790 Skip_B1( "Reserved");
14791 break;
14792 default :
14793 Skip_B3( "Unknown");
14794 }
14795 }
14796 break;
14797 default :
14798 Skip_B3( "Unknown");
14799 }
14800 }
14801 break;
14802 default :
14803 Skip_B4( "Unknown");
14804 }
14805 }
14806 break;
14807 case 0x03 :
14808 {
14809 Param_Info1("MXF Generic Container Keys");
14810 Info_B1(Code4, "Structure Version");
14811 switch (Code4)
14812 {
14813 case 0x01 :
14814 {
14815 Param_Info1("MXF-GC Version 1");
14816 Info_B1(Code5, "Item Type Identifier");
14817 switch (Code5)
14818 {
14819 case 0x04 :
14820 {
14821 Param_Info1("CP-Compatible System Item"); //SMPTE 379M
14822 Info_B1(Code6, "System Scheme Identifier");
14823 switch (Code6)
14824 {
14825 case 0x02 :
14826 {
14827 Param_Info1("SDTI-CP, version 1"); //SMPTE 385M
14828 Info_B1(Code7, "Metadata or Control Element Identifier");
14829 switch (Code7)
14830 {
14831 case 0x01 :
14832 {
14833 Param_Info1("System Metadata Pack");
14834 Info_B1(Code8, "Reserved");
14835 }
14836 break;
14837 case 0x02 :
14838 {
14839 Param_Info1("Package metadata set");
14840 Info_B1(Code8, "Metadata Block Count");
14841 }
14842 break;
14843 case 0x03 :
14844 {
14845 Param_Info1("Picture metadata set");
14846 Info_B1(Code8, "Metadata Block Count");
14847 }
14848 break;
14849 case 0x04 :
14850 {
14851 Param_Info1("Sound metadata set");
14852 Info_B1(Code8, "Metadata Block Count");
14853 }
14854 break;
14855 case 0x05 :
14856 {
14857 Param_Info1("Data metadata set");
14858 Info_B1(Code8, "Metadata Block Count");
14859 }
14860 break;
14861 case 0x06 :
14862 {
14863 Param_Info1("Control data set");
14864 Info_B1(Code8, "Metadata Block Count");
14865 }
14866 break;
14867 default :
14868 Info_B1(Code8, "Metadata Block Count");
14869 }
14870 }
14871 break;
14872 default :
14873 Info_B1(Code7, "Metadata or Control Element Identifier");
14874 Info_B1(Code8, "Reserved");
14875 }
14876 }
14877 break;
14878 case 0x14 :
14879 {
14880 Param_Info1("GC-Compatible System Item"); //SMPTE 379M
14881 Info_B1(Code6, "System Scheme Identifier");
14882 switch (Code6)
14883 {
14884 case 0x02 :
14885 {
14886 Param_Info1("GC System Scheme 1"); //SMPTE 394M
14887 Info_B1(Code7, "Metadata or Control Element Identifier");
14888 switch (Code7)
14889 {
14890 case 0x01 :
14891 Param_Info1("First Element");
14892 break;
14893 case 0x02 :
14894 Param_Info1("Subsequent Element");
14895 break;
14896 case 0x03 :
14897 Param_Info1("Picture Item Descriptor");
14898 break;
14899 case 0x04 :
14900 Param_Info1("Sound Item Descriptor");
14901 break;
14902 case 0x05 :
14903 Param_Info1("Data Item Descriptor");
14904 break;
14905 case 0x06 :
14906 Param_Info1("Control Item Descriptor");
14907 break;
14908 case 0x07 :
14909 Param_Info1("Compound Item Descriptor");
14910 break;
14911 default : if (Code7>=0x10 && Code7<=0x7F) Param_Info1("Pack coded System Elements (SMPTE 336M)");
14912 }
14913 Info_B1(Code8, "Element Number");
14914 }
14915 break;
14916 default :
14917 Info_B1(Code7, "Metadata or Control Element Identifier");
14918 Info_B1(Code8, "Unknown");
14919 }
14920 }
14921 break;
14922 default :
14923 Skip_B3( "Unknown");
14924 }
14925 }
14926 break;
14927 default :
14928 Skip_B4( "Unknown");
14929 }
14930 }
14931 break;
14932 case 0x04 :
14933 {
14934 Param_Info1("MXF / AAF Descriptive Metadata sets");
14935 Info_B1(Code4, "Structure Version");
14936 switch (Code4)
14937 {
14938 case 0x01 :
14939 {
14940 Param_Info1("Version 1");
14941 Info_B1(Code5, "Structure / Scheme Kind");
14942 Info_B1(Code6, "Reserved");
14943 Info_B1(Code7, "Reserved");
14944 Info_B1(Code8, "Reserved");
14945 }
14946 break;
14947 default :
14948 Skip_B4( "Unknown");
14949 }
14950 }
14951 break;
14952 default :
14953 Skip_B5( "Unknown");
14954 }
14955 }
14956 break;
14957 default :
14958 Skip_B6( "Unknown");
14959 }
14960 }
14961 break;
14962 case 0x0E :
14963 {
14964 Param_Info1("User Organisation Registered For Private Use");
14965 Skip_B7( "Private");
14966 break;
14967 }
14968 default :
14969 Skip_B7( "Unknown");
14970 }
14971 }
14972 #endif //MEDIAINFO_TRACE
14973
14974 //---------------------------------------------------------------------------
14975 #if MEDIAINFO_TRACE
Info_UL_040101_Values()14976 void File_Mxf::Info_UL_040101_Values()
14977 {
14978 Info_B1(Code1, "Item Designator");
14979 switch (Code1)
14980 {
14981 case 0x01 :
14982 {
14983 Param_Info1("Identification and location");
14984 Info_B1(Code2, "Code (2)");
14985 switch (Code2)
14986 {
14987 case 0x01 :
14988 {
14989 Param_Info1("Globally Unique Identifiers");
14990 Info_B1(Code3, "Code (3)");
14991 switch (Code3)
14992 {
14993 case 0x01 :
14994 {
14995 Param_Info1("SDTI Payload Identifiers");
14996 Skip_B5( "Data");
14997 }
14998 break;
14999 case 0x02 :
15000 {
15001 Param_Info1("File Format Identifiers");
15002 Skip_B5( "Data");
15003 }
15004 break;
15005 case 0x03 :
15006 {
15007 Param_Info1("Definition Identifiers");
15008 Skip_B5( "Data");
15009 }
15010 break;
15011 default :
15012 Skip_B5( "Unknown");
15013 }
15014 }
15015 break;
15016 case 0x02 :
15017 {
15018 Param_Info1("Globally Unique Locators");
15019 Info_B1(Code3, "Code (3)");
15020 Skip_B5( "Unknown");
15021 }
15022 break;
15023 case 0x03 :
15024 {
15025 Param_Info1("Locally Unique Identifiers");
15026 Info_B1(Code3, "Code (3)");
15027 switch (Code3)
15028 {
15029 case 0x01 :
15030 {
15031 Param_Info1("For Information Only Do Not Use");
15032 Skip_B5( "Unknown");
15033 }
15034 break;
15035 case 0x02 :
15036 {
15037 Param_Info1("Track Identifiers");
15038 Info_B1(Code4, "Kind");
15039 switch (Code4)
15040 {
15041 case 0x01 :
15042 {
15043 Param_Info1("Metadata Track Kinds");
15044 Skip_B1( "Unknown");
15045 Skip_B3( "Unknown");
15046 }
15047 break;
15048 case 0x02 :
15049 {
15050 Param_Info1("Essence Track Kinds");
15051 Skip_B1( "Unknown");
15052 Skip_B3( "Unknown");
15053 }
15054 break;
15055 case 0x03 :
15056 {
15057 Param_Info1("Other Track Kinds");
15058 Skip_B1( "Unknown");
15059 Skip_B3( "Unknown");
15060 }
15061 break;
15062 default :
15063 Skip_B4( "Unknown");
15064 }
15065 }
15066 break;
15067 default :
15068 Skip_B5( "Unknown");
15069 }
15070 }
15071 break;
15072 default :
15073 Skip_B6( "Unknown");
15074 }
15075 }
15076 break;
15077 case 0x03 :
15078 {
15079 Param_Info1("Interpretive");
15080 Info_B1(Code2, "Code (2)");
15081 switch (Code2)
15082 {
15083 case 0x01 :
15084 {
15085 Param_Info1("Per element?");
15086 Info_B1(Code3, "Code (3)");
15087 switch (Code3)
15088 {
15089 case 0x01 :
15090 {
15091 Param_Info1("Channels?");
15092 Info_B1(Code4, "Code (4)");
15093 switch (Code4)
15094 {
15095 case 0x01 :
15096 {
15097 Param_Info1("L");
15098 Skip_B4( "Reserved");
15099 }
15100 break;
15101 case 0x02 :
15102 {
15103 Param_Info1("R");
15104 Skip_B4( "Reserved");
15105 }
15106 break;
15107 case 0x03 :
15108 {
15109 Param_Info1("C");
15110 Skip_B4( "Reserved");
15111 }
15112 break;
15113 case 0x04 :
15114 {
15115 Param_Info1("LFE");
15116 Skip_B4( "Reserved");
15117 }
15118 break;
15119 case 0x05 :
15120 {
15121 Param_Info1("Ls");
15122 Skip_B4( "Reserved");
15123 }
15124 break;
15125 case 0x06 :
15126 {
15127 Param_Info1("Rs");
15128 Skip_B4( "Reserved");
15129 }
15130 break;
15131 case 0x20 :
15132 {
15133 Param_Info1("M1");
15134 Skip_B4( "Reserved");
15135 }
15136 break;
15137 case 0x21 :
15138 {
15139 Param_Info1("M2");
15140 Skip_B4( "Reserved");
15141 }
15142 break;
15143 case 0x22 :
15144 {
15145 Param_Info1("Lt");
15146 Skip_B4( "Reserved");
15147 }
15148 break;
15149 case 0x23 :
15150 {
15151 Param_Info1("Rt");
15152 Skip_B4( "Reserved");
15153 }
15154 break;
15155 default :
15156 Skip_B4( "Unknown");
15157 }
15158 }
15159 break;
15160 case 0x02 :
15161 {
15162 Param_Info1("Per group?");
15163 Info_B1(Code4, "Code (4)");
15164 switch (Code4)
15165 {
15166 case 0x01 :
15167 {
15168 Param_Info1("5.1");
15169 Skip_B4( "Reserved");
15170 }
15171 break;
15172 case 0x11 :
15173 {
15174 Param_Info1("Dual Mono");
15175 Skip_B4( "Reserved");
15176 }
15177 break;
15178 case 0x18 :
15179 {
15180 Param_Info1("Lt+Rt");
15181 Skip_B4( "Reserved");
15182 }
15183 break;
15184 default :
15185 Skip_B4( "Unknown");
15186 }
15187 }
15188 break;
15189 default :
15190 Skip_B5( "Unknown");
15191 }
15192 }
15193 break;
15194 case 0x02 :
15195 {
15196 Param_Info1("Per element?");
15197 Info_B1(Code3, "Code (3)");
15198 switch (Code3)
15199 {
15200 case 0x01 :
15201 {
15202 Param_Info1("Channels?");
15203 Info_B1(Code4, "Code (4)");
15204 switch (Code4)
15205 {
15206 case 0x01 :
15207 {
15208 Param_Info1("L");
15209 Skip_B4( "Reserved");
15210 }
15211 break;
15212 case 0x02 :
15213 {
15214 Param_Info1("R");
15215 Skip_B4( "Reserved");
15216 }
15217 break;
15218 case 0x03 :
15219 {
15220 Param_Info1("C");
15221 Skip_B4( "Reserved");
15222 }
15223 break;
15224 case 0x04 :
15225 {
15226 Param_Info1("LFE");
15227 Skip_B4( "Reserved");
15228 }
15229 break;
15230 case 0x05 :
15231 {
15232 Param_Info1("Ls");
15233 Skip_B4( "Reserved");
15234 }
15235 break;
15236 case 0x06 :
15237 {
15238 Param_Info1("Rs");
15239 Skip_B4( "Reserved");
15240 }
15241 break;
15242 case 0x20 :
15243 {
15244 Param_Info1("Lt+Rt?");
15245 Info_B1(Code5, "Code (5)");
15246 switch (Code5)
15247 {
15248 case 0x03 :
15249 {
15250 Param_Info1("Lt");
15251 Skip_B3( "Reserved");
15252 }
15253 break;
15254 case 0x04 :
15255 {
15256 Param_Info1("Rt");
15257 Skip_B3( "Reserved");
15258 }
15259 break;
15260 default :
15261 Skip_B3( "Unknown");
15262 }
15263 }
15264 break;
15265 default :
15266 Skip_B4( "Unknown");
15267 }
15268 }
15269 break;
15270 case 0x02 :
15271 {
15272 Param_Info1("Per group?");
15273 Info_B1(Code4, "Code (4)");
15274 switch (Code4)
15275 {
15276 case 0x01 :
15277 {
15278 Param_Info1("5.1");
15279 Skip_B4( "Reserved");
15280 }
15281 break;
15282 case 0x10 :
15283 {
15284 Param_Info1("2.0");
15285 Skip_B4( "Reserved");
15286 }
15287 break;
15288 case 0x18 :
15289 {
15290 Param_Info1("Lt+Rt");
15291 Skip_B4( "Reserved");
15292 }
15293 break;
15294 case 0x20 :
15295 {
15296 Param_Info1("?");
15297 Info_B1(Code5, "Code (5)");
15298 switch (Code5)
15299 {
15300 case 0x01 :
15301 {
15302 Param_Info1("2.0");
15303 Skip_B3( "Reserved");
15304 }
15305 break;
15306 case 0x09 :
15307 {
15308 Param_Info1("Lt+Rt");
15309 Skip_B3( "Reserved");
15310 }
15311 break;
15312 default :
15313 Skip_B3( "Unknown");
15314 }
15315 }
15316 break;
15317 default :
15318 Skip_B4( "Unknown");
15319 }
15320 }
15321 break;
15322 default :
15323 Skip_B5( "Unknown");
15324 }
15325 }
15326 break;
15327 default :
15328 Skip_B6( "Unknown");
15329 }
15330 }
15331 break;
15332 case 0x04 :
15333 {
15334 Param_Info1("Parametric");
15335 Info_B1(Code2, "Code (2)");
15336 switch (Code2)
15337 {
15338 case 0x01 :
15339 {
15340 Param_Info1("Picture essence");
15341 Info_B1(Code3, "Code (3)");
15342 switch (Code3)
15343 {
15344 case 0x01 :
15345 {
15346 Param_Info1("Fundamental Picture Characteristics");
15347 Info_B1(Code4, "Code (4)");
15348 switch (Code4)
15349 {
15350 case 0x01 :
15351 {
15352 Param_Info1("Picture Source Characteristics");
15353 Info_B1(Code5, "Code (5)");
15354 switch (Code5)
15355 {
15356 case 0x01 :
15357 {
15358 Param_Info1("Transfer Characteristic");
15359 Info_B1(Code6, "Code (6)");
15360 switch (Code6)
15361 {
15362 case 0x01 :
15363 Param_Info1("BT.470 System B/G");
15364 Skip_B2( "Reserved");
15365 break;
15366 case 0x02 :
15367 Param_Info1("BT.709");
15368 Skip_B2( "Reserved");
15369 break;
15370 case 0x03 :
15371 Param_Info1("SMPTE 240M");
15372 Skip_B2( "Reserved");
15373 break;
15374 case 0x04 :
15375 Param_Info1("SMPTE 274M");
15376 Skip_B2( "Reserved");
15377 break;
15378 case 0x05 :
15379 Param_Info1("BT.1361");
15380 Skip_B2( "Reserved");
15381 break;
15382 case 0x06 :
15383 Param_Info1("Linear");
15384 Skip_B2( "Reserved");
15385 break;
15386 case 0x07 :
15387 Param_Info1("SMPTE 428M");
15388 Skip_B2( "Reserved");
15389 break;
15390 default :
15391 Skip_B2( "Unknown");
15392 }
15393 }
15394 break;
15395 case 0x02 :
15396 {
15397 Param_Info1("Coding Equations");
15398 Info_B1(Code6, "Code (6)");
15399 switch (Code6)
15400 {
15401 case 0x01 :
15402 Param_Info1("BT.601");
15403 Skip_B2( "Reserved");
15404 break;
15405 case 0x02 :
15406 Param_Info1("BT.709");
15407 Skip_B2( "Reserved");
15408 break;
15409 case 0x03 :
15410 Param_Info1("SMPTE 240M");
15411 Skip_B2( "Reserved");
15412 break;
15413 default :
15414 Skip_B2( "Unknown");
15415 }
15416 }
15417 break;
15418 case 0x03 :
15419 {
15420 Param_Info1("Color Primaries");
15421 Info_B1(Code6, "Code (6)");
15422 switch (Code6)
15423 {
15424 case 0x01 :
15425 Param_Info1("BT.601 NTSC");
15426 Skip_B2( "Reserved");
15427 break;
15428 case 0x02 :
15429 Param_Info1("BT.470 System B/G");
15430 Skip_B2( "Reserved");
15431 break;
15432 case 0x03 :
15433 Param_Info1("BT.709");
15434 Skip_B2( "Reserved");
15435 break;
15436 default :
15437 Skip_B2( "Unknown");
15438 }
15439 }
15440 break;
15441 default :
15442 Skip_B3( "Unknown");
15443 }
15444 }
15445 break;
15446 default :
15447 Skip_B4( "Unknown");
15448 }
15449 }
15450 break;
15451 case 0x02 :
15452 Param_Info1("Picture Coding Characteristics");
15453 Info_B1(Code4, "Code (4)");
15454 switch (Code4)
15455 {
15456 case 0x01 :
15457 Param_Info1("Uncompressed Picture Coding");
15458 Skip_B1( "Item Type Identifier"); //if 0x14: SMPTE 384M Uncompressed picture Line wrapped
15459 Skip_B1( "System Scheme Identifier"); //SMPTE 384M
15460 Skip_B1( "System Element Identifier"); //SMPTE 384M
15461 Skip_B1( "Reserved");
15462 break;
15463 case 0x02 :
15464 {
15465 Param_Info1("Compressed Picture Coding");
15466 Info_B1(Code5, "Code (5)");
15467 switch (Code5)
15468 {
15469 case 0x01 :
15470 {
15471 Param_Info1("MPEG Compression");
15472 Info_B1(Code6, "Code (6)");
15473 switch (Code6)
15474 {
15475 case 0x01 :
15476 Param_Info1("MPEG-2 MP@ML");
15477 Skip_B2( "Unknown");
15478 break;
15479 case 0x02 :
15480 Param_Info1("MPEG-2 422P@ML");
15481 Skip_B2( "Unknown");
15482 break;
15483 case 0x03 :
15484 Param_Info1("MPEG-2 MP@HL");
15485 Skip_B2( "Unknown");
15486 break;
15487 case 0x04 :
15488 Param_Info1("MPEG-2 422P@HL");
15489 Skip_B2( "Unknown");
15490 break;
15491 case 0x10 :
15492 Param_Info1("MPEG-1");
15493 Skip_B2( "Unknown");
15494 break;
15495 case 0x20 :
15496 Param_Info1("MPEG-4 Visual");
15497 Skip_B2( "Unknown");
15498 break;
15499 case 0x32 :
15500 Param_Info1("AVC");
15501 Skip_B2( "Unknown");
15502 break;
15503 default :
15504 Skip_B2( "Unknown");
15505 }
15506 }
15507 break;
15508 case 0x02 :
15509 {
15510 Param_Info1("DV Video Compression");
15511 Info_B1(Code6, "Code (6)");
15512 switch (Code6)
15513 {
15514 case 0x02 :
15515 Param_Info1("DV-Based Compression");
15516 Info_B1(Code7, "DV type (SMPTE 383)");
15517 Info_B1(Code8, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
15518 break;
15519 default :
15520 Skip_B2( "Unknown");
15521 }
15522 }
15523 break;
15524 case 0x03 :
15525 {
15526 Param_Info1("Individual Picture Coding Schemes");
15527 Info_B1(Code6, "Code (6)");
15528 switch (Code6)
15529 {
15530 case 0x01 :
15531 Param_Info1("JPEG 2000");
15532 Skip_B1( "Unused");
15533 Skip_B1( "Unused");
15534 break;
15535 case 0x06 :
15536 Param_Info1("ProRes");
15537 Skip_B1( "Profile");
15538 Skip_B1( "Unused");
15539 break;
15540 default :
15541 Skip_B2( "Unknown");
15542 }
15543 }
15544 break;
15545 case 0x71 :
15546 {
15547 Param_Info1("VC-3");
15548 Skip_B1( "Variant");
15549 Skip_B1( "Unused");
15550 Skip_B1( "Unused");
15551 }
15552 break;
15553 default :
15554 Skip_B3( "Unknown");
15555 }
15556 }
15557 break;
15558 default :
15559 Skip_B4( "Unknown");
15560 }
15561 break;
15562 default :
15563 Skip_B5( "Unknown");
15564 }
15565 }
15566 break;
15567 case 0x02 :
15568 {
15569 Param_Info1("Sound essence");
15570 Info_B1(Code3, "Code (3)");
15571 switch (Code3)
15572 {
15573 case 0x01 :
15574 Skip_B5( "Sound coding or compression");
15575 break;
15576 case 0x02 :
15577 {
15578 Param_Info1("Sound Coding Characteristics");
15579 Info_B1(Code4, "Code (4)");
15580 switch (Code4)
15581 {
15582 case 0x01 :
15583 {
15584 Param_Info1("Uncompressed Sound Coding");
15585 Info_B1(Code5, "Code (5)");
15586 switch (Code5)
15587 {
15588 case 0x7E :
15589 {
15590 Param_Info1("PCM (AIFF)");
15591 Skip_B3( "Reserved");
15592 }
15593 break;
15594 case 0x7F :
15595 {
15596 Param_Info1("Undefined");
15597 Skip_B3( "Reserved");
15598 }
15599 break;
15600 default :
15601 Skip_B3( "Unknown");
15602 }
15603 }
15604 break;
15605 case 0x02 :
15606 {
15607 Param_Info1("Compressed Sound Coding");
15608 Info_B1(Code5, "Code (5)");
15609 switch (Code5)
15610 {
15611 case 0x03 :
15612 {
15613 Param_Info1("Compressed Audio Coding");
15614 Info_B1(Code6, "Code (6)");
15615 switch (Code6)
15616 {
15617 case 0x01 :
15618 {
15619 Param_Info1("Compandeded Audio Coding");
15620 Info_B1(Code7, "Code (7)");
15621 switch (Code7)
15622 {
15623 case 0x01 :
15624 Param_Info1("A-law Coded Audio (default)");
15625 Skip_B1("Unknown");
15626 break;
15627 case 0x02 :
15628 Param_Info1("DV Compressed Audio");
15629 Skip_B1("Unknown");
15630 break;
15631 default :
15632 Skip_B2("Unknown");
15633 }
15634 }
15635 break;
15636 case 0x02 :
15637 {
15638 Param_Info1("SMPTE 338M Audio Coding");
15639 Info_B1(Code7, "Code (7)");
15640 switch (Code7)
15641 {
15642 case 0x01 :
15643 Param_Info1("AC-3");
15644 Skip_B1("Unknown");
15645 break;
15646 case 0x04 :
15647 Param_Info1("MPEG-1 Audio Layer 1");
15648 Skip_B1("Unknown");
15649 break;
15650 case 0x05 :
15651 Param_Info1("MPEG-1 Audio Layer 2");
15652 Skip_B1("Unknown");
15653 break;
15654 case 0x06 :
15655 Param_Info1("MPEG-2 Audio Layer 1");
15656 Skip_B1("Unknown");
15657 break;
15658 case 0x1C :
15659 Param_Info1("Dolby E");
15660 Skip_B1("Unknown");
15661 break;
15662 default :
15663 Skip_B2("Unknown");
15664 }
15665 }
15666 break;
15667 case 0x03 :
15668 {
15669 Param_Info1("MPEG-2 Coding (not defined in SMPTE 338M)");
15670 Info_B1(Code7, "Code (7)");
15671 switch (Code7)
15672 {
15673 case 0x01 :
15674 Param_Info1("AAC version 2");
15675 Skip_B1("Unknown");
15676 break;
15677 default :
15678 Skip_B2("Unknown");
15679 }
15680 }
15681 break;
15682 case 0x04 :
15683 {
15684 Param_Info1("MPEG-4 Audio Coding");
15685 Info_B1(Code7, "Code (7)");
15686 switch (Code7)
15687 {
15688 case 0x01 :
15689 Param_Info1("MPEG-4 Speech Profile");
15690 Skip_B1("Unknown");
15691 break;
15692 case 0x02 :
15693 Param_Info1("MPEG-4 Synthesis Profile");
15694 Skip_B1("Unknown");
15695 break;
15696 case 0x03 :
15697 Param_Info1("MPEG-4 Scalable Profile");
15698 Skip_B1("Unknown");
15699 break;
15700 case 0x04 :
15701 Param_Info1("MPEG-4 Main Profile");
15702 Skip_B1("Unknown");
15703 break;
15704 case 0x05 :
15705 Param_Info1("MPEG-4 High Quality Audio Profile");
15706 Skip_B1("Unknown");
15707 break;
15708 case 0x06 :
15709 Param_Info1("MPEG-4 Low Delay Audio Profile");
15710 Skip_B1("Unknown");
15711 break;
15712 case 0x07 :
15713 Param_Info1("MPEG-4 Natural Audio Profile");
15714 Skip_B1("Unknown");
15715 break;
15716 case 0x08 :
15717 Param_Info1("MPEG-4 Mobile Audio Internetworking Profile");
15718 Skip_B1("Unknown");
15719 break;
15720 default :
15721 Skip_B1("Unknown");
15722 }
15723 }
15724 break;
15725 default :
15726 Skip_B2( "Unknown");
15727 }
15728 }
15729 break;
15730 default :
15731 Skip_B3( "Unknown");
15732 }
15733 }
15734 break;
15735 case 0x10 :
15736 {
15737 Param_Info1("Sound Channel Labeling");
15738 Info_B1(Code5, "Code (5)");
15739 switch (Code5)
15740 {
15741 case 0x03 :
15742 {
15743 Param_Info1("Sound Channel Labeling SMPTE 429-2");
15744 Info_B1(Code6, "Code (6)");
15745 switch (Code6)
15746 {
15747 case 0x01 :
15748 {
15749 Param_Info1("Sound Channel Labeling SMPTE 429-2 Sets");
15750 Info_B1(Code7, "Code (7)");
15751 switch (Code7)
15752 {
15753 case 0x01 :
15754 Param_Info1("SMPTE-429-2 Channel Configuration 1");
15755 Skip_B1("Reserved");
15756 break;
15757 default :
15758 Skip_B1("Unknown");
15759 }
15760 }
15761 break;
15762 default :
15763 Skip_B2( "Unknown");
15764 }
15765 }
15766 break;
15767 case 0x04 :
15768 {
15769 Param_Info1("Sound Channel Labeling SMPTE 2067-2");
15770 Info_B1(Code6, "Code (6)");
15771 switch (Code6)
15772 {
15773 case 0x01 :
15774 {
15775 Param_Info1("MXF Multichannel Audio Framework");
15776 Skip_B2( "Reserved");
15777 }
15778 break;
15779 default :
15780 Skip_B2( "Unknown");
15781 }
15782 }
15783 break;
15784 default :
15785 Skip_B3( "Unknown");
15786 }
15787 }
15788 break;
15789 default :
15790 Skip_B4( "Unknown");
15791 }
15792 }
15793 break;
15794 default :
15795 Skip_B5( "Unknown");
15796 }
15797 }
15798 break;
15799 default :
15800 Skip_B6( "Unknown");
15801 }
15802 }
15803 break;
15804 case 0x0D :
15805 {
15806 Param_Info1("User Organisation Registered For Public Use");
15807 Info_B1(Code2, "Organization");
15808 switch (Code2)
15809 {
15810 case 0x01 :
15811 {
15812 Param_Info1("AAF");
15813 Info_B1(Code3, "Application");
15814 switch (Code3)
15815 {
15816 case 0x02 :
15817 {
15818 Param_Info1("Operational Patterns");
15819 Info_B1(Code4, "Version");
15820 switch (Code4)
15821 {
15822 case 0x01 :
15823 {
15824 Param_Info1("Version 1");
15825 Info_B1(Code5, "Item Complexity");
15826 Info_B1(Code6, "Package Complexity");
15827 Info_B1(Code7, "Qualifier");
15828 Skip_Flags(Code7, 3, "uni/multi-track");
15829 Skip_Flags(Code7, 2, "stream/non-stream file");
15830 Skip_Flags(Code7, 1, "internal/external essence");
15831 Info_B1(Code8, "Reserved");
15832 }
15833 break;
15834 case 0x02 :
15835 {
15836 Info_B1(Code5, "Code (5)");
15837 switch (Code5)
15838 {
15839 case 0x01 :
15840 Skip_B3( "Essence container kind");
15841 break;
15842 default :
15843 Skip_B3( "Unknown");
15844 }
15845 }
15846 break;
15847 default :
15848 Skip_B4( "Unknown");
15849 }
15850 }
15851 break;
15852 case 0x03 :
15853 {
15854 Param_Info1("Essence Container Application");
15855 Info_B1(Code4, "Structure Version");
15856 switch (Code4)
15857 {
15858 case 0x01 :
15859 {
15860 Param_Info1("MXF EC Structure Version 1");
15861 Info_B1(Code5, "Essence container Kind");
15862 switch (Code5)
15863 {
15864 case 0x01 :
15865 Param_Info1("Deprecated Essence Container Kind");
15866 Skip_B3( "Unknown");
15867 break;
15868 case 0x02 :
15869 {
15870 Param_Info1("Essence Container Kind");
15871 Info_B1(Code6, "Code (6)");
15872 switch (Code6)
15873 {
15874 case 0x01 : //SMPTE 386M
15875 {
15876 Param_Info1("Type D-10 Mapping");
15877 Skip_B1( "MPEG Constraints"); //SMPTE 356M
15878 Skip_B1( "Template Extension");
15879 }
15880 break;
15881 case 0x02 :
15882 {
15883 Param_Info1("DV Mappings");
15884 Skip_B1( "Mapping Kind");
15885 Skip_B1( "Locally defined");
15886 }
15887 break;
15888 case 0x03 :
15889 {
15890 Param_Info1("Type D-11 Mapping");
15891 Skip_B1( "Mapping Kind");
15892 Skip_B1( "Locally defined");
15893 }
15894 break;
15895 case 0x04 :
15896 {
15897 Param_Info1("MPEG ES mappings");
15898 Info_B1(Code7, "ISO13818-1 stream_id bits 6..0"); Param_Info1(Ztring::ToZtring(0x80+Code7, 16));
15899 Info_B1(Code8, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
15900 }
15901 break;
15902 case 0x05 : //SMPTE 384M
15903 {
15904 Param_Info1("Uncompressed Pictures");
15905 Info_B1(Code7, "Number of lines / field rate combination"); //SMPTE 384M
15906 Info_B1(Code8, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
15907 }
15908 break;
15909 case 0x06 :
15910 {
15911 Param_Info1("AES-BWF");
15912 Info_B1(Code7, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, 0x00));
15913 Skip_B1( "Locally defined");
15914 }
15915 break;
15916 case 0x07 :
15917 {
15918 Param_Info1("MPEG PES mappings");
15919 Info_B1(Code7, "ISO13818-1 stream_id bits 6..0"); Param_Info1(Ztring::ToZtring(0x80+Code7, 16));
15920 Info_B1(Code8, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
15921 }
15922 break;
15923 case 0x08 :
15924 {
15925 Param_Info1("MPEG PS mappings");
15926 Info_B1(Code7, "ISO13818-1 stream_id bits 6..0"); Param_Info1(Ztring::ToZtring(0x80+Code7, 16));
15927 Info_B1(Code8, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
15928 }
15929 break;
15930 case 0x09 :
15931 {
15932 Param_Info1("MPEG TS mappings");
15933 Info_B1(Code7, "ISO13818-1 stream_id bits 6..0"); Param_Info1(Ztring::ToZtring(0x80+Code7, 16));
15934 Info_B1(Code8, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, Code8));
15935 }
15936 break;
15937 case 0x0A :
15938 {
15939 Param_Info1("A-law Sound Element Mapping");
15940 Info_B1(Code7, "Mapping Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, 0xFF));
15941 Skip_B1( "Locally defined");
15942 }
15943 break;
15944 case 0x0B :
15945 {
15946 Param_Info1("Encrypted Generic Container");
15947 Skip_B1( "Mapping Kind");
15948 Skip_B1( "Locally defined");
15949 }
15950 break;
15951 case 0x0C :
15952 {
15953 Param_Info1("JPEG 2000 Picture Mapping");
15954 Skip_B1( "Mapping Kind");
15955 Skip_B1( "Locally defined");
15956 }
15957 break;
15958 case 0x11 :
15959 {
15960 Param_Info1("VC-3 Picture Element");
15961 Info_B1(Code7, "Content Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, 0xFF));
15962 Skip_B1( "Reserved");
15963 }
15964 break;
15965 case 0x13 :
15966 {
15967 Param_Info1("Timed Text");
15968 Skip_B1( "Reserved");
15969 Skip_B1( "Reserved");
15970 }
15971 break;
15972 case 0x16 :
15973 {
15974 Param_Info1("AVC Picture Element");
15975 Skip_B1( "Unknown");
15976 Skip_B1( "Unknown");
15977 }
15978 break;
15979 case 0x1C :
15980 {
15981 Param_Info1("ProRes");
15982 Info_B1(Code7, "Content Kind"); Param_Info1(Mxf_EssenceContainer_Mapping(Code6, Code7, 0xFF));
15983 Skip_B1( "Unknown");
15984 }
15985 break;
15986 case 0x7F :
15987 {
15988 Param_Info1("Generic Essence Container Wrapping");
15989 Skip_B1( "Mapping Kind");
15990 Skip_B1( "Locally defined");
15991 }
15992 break;
15993 default :
15994 {
15995 Skip_B1( "Mapping Kind");
15996 Skip_B1( "Locally defined");
15997 }
15998 }
15999 }
16000 break;
16001 default :
16002 Skip_B1( "Essence container Kind");
16003 Skip_B1( "Mapping Kind");
16004 Skip_B1( "Locally defined");
16005 }
16006 }
16007 break;
16008 default :
16009 Skip_B4( "Unknown");
16010 }
16011 }
16012 break;
16013 case 0x04 :
16014 {
16015 Param_Info1("MXF / AAF compatible Descriptive Metadata Labels");
16016 Info_B1(Code4, "Label Version");
16017 switch (Code4)
16018 {
16019 case 0x01 :
16020 {
16021 Param_Info1("Version 1");
16022 Info_B1(Code5, "Scheme Kind");
16023 Info_B1(Code6, "Reserved");
16024 Info_B1(Code7, "Reserved");
16025 Info_B1(Code8, "Reserved");
16026 }
16027 break;
16028 default :
16029 Skip_B4( "Unknown");
16030 }
16031 }
16032 break;
16033 default :
16034 Skip_B5( "Unknown");
16035 }
16036 }
16037 break;
16038 case 0x02 :
16039 {
16040 Param_Info1("EBU/UER");
16041 Skip_B6( "Unknown");
16042 }
16043 break;
16044 case 0x03 :
16045 {
16046 Param_Info1("Pro-MPEG Forum");
16047 Skip_B6( "Unknown");
16048 }
16049 break;
16050 case 0x04 :
16051 {
16052 Param_Info1("BBC");
16053 Skip_B6( "Unknown");
16054 }
16055 break;
16056 case 0x05 :
16057 {
16058 Param_Info1("IRT");
16059 Skip_B6( "Unknown");
16060 }
16061 break;
16062 case 0x06 :
16063 {
16064 Param_Info1("ARIB");
16065 Skip_B6( "Unknown");
16066 }
16067 break;
16068 default :
16069 Skip_B6( "Unknown");
16070 }
16071 }
16072 break;
16073 case 0x0E :
16074 {
16075 Param_Info1("User Organisation Registered For Private Use");
16076 Info_B1(Code2, "Code (2)");
16077 switch (Code2)
16078 {
16079 case 0x04 :
16080 {
16081 Param_Info1("Avid");
16082 Info_B1(Code3, "Code (3)");
16083 switch (Code3)
16084 {
16085 case 0x02 :
16086 {
16087 Param_Info1("Essence Compression?");
16088 Info_B1(Code4, "?");
16089 switch (Code4)
16090 {
16091 case 0x01 :
16092 {
16093 Param_Info1("?");
16094 Info_B1(Code5, "?");
16095 switch (Code5)
16096 {
16097 case 0x02 :
16098 {
16099 Param_Info1("?");
16100 Info_B1(Code6, "Code (6)");
16101 switch (Code6)
16102 {
16103 case 0x04 :
16104 Param_Info1("VC-3");
16105 Skip_B2( "Unknown");
16106 break;
16107 default :
16108 Skip_B2( "Unknown");
16109 }
16110 }
16111 break;
16112 default :
16113 Skip_B3( "Unknown");
16114 }
16115 }
16116 break;
16117 default :
16118 Skip_B4( "Unknown");
16119 }
16120 }
16121 break;
16122 case 0x03 :
16123 {
16124 Param_Info1("Essence Container Application");
16125 Info_B1(Code4, "Structure Version");
16126 switch (Code4)
16127 {
16128 case 0x01 :
16129 {
16130 Param_Info1("MXF EC Structure Version 1");
16131 Info_B1(Code5, "Essence container Kind");
16132 switch (Code5)
16133 {
16134 case 0x02 :
16135 {
16136 Param_Info1("Essence Container Kind");
16137 Info_B1(Code6, "Code (6)");
16138 switch (Code6)
16139 {
16140 case 0x06 :
16141 Param_Info1("VC-3");
16142 Skip_B2( "Unknown");
16143 break;
16144 default :
16145 Skip_B2( "Unknown");
16146 }
16147 }
16148 break;
16149 default :
16150 Skip_B3( "Unknown");
16151 }
16152 }
16153 break;
16154 default :
16155 Skip_B4( "Unknown");
16156 }
16157 }
16158 break;
16159 default :
16160 Skip_B5( "Unknown");
16161 }
16162 }
16163 break;
16164 case 0x06 :
16165 {
16166 Param_Info1("Sony");
16167 Info_B1(Code3, "Code (3)");
16168 switch (Code3)
16169 {
16170 case 0x04 :
16171 {
16172 Param_Info1("Essence Compression?");
16173 Info_B1(Code4, "?");
16174 switch (Code4)
16175 {
16176 case 0x01 :
16177 {
16178 Param_Info1("?");
16179 Info_B1(Code5, "?");
16180 switch (Code5)
16181 {
16182 case 0x02 :
16183 {
16184 Param_Info1("?");
16185 Info_B1(Code6, "Code (6)");
16186 switch (Code6)
16187 {
16188 case 0x04 :
16189 {
16190 Param_Info1("?");
16191 Info_B1(Code7, "Code (7)");
16192 switch (Code7)
16193 {
16194 case 0x02 :
16195 Param_Info1("?");
16196 Info_B1(Code8, "Code (8)");
16197 switch (Code8)
16198 {
16199 case 0x01 :
16200 Param_Info1("RAW SQ");
16201 break;
16202 default :
16203 ;
16204 }
16205 break;
16206 default :
16207 Skip_B1( "Unknown");
16208 }
16209 }
16210 break;
16211 default :
16212 Skip_B2( "Unknown");
16213 }
16214 }
16215 break;
16216 default :
16217 Skip_B3( "Unknown");
16218 }
16219 }
16220 break;
16221 default :
16222 Skip_B4( "Unknown");
16223 }
16224 }
16225 break;
16226 case 0x0D :
16227 {
16228 Param_Info1("Essence Container?");
16229 Info_B1(Code4, "?");
16230 switch (Code4)
16231 {
16232 case 0x03 :
16233 {
16234 Param_Info1("?");
16235 Info_B1(Code5, "?");
16236 switch (Code5)
16237 {
16238 case 0x02 :
16239 {
16240 Param_Info1("?");
16241 Info_B1(Code6, "Code (6)");
16242 switch (Code6)
16243 {
16244 case 0x01 :
16245 {
16246 Param_Info1("?");
16247 Info_B1(Code7, "Code (7)");
16248 switch (Code7)
16249 {
16250 case 0x01 :
16251 Param_Info1("RAW?");
16252 Skip_B1( "Unknown");
16253 break;
16254 default :
16255 Skip_B1( "Unknown");
16256 }
16257 }
16258 break;
16259 default :
16260 Skip_B2( "Unknown");
16261 }
16262 }
16263 break;
16264 default :
16265 Skip_B3( "Unknown");
16266 }
16267 }
16268 break;
16269 default :
16270 Skip_B4( "Unknown");
16271 }
16272 }
16273 break;
16274 default :
16275 Skip_B5( "Private");
16276 }
16277 }
16278 break;
16279 default :
16280 Skip_B6( "Private");
16281 }
16282 }
16283 break;
16284 default :
16285 Skip_B7( "Unknown");
16286 }
16287 }
16288 #endif //MEDIAINFO_TRACE
16289
16290 //---------------------------------------------------------------------------
Skip_UL(const char * Name)16291 void File_Mxf::Skip_UL(const char* Name)
16292 {
16293 #ifdef MEDIAINFO_MINIMIZE_SIZE
16294 Skip_UUID();
16295 #else
16296 int128u Value;
16297 Get_UL(Value, Name, NULL);
16298 #endif
16299 }
16300
16301 //---------------------------------------------------------------------------
Get_UMID(int256u & Value,const char * Name)16302 void File_Mxf::Get_UMID(int256u &Value, const char* Name)
16303 {
16304 Element_Name(Name);
16305
16306 //Parsing
16307 Get_UUID (Value.hi, "Fixed");
16308 Get_UUID (Value.lo, "UUID"); Element_Info1(Ztring().From_UUID(Value.lo));
16309 }
16310
16311 //---------------------------------------------------------------------------
Skip_UMID()16312 void File_Mxf::Skip_UMID()
16313 {
16314 //Parsing
16315 Skip_UUID( "Fixed");
16316 Info_UUID(Data, "UUID"); Element_Info1(Ztring().From_UUID(Data));
16317 }
16318
16319 //---------------------------------------------------------------------------
Get_Timestamp(Ztring & Value)16320 void File_Mxf::Get_Timestamp(Ztring &Value)
16321 {
16322 //Parsing
16323 int16u Year;
16324 int8u Month, Day, Hours, Minutes, Seconds, Milliseconds;
16325 Get_B2 (Year, "Year");
16326 Get_B1 (Month, "Month");
16327 Get_B1 (Day, "Day");
16328 Get_B1 (Hours, "Hours");
16329 Get_B1 (Minutes, "Minutes");
16330 Get_B1 (Seconds, "Seconds");
16331 Get_B1 (Milliseconds, "Milliseconds/4"); Param_Info2(Milliseconds*4, " ms");
16332 Value.From_Number(Year);
16333 Value+=__T('-');
16334 Ztring Temp;
16335 Temp.From_Number(Month);
16336 if (Temp.size()<2)
16337 Temp.insert(0, 1, __T('0'));
16338 Value+=Temp;
16339 Value+=__T('-');
16340 Temp.From_Number(Day);
16341 if (Temp.size()<2)
16342 Temp.insert(0, 1, __T('0'));
16343 Value+=Temp;
16344 Value+=__T(' ');
16345 Temp.From_Number(Hours);
16346 if (Temp.size()<2)
16347 Temp.insert(0, 1, __T('0'));
16348 Value+=Temp;
16349 Value+=__T(':');
16350 Temp.From_Number(Minutes);
16351 if (Temp.size()<2)
16352 Temp.insert(0, 1, __T('0'));
16353 Value+=Temp;
16354 Value+=__T(':');
16355 Temp.From_Number(Seconds);
16356 if (Temp.size()<2)
16357 Temp.insert(0, 1, __T('0'));
16358 Value+=Temp;
16359 Value+=__T('.');
16360 Temp.From_Number(Milliseconds*4);
16361 if (Temp.size()<3)
16362 Temp.insert(0, 3-Temp.size(), __T('0'));
16363 Value+=Temp;
16364 }
16365
16366 //---------------------------------------------------------------------------
Skip_Timestamp()16367 void File_Mxf::Skip_Timestamp()
16368 {
16369 //Parsing
16370 Skip_B2( "Year");
16371 Skip_B1( "Month");
16372 Skip_B1( "Day");
16373 Skip_B1( "Hours");
16374 Skip_B1( "Minutes");
16375 Skip_B1( "Seconds");
16376 Info_B1(Milliseconds, "Milliseconds/4"); Param_Info2(Milliseconds*4, " ms");
16377 }
16378
16379 //---------------------------------------------------------------------------
Info_Timestamp()16380 void File_Mxf::Info_Timestamp()
16381 {
16382 //Parsing
16383 Info_B2(Year, "Year");
16384 Info_B1(Month, "Month");
16385 Info_B1(Day, "Day");
16386 Info_B1(Hours, "Hours");
16387 Info_B1(Minutes, "Minutes");
16388 Info_B1(Seconds, "Seconds");
16389 Info_B1(Milliseconds, "Milliseconds/4"); Param_Info2(Milliseconds*4, " ms");
16390 Element_Info1(Ztring::ToZtring(Year )+__T('-')+
16391 Ztring::ToZtring(Month )+__T('-')+
16392 Ztring::ToZtring(Day )+__T(' ')+
16393 Ztring::ToZtring(Hours )+__T(':')+
16394 Ztring::ToZtring(Minutes )+__T(':')+
16395 Ztring::ToZtring(Seconds )+__T('.')+
16396 Ztring::ToZtring(Milliseconds*4) );
16397 }
16398
16399 //---------------------------------------------------------------------------
Get_BER(int64u & Value,const char * Name)16400 void File_Mxf::Get_BER(int64u &Value, const char* Name)
16401 {
16402 int8u Length;
16403 Get_B1(Length, Name);
16404 if (Length<0x80)
16405 {
16406 Value=Length; //1-byte
16407 return;
16408 }
16409
16410 Length&=0x7F;
16411 switch (Length)
16412 {
16413 case 1 :
16414 {
16415 int8u Length1;
16416 Get_B1(Length1, Name);
16417 Value=Length1;
16418 break;
16419 }
16420 case 2 :
16421 {
16422 int16u Length2;
16423 Get_B2(Length2, Name);
16424 Value=Length2;
16425 break;
16426 }
16427 case 3 :
16428 {
16429 int32u Length3;
16430 Get_B3(Length3, Name);
16431 Value=Length3;
16432 break;
16433 }
16434 case 4 :
16435 {
16436 int32u Length4;
16437 Get_B4(Length4, Name);
16438 Value=Length4;
16439 break;
16440 }
16441 case 5 :
16442 {
16443 int64u Length5;
16444 Get_B5(Length5, Name);
16445 Value=Length5;
16446 break;
16447 }
16448 case 6 :
16449 {
16450 int64u Length6;
16451 Get_B6(Length6, Name);
16452 Value=Length6;
16453 break;
16454 }
16455 case 7 :
16456 {
16457 int64u Length7;
16458 Get_B7(Length7, Name);
16459 Value=Length7;
16460 break;
16461 }
16462 case 8 :
16463 {
16464 int64u Length8;
16465 Get_B8(Length8, Name);
16466 Value=Length8;
16467 break;
16468 }
16469 default:Value=(int64u)-1; //Problem
16470 }
16471 }
16472
16473 //***************************************************************************
16474 // Parsers
16475 //***************************************************************************
16476
16477 //---------------------------------------------------------------------------
ChooseParser(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16478 void File_Mxf::ChooseParser(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16479 {
16480 if ((Descriptor->second.EssenceCompression.hi&0xFFFFFFFFFFFFFF00LL)!=0x060E2B3404010100LL || (Descriptor->second.EssenceCompression.lo&0xFF00000000000000LL)!=0x0400000000000000LL)
16481 return ChooseParser__FromEssenceContainer (Essence, Descriptor);
16482
16483 int8u Code2=(int8u)((Descriptor->second.EssenceCompression.lo&0x00FF000000000000LL)>>48);
16484 int8u Code3=(int8u)((Descriptor->second.EssenceCompression.lo&0x0000FF0000000000LL)>>40);
16485 int8u Code4=(int8u)((Descriptor->second.EssenceCompression.lo&0x000000FF00000000LL)>>32);
16486 int8u Code5=(int8u)((Descriptor->second.EssenceCompression.lo&0x00000000FF000000LL)>>24);
16487 int8u Code6=(int8u)((Descriptor->second.EssenceCompression.lo&0x0000000000FF0000LL)>>16);
16488 int8u Code7=(int8u)((Descriptor->second.EssenceCompression.lo&0x000000000000FF00LL)>> 8);
16489
16490 switch (Code2)
16491 {
16492 case 0x01 : //Picture
16493 switch (Code3)
16494 {
16495 case 0x02 : //Coding characteristics
16496 switch (Code4)
16497 {
16498 case 0x01 : //Uncompressed Picture Coding
16499 switch (Code5)
16500 {
16501 case 0x01 : return ChooseParser_Raw(Essence, Descriptor);
16502 case 0x7F : return ChooseParser_RV24(Essence, Descriptor);
16503 default : return;
16504 }
16505 case 0x02 : //Compressed coding
16506 switch (Code5)
16507 {
16508 case 0x01 : //MPEG Compression
16509 switch (Code6)
16510 {
16511 case 0x01 :
16512 case 0x02 :
16513 case 0x03 :
16514 case 0x04 :
16515 case 0x11 : return ChooseParser_Mpegv(Essence, Descriptor);
16516 case 0x20 : return ChooseParser_Mpeg4v(Essence, Descriptor);
16517 case 0x30 :
16518 case 0x31 :
16519 case 0x32 :
16520 case 0x33 :
16521 case 0x34 :
16522 case 0x35 :
16523 case 0x36 :
16524 case 0x37 :
16525 case 0x38 :
16526 case 0x39 :
16527 case 0x3A :
16528 case 0x3B :
16529 case 0x3C :
16530 case 0x3D :
16531 case 0x3E :
16532 case 0x3F : return ChooseParser_Avc(Essence, Descriptor);
16533 default : return;
16534 }
16535 case 0x02 : return ChooseParser_DV(Essence, Descriptor);
16536 case 0x03 : //Individual Picture Coding Schemes
16537 switch (Code6)
16538 {
16539 case 0x01 : return ChooseParser_Jpeg2000(Essence, Descriptor);
16540 case 0x06 : return ChooseParser_ProRes(Essence, Descriptor);
16541 default : return;
16542 }
16543 case 0x71 : return ChooseParser_Vc3(Essence, Descriptor);
16544 default : return;
16545 }
16546 default : return;
16547 }
16548 default : return;
16549 }
16550 case 0x02 : //Sound
16551 switch (Code3)
16552 {
16553 case 0x02 : //Coding characteristics
16554 switch (Code4)
16555 {
16556 case 0x01 : //Uncompressed Sound Coding
16557 ChooseParser__FromEssenceContainer (Essence, Descriptor); //e.g. for D-10 Audio
16558 if (!Essence->second.Parsers.empty())
16559 return;
16560 switch (Code5)
16561 {
16562 case 0x01 :
16563 case 0x7E :
16564 case 0x7F : if (Descriptor->second.ChannelCount==1) //PCM, but one file is found with Dolby E in it
16565 ChooseParser_ChannelGrouping(Essence, Descriptor);
16566 if (Descriptor->second.ChannelCount==2) //PCM, but one file is found with Dolby E in it
16567 ChooseParser_SmpteSt0337(Essence, Descriptor);
16568 if (Descriptor->second.ChannelCount>=2 && Descriptor->second.ChannelCount!=(int32u)-1) //PCM, but one file is found with Dolby E in it
16569 ChooseParser_ChannelSplitting(Essence, Descriptor);
16570 default : return ChooseParser_Pcm(Essence, Descriptor);
16571 }
16572 case 0x02 : //Compressed coding
16573 switch (Code5)
16574 {
16575 case 0x03 : //Compressed Audio Coding
16576 switch (Code6)
16577 {
16578 case 0x01 : //Compandeded Audio Coding
16579 switch (Code7)
16580 {
16581 case 0x01 : if ((Descriptor->second.EssenceContainer.lo&0xFFFF0000)==0x02060000) //Test coherency between container and compression
16582 return ChooseParser_Pcm(Essence, Descriptor); //Compression is A-Law but Container is PCM, not logic, prioritizing PCM
16583 else
16584 return ChooseParser_Alaw(Essence, Descriptor);
16585 case 0x10 : return ChooseParser_Pcm(Essence, Descriptor); //DV 12-bit
16586 default : return;
16587 }
16588 case 0x02 : //SMPTE 338M Audio Coding
16589 switch (Code7)
16590 {
16591 case 0x01 : if (Descriptor->second.IsAes3Descriptor)
16592 return ChooseParser_SmpteSt0337(Essence, Descriptor);
16593 else
16594 return ChooseParser_Ac3(Essence, Descriptor);
16595 case 0x04 :
16596 case 0x05 :
16597 case 0x06 : if (Descriptor->second.IsAes3Descriptor)
16598 return ChooseParser_SmpteSt0337(Essence, Descriptor);
16599 else
16600 return ChooseParser_Mpega(Essence, Descriptor);
16601 case 0x0A : return ChooseParser_Iab(Essence, Descriptor);
16602 case 0x1C : if (Descriptor->second.ChannelCount==1)
16603 return ChooseParser_ChannelGrouping(Essence, Descriptor); //Dolby E (in 2 mono streams)
16604 else
16605 return ChooseParser_SmpteSt0337(Essence, Descriptor); //Dolby E (in 1 stereo streams)
16606 default : return;
16607 }
16608 case 0x03 : //MPEG-2 Coding (not defined in SMPTE 338M)
16609 switch (Code7)
16610 {
16611 case 0x01 : return ChooseParser_Aac(Essence, Descriptor);
16612 default : return;
16613 }
16614 case 0x04 : //MPEG-4 Audio Coding
16615 switch (Code7)
16616 {
16617 case 0x01 :
16618 case 0x02 :
16619 case 0x03 :
16620 case 0x04 :
16621 case 0x05 :
16622 case 0x06 :
16623 case 0x07 :
16624 case 0x08 : return ChooseParser_Aac(Essence, Descriptor);
16625 default : return;
16626 }
16627 default : return;
16628 }
16629 default : return;
16630 }
16631 default : return;
16632 }
16633 default : return;
16634 }
16635 default : return;
16636 }
16637 }
16638
16639 //---------------------------------------------------------------------------
ChooseParser__FromEssenceContainer(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16640 void File_Mxf::ChooseParser__FromEssenceContainer(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16641 {
16642 int8u Code1=(int8u)((Descriptor->second.EssenceContainer.lo&0xFF00000000000000LL)>>56);
16643 int8u Code2=(int8u)((Descriptor->second.EssenceContainer.lo&0x00FF000000000000LL)>>48);
16644 int8u Code3=(int8u)((Descriptor->second.EssenceContainer.lo&0x0000FF0000000000LL)>>40);
16645 int8u Code4=(int8u)((Descriptor->second.EssenceContainer.lo&0x000000FF00000000LL)>>32);
16646 int8u Code5=(int8u)((Descriptor->second.EssenceContainer.lo&0x00000000FF000000LL)>>24);
16647 int8u Code6=(int8u)((Descriptor->second.EssenceContainer.lo&0x0000000000FF0000LL)>>16);
16648 //int8u Code7=(int8u)((Descriptor->second.EssenceContainer.lo&0x000000000000FF00LL)>> 8);
16649
16650 switch (Code1)
16651 {
16652 case 0x0D : //Public Use
16653 switch (Code2)
16654 {
16655 case 0x01 : //AAF
16656 switch (Code3)
16657 {
16658 case 0x03 : //Essence Container Application
16659 switch (Code4)
16660 {
16661 case 0x01 : //MXF EC Structure version
16662 switch (Code5)
16663 {
16664 case 0x02 : //Essence container kind
16665 switch (Code6)
16666 {
16667 case 0x01 : switch(Descriptor->second.StreamKind)
16668 {
16669 case Stream_Video : return ChooseParser_Mpegv(Essence, Descriptor);
16670 case Stream_Audio : return ChooseParser_SmpteSt0331(Essence, Descriptor);
16671 default : return;
16672 }
16673 case 0x02 : return; //DV
16674 case 0x05 : return ChooseParser_Raw(Essence, Descriptor);
16675 case 0x06 : if (Descriptor->second.ChannelCount==1) //PCM, but one file is found with Dolby E in it
16676 ChooseParser_ChannelGrouping(Essence, Descriptor);
16677 if (Descriptor->second.ChannelCount==2) //PCM, but one file is found with Dolby E in it
16678 ChooseParser_SmpteSt0337(Essence, Descriptor);
16679 if (Descriptor->second.ChannelCount>2 && Descriptor->second.ChannelCount!=(int32u)-1) //PCM, but one file is found with Dolby E in it
16680 ChooseParser_ChannelSplitting(Essence, Descriptor);
16681 return ChooseParser_Pcm(Essence, Descriptor);
16682 case 0x04 : return; //MPEG ES mappings with Stream ID
16683 case 0x0A : return ChooseParser_Alaw(Essence, Descriptor);
16684 case 0x0C : return ChooseParser_Jpeg2000(Essence, Descriptor);
16685 case 0x10 : return ChooseParser_Avc(Essence, Descriptor);
16686 case 0x11 : return ChooseParser_Vc3(Essence, Descriptor);
16687 case 0x13 : return ChooseParser_TimedText(Essence, Descriptor);
16688 default : return;
16689 }
16690 default : return;
16691 }
16692 default : return;
16693 }
16694 default : return;
16695 }
16696 default : return;
16697 }
16698 case 0x0E : //Private Use
16699 switch (Code2)
16700 {
16701 case 0x04 : //Avid
16702 switch (Code3)
16703 {
16704 case 0x03 : //Essence Container Application
16705 switch (Code4)
16706 {
16707 case 0x01 : //MXF EC Structure version
16708 switch (Code5)
16709 {
16710 case 0x02 : //Essence container kind
16711 switch (Code6)
16712 {
16713 case 0x06 : return ChooseParser_Vc3(Essence, Descriptor);
16714 default : return;
16715 }
16716 default : return;
16717 }
16718 default : return;
16719 }
16720 default : return;
16721 }
16722 default : return;
16723 }
16724 default : return;
16725 }
16726 }
16727
16728 //---------------------------------------------------------------------------
ChooseParser__FromEssence(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16729 void File_Mxf::ChooseParser__FromEssence(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16730 {
16731 int32u Code_Compare3=Code.lo>>32;
16732
16733 switch (Code_Compare3)
16734 {
16735 case Elements::GenericContainer_Aaf3 : return ChooseParser__Aaf(Essence, Descriptor);
16736 case Elements::GenericContainer_Avid3 : return ChooseParser__Avid(Essence, Descriptor);
16737 case Elements::Dolby_PHDRImageMetadataItem3 : return ChooseParser__Dolby(Essence, Descriptor);
16738 case Elements::GenericContainer_Sony3 : return ChooseParser__Sony(Essence, Descriptor);
16739 default : return;
16740 }
16741 }
16742
16743 //---------------------------------------------------------------------------
ChooseParser__Aaf(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16744 void File_Mxf::ChooseParser__Aaf(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16745 {
16746 int32u Code_Compare4=(int32u)Code.lo;
16747 int8u Code_Compare4_1=Code_Compare4>>24;
16748
16749 switch (Code_Compare4_1)
16750 {
16751 case 0x05 : //CP Picture
16752 ChooseParser__Aaf_CP_Picture(Essence, Descriptor);
16753 break;
16754 case 0x06 : //CP Sound
16755 ChooseParser__Aaf_CP_Sound(Essence, Descriptor);
16756 break;
16757 case 0x07 : //CP Data
16758 ChooseParser__Aaf_CP_Data(Essence, Descriptor);
16759 break;
16760 case 0x14 : //MXF in MXF?
16761 ChooseParser__Aaf_14(Essence, Descriptor);
16762 break;
16763 case 0x15 : //CP Picture
16764 ChooseParser__Aaf_GC_Picture(Essence, Descriptor);
16765 break;
16766 case 0x16 : //CP Sound
16767 ChooseParser__Aaf_GC_Sound(Essence, Descriptor);
16768 break;
16769 case 0x17 : //CP Data
16770 ChooseParser__Aaf_GC_Data(Essence, Descriptor);
16771 break;
16772 case 0x18 : //CP Compound
16773 ChooseParser__Aaf_GC_Compound(Essence, Descriptor);
16774 break;
16775 default : //Unknown
16776 ;
16777 }
16778 }
16779
16780 //---------------------------------------------------------------------------
ChooseParser__Avid(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16781 void File_Mxf::ChooseParser__Avid(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16782 {
16783 int32u Code_Compare4=(int32u)Code.lo;
16784 int8u Code_Compare4_1=Code_Compare4>>24;
16785
16786 switch (Code_Compare4_1)
16787 {
16788 case 0x15 : //CP Picture
16789 ChooseParser__Avid_Picture(Essence, Descriptor);
16790 break;
16791 default : //Unknown
16792 ;
16793 }
16794 }
16795
16796 //---------------------------------------------------------------------------
16797 // 0x05, SMPTE 386M
ChooseParser__Aaf_CP_Picture(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16798 void File_Mxf::ChooseParser__Aaf_CP_Picture(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16799 {
16800 int32u Code_Compare4=(int32u)Code.lo;
16801 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
16802
16803 Essences[Code_Compare4].StreamKind=Stream_Video;
16804 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
16805
16806 switch (Code_Compare4_3)
16807 {
16808 case 0x01 : //D-10 Video, SMPTE 386M
16809 ChooseParser_Mpegv(Essence, Descriptor);
16810 break;
16811 default : //Unknown
16812 ;
16813 }
16814 }
16815
16816 //---------------------------------------------------------------------------
ChooseParser__Dolby(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16817 void File_Mxf::ChooseParser__Dolby(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16818 {
16819 int8u Code3=(int8u)((Code.lo&0x0000FF0000000000LL)>>40);
16820 int8u Code4=(int8u)((Code.lo&0x000000FF00000000LL)>>32);
16821
16822 switch (Code3)
16823 {
16824 case 0x06 :
16825 switch (Code4)
16826 {
16827
16828 case 0x07 : ChooseParser_DolbyVisionFrameData(Essence, Descriptor);
16829 default:;
16830 }
16831 break;
16832 default : ;
16833 }
16834 }
16835
16836 //---------------------------------------------------------------------------
ChooseParser__Sony(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16837 void File_Mxf::ChooseParser__Sony(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16838 {
16839 int32u Code_Compare4=(int32u)Code.lo;
16840 int8u Code_Compare4_1=Code_Compare4>>24;
16841
16842 switch (Code_Compare4_1)
16843 {
16844 case 0x15 : //CP Picture
16845 ChooseParser__Sony_Picture(Essence, Descriptor);
16846 break;
16847 default : //Unknown
16848 ;
16849 }
16850 }
16851
16852 //---------------------------------------------------------------------------
16853 // 0x06, SMPTE 386M
ChooseParser__Aaf_CP_Sound(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16854 void File_Mxf::ChooseParser__Aaf_CP_Sound(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16855 {
16856 int32u Code_Compare4=(int32u)Code.lo;
16857 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
16858
16859 Essences[Code_Compare4].StreamKind=Stream_Audio;
16860 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
16861
16862 switch (Code_Compare4_3)
16863 {
16864 case 0x10 : //D-10 Audio, SMPTE 386M
16865 ChooseParser_SmpteSt0331(Essence, Descriptor);
16866 break;
16867 default : //Unknown
16868 ;
16869 }
16870 }
16871
16872 //---------------------------------------------------------------------------
16873 // 0x07, SMPTE 386M
ChooseParser__Aaf_CP_Data(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16874 void File_Mxf::ChooseParser__Aaf_CP_Data(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16875 {
16876 }
16877
16878 //---------------------------------------------------------------------------
16879 // 0x14
ChooseParser__Aaf_14(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16880 void File_Mxf::ChooseParser__Aaf_14(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16881 {
16882 int32u Code_Compare4=(int32u)Code.lo;
16883 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
16884
16885 switch (Code_Compare4_3)
16886 {
16887 case 0x01 : //MXF in MXF?
16888 Essence->second.Parsers.push_back(new File_Mxf());
16889 break;
16890 default : ;
16891 }
16892 }
16893
16894 //---------------------------------------------------------------------------
16895 // 0x15
ChooseParser__Aaf_GC_Picture(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16896 void File_Mxf::ChooseParser__Aaf_GC_Picture(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16897 {
16898 int32u Code_Compare4=(int32u)Code.lo;
16899 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
16900
16901 Essences[Code_Compare4].StreamKind=Stream_Video;
16902 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
16903
16904 switch (Code_Compare4_3)
16905 {
16906 case 0x01 : //RV24
16907 ChooseParser_RV24(Essence, Descriptor);
16908 break;
16909 case 0x02 : //Raw video
16910 ChooseParser_Raw(Essence, Descriptor);
16911 break;
16912 case 0x05 : //SMPTE 381M, Frame wrapped
16913 ChooseParser_Mpegv(Essence, Descriptor); //Trying...
16914 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Frame");
16915 DataMustAlwaysBeComplete=true;
16916 break;
16917 case 0x06 : //SMPTE 381M, Clip wrapped
16918 ChooseParser_Mpegv(Essence, Descriptor); //Trying...
16919 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Clip");
16920 break;
16921 case 0x07 : //SMPTE 381M, Custom wrapped
16922 ChooseParser_Mpegv(Essence, Descriptor); //Trying...
16923 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Custom");
16924 break;
16925 case 0x08 : //JPEG 2000
16926 ChooseParser_Jpeg2000(Essence, Descriptor);
16927 break;
16928 case 0x0D : //VC-3
16929 ChooseParser_Vc3(Essence, Descriptor);
16930 break;
16931 case 0x17 : //ProRes
16932 ChooseParser_ProRes(Essence, Descriptor);
16933 break;
16934 default : //Unknown
16935 ;
16936 }
16937 }
16938
16939 //---------------------------------------------------------------------------
16940 // 0x16
ChooseParser__Aaf_GC_Sound(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16941 void File_Mxf::ChooseParser__Aaf_GC_Sound(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16942 {
16943 int32u Code_Compare4=(int32u)Code.lo;
16944 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
16945
16946 Essences[Code_Compare4].StreamKind=Stream_Audio;
16947 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
16948
16949 switch (Code_Compare4_3)
16950 {
16951 case 0x01 : //BWF (PCM)
16952 case 0x02 : //BWF (PCM)
16953 case 0x03 : //DV Audio (PCM)
16954 case 0x04 : //P2 Audio (PCM)
16955 ChooseParser_Pcm(Essence, Descriptor);
16956 break;
16957 case 0x05 : //MPEG Audio
16958 ChooseParser_Mpega(Essence, Descriptor);
16959 break;
16960 case 0x08 : //A-law, Frame wrapped
16961 ChooseParser_Alaw(Essence, Descriptor);
16962 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Frame");
16963 DataMustAlwaysBeComplete=true;
16964 break;
16965 case 0x09 : //A-law, Clip wrapped
16966 ChooseParser_Alaw(Essence, Descriptor);
16967 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Clip");
16968 break;
16969 case 0x0A : //A-law, Custom wrapped
16970 ChooseParser_Alaw(Essence, Descriptor);
16971 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Custom");
16972 break;
16973 case 0x0D : //IAB
16974 ChooseParser_Iab(Essence, Descriptor);
16975 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Clip");
16976 break;
16977 default : //Unknown
16978 ;
16979 }
16980 }
16981
16982 //---------------------------------------------------------------------------
16983 // 0x17
ChooseParser__Aaf_GC_Data(const essences::iterator & Essence,const descriptors::iterator & Descriptor)16984 void File_Mxf::ChooseParser__Aaf_GC_Data(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
16985 {
16986 int32u Code_Compare4=(int32u)Code.lo;
16987 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
16988
16989 switch (Code_Compare4_3)
16990 {
16991 case 0x01 : //VBI, SMPTE ST 436
16992 #if defined(MEDIAINFO_VBI_YES)
16993 MayHaveCaptionsInStream=true;
16994 Essence->second.Parsers.push_back(new File_Vbi());
16995 #else
16996 Essence->second.Parsers.push_back(new File__Analyze());
16997 #endif //defined(MEDIAINFO_VBI_YES)
16998 break;
16999 case 0x02 : //Ancillary
17000 #if defined(MEDIAINFO_ANCILLARY_YES)
17001 if (!Ancillary)
17002 {
17003 Ancillary=new File_Ancillary();
17004 MayHaveCaptionsInStream=true;
17005 }
17006 Essence->second.Parsers.push_back(Ancillary);
17007 Ancillary_IsBinded=true;
17008 #endif //defined(MEDIAINFO_ANCILLARY_YES)
17009 break;
17010 case 0x08 : //Line Wrapped Data Element, SMPTE 384M
17011 case 0x09 : //Line Wrapped VANC Data Element, SMPTE 384M
17012 case 0x0A : //Line Wrapped HANC Data Element, SMPTE 384M
17013 break;
17014 case 0x0B : //Timed Text
17015 ChooseParser_TimedText(Essence, Descriptor);
17016 break;
17017 default : //Unknown
17018 ;
17019 }
17020 }
17021
17022 //---------------------------------------------------------------------------
17023 // 0x18
ChooseParser__Aaf_GC_Compound(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17024 void File_Mxf::ChooseParser__Aaf_GC_Compound(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17025 {
17026 int32u Code_Compare4=(int32u)Code.lo;
17027 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
17028
17029 Essences[Code_Compare4].StreamKind=Stream_Video; //Default to video, audio will be merge later
17030 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
17031
17032 switch (Code_Compare4_3)
17033 {
17034 case 0x01 : //DV
17035 case 0x02 : //DV
17036 ChooseParser_DV(Essence, Descriptor);
17037 break;
17038 default : //Unknown
17039 ;
17040 }
17041 }
17042
17043 //---------------------------------------------------------------------------
17044 // 0x15
ChooseParser__Avid_Picture(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17045 void File_Mxf::ChooseParser__Avid_Picture(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17046 {
17047 int32u Code_Compare4=(int32u)Code.lo;
17048 int8u Code_Compare4_3=(int8u)(Code_Compare4>>8);
17049
17050 Essences[Code_Compare4].StreamKind=Stream_Video;
17051 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
17052
17053 switch (Code_Compare4_3)
17054 {
17055 case 0x05 : //VC-1, Frame wrapped
17056 ChooseParser_Vc3(Essence, Descriptor);
17057 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Frame");
17058 DataMustAlwaysBeComplete=true;
17059 break;
17060 case 0x06 : //VC-1, Clip wrapped
17061 ChooseParser_Vc3(Essence, Descriptor);
17062 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Clip");
17063 break;
17064 case 0x07 : //VC-1, Custom wrapped
17065 ChooseParser_Vc3(Essence, Descriptor);
17066 Essences[Code_Compare4].Infos["Format_Settings_Wrapping"]=__T("Custom");
17067 break;
17068 default : //Unknown
17069 ;
17070 }
17071 }
17072
17073 //---------------------------------------------------------------------------
17074 // 0x15
ChooseParser__Sony_Picture(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17075 void File_Mxf::ChooseParser__Sony_Picture(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17076 {
17077 int32u Code_Compare4=(int32u)Code.lo;
17078
17079 Essences[Code_Compare4].StreamKind=Stream_Video;
17080 Essences[Code_Compare4].StreamPos=Code_Compare4&0x000000FF;
17081 }
17082
17083 //---------------------------------------------------------------------------
ChooseParser_Avc(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17084 void File_Mxf::ChooseParser_Avc(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17085 {
17086 Essence->second.StreamKind=Stream_Video;
17087
17088 //Filling
17089 #if defined(MEDIAINFO_AVC_YES)
17090 File_Avc* Parser=new File_Avc;
17091 MayHaveCaptionsInStream=true;
17092 #else
17093 //Filling
17094 File__Analyze* Parser=new File_Unknown();
17095 Open_Buffer_Init(Parser);
17096 Parser->Stream_Prepare(Stream_Video);
17097 Parser->Fill(Stream_Video, 0, Video_Format, "AVC");
17098 #endif
17099 Essence->second.Parsers.push_back(Parser);
17100 }
17101
17102 //---------------------------------------------------------------------------
ChooseParser_DV(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17103 void File_Mxf::ChooseParser_DV(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17104 {
17105 Essence->second.StreamKind=Stream_Video;
17106
17107 //Filling
17108 #if defined(MEDIAINFO_DVDIF_YES)
17109 File_DvDif* Parser=new File_DvDif;
17110 #else
17111 //Filling
17112 File__Analyze* Parser=new File_Unknown();
17113 Open_Buffer_Init(Parser);
17114 Parser->Stream_Prepare(Stream_Video);
17115 Parser->Fill(Stream_Audio, 0, Audio_Format, "DV");
17116 #endif
17117 Essence->second.Parsers.push_back(Parser);
17118 }
17119
17120 //---------------------------------------------------------------------------
ChooseParser_Mpeg4v(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17121 void File_Mxf::ChooseParser_Mpeg4v(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17122 {
17123 Essence->second.StreamKind=Stream_Video;
17124
17125 //Filling
17126 #if defined(MEDIAINFO_MPEG4V_YES)
17127 File_Mpeg4v* Parser=new File_Mpeg4v;
17128 Open_Buffer_Init(Parser);
17129 Parser->OnlyVOP();
17130 #else
17131 //Filling
17132 File__Analyze* Parser=new File_Unknown();
17133 Open_Buffer_Init(Parser);
17134 Parser->Stream_Prepare(Stream_Video);
17135 Parser->Fill(Stream_Video, 0, Video_Format, "MPEG-4 Visual");
17136 #endif
17137 Essence->second.Parsers.push_back(Parser);
17138 }
17139
17140 //---------------------------------------------------------------------------
ChooseParser_Mpegv(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17141 void File_Mxf::ChooseParser_Mpegv(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17142 {
17143 Essence->second.StreamKind=Stream_Video;
17144
17145 //Filling
17146 #if defined(MEDIAINFO_MPEGV_YES)
17147 File_Mpegv* Parser=new File_Mpegv();
17148 Parser->Ancillary=&Ancillary;
17149 MayHaveCaptionsInStream=true;
17150 #if MEDIAINFO_ADVANCED
17151 Parser->InitDataNotRepeated_Optional=true;
17152 #endif // MEDIAINFO_ADVANCED
17153 #if MEDIAINFO_DEMUX
17154 if (Demux_UnpacketizeContainer)
17155 {
17156 Parser->Demux_Level=2; //Container
17157 Parser->Demux_UnpacketizeContainer=true;
17158 }
17159 #endif //MEDIAINFO_DEMUX
17160 #else
17161 File__Analyze* Parser=new File_Unknown();
17162 Open_Buffer_Init(Parser);
17163 Parser->Stream_Prepare(Stream_Video);
17164 Parser->Fill(Stream_Video, 0, Video_Format, "MPEG Video");
17165 #endif
17166 Essence->second.Parsers.push_back(Parser);
17167 }
17168
17169 //---------------------------------------------------------------------------
ChooseParser_Raw(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17170 void File_Mxf::ChooseParser_Raw(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17171 {
17172 Essence->second.StreamKind=Stream_Video;
17173
17174 //Filling
17175 File__Analyze* Parser=new File_Unknown();
17176 Open_Buffer_Init(Parser);
17177 Parser->Stream_Prepare(Stream_Video);
17178 Parser->Fill(Stream_Video, 0, Video_Format, "YUV");
17179 Essence->second.Parsers.push_back(Parser);
17180 }
17181
17182 //---------------------------------------------------------------------------
ChooseParser_RV24(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17183 void File_Mxf::ChooseParser_RV24(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17184 {
17185 Essence->second.StreamKind=Stream_Video;
17186
17187 //Filling
17188 File__Analyze* Parser=new File_Unknown();
17189 Open_Buffer_Init(Parser);
17190 Parser->Stream_Prepare(Stream_Video);
17191 Parser->Fill(Stream_Video, 0, Video_Format, "RV24");
17192 Essence->second.Parsers.push_back(Parser);
17193 }
17194
17195 //---------------------------------------------------------------------------
ChooseParser_Vc3(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17196 void File_Mxf::ChooseParser_Vc3(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17197 {
17198 Essence->second.StreamKind=Stream_Video;
17199
17200 //Filling
17201 #if defined(MEDIAINFO_VC3_YES)
17202 File_Vc3* Parser=new File_Vc3;
17203 if (Descriptor!=Descriptors.end())
17204 Parser->FrameRate=Descriptor->second.SampleRate;
17205 #else
17206 //Filling
17207 File__Analyze* Parser=new File_Unknown();
17208 Open_Buffer_Init(Parser);
17209 Parser->Stream_Prepare(Stream_Video);
17210 Parser->Fill(Stream_Video, 0, Video_Format, "VC-3");
17211 #endif
17212 Essence->second.Parsers.push_back(Parser);
17213 }
17214
17215 //---------------------------------------------------------------------------
ChooseParser_TimedText(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17216 void File_Mxf::ChooseParser_TimedText(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17217 {
17218 Essence->second.StreamKind=Stream_Text;
17219
17220 //Filling
17221 #if defined(MEDIAINFO_TTML_YES)
17222 File_Ttml* Parser=new File_Ttml;
17223 #else
17224 //Filling
17225 File__Analyze* Parser=new File_Unknown();
17226 Open_Buffer_Init(Parser);
17227 Parser->Stream_Prepare(Stream_Text);
17228 Parser->Fill(Stream_Text, 0, Text_Format, "Timed Text");
17229 #endif
17230 Essence->second.Parsers.push_back(Parser);
17231 }
17232
17233 //---------------------------------------------------------------------------
ChooseParser_Aac(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17234 void File_Mxf::ChooseParser_Aac(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17235 {
17236 Essence->second.StreamKind=Stream_Audio;
17237
17238 //Filling
17239 #if defined(MEDIAINFO_AAC_YES)
17240 File_Aac* Parser=new File_Aac;
17241 #else
17242 //Filling
17243 File__Analyze* Parser=new File_Unknown();
17244 Open_Buffer_Init(Parser);
17245 Parser->Stream_Prepare(Stream_Audio);
17246 Parser->Fill(Stream_Audio, 0, Audio_Format, "AAC");
17247 #endif
17248 Essence->second.Parsers.push_back(Parser);
17249 }
17250
17251 //---------------------------------------------------------------------------
ChooseParser_Ac3(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17252 void File_Mxf::ChooseParser_Ac3(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17253 {
17254 Essence->second.StreamKind=Stream_Audio;
17255
17256 //Filling
17257 #if defined(MEDIAINFO_AC3_YES)
17258 File_Ac3* Parser=new File_Ac3;
17259 #else
17260 //Filling
17261 File__Analyze* Parser=new File_Unknown();
17262 Open_Buffer_Init(Parser);
17263 Parser->Stream_Prepare(Stream_Audio);
17264 Parser->Fill(Stream_Audio, 0, Audio_Format, "AC-3");
17265 #endif
17266 Essence->second.Parsers.push_back(Parser);
17267 }
17268
17269 //---------------------------------------------------------------------------
ChooseParser_Alaw(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17270 void File_Mxf::ChooseParser_Alaw(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17271 {
17272 Essence->second.StreamKind=Stream_Audio;
17273
17274 //Filling
17275 File__Analyze* Parser=new File_Unknown();
17276 Open_Buffer_Init(Parser);
17277 Parser->Stream_Prepare(Stream_Audio);
17278 Parser->Fill(Stream_Audio, 0, Audio_Format, "Alaw");
17279 Essence->second.Parsers.push_back(Parser);
17280 }
17281
17282
17283 //---------------------------------------------------------------------------
ChooseParser_ChannelGrouping(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17284 void File_Mxf::ChooseParser_ChannelGrouping(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17285 {
17286 Essence->second.StreamKind=Stream_Audio;
17287 if ((Essence->first&0x000000FF)==0x00000000)
17288 StreamPos_StartAtZero.set(Essence->second.StreamKind); // Need to do it here because we use StreamPos_StartAtZero immediately
17289
17290 #if defined(MEDIAINFO_SMPTEST0337_YES)
17291
17292 //Creating the parser
17293 if (!((Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1))%2 && Essences[Essence->first-1].Parsers.size()<=1))
17294 {
17295 File_ChannelGrouping* Parser;
17296 if ((Essence->second.StreamPos-(StreamPos_StartAtZero[Essence->second.StreamKind]?0:1))%2) //If the first half-stream was already rejected, don't try this one
17297 {
17298 essences::iterator FirstChannel=Essences.find(Essence->first-1);
17299 if (FirstChannel==Essences.end() || !FirstChannel->second.IsChannelGrouping)
17300 return ChooseParser_Pcm(Essence, Descriptor); //Not a channel grouping
17301
17302 Parser=new File_ChannelGrouping;
17303 Parser->Channel_Pos=1;
17304 Parser->Common=((File_ChannelGrouping*)Essences[Essence->first-1].Parsers[0])->Common;
17305 Parser->StreamID=Essence->second.TrackID-1;
17306 }
17307 else
17308 {
17309 Parser=new File_ChannelGrouping;
17310 Parser->Channel_Pos=0;
17311 if (Descriptor!=Descriptors.end())
17312 {
17313 std::map<std::string, Ztring>::const_iterator i=Descriptor->second.Infos.find("SamplingRate");
17314 if (i!=Descriptor->second.Infos.end())
17315 Parser->SamplingRate=i->second.To_int16u();
17316 }
17317 Essence->second.IsChannelGrouping=true;
17318 }
17319 Parser->Channel_Total=2;
17320 if (Descriptor!=Descriptors.end())
17321 {
17322 Parser->BitDepth=(int8u)(Descriptor->second.BlockAlign<=4?(Descriptor->second.BlockAlign*8):(Descriptor->second.BlockAlign*4)); //In one file, BlockAlign is size of the aggregated channelgroup
17323 std::map<std::string, Ztring>::const_iterator i=Descriptor->second.Infos.find("Format_Settings_Endianness");
17324 if (i!=Descriptor->second.Infos.end())
17325 {
17326 if (i->second==__T("Big"))
17327 Parser->Endianness='B';
17328 else
17329 Parser->Endianness='L';
17330 }
17331 else
17332 Parser->Endianness='L';
17333 }
17334 else
17335 Parser->Endianness='L';
17336
17337 #if MEDIAINFO_DEMUX
17338 if (Demux_UnpacketizeContainer)
17339 {
17340 Parser->Demux_Level=2; //Container
17341 Parser->Demux_UnpacketizeContainer=true;
17342 }
17343 #endif //MEDIAINFO_DEMUX
17344
17345 Essence->second.Parsers.push_back(Parser);
17346 }
17347 #endif //defined(MEDIAINFO_SMPTEST0337_YES)
17348
17349 //Adding PCM
17350 ChooseParser_Pcm(Essence, Descriptor);
17351 }
17352
17353 //---------------------------------------------------------------------------
ChooseParser_ChannelSplitting(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17354 void File_Mxf::ChooseParser_ChannelSplitting(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17355 {
17356 Essence->second.StreamKind=Stream_Audio;
17357
17358 //Filling
17359 #if defined(MEDIAINFO_SMPTEST0337_YES)
17360 File_ChannelSplitting* Parser=new File_ChannelSplitting;
17361 if (Descriptor!=Descriptors.end())
17362 {
17363 Parser->Channel_Total=Descriptor->second.ChannelCount;
17364 if (Descriptor->second.BlockAlign<64)
17365 Parser->BitDepth=(int8u)(Descriptor->second.BlockAlign*8/Descriptor->second.ChannelCount);
17366 else if (Descriptor->second.QuantizationBits!=(int32u)-1)
17367 Parser->BitDepth=(int8u)Descriptor->second.QuantizationBits;
17368 std::map<std::string, Ztring>::const_iterator i=Descriptor->second.Infos.find("SamplingRate");
17369 if (i!=Descriptor->second.Infos.end())
17370 Parser->SamplingRate=i->second.To_int16u();
17371 i=Descriptor->second.Infos.find("Format_Settings_Endianness");
17372 if (i!=Descriptor->second.Infos.end())
17373 {
17374 if (i->second==__T("Big"))
17375 Parser->Endianness='B';
17376 else
17377 Parser->Endianness='L';
17378 }
17379 else
17380 Parser->Endianness='L';
17381 }
17382 else
17383 Parser->Endianness='L';
17384 Parser->Aligned=true;
17385
17386 #if MEDIAINFO_DEMUX
17387 if (Demux_UnpacketizeContainer)
17388 {
17389 Parser->Demux_Level=2; //Container
17390 Parser->Demux_UnpacketizeContainer=true;
17391 }
17392 #endif //MEDIAINFO_DEMUX
17393
17394 Essence->second.Parsers.push_back(Parser);
17395 #endif //defined(MEDIAINFO_SMPTEST0337_YES)
17396
17397 //Adding PCM
17398 ChooseParser_Pcm(Essence, Descriptor);
17399 }
17400 //---------------------------------------------------------------------------
ChooseParser_Mpega(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17401 void File_Mxf::ChooseParser_Mpega(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17402 {
17403 Essence->second.StreamKind=Stream_Audio;
17404
17405 //Filling
17406 #if defined(MEDIAINFO_MPEGA_YES)
17407 File_Mpega* Parser=new File_Mpega;
17408 #else
17409 //Filling
17410 File__Analyze* Parser=new File_Unknown();
17411 Open_Buffer_Init(Parser);
17412 Parser->Stream_Prepare(Stream_Audio);
17413 Parser->Fill(Stream_Audio, 0, Audio_Format, "MPEG Audio");
17414 #endif
17415 Essence->second.Parsers.push_back(Parser);
17416 }
17417
17418 //---------------------------------------------------------------------------
ChooseParser_Pcm(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17419 void File_Mxf::ChooseParser_Pcm(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17420 {
17421 Essence->second.StreamKind=Stream_Audio;
17422
17423 int8u Channels=0;
17424 if (Descriptor!=Descriptors.end())
17425 {
17426 std::map<std::string, Ztring>::const_iterator i=Descriptor->second.Infos.find("Channel(s)");
17427 if (i!=Descriptor->second.Infos.end())
17428 Channels=i->second.To_int8u();
17429
17430 //Handling some buggy cases
17431 if (Channels>1 && Descriptor->second.BlockAlign!=(int16u)-1 && Descriptor->second.QuantizationBits!=(int32u)-1)
17432 {
17433 if (((int32u)Descriptor->second.BlockAlign)*8==Descriptor->second.QuantizationBits)
17434 Descriptor->second.BlockAlign*=Channels; //BlockAlign is by channel, it should be by block.
17435 }
17436 }
17437
17438 //Creating the parser
17439 #if defined(MEDIAINFO_PCM_YES)
17440 File_Pcm* Parser=new File_Pcm;
17441 if (Descriptor!=Descriptors.end())
17442 {
17443 if (Channels)
17444 Parser->Channels=Channels;
17445 std::map<std::string, Ztring>::const_iterator i=Descriptor->second.Infos.find("SamplingRate");
17446 if (i!=Descriptor->second.Infos.end())
17447 Parser->SamplingRate=i->second.To_int16u();
17448 if (Parser->Channels && Descriptor->second.BlockAlign!=(int16u)-1)
17449 Parser->BitDepth=(int8u)(Descriptor->second.BlockAlign*8/Parser->Channels);
17450 else if (Descriptor->second.QuantizationBits<256)
17451 Parser->BitDepth=(int8u)Descriptor->second.QuantizationBits;
17452 else
17453 {
17454 i=Descriptor->second.Infos.find("BitDepth");
17455 if (i!=Descriptor->second.Infos.end())
17456 Parser->BitDepth=i->second.To_int8u();
17457 }
17458 //Handling of quantization bits not being same as BlockAlign/Channels
17459 if (Channels && Descriptor->second.BlockAlign!=(int16u)-1 && Descriptor->second.QuantizationBits!=(int32u)-1)
17460 {
17461 if (Channels*Descriptor->second.QuantizationBits!=((int32u)Descriptor->second.BlockAlign)*8)
17462 {
17463 //Moving Bit depth info to the "Significant" piece of etadata
17464 if (Descriptor->second.QuantizationBits<256)
17465 Parser->BitDepth_Significant=(int8u)Descriptor->second.QuantizationBits;
17466 else
17467 Parser->BitDepth_Significant=Parser->BitDepth;
17468 Parser->BitDepth=((int8u)Descriptor->second.BlockAlign)*8/Channels;
17469 }
17470 }
17471 i = Descriptor->second.Infos.find("Format_Settings_Endianness");
17472 if (i!=Descriptor->second.Infos.end())
17473 {
17474 if (i->second==__T("Big"))
17475 Parser->Endianness='B';
17476 else
17477 Parser->Endianness='L';
17478 }
17479 else
17480 Parser->Endianness='L';
17481 }
17482 else
17483 Parser->Endianness='L';
17484
17485 #if MEDIAINFO_DEMUX
17486 if (Demux_UnpacketizeContainer)
17487 {
17488 Parser->Demux_Level=2; //Container
17489 Parser->Demux_UnpacketizeContainer=true;
17490 }
17491 #endif //MEDIAINFO_DEMUX
17492
17493 if (Essence->second.Parsers.empty())
17494 Parser->Frame_Count_Valid=1;
17495 Essence->second.Parsers.push_back(Parser);
17496 #endif
17497 }
17498
17499 //---------------------------------------------------------------------------
ChooseParser_SmpteSt0331(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17500 void File_Mxf::ChooseParser_SmpteSt0331(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17501 {
17502 Essence->second.StreamKind=Stream_Audio;
17503
17504 //Filling
17505 #if defined(MEDIAINFO_SMPTEST0331_YES)
17506 File_SmpteSt0331* Parser=new File_SmpteSt0331;
17507 if (Descriptor!=Descriptors.end() && Descriptor->second.QuantizationBits!=(int32u)-1)
17508 Parser->QuantizationBits=Descriptor->second.QuantizationBits;
17509
17510 #if MEDIAINFO_DEMUX
17511 if (Demux_UnpacketizeContainer)
17512 {
17513 Parser->Demux_Level=2; //Container
17514 Parser->Demux_UnpacketizeContainer=true;
17515 }
17516 #endif //MEDIAINFO_DEMUX
17517
17518 Essence->second.Parsers.push_back(Parser);
17519 #endif
17520 }
17521
17522 //---------------------------------------------------------------------------
ChooseParser_SmpteSt0337(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17523 void File_Mxf::ChooseParser_SmpteSt0337(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17524 {
17525 Essence->second.StreamKind=Stream_Audio;
17526
17527 //Filling
17528 #if defined(MEDIAINFO_SMPTEST0337_YES)
17529 File_SmpteSt0337* Parser=new File_SmpteSt0337;
17530 if (Descriptor!=Descriptors.end())
17531 {
17532 if (Descriptor->second.BlockAlign<64)
17533 Parser->Container_Bits=(int8u)(Descriptor->second.BlockAlign*4);
17534 else if (Descriptor->second.QuantizationBits!=(int32u)-1)
17535 Parser->Container_Bits=(int8u)Descriptor->second.QuantizationBits;
17536 std::map<std::string, Ztring>::const_iterator i=Descriptor->second.Infos.find("Format_Settings_Endianness");
17537 if (i!=Descriptor->second.Infos.end())
17538 {
17539 if (i->second==__T("Big"))
17540 Parser->Endianness='B';
17541 else
17542 Parser->Endianness='L';
17543 }
17544 else
17545 Parser->Endianness='L';
17546 }
17547 else
17548 Parser->Endianness='L';
17549 Parser->Aligned=true;
17550
17551 #if MEDIAINFO_DEMUX
17552 if (Demux_UnpacketizeContainer)
17553 {
17554 Parser->Demux_Level=2; //Container
17555 Parser->Demux_UnpacketizeContainer=true;
17556 }
17557 #endif //MEDIAINFO_DEMUX
17558
17559 Essence->second.Parsers.push_back(Parser);
17560 #endif
17561 }
17562
17563 //---------------------------------------------------------------------------
ChooseParser_Jpeg2000(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17564 void File_Mxf::ChooseParser_Jpeg2000(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17565 {
17566 Essence->second.StreamKind=Stream_Video;
17567
17568 //Filling
17569 #if defined(MEDIAINFO_JPEG_YES)
17570 File_Jpeg* Parser=new File_Jpeg;
17571 Parser->StreamKind=Stream_Video;
17572 if (Descriptor!=Descriptors.end())
17573 {
17574 Parser->Interlaced=Descriptor->second.Is_Interlaced();
17575 #if MEDIAINFO_DEMUX
17576 if (Parser->Interlaced)
17577 {
17578 Parser->Demux_Level=2; //Container
17579 Parser->Demux_UnpacketizeContainer=true;
17580 Parser->FrameRate=Descriptor->second.SampleRate;
17581 }
17582 #endif //MEDIAINFO_DEMUX
17583 }
17584 #else
17585 //Filling
17586 File__Analyze* Parser=new File_Unknown();
17587 Open_Buffer_Init(Parser);
17588 Parser->Stream_Prepare(Stream_Video);
17589 Parser->Fill(Stream_Video, 0, Video_Format, "JPEG 2000");
17590 #endif
17591 Essence->second.Parsers.push_back(Parser);
17592 }
17593
17594 //---------------------------------------------------------------------------
ChooseParser_ProRes(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17595 void File_Mxf::ChooseParser_ProRes(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17596 {
17597 Essence->second.StreamKind=Stream_Video;
17598
17599 //Filling
17600 #if defined(MEDIAINFO_PRORES_YES)
17601 File_ProRes* Parser=new File_ProRes;
17602 #else
17603 //Filling
17604 File__Analyze* Parser=new File_Unknown();
17605 Open_Buffer_Init(Parser);
17606 Parser->Stream_Prepare(Stream_Video);
17607 Parser->Fill(Stream_Video, 0, Video_Format, "ProRes");
17608 #endif
17609 Essence->second.Parsers.push_back(Parser);
17610 }
17611
17612 //---------------------------------------------------------------------------
ChooseParser_DolbyVisionFrameData(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17613 void File_Mxf::ChooseParser_DolbyVisionFrameData(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17614 {
17615 Essence->second.StreamKind=Stream_Other;
17616
17617 //Filling
17618 File__Analyze* Parser=new File_Unknown();
17619 Open_Buffer_Init(Parser);
17620 Parser->Stream_Prepare(Stream_Other);
17621 Parser->Fill(Stream_Other, 0, Other_Format, "Dolby Vision Metadata");
17622 Essence->second.Parsers.push_back(Parser);
17623 }
17624
17625 //---------------------------------------------------------------------------
ChooseParser_Iab(const essences::iterator & Essence,const descriptors::iterator & Descriptor)17626 void File_Mxf::ChooseParser_Iab(const essences::iterator &Essence, const descriptors::iterator &Descriptor)
17627 {
17628 Essence->second.StreamKind=Stream_Audio;
17629
17630 //Filling
17631 #if defined(MEDIAINFO_IAB_YES)
17632 File_Iab* Parser=new File_Iab;
17633 #else
17634 //Filling
17635 File__Analyze* Parser=new File_Unknown();
17636 Open_Buffer_Init(Parser);
17637 Parser->Stream_Prepare(Stream_Audio);
17638 Parser->Fill(Stream_Audio, 0, Audio_Format, "IAB");
17639 #endif
17640 Essence->second.Parsers.push_back(Parser);
17641 }
17642
17643 //***************************************************************************
17644 // Helpers
17645 //***************************************************************************
17646
17647 //---------------------------------------------------------------------------
Vector(int32u ExpectedLength)17648 int32u File_Mxf::Vector(int32u ExpectedLength)
17649 {
17650 if (Element_Offset+8>Element_Size)
17651 {
17652 Element_Error("Incoherent element size");
17653 return (int32u)-1;
17654 }
17655
17656 int32u Count, Length;
17657 Get_B4 (Count, "Count");
17658 Get_B4 (Length, "Length");
17659
17660 if (Count*Length!=Element_Size-Element_Offset)
17661 {
17662 Param_Error("Incoherent Count*Length");
17663 return (int32u)-1;
17664 }
17665
17666 if (Count && ExpectedLength!=(int32u)-1 && Length!=ExpectedLength)
17667 {
17668 Param_Error("Unexpected item length");
17669 return (int32u)-1;
17670 }
17671
17672 return Length;
17673 }
17674
17675 //---------------------------------------------------------------------------
Subsampling_Compute(descriptors::iterator Descriptor)17676 void File_Mxf::Subsampling_Compute(descriptors::iterator Descriptor)
17677 {
17678 if (Descriptor==Descriptors.end() || (Descriptor->second.SubSampling_Horizontal==(int32u)-1 || Descriptor->second.SubSampling_Vertical==(int32u)-1))
17679 return;
17680
17681 switch (Descriptor->second.SubSampling_Horizontal)
17682 {
17683 case 1 : switch (Descriptor->second.SubSampling_Vertical)
17684 {
17685 case 1 : Descriptor->second.Infos["ChromaSubsampling"]=__T("4:4:4"); return;
17686 default: Descriptor->second.Infos["ChromaSubsampling"].clear(); return;
17687 }
17688 case 2 : switch (Descriptor->second.SubSampling_Vertical)
17689 {
17690 case 1 : Descriptor->second.Infos["ChromaSubsampling"]=__T("4:2:2"); return;
17691 case 2 : Descriptor->second.Infos["ChromaSubsampling"]=__T("4:2:0"); return;
17692 default: Descriptor->second.Infos["ChromaSubsampling"].clear(); return;
17693 }
17694 case 4 : switch (Descriptor->second.SubSampling_Vertical)
17695 {
17696 case 1 : Descriptor->second.Infos["ChromaSubsampling"]=__T("4:1:1"); return;
17697 default: Descriptor->second.Infos["ChromaSubsampling"].clear(); return;
17698 }
17699 default: return;
17700 }
17701 }
17702
17703
17704 //---------------------------------------------------------------------------
ColorLevels_Compute(descriptors::iterator Descriptor,bool Force,int32u BitDepth)17705 void File_Mxf::ColorLevels_Compute(descriptors::iterator Descriptor, bool Force, int32u BitDepth)
17706 {
17707 if (Descriptor == Descriptors.end())
17708 return;
17709 // BitDepth check
17710 std::map<std::string, Ztring>::iterator Info=Descriptor->second.Infos.find("BitDepth");
17711 if (Info!=Descriptor->second.Infos.end())
17712 {
17713 if (BitDepth==0 || BitDepth==(int32u)-1)
17714 BitDepth=Info->second.To_int32u();
17715 else if (Force && BitDepth!=Info->second.To_int32u())
17716 Fill(StreamKind_Last, StreamPos_Last, "BitDepth_Container", Info->second);
17717 }
17718
17719 // Known values
17720 if (BitDepth>=8 && BitDepth<=16)
17721 {
17722 int32u Multiplier=1<<(BitDepth-8);
17723 if (Descriptor->second.MinRefLevel==16*Multiplier && Descriptor->second.MaxRefLevel==235*Multiplier && (Descriptor->second.Type==descriptor::Type_RGBA || Descriptor->second.ColorRange==1+224*Multiplier))
17724 {
17725 Descriptor->second.Infos["colour_range"]=__T("Limited");
17726 return;
17727 }
17728 if (Descriptor->second.MinRefLevel==0*Multiplier && Descriptor->second.MaxRefLevel==256*Multiplier-1 && (Descriptor->second.Type==descriptor::Type_RGBA || Descriptor->second.ColorRange==256*Multiplier))
17729 {
17730 Descriptor->second.Infos["colour_range"]=__T("Full");
17731 return;
17732 }
17733 }
17734
17735 if (!Force && (Descriptor->second.MinRefLevel==(int32u)-1 || Descriptor->second.MaxRefLevel==(int32u)-1) || (Descriptor->second.Type!=descriptor::Type_RGBA && Descriptor->second.ColorRange==(int32u)-1))
17736 return;
17737
17738 // Listing values
17739 ZtringList List;
17740 if (Descriptor->second.MinRefLevel!=(int32u)-1)
17741 List.push_back(__T("Min: ")+Ztring::ToZtring(Descriptor->second.MinRefLevel));
17742 if (Descriptor->second.MaxRefLevel!=(int32u)-1)
17743 List.push_back(__T("Max: ")+Ztring::ToZtring(Descriptor->second.MaxRefLevel));
17744 if (Descriptor->second.ColorRange!=(int32u)-1)
17745 List.push_back(__T("Chroma range: ")+Ztring::ToZtring(Descriptor->second.ColorRange));
17746 if (!List.empty())
17747 {
17748 List.Separator_Set(0, __T(", "));
17749 Descriptor->second.Infos["colour_range"]=List.Read();
17750 }
17751 }
17752
17753 //---------------------------------------------------------------------------
17754 #if defined(MEDIAINFO_REFERENCES_YES)
Locators_CleanUp()17755 void File_Mxf::Locators_CleanUp()
17756 {
17757 //Testing locators (TODO: check if this is still useful after refactoring, with MXF having essence and locators)
17758 if (Locators.size()==1 && !Essences.empty())
17759 {
17760 Locators.clear();
17761 return;
17762 }
17763
17764 locators::iterator Locator=Locators.begin();
17765 while (Locator!=Locators.end())
17766 {
17767 bool IsReferenced=false;
17768 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
17769 for (size_t Pos=0; Pos<Descriptor->second.Locators.size(); Pos++)
17770 if (Locator->first==Descriptor->second.Locators[Pos])
17771 IsReferenced=true;
17772 if (!IsReferenced)
17773 {
17774 //Deleting current locator
17775 locators::iterator LocatorToDelete=Locator;
17776 ++Locator;
17777 Locators.erase(LocatorToDelete);
17778 }
17779 else
17780 ++Locator;
17781 }
17782
17783 }
17784 #endif //defined(MEDIAINFO_REFERENCES_YES)
17785
17786 //---------------------------------------------------------------------------
17787 #if defined(MEDIAINFO_REFERENCES_YES)
Locators_Test()17788 void File_Mxf::Locators_Test()
17789 {
17790 Locators_CleanUp();
17791
17792 if (!Locators.empty() && ReferenceFiles==NULL)
17793 {
17794 ReferenceFiles_Accept(this, Config);
17795
17796 for (locators::iterator Locator=Locators.begin(); Locator!=Locators.end(); ++Locator)
17797 if (!Locator->second.IsTextLocator && !Locator->second.EssenceLocator.empty())
17798 {
17799 sequence* Sequence=new sequence;
17800 Sequence->AddFileName(Locator->second.EssenceLocator);
17801 Sequence->StreamKind=Locator->second.StreamKind;
17802 Sequence->StreamPos=Locator->second.StreamPos;
17803 if (Locator->second.LinkedTrackID!=(int32u)-1)
17804 Sequence->StreamID=Locator->second.LinkedTrackID;
17805 else if (!Retrieve(Locator->second.StreamKind, Locator->second.StreamPos, General_ID).empty())
17806 Sequence->StreamID=Retrieve(Locator->second.StreamKind, Locator->second.StreamPos, General_ID).To_int64u();
17807 Sequence->Delay=float64_int64s(DTS_Delay*1000000000);
17808
17809 //Special cases
17810 if (Locator->second.StreamKind==Stream_Video)
17811 {
17812 //Searching the corresponding frame rate
17813 for (descriptors::iterator Descriptor=Descriptors.begin(); Descriptor!=Descriptors.end(); ++Descriptor)
17814 for (size_t LocatorPos=0; LocatorPos<Descriptor->second.Locators.size(); LocatorPos++)
17815 if (Descriptor->second.Locators[LocatorPos]==Locator->first)
17816 Sequence->FrameRate_Set(Descriptor->second.SampleRate);
17817 }
17818
17819 if (Sequence->StreamID!=(int32u)-1)
17820 {
17821 //Descriptive Metadata
17822 std::vector<int128u> DMScheme1s_List;
17823
17824 for (dmsegments::iterator DMSegment=DMSegments.begin(); DMSegment!=DMSegments.end(); ++DMSegment)
17825 for (size_t Pos=0; Pos<DMSegment->second.TrackIDs.size(); Pos++)
17826 if (DMSegment->second.TrackIDs[Pos]==Sequence->StreamID)
17827 DMScheme1s_List.push_back(DMSegment->second.Framework);
17828
17829 for (size_t Pos=0; Pos<DMScheme1s_List.size(); Pos++)
17830 {
17831 dmscheme1s::iterator DMScheme1=DMScheme1s.find(DMScheme1s_List[Pos]);
17832 if (DMScheme1!=DMScheme1s.end())
17833 {
17834 Sequence->Infos["Language"]=DMScheme1->second.PrimaryExtendedSpokenLanguage;
17835 }
17836 }
17837 }
17838
17839 ReferenceFiles->AddSequence(Sequence);
17840 }
17841 else
17842 {
17843 Fill(Stream_General, 0, "UnsupportedSources", Locator->second.EssenceLocator);
17844 Fill_SetOptions(Stream_General, 0, "UnsupportedSources", "N NT");
17845 }
17846
17847 ReferenceFiles->ParseReferences();
17848 }
17849 }
17850 #endif //defined(MEDIAINFO_REFERENCES_YES)
17851
17852 //---------------------------------------------------------------------------
NextRandomIndexPack()17853 void File_Mxf::NextRandomIndexPack()
17854 {
17855 //We have the necessary for indexes, jumping to next index
17856 Skip_XX(Element_Size-Element_Offset, "Data");
17857 if (RandomIndexPacks.empty())
17858 {
17859 if (!RandomIndexPacks_AlreadyParsed)
17860 {
17861 Partitions_Pos=0;
17862 while (Partitions_Pos<Partitions.size() && Partitions[Partitions_Pos].StreamOffset!=PartitionMetadata_PreviousPartition)
17863 Partitions_Pos++;
17864 if (Partitions_Pos==Partitions.size())
17865 {
17866 GoTo(PartitionMetadata_PreviousPartition);
17867 Open_Buffer_Unsynch();
17868 }
17869 else
17870 GoToFromEnd(0);
17871 }
17872 else
17873 GoToFromEnd(0);
17874 }
17875 else
17876 {
17877 GoTo(RandomIndexPacks[0].ByteOffset);
17878 RandomIndexPacks.erase(RandomIndexPacks.begin());
17879 Open_Buffer_Unsynch();
17880 }
17881
17882 RandomIndexPacks_MaxOffset=(int64u)-1;
17883 }
17884
17885 //---------------------------------------------------------------------------
BookMark_Needed()17886 bool File_Mxf::BookMark_Needed()
17887 {
17888 Frame_Count_NotParsedIncluded=(int64u)-1;
17889
17890 if (MayHaveCaptionsInStream && !IsSub && IsParsingEnd && File_Size!=(int64u)-1 && Config->ParseSpeed && Config->ParseSpeed<1 && IsParsingMiddle_MaxOffset==(int64u)-1 && File_Size/2>0x4000000) //TODO: 64 MB by default; // Do not search in the middle of the file if quick pass or full pass
17891 {
17892 IsParsingMiddle_MaxOffset=File_Size/2+0x4000000; //TODO: 64 MB by default;
17893 GoTo(File_Size/2);
17894 Open_Buffer_Unsynch();
17895 IsParsingEnd=false;
17896 IsCheckingRandomAccessTable=false;
17897 Streams_Count=(size_t)-1;
17898 }
17899
17900 if (ExtraMetadata_Offset!=(int64u)-1)
17901 {
17902 GoTo(ExtraMetadata_Offset);
17903 ExtraMetadata_Offset=(int64u)-1;
17904 }
17905
17906 return false;
17907 }
17908
17909 //---------------------------------------------------------------------------
Descriptor_Fill(const char * Name,const Ztring & Value)17910 void File_Mxf::Descriptor_Fill(const char* Name, const Ztring& Value)
17911 {
17912 descriptor& Descriptor = Descriptors[InstanceUID];
17913 std::map<std::string, Ztring>::iterator Info = Descriptor.Infos.find(Name);
17914
17915 //Ignore value if header partition has aleady a value
17916 if (Partitions_IsFooter && InstanceUID != int128u() && Info != Descriptor.Infos.end())
17917 {
17918 //Test
17919 if (Value != Info->second)
17920 Descriptor.Infos[string(Name)+"_Footer"] = Value;
17921
17922 return;
17923 }
17924
17925 if (Info == Descriptor.Infos.end())
17926 Descriptor.Infos[Name] = Value;
17927 else
17928 Info->second = Value;
17929 }
17930
17931 } //NameSpace
17932
17933 #endif //MEDIAINFO_MXF_*
17934