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 // Constants
21 //***************************************************************************
22
23 //---------------------------------------------------------------------------
24 #if defined(MEDIAINFO_AVC_YES) || defined(MEDIAINFO_MPEGPS_YES) || defined(MEDIAINFO_MPEGTS_YES)
25 //---------------------------------------------------------------------------
26
27 namespace MediaInfoLib
28 {
29
30 #include "ZenLib/Conf.h"
31 using namespace ZenLib;
32
33 //---------------------------------------------------------------------------
Avc_profile_idc(int8u profile_idc)34 const char* Avc_profile_idc(int8u profile_idc)
35 {
36 switch (profile_idc)
37 {
38 case 44 : return "CAVLC 4:4:4 Intra";
39 case 66 : return "Baseline";
40 case 77 : return "Main";
41 case 83 : return "Scalable Baseline";
42 case 86 : return "Scalable High";
43 case 88 : return "Extended";
44 case 100 : return "High";
45 case 110 : return "High 10";
46 case 118 : return "Multiview High";
47 case 122 : return "High 4:2:2";
48 case 128 : return "Stereo High";
49 case 138 : return "Multiview Depth High";
50 case 144 : return "High 4:4:4";
51 case 244 : return "High 4:4:4 Predictive";
52 default : return "";
53 }
54 }
55
56 //---------------------------------------------------------------------------
57 } //NameSpace
58
59 //---------------------------------------------------------------------------
60 #endif //...
61 //---------------------------------------------------------------------------
62
63 //***************************************************************************
64 //
65 //***************************************************************************
66
67 //---------------------------------------------------------------------------
68 #if defined(MEDIAINFO_AVC_YES)
69 //---------------------------------------------------------------------------
70
71 //---------------------------------------------------------------------------
72 #include "MediaInfo/Video/File_Avc.h"
73 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
74 #include "MediaInfo/Text/File_DtvccTransport.h"
75 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
76 #if MEDIAINFO_ADVANCED2
77 #include "ThirdParty/base64/base64.h"
78 #endif //MEDIAINFO_ADVANCED2
79 #include "MediaInfo/MediaInfo_Config_MediaInfo.h"
80 #if MEDIAINFO_EVENTS
81 #include "MediaInfo/MediaInfo_Config_PerPackage.h"
82 #include "MediaInfo/MediaInfo_Events.h"
83 #include "MediaInfo/MediaInfo_Events_Internal.h"
84 #endif //MEDIAINFO_EVENTS
85 #include <cstring>
86 #include <algorithm>
87 using namespace std;
88 using namespace ZenLib;
89 //---------------------------------------------------------------------------
90
91 namespace MediaInfoLib
92 {
93
94 //***************************************************************************
95 // Infos
96 //***************************************************************************
97
98 //---------------------------------------------------------------------------
99 const size_t Avc_Errors_MaxCount=32;
100
101 //---------------------------------------------------------------------------
102 extern const int8u Avc_PixelAspectRatio_Size=17;
103 extern const float32 Avc_PixelAspectRatio[Avc_PixelAspectRatio_Size]=
104 {
105 (float32)1, //Reserved
106 (float32)1,
107 (float32)12/(float32)11,
108 (float32)10/(float32)11,
109 (float32)16/(float32)11,
110 (float32)40/(float32)33,
111 (float32)24/(float32)11,
112 (float32)20/(float32)11,
113 (float32)32/(float32)11,
114 (float32)80/(float32)33,
115 (float32)18/(float32)11,
116 (float32)15/(float32)11,
117 (float32)64/(float32)33,
118 (float32)160/(float32)99,
119 (float32)4/(float32)3,
120 (float32)3/(float32)2,
121 (float32)2,
122 };
123
124 //---------------------------------------------------------------------------
125 const char* Avc_video_format[]=
126 {
127 "Component",
128 "PAL",
129 "NTSC",
130 "SECAM",
131 "MAC",
132 "",
133 "Reserved",
134 "Reserved",
135 };
136
137 //---------------------------------------------------------------------------
138 const char* Avc_video_full_range[]=
139 {
140 "Limited",
141 "Full",
142 };
143
144 //---------------------------------------------------------------------------
145 static const char* Avc_primary_pic_type[]=
146 {
147 "I",
148 "I, P",
149 "I, P, B",
150 "SI",
151 "SI, SP",
152 "I, SI",
153 "I, SI, P, SP",
154 "I, SI, P, SP, B",
155 };
156
157 //---------------------------------------------------------------------------
158 static const char* Avc_slice_type[]=
159 {
160 "P",
161 "B",
162 "I",
163 "SP",
164 "SI",
165 "P",
166 "B",
167 "I",
168 "SP",
169 "SI",
170 };
171
172 //---------------------------------------------------------------------------
173 const int8u Avc_pic_struct_Size=9;
174 static const char* Avc_pic_struct[]=
175 {
176 "frame",
177 "top field",
178 "bottom field",
179 "top field, bottom field",
180 "bottom field, top field",
181 "top field, bottom field, top field repeated",
182 "bottom field, top field, bottom field repeated",
183 "frame doubling",
184 "frame tripling",
185 };
186
187 //---------------------------------------------------------------------------
188 static const int8u Avc_NumClockTS[]=
189 {
190 1,
191 1,
192 1,
193 2,
194 2,
195 3,
196 3,
197 2,
198 3,
199 };
200
201 //---------------------------------------------------------------------------
202 static const char* Avc_ct_type[]=
203 {
204 "Progressive",
205 "Interlaced",
206 "Unknown",
207 "Reserved",
208 };
209
210 //---------------------------------------------------------------------------
211 static const int8u Avc_SubWidthC[]=
212 {
213 1,
214 2,
215 2,
216 1,
217 };
218
219 //---------------------------------------------------------------------------
220 static const int8u Avc_SubHeightC[]=
221 {
222 1,
223 2,
224 1,
225 1,
226 };
227
228 //---------------------------------------------------------------------------
229 const char* Avc_user_data_DTG1_active_format[]=
230 {
231 //1st value is for 4:3, 2nd is for 16:9
232 "", //Undefined
233 "Reserved",
234 "Not recommended",
235 "Not recommended",
236 "Aspect ratio greater than 16:9", //Use GA94
237 "Reserved",
238 "Reserved",
239 "Reserved",
240 "4:3 full frame image / 16:9 full frame image",
241 "4:3 full frame image / 4:3 pillarbox image",
242 "16:9 letterbox image / 16:9 full frame image",
243 "14:9 letterbox image / 14:9 pillarbox image",
244 "Reserved",
245 "4:3 full frame image, alternative 14:9 center / 4:3 pillarbox image, alternative 14:9 center",
246 "16:9 letterbox image, alternative 14:9 center / 16:9 full frame image, alternative 14:9 center",
247 "16:9 letterbox image, alternative 4:3 center / 16:9 full frame image, alternative 4:3 center",
248 };
249
250 //---------------------------------------------------------------------------
251 const char* Mpegv_colour_primaries(int8u colour_primaries);
252 const char* Mpegv_transfer_characteristics(int8u transfer_characteristics);
253 const char* Mpegv_matrix_coefficients(int8u matrix_coefficients);
254 const char* Mpegv_matrix_coefficients_ColorSpace(int8u matrix_coefficients);
255
256 //---------------------------------------------------------------------------
Avc_ChromaSubsampling_format_idc(int8u chroma_format_idc)257 static const char* Avc_ChromaSubsampling_format_idc(int8u chroma_format_idc)
258 {
259 switch (chroma_format_idc)
260 {
261 case 1: return "4:2:0";
262 case 2: return "4:2:2";
263 case 3: return "4:4:4";
264 default: return "";
265 }
266 }
267
268 //---------------------------------------------------------------------------
Avc_ChromaSubsampling_format_idc_ColorSpace(int8u chroma_format_idc)269 static const char* Avc_ChromaSubsampling_format_idc_ColorSpace(int8u chroma_format_idc)
270 {
271 switch (chroma_format_idc)
272 {
273 case 0: return "Y";
274 case 1: return "YUV";
275 case 2: return "YUV";
276 default: return "";
277 }
278 }
279
280 //---------------------------------------------------------------------------
Avc_user_data_GA94_cc_type(int8u cc_type)281 const char* Avc_user_data_GA94_cc_type(int8u cc_type)
282 {
283 switch (cc_type)
284 {
285 case 0 : return "CEA-608 line 21 field 1 closed captions"; //closed caption 3 if this is second field
286 case 1 : return "CEA-608 line 21 field 2 closed captions"; //closed caption 4 if this is second field
287 case 2 : return "DTVCC Channel Packet Data";
288 case 3 : return "DTVCC Channel Packet Start";
289 default : return "";
290 }
291 }
292
293 //---------------------------------------------------------------------------
Avc_MaxDpbMbs(int8u level)294 int32u Avc_MaxDpbMbs(int8u level)
295 {
296 switch (level)
297 {
298 case 10 : return 1485;
299 case 11 : return 3000;
300 case 12 : return 6000;
301 case 13 :
302 case 20 : return 11880;
303 case 21 : return 19800;
304 case 22 : return 20250;
305 case 30 : return 40500;
306 case 31 : return 108000;
307 case 32 : return 216000;
308 case 40 :
309 case 41 : return 245760;
310 case 42 : return 522240;
311 case 50 : return 589824;
312 case 51 : return 983040;
313 default : return 0;
314 }
315 }
316
317 //---------------------------------------------------------------------------
318 namespace AVC_Intra_Headers
319 {
320 //720p50
321 static const size_t __720p50__50_Size = 4 * 0x10 + 0xA;
322 static const int8u __720p50__50[__720p50__50_Size] = { 0x00, 0x00, 0x01, 0x67, 0x6E, 0x10, 0x20, 0xA6, 0xD4, 0x20, 0x32, 0x33, 0x0C, 0x71, 0x18, 0x88,
323 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8C, 0x44, 0x30, 0x21, 0x02, 0x56, 0x4E, 0x6F, 0x37, 0xCD,
324 0xF9, 0xBF, 0x81, 0x6B, 0xF3, 0x7C, 0xDE, 0x6E, 0x6C, 0xD3, 0x3C, 0x0F, 0x01, 0x6E, 0xFF, 0xC0,
325 0x00, 0xC0, 0x01, 0x38, 0xC0, 0x40, 0x40, 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x06,
326 0x48, 0x40, 0x00, 0x00, 0x01, 0x68, 0xEE, 0x31, 0x12, 0x11 };
327 static const size_t __720p50_100_Size = 5 * 0x10 + 0x2;
328 static const int8u __720p50_100[__720p50_100_Size] = { 0x00, 0x00, 0x01, 0x67, 0x7A, 0x10, 0x29, 0xB6, 0xD4, 0x20, 0x2A, 0x33, 0x1D, 0xC7, 0x62, 0xA1,
329 0x08, 0x40, 0x54, 0x66, 0x3B, 0x8E, 0xC5, 0x42, 0x02, 0x10, 0x25, 0x64, 0x2C, 0x89, 0xE8, 0x85,
330 0xE4, 0x21, 0x4B, 0x90, 0x83, 0x06, 0x95, 0xD1, 0x06, 0x46, 0x97, 0x20, 0xC8, 0xD7, 0x43, 0x08,
331 0x11, 0xC2, 0x1E, 0x4C, 0x91, 0x0F, 0x01, 0x40, 0x16, 0xEC, 0x07, 0x8C, 0x04, 0x04, 0x05, 0x00,
332 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03, 0x00, 0x64, 0x84, 0x00, 0x00, 0x01, 0x68, 0xCE, 0x31,
333 0x12, 0x11 };
334 //720p60
335 static const size_t __720p60__50_Size = 4 * 0x10 + 0xB;
336 static const int8u __720p60__50[__720p60__50_Size] = { 0x00, 0x00, 0x01, 0x67, 0x6E, 0x10, 0x20, 0xA6, 0xD4, 0x20, 0x32, 0x33, 0x0C, 0x71, 0x18, 0x88,
337 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8C, 0x44, 0x30, 0x21, 0x02, 0x56, 0x4E, 0x6F, 0x37, 0xCD,
338 0xF9, 0xBF, 0x81, 0x6B, 0xF3, 0x7C, 0xDE, 0x6E, 0x6C, 0xD3, 0x3C, 0x0F, 0x01, 0x6E, 0xFF, 0xC0,
339 0x00, 0xC0, 0x01, 0x38, 0xC0, 0x40, 0x40, 0x50, 0x00, 0x00, 0x3E, 0x90, 0x00, 0x1D, 0x4C, 0x08,
340 0x40, 0x00, 0x00, 0x00, 0x00, 0x01, 0x68, 0xEE, 0x31, 0x12, 0x11 };
341 static const size_t __720p60_100_Size = 5 * 0x10 + 0x1;
342 static const int8u __720p60_100[__720p60_100_Size] = { 0x00, 0x00, 0x01, 0x67, 0x7A, 0x10, 0x29, 0xB6, 0xD4, 0x20, 0x2A, 0x33, 0x1D, 0xC7, 0x62, 0xA1,
343 0x08, 0x40, 0x54, 0x66, 0x3B, 0x8E, 0xC5, 0x42, 0x02, 0x10, 0x25, 0x64, 0x2C, 0x89, 0xE8, 0x85,
344 0xE4, 0x21, 0x4B, 0x90, 0x83, 0x06, 0x95, 0xD1, 0x06, 0x46, 0x97, 0x20, 0xC8, 0xD7, 0x43, 0x08,
345 0x11, 0xC2, 0x1E, 0x4C, 0x91, 0x0F, 0x01, 0x40, 0x16, 0xEC, 0x07, 0x8C, 0x04, 0x04, 0x05, 0x00,
346 0x00, 0x03, 0x03, 0xE9, 0x00, 0x01, 0xD4, 0xC0, 0x84, 0x00, 0x00, 0x01, 0x68, 0xCE, 0x31, 0x12,
347 0x11 };
348
349 //1080i50
350 static const size_t _1080i50__50_Size = 5 * 0x10 + 0xE;
351 static const int8u _1080i50__50[_1080i50__50_Size] = { 0x00, 0x00, 0x01, 0x67, 0x6E, 0x10, 0x28, 0xA6, 0xD4, 0x20, 0x32, 0x33, 0x0C, 0x71, 0x18, 0x88,
352 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8C, 0x44, 0x30, 0x21, 0x02, 0x56, 0x4E, 0x6E, 0x61, 0x87,
353 0x3E, 0x73, 0x4D, 0x98, 0x0C, 0x03, 0x06, 0x9C, 0x0B, 0x73, 0xE6, 0xC0, 0xB5, 0x18, 0x63, 0x0D,
354 0x39, 0xE0, 0x5B, 0x02, 0xD4, 0xC6, 0x19, 0x1A, 0x79, 0x8C, 0x32, 0x34, 0x24, 0xF0, 0x16, 0x81,
355 0x13, 0xF7, 0xFF, 0x80, 0x01, 0x80, 0x02, 0x71, 0x80, 0x80, 0x80, 0xA0, 0x00, 0x00, 0x03, 0x00,
356 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00, 0x00, 0x01, 0x68, 0xEE, 0x31, 0x12, 0x11 };
357 static const size_t _1080i50_100_Size = 5 * 0x10 + 0xF;
358 static const int8u _1080i50_100[_1080i50_100_Size] = { 0x00, 0x00, 0x01, 0x67, 0x7A, 0x10, 0x29, 0xB6, 0xD4, 0x20, 0x22, 0x33, 0x19, 0xC6, 0x63, 0x23,
359 0x21, 0x01, 0x11, 0x98, 0xCE, 0x33, 0x19, 0x18, 0x21, 0x03, 0x3A, 0x46, 0x65, 0x6A, 0x65, 0x24,
360 0xAD, 0xE9, 0x12, 0x32, 0x14, 0x1A, 0x26, 0x34, 0xAD, 0xA4, 0x41, 0x82, 0x23, 0x01, 0x50, 0x2B,
361 0x1A, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2E, 0x11, 0x12, 0x08, 0xC6, 0x8C, 0x04, 0x41, 0x28, 0x4C,
362 0x34, 0xF0, 0x1E, 0x01, 0x13, 0xF2, 0xE0, 0x3C, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03, 0x00,
363 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20, 0x00, 0x00, 0x01, 0x68, 0xCE, 0x33, 0x48, 0xD0 };
364 //1080i60
365 static const size_t _1080i60__50_Size = 5 * 0x10 + 0xD;
366 static const int8u _1080i60__50[_1080i60__50_Size] = { 0x00, 0x00, 0x01, 0x67, 0x6E, 0x10, 0x28, 0xA6, 0xD4, 0x20, 0x32, 0x33, 0x0C, 0x71, 0x18, 0x88,
367 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8C, 0x44, 0x30, 0x21, 0x02, 0x56, 0x4E, 0x6E, 0x61, 0x87,
368 0x3E, 0x73, 0x4D, 0x98, 0x0C, 0x03, 0x06, 0x9C, 0x0B, 0x73, 0xE6, 0xC0, 0xB5, 0x18, 0x63, 0x0D,
369 0x39, 0xE0, 0x5B, 0x02, 0xD4, 0xC6, 0x19, 0x1A, 0x79, 0x8C, 0x32, 0x34, 0x24, 0xF0, 0x16, 0x81,
370 0x13, 0xF7, 0xFF, 0x80, 0x01, 0x80, 0x02, 0x71, 0x80, 0x80, 0x80, 0xA0, 0x00, 0x00, 0x7D, 0x20,
371 0x00, 0x1D, 0x4C, 0x10, 0x80, 0x00, 0x00, 0x01, 0x68, 0xEE, 0x31, 0x12, 0x11 };
372 static const size_t _1080i60_100_Size = 5 * 0x10 + 0xD;
373 static const int8u _1080i60_100[_1080i60_100_Size] = { 0x00, 0x00, 0x01, 0x67, 0x7A, 0x10, 0x29, 0xB6, 0xD4, 0x20, 0x22, 0x33, 0x19, 0xC6, 0x63, 0x23,
374 0x21, 0x01, 0x11, 0x98, 0xCE, 0x33, 0x19, 0x18, 0x21, 0x03, 0x3A, 0x46, 0x65, 0x6A, 0x65, 0x24,
375 0xAD, 0xE9, 0x12, 0x32, 0x14, 0x1A, 0x26, 0x34, 0xAD, 0xA4, 0x41, 0x82, 0x23, 0x01, 0x50, 0x2B,
376 0x1A, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2E, 0x11, 0x12, 0x08, 0xC6, 0x8C, 0x04, 0x41, 0x28, 0x4C,
377 0x34, 0xF0, 0x1E, 0x01, 0x13, 0xF2, 0xE0, 0x3C, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x1F, 0x48,
378 0x00, 0x07, 0x53, 0x04, 0x20, 0x00, 0x00, 0x01, 0x68, 0xCE, 0x33, 0x48, 0xD0 };
379
380 //1080p50
381 static const size_t _1080p50_100_Size = 4 * 0x10 + 0xA;
382 static const int8u _1080p50_100[_1080p50_100_Size] = { 0x00, 0x00, 0x01, 0x67, 0x7A, 0x10, 0x2A, 0xB6, 0xD4, 0x20, 0x22, 0x33, 0x19, 0xC6, 0x63, 0x23,
383 0x21, 0x01, 0x11, 0x98, 0xCE, 0x33, 0x19, 0x18, 0x21, 0x02, 0x56, 0xB9, 0x3D, 0x7D, 0x7E, 0x4F,
384 0xE3, 0x3F, 0x11, 0xF1, 0x9E, 0x08, 0xB8, 0x8C, 0x54, 0x43, 0xC0, 0x78, 0x02, 0x27, 0xE2, 0x70,
385 0x1E, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x01, 0x92, 0x10,
386 0x00, 0x00, 0x00, 0x00, 0x01, 0x68, 0xCE, 0x33, 0x48, 0xD0 };
387 //1080p60
388 static const size_t _1080p60_100_Size = 4 * 0x10 + 0x8;
389 static const int8u _1080p60_100[_1080p60_100_Size] = { 0x00, 0x00, 0x01, 0x67, 0x7A, 0x10, 0x2A, 0xB6, 0xD4, 0x20, 0x22, 0x33, 0x19, 0xC6, 0x63, 0x23,
390 0x21, 0x01, 0x11, 0x98, 0xCE, 0x33, 0x19, 0x18, 0x21, 0x02, 0x56, 0xB9, 0x3D, 0x7D, 0x7E, 0x4F,
391 0xE3, 0x3F, 0x11, 0xF1, 0x9E, 0x08, 0xB8, 0x8C, 0x54, 0x43, 0xC0, 0x78, 0x02, 0x27, 0xE2, 0x70,
392 0x1E, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00, 0x0F, 0xA4, 0x00, 0x07, 0x53, 0x02, 0x10, 0x00, 0x00,
393 0x00, 0x00, 0x01, 0x68, 0xCE, 0x33, 0x48, 0xD0 };
394 };
395
396
397 //---------------------------------------------------------------------------
398 // Some DV Metadata info: http://www.freepatentsonline.com/20050076039.pdf
MDPM(int8u ID)399 static const char* MDPM(int8u ID)
400 {
401 switch (ID)
402 {
403 case 0x18: return "Date/Time"; // Is "Text header" in doc?
404 case 0x19: return "Date/Time (continue 1)"; // Is "Text" in doc?
405 case 0x70: return "Consumer Camera 1";
406 case 0x71: return "Consumer Camera 2";
407 case 0x73: return "Lens";
408 case 0x7F: return "Camera shutter";
409 case 0xA1: return "Iris (F)";
410 case 0xE0: return "Make Model";
411 case 0xE1: return "Rec Info";
412 case 0xE4: return "Model Name";
413 case 0xE5: return "Model Name (continue 1)";
414 case 0xE6: return "Model Name (continue 1)";
415 default : return "";
416 }
417 }
418
419 //---------------------------------------------------------------------------
MDPM_MakeName(int16u Value)420 static const char* MDPM_MakeName(int16u Value)
421 {
422 switch (Value)
423 {
424 case 0x0103: return "Panasonic";
425 case 0x0108: return "Sony";
426 case 0x1011: return "Canon";
427 case 0x1104: return "JVC";
428 default : return "";
429 }
430 }
431
432 //---------------------------------------------------------------------------
433 // From DV
434 extern const char* Dv_consumer_camera_1_ae_mode[];
435 extern const char* Dv_consumer_camera_1_wb_mode[];
436 extern const char* Dv_consumer_camera_1_white_balance(int8u white_balance);
437 extern const char* Dv_consumer_camera_1_fcm[];
438
439 //***************************************************************************
440 // Constructor/Destructor
441 //***************************************************************************
442
443 //---------------------------------------------------------------------------
File_Avc()444 File_Avc::File_Avc()
445 #if MEDIAINFO_DUPLICATE
446 :File__Duplicate()
447 #endif //MEDIAINFO_DUPLICATE
448 {
449 //Config
450 #if MEDIAINFO_EVENTS
451 ParserIDs[0]=MediaInfo_Parser_Avc;
452 StreamIDs_Width[0]=0;
453 #endif //MEDIAINFO_EVENTS
454 #if MEDIAINFO_TRACE
455 Trace_Layers_Update(8); //Stream
456 #endif //MEDIAINFO_TRACE
457 MustSynchronize=true;
458 Buffer_TotalBytes_FirstSynched_Max=64*1024;
459 PTS_DTS_Needed=true;
460 StreamSource=IsStream;
461 Frame_Count_NotParsedIncluded=0;
462
463 //In
464 Frame_Count_Valid=0;
465 FrameIsAlwaysComplete=false;
466 MustParse_SPS_PPS=false;
467 SizedBlocks=false;
468
469 //Temporal references
470 TemporalReferences_DelayedElement=NULL;
471
472 //Temp
473 preferred_transfer_characteristics=2;
474
475 //Text
476 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
477 GA94_03_Parser=NULL;
478 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
479 }
480
481 //---------------------------------------------------------------------------
~File_Avc()482 File_Avc::~File_Avc()
483 {
484 Clean_Temp_References();
485 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
486 delete GA94_03_Parser; //GA94_03_Parser=NULL;
487 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
488 Clean_Seq_Parameter();
489 }
490
491 //---------------------------------------------------------------------------
Clean_Temp_References()492 void File_Avc::Clean_Temp_References()
493 {
494 for (size_t Pos = 0; Pos<TemporalReferences.size(); Pos++)
495 delete TemporalReferences[Pos]; //TemporalReferences[Pos]=NULL;
496 TemporalReferences.clear();
497 }
498 //---------------------------------------------------------------------------
Clean_Seq_Parameter()499 void File_Avc::Clean_Seq_Parameter()
500 {
501 for (size_t Pos = 0; Pos<seq_parameter_sets.size(); Pos++)
502 delete seq_parameter_sets[Pos]; //TemporalReferences[Pos]=NULL;
503 seq_parameter_sets.clear();
504 for (size_t Pos = 0; Pos<subset_seq_parameter_sets.size(); Pos++)
505 delete subset_seq_parameter_sets[Pos]; //subset_seq_parameter_sets[Pos]=NULL;
506 subset_seq_parameter_sets.clear();
507 for (size_t Pos = 0; Pos<pic_parameter_sets.size(); Pos++)
508 delete pic_parameter_sets[Pos]; //pic_parameter_sets[Pos]=NULL;
509 pic_parameter_sets.clear();
510 }
511 //***************************************************************************
512 // AVC-Intra hardcoded headers
513 //***************************************************************************
514
515 //---------------------------------------------------------------------------
AVC_Intra_Headers_Data(int32u CodecID)516 File_Avc::avcintra_header File_Avc::AVC_Intra_Headers_Data(int32u CodecID)
517 {
518 switch (CodecID)
519 {
520 case 0x61693132: //ai12
521 case 0x61693232: //ai22
522 return avcintra_header(AVC_Intra_Headers::_1080p50_100, AVC_Intra_Headers::_1080p50_100_Size); // AVC-Intra 1080p50 class 100/200
523 case 0x61693133: //ai13
524 case 0x61693233: //ai23
525 return avcintra_header(AVC_Intra_Headers::_1080p60_100, AVC_Intra_Headers::_1080p60_100_Size); // AVC-Intra 1080p60 class 100/200
526 case 0x61693135: //ai15
527 case 0x61693235: //ai25
528 return avcintra_header(AVC_Intra_Headers::_1080i50_100, AVC_Intra_Headers::_1080i50_100_Size); // AVC-Intra 1080i50 class 100/200
529 case 0x61693136: //ai16
530 case 0x61693236: //ai26
531 return avcintra_header(AVC_Intra_Headers::_1080i60_100, AVC_Intra_Headers::_1080i60_100_Size); // AVC-Intra 1080i60 class 100/200
532 case 0x61693170: //ai1p
533 case 0x61693270: //ai2p
534 return avcintra_header(AVC_Intra_Headers::__720p60_100, AVC_Intra_Headers::__720p60_100_Size); // AVC-Intra 720p60 class 100/200
535 case 0x61693171: //ai1q
536 case 0x61693271: //ai2q
537 return avcintra_header(AVC_Intra_Headers::__720p50_100, AVC_Intra_Headers::__720p50_100_Size); // AVC-Intra 720p50 class 100/200
538 //case 0x61693532: //ai52
539 // return avcintra_header(NULL, 0); // AVC-Intra 1080p25 class 50 (not supported)
540 //case 0x61693533: //ai53
541 // return avcintra_header(NULL, 0); // AVC-Intra 1080p30 class 50 (not supported)
542 case 0x61693535: //ai55
543 return avcintra_header(AVC_Intra_Headers::_1080i50__50, AVC_Intra_Headers::_1080i50__50_Size); // AVC-Intra 1080i50 class 50
544 case 0x61693536: //ai56
545 return avcintra_header(AVC_Intra_Headers::_1080i60__50, AVC_Intra_Headers::_1080i60__50_Size); // AVC-Intra 1080i60 class 50
546 case 0x61693570: //ai5p
547 return avcintra_header(AVC_Intra_Headers::__720p60__50, AVC_Intra_Headers::__720p60__50_Size); // AVC-Intra 720p60 class 50
548 case 0x61693571: //ai5q
549 return avcintra_header(AVC_Intra_Headers::__720p50__50, AVC_Intra_Headers::__720p50__50_Size); // AVC-Intra 720p50 class 50
550 default :
551 return avcintra_header(NULL, 0);
552 }
553 }
554
555 //---------------------------------------------------------------------------
AVC_Intra_CodecID_FromMeta(int32u Height,int32u Fields,int32u SampleDuration,int32u TimeScale,int32u SizePerFrame)556 int32u File_Avc::AVC_Intra_CodecID_FromMeta(int32u Height, int32u Fields, int32u SampleDuration, int32u TimeScale, int32u SizePerFrame)
557 {
558 // Computing bitrate
559 int64u BitRate=((int64u)SizePerFrame)*8*TimeScale/SampleDuration;
560 int64u SampleRate=float64_int64s(((float64)TimeScale)/SampleDuration);
561 int32u Class=BitRate<=75000000?50:100; //Arbitrary choosen. TODO: check real maximumm bitrate, check class 200
562 switch (Class)
563 {
564 case 100 :
565 switch (Height)
566 {
567 case 1080 :
568 switch (Fields)
569 {
570 case 1:
571 switch (SampleRate)
572 {
573 case 50: return 0x61693132; //ai12
574 case 60: return 0x61693133; //ai13
575 default: return 0x4156696E; //AVin (neutral)
576 }
577 case 2:
578 switch (SampleRate)
579 {
580 case 25: return 0x61693135; //ai15 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
581 case 30: return 0x61693136; //ai16 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
582 case 50: return 0x61693135; //ai15 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
583 case 60: return 0x61693136; //ai16 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
584 default: return 0x4156696E; //AVin (neutral)
585 }
586 default: return 0x4156696E; //AVin (neutral)
587 }
588 case 720 :
589 switch (Fields)
590 {
591 case 1:
592 switch (SampleRate)
593 {
594 case 50: return 0x61693170; //ai1p
595 case 60: return 0x61693171; //ai1q
596 default: return 0x4156696E; //AVin (neutral)
597 }
598 default: return 0x4156696E; //AVin (neutral)
599 }
600 default : return 0x4156696E; //AVin (neutral)
601 }
602 case 50 :
603 switch (Height)
604 {
605 case 1080 :
606 switch (Fields)
607 {
608 case 1:
609 switch (SampleRate)
610 {
611 case 25: return 0x61693532; //ai52
612 case 30: return 0x61693533; //ai53
613 default: return 0x4156696E; //AVin (neutral)
614 }
615 case 2:
616 switch (SampleRate)
617 {
618 case 25: return 0x61693535; //ai55 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
619 case 30: return 0x61693536; //ai56 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
620 case 50: return 0x61693535; //ai55 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
621 case 60: return 0x61693536; //ai56 //TODO: check more files in order to know if it should be 1 or 2 fields per sample
622 default: return 0x4156696E; //AVin (neutral)
623 }
624 default: return 0x4156696E; //AVin (neutral)
625 }
626 case 720 :
627 switch (Fields)
628 {
629 case 1:
630 switch (SampleRate)
631 {
632 case 50: return 0x61693570; //ai5p
633 case 60: return 0x61693571; //ai5q
634 default: return 0x4156696E; //AVin (neutral)
635 }
636 default: return 0x4156696E; //AVin (neutral)
637 }
638 default : return 0x4156696E; //AVin (neutral)
639 }
640 default: return 0x4156696E; //AVin (neutral)
641 }
642 }
643
644 //***************************************************************************
645 // Streams management
646 //***************************************************************************
647
648 //---------------------------------------------------------------------------
Streams_Fill()649 void File_Avc::Streams_Fill()
650 {
651 for (std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item=seq_parameter_sets.begin(); seq_parameter_set_Item!=seq_parameter_sets.end(); ++seq_parameter_set_Item)
652 if ((*seq_parameter_set_Item))
653 Streams_Fill(seq_parameter_set_Item);
654 for (std::vector<seq_parameter_set_struct*>::iterator subset_seq_parameter_set_Item=subset_seq_parameter_sets.begin(); subset_seq_parameter_set_Item!=subset_seq_parameter_sets.end(); ++subset_seq_parameter_set_Item)
655 if ((*subset_seq_parameter_set_Item))
656 {
657 if (seq_parameter_sets.empty())
658 Streams_Fill(subset_seq_parameter_set_Item);
659 else
660 Streams_Fill_subset(subset_seq_parameter_set_Item);
661 Fill(Stream_Video, 0, Video_MultiView_Count, (*subset_seq_parameter_set_Item)->num_views_minus1+1);
662 }
663
664 #if MEDIAINFO_ADVANCED2
665 for (size_t Pos = 0; Pos<Dump_SPS.size(); Pos++)
666 Fill(Stream_Video, 0, "Dump_seq_parameter_set", Dump_SPS[Pos].c_str());
667 for (size_t Pos = 0; Pos<Dump_PPS.size(); Pos++)
668 Fill(Stream_Video, 0, "Dump_pic_parameter_set", Dump_PPS[Pos].c_str());
669 #endif //MEDIAINFO_ADVANCED2
670 }
671
672 //---------------------------------------------------------------------------
Streams_Fill(std::vector<seq_parameter_set_struct * >::iterator seq_parameter_set_Item)673 void File_Avc::Streams_Fill(std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item)
674 {
675 if (Count_Get(Stream_Video))
676 return;
677 Stream_Prepare(Stream_Video);
678 Fill(Stream_Video, 0, Video_Format, "AVC");
679 Fill(Stream_Video, 0, Video_Codec, "AVC");
680
681 //Calculating - Pixels
682 int32u Width =((*seq_parameter_set_Item)->pic_width_in_mbs_minus1 +1)*16;
683 int32u Height=((*seq_parameter_set_Item)->pic_height_in_map_units_minus1+1)*16*(2-(*seq_parameter_set_Item)->frame_mbs_only_flag);
684 int8u chromaArrayType = (*seq_parameter_set_Item)->ChromaArrayType();
685 if (chromaArrayType >= 4)
686 chromaArrayType = 0;
687 int32u CropUnitX=Avc_SubWidthC [chromaArrayType];
688 int32u CropUnitY=Avc_SubHeightC[chromaArrayType]*(2-(*seq_parameter_set_Item)->frame_mbs_only_flag);
689 Width -=((*seq_parameter_set_Item)->frame_crop_left_offset+(*seq_parameter_set_Item)->frame_crop_right_offset )*CropUnitX;
690 Height-=((*seq_parameter_set_Item)->frame_crop_top_offset +(*seq_parameter_set_Item)->frame_crop_bottom_offset)*CropUnitY;
691
692 //From vui_parameters
693 float64 PixelAspectRatio=1;
694 if ((*seq_parameter_set_Item)->vui_parameters)
695 {
696 if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_info_present_flag)
697 {
698 if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc<Avc_PixelAspectRatio_Size)
699 PixelAspectRatio=Avc_PixelAspectRatio[(*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc];
700 else if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc==0xFF && (*seq_parameter_set_Item)->vui_parameters->sar_height)
701 PixelAspectRatio=((float64)(*seq_parameter_set_Item)->vui_parameters->sar_width)/(*seq_parameter_set_Item)->vui_parameters->sar_height;
702 }
703 if ((*seq_parameter_set_Item)->vui_parameters->timing_info_present_flag)
704 {
705 if (!(*seq_parameter_set_Item)->vui_parameters->fixed_frame_rate_flag)
706 Fill(Stream_Video, StreamPos_Last, Video_FrameRate_Mode, "VFR");
707 else if ((*seq_parameter_set_Item)->vui_parameters->timing_info_present_flag && (*seq_parameter_set_Item)->vui_parameters->time_scale && (*seq_parameter_set_Item)->vui_parameters->num_units_in_tick)
708 Fill(Stream_Video, StreamPos_Last, Video_FrameRate, (float64)(*seq_parameter_set_Item)->vui_parameters->time_scale/(*seq_parameter_set_Item)->vui_parameters->num_units_in_tick/((*seq_parameter_set_Item)->frame_mbs_only_flag?2:(((*seq_parameter_set_Item)->pic_order_cnt_type==2 && Structure_Frame/2>Structure_Field)?1:2))/FrameRate_Divider);
709 }
710
711 //Colour description
712 if (preferred_transfer_characteristics!=2)
713 Fill(Stream_Video, 0, Video_transfer_characteristics, Mpegv_transfer_characteristics(preferred_transfer_characteristics));
714 if ((*seq_parameter_set_Item)->vui_parameters->video_signal_type_present_flag)
715 {
716 Fill(Stream_Video, 0, Video_Standard, Avc_video_format[(*seq_parameter_set_Item)->vui_parameters->video_format]);
717 Fill(Stream_Video, 0, Video_colour_range, Avc_video_full_range[(*seq_parameter_set_Item)->vui_parameters->video_full_range_flag]);
718 if ((*seq_parameter_set_Item)->vui_parameters->colour_description_present_flag)
719 {
720 Fill(Stream_Video, 0, Video_colour_description_present, "Yes");
721 Fill(Stream_Video, 0, Video_colour_primaries, Mpegv_colour_primaries((*seq_parameter_set_Item)->vui_parameters->colour_primaries));
722 Fill(Stream_Video, 0, Video_transfer_characteristics, Mpegv_transfer_characteristics((*seq_parameter_set_Item)->vui_parameters->transfer_characteristics));
723 Fill(Stream_Video, 0, Video_matrix_coefficients, Mpegv_matrix_coefficients((*seq_parameter_set_Item)->vui_parameters->matrix_coefficients));
724 if ((*seq_parameter_set_Item)->vui_parameters->matrix_coefficients!=2)
725 Fill(Stream_Video, 0, Video_ColorSpace, Mpegv_matrix_coefficients_ColorSpace((*seq_parameter_set_Item)->vui_parameters->matrix_coefficients), Unlimited, true, true);
726 }
727 }
728
729 //hrd_parameter_sets
730 int64u bit_rate_value=(int64u)-1;
731 bool bit_rate_value_IsValid=true;
732 bool cbr_flag=false;
733 bool cbr_flag_IsSet=false;
734 bool cbr_flag_IsValid=true;
735 seq_parameter_set_struct::vui_parameters_struct::xxl* NAL=(*seq_parameter_set_Item)->vui_parameters->NAL;
736 if (NAL)
737 for (size_t Pos=0; Pos<NAL->SchedSel.size(); Pos++)
738 {
739 if (NAL->SchedSel[Pos].cpb_size_value!=(int32u)-1)
740 Fill(Stream_Video, 0, Video_BufferSize, NAL->SchedSel[Pos].cpb_size_value);
741 if (bit_rate_value!=(int64u)-1 && bit_rate_value!=NAL->SchedSel[Pos].bit_rate_value)
742 bit_rate_value_IsValid=false;
743 if (bit_rate_value==(int64u)-1)
744 bit_rate_value=NAL->SchedSel[Pos].bit_rate_value;
745 if (cbr_flag_IsSet==true && cbr_flag!=NAL->SchedSel[Pos].cbr_flag)
746 cbr_flag_IsValid=false;
747 if (cbr_flag_IsSet==0)
748 {
749 cbr_flag=NAL->SchedSel[Pos].cbr_flag;
750 cbr_flag_IsSet=true;
751 }
752 }
753 seq_parameter_set_struct::vui_parameters_struct::xxl* VCL=(*seq_parameter_set_Item)->vui_parameters->VCL;
754 if (VCL)
755 for (size_t Pos=0; Pos<VCL->SchedSel.size(); Pos++)
756 {
757 Fill(Stream_Video, 0, Video_BufferSize, VCL->SchedSel[Pos].cpb_size_value);
758 if (bit_rate_value!=(int64u)-1 && bit_rate_value!=VCL->SchedSel[Pos].bit_rate_value)
759 bit_rate_value_IsValid=false;
760 if (bit_rate_value==(int64u)-1)
761 bit_rate_value=VCL->SchedSel[Pos].bit_rate_value;
762 if (cbr_flag_IsSet==true && cbr_flag!=VCL->SchedSel[Pos].cbr_flag)
763 cbr_flag_IsValid=false;
764 if (cbr_flag_IsSet==0)
765 {
766 cbr_flag=VCL->SchedSel[Pos].cbr_flag;
767 cbr_flag_IsSet=true;
768 }
769 }
770 if (cbr_flag_IsSet && cbr_flag_IsValid)
771 {
772 Fill(Stream_Video, 0, Video_BitRate_Mode, cbr_flag?"CBR":"VBR");
773 if (bit_rate_value!=(int64u)-1 && bit_rate_value_IsValid)
774 Fill(Stream_Video, 0, cbr_flag?Video_BitRate_Nominal:Video_BitRate_Maximum, bit_rate_value);
775 }
776 }
777
778 Ztring Profile=Ztring().From_UTF8(Avc_profile_idc((*seq_parameter_set_Item)->profile_idc));
779 switch ((*seq_parameter_set_Item)->profile_idc)
780 {
781 case 44 : // CAVLC 4:4:4 Intra
782 case 100 : // High
783 case 110 : // High 10
784 case 122 : // High 4:2:2"
785 case 244 : // High 4:4:4 Predictive
786 if ((*seq_parameter_set_Item)->constraint_set3_flag)
787 Profile+=__T(" Intra");
788 }
789 Profile+=__T("@L")+Ztring().From_Number(((float)(*seq_parameter_set_Item)->level_idc)/10, ((*seq_parameter_set_Item)->level_idc%10)?1:0);
790 Fill(Stream_Video, 0, Video_Format_Profile, Profile);
791 Fill(Stream_Video, 0, Video_Codec_Profile, Profile);
792 Fill(Stream_Video, StreamPos_Last, Video_Width, Width);
793 Fill(Stream_Video, StreamPos_Last, Video_Height, Height);
794 if ((*seq_parameter_set_Item)->frame_crop_left_offset || (*seq_parameter_set_Item)->frame_crop_right_offset)
795 Fill(Stream_Video, StreamPos_Last, Video_Stored_Width, ((*seq_parameter_set_Item)->pic_width_in_mbs_minus1 +1)*16);
796 if ((*seq_parameter_set_Item)->frame_crop_top_offset || (*seq_parameter_set_Item)->frame_crop_bottom_offset)
797 Fill(Stream_Video, StreamPos_Last, Video_Stored_Height, ((*seq_parameter_set_Item)->pic_height_in_map_units_minus1+1)*16*(2-(*seq_parameter_set_Item)->frame_mbs_only_flag));
798 Fill(Stream_Video, 0, Video_PixelAspectRatio, PixelAspectRatio, 3, true);
799 if(Height)
800 Fill(Stream_Video, 0, Video_DisplayAspectRatio, Width*PixelAspectRatio/Height, 3, true); //More precise
801 if (FrameRate_Divider==2)
802 {
803 Fill(Stream_Video, StreamPos_Last, Video_Format_Settings_FrameMode, "Frame doubling");
804 Fill(Stream_Video, StreamPos_Last, Video_Format_Settings, "Frame doubling");
805 }
806 if (FrameRate_Divider==3)
807 {
808 Fill(Stream_Video, StreamPos_Last, Video_Format_Settings_FrameMode, "Frame tripling");
809 Fill(Stream_Video, StreamPos_Last, Video_Format_Settings, "Frame tripling");
810 }
811
812 //Interlacement
813 if ((*seq_parameter_set_Item)->mb_adaptive_frame_field_flag && Structure_Frame>0) //Interlaced macro-block
814 {
815 Fill(Stream_Video, 0, Video_ScanType, "MBAFF");
816 Fill(Stream_Video, 0, Video_Interlacement, "MBAFF");
817 }
818 else if ((*seq_parameter_set_Item)->frame_mbs_only_flag || (Structure_Frame>0 && Structure_Field==0)) //No interlaced frame
819 {
820 switch ((*seq_parameter_set_Item)->pic_struct_FirstDetected)
821 {
822 case 3 :
823 Fill(Stream_Video, 0, Video_ScanType, "Interlaced");
824 Fill(Stream_Video, 0, Video_Interlacement, "TFF");
825 Fill(Stream_Video, 0, Video_Format_Settings_PictureStructure, "Frame");
826 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "InterleavedFields");
827 break;
828 case 4 :
829 Fill(Stream_Video, 0, Video_ScanType, "Interlaced");
830 Fill(Stream_Video, 0, Video_Interlacement, "BFF");
831 Fill(Stream_Video, 0, Video_Format_Settings_PictureStructure, "Frame");
832 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "InterleavedFields");
833 break;
834 default :
835 Fill(Stream_Video, 0, Video_ScanType, "Progressive");
836 Fill(Stream_Video, 0, Video_Interlacement, "PPF");
837 }
838 }
839 else if (Structure_Field>0)
840 {
841 Fill(Stream_Video, 0, Video_ScanType, "Interlaced");
842 Fill(Stream_Video, 0, Video_Interlacement, "Interlaced");
843 }
844 std::string ScanOrders, PictureTypes(PictureTypes_PreviousFrames);
845 ScanOrders.reserve(TemporalReferences.size());
846 for (size_t Pos=0; Pos<TemporalReferences.size(); Pos++)
847 if (TemporalReferences[Pos])
848 {
849 ScanOrders+=TemporalReferences[Pos]->IsTop?'T':'B';
850 if ((Pos%2)==0)
851 PictureTypes+=Avc_slice_type[TemporalReferences[Pos]->slice_type];
852 }
853 else if (!PictureTypes.empty()) //Only if stream already started
854 {
855 ScanOrders+=' ';
856 if ((Pos%2)==0)
857 PictureTypes+=' ';
858 }
859 Fill(Stream_Video, 0, Video_ScanOrder, ScanOrder_Detect(ScanOrders));
860 { //Legacy
861 string Result=ScanOrder_Detect(ScanOrders);
862 if (!Result.empty())
863 {
864 Fill(Stream_Video, 0, Video_Interlacement, Result, true, true);
865 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "SeparatedFields", Unlimited, true, true);
866 }
867 else
868 {
869 switch ((*seq_parameter_set_Item)->pic_struct_FirstDetected)
870 {
871 case 1 :
872 Fill(Stream_Video, 0, Video_ScanOrder, (string) "TFF");
873 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "SeparatedFields", Unlimited, true, true);
874 break;
875 case 2 :
876 Fill(Stream_Video, 0, Video_ScanOrder, (string) "BFF");
877 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "SeparatedFields", Unlimited, true, true);
878 break;
879 case 3 :
880 Fill(Stream_Video, 0, Video_ScanOrder, (string) "TFF");
881 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "InterleavedFields", Unlimited, true, true);
882 break;
883 case 4 :
884 Fill(Stream_Video, 0, Video_ScanOrder, (string) "BFF");
885 Fill(Stream_Video, 0, Video_ScanType_StoreMethod, "InterleavedFields", Unlimited, true, true);
886 break;
887 default : ;
888 }
889 }
890 }
891 Fill(Stream_Video, 0, Video_Format_Settings_GOP, GOP_Detect(PictureTypes));
892
893 Fill(Stream_General, 0, General_Encoded_Library, Encoded_Library);
894 Fill(Stream_General, 0, General_Encoded_Library_Name, Encoded_Library_Name);
895 Fill(Stream_General, 0, General_Encoded_Library_Version, Encoded_Library_Version);
896 Fill(Stream_General, 0, General_Encoded_Library_Settings, Encoded_Library_Settings);
897 Fill(Stream_Video, 0, Video_Encoded_Library, Encoded_Library);
898 Fill(Stream_Video, 0, Video_Encoded_Library_Name, Encoded_Library_Name);
899 Fill(Stream_Video, 0, Video_Encoded_Library_Version, Encoded_Library_Version);
900 Fill(Stream_Video, 0, Video_Encoded_Library_Settings, Encoded_Library_Settings);
901 if (Retrieve_Const(Stream_Video, 0, Video_BitRate_Nominal).empty()) // SPS has priority over other metadata
902 Fill(Stream_Video, 0, Video_BitRate_Nominal, BitRate_Nominal);
903 Fill(Stream_Video, 0, Video_MuxingMode, MuxingMode);
904 for (std::vector<pic_parameter_set_struct*>::iterator pic_parameter_set_Item=pic_parameter_sets.begin(); pic_parameter_set_Item!=pic_parameter_sets.end(); ++pic_parameter_set_Item)
905 if (*pic_parameter_set_Item && (*pic_parameter_set_Item)->seq_parameter_set_id==seq_parameter_set_Item-(seq_parameter_sets.empty()?subset_seq_parameter_sets.begin():seq_parameter_sets.begin()))
906 {
907 if ((*pic_parameter_set_Item)->entropy_coding_mode_flag)
908 {
909 Fill(Stream_Video, 0, Video_Format_Settings, "CABAC");
910 Fill(Stream_Video, 0, Video_Format_Settings_CABAC, "Yes");
911 Fill(Stream_Video, 0, Video_Codec_Settings, "CABAC");
912 Fill(Stream_Video, 0, Video_Codec_Settings_CABAC, "Yes");
913 }
914 else
915 {
916 Fill(Stream_Video, 0, Video_Format_Settings_CABAC, "No");
917 Fill(Stream_Video, 0, Video_Codec_Settings_CABAC, "No");
918 }
919 break; //TODO: currently, testing only the first pic_parameter_set
920 }
921 if ((*seq_parameter_set_Item)->max_num_ref_frames>0)
922 {
923 Fill(Stream_Video, 0, Video_Format_Settings, Ztring::ToZtring((*seq_parameter_set_Item)->max_num_ref_frames)+__T(" Ref Frames"));
924 Fill(Stream_Video, 0, Video_Codec_Settings, Ztring::ToZtring((*seq_parameter_set_Item)->max_num_ref_frames)+__T(" Ref Frames"));
925 Fill(Stream_Video, 0, Video_Format_Settings_RefFrames, (*seq_parameter_set_Item)->max_num_ref_frames);
926 Fill(Stream_Video, 0, Video_Codec_Settings_RefFrames, (*seq_parameter_set_Item)->max_num_ref_frames);
927 }
928 if (Retrieve(Stream_Video, 0, Video_ColorSpace).empty())
929 Fill(Stream_Video, 0, Video_ColorSpace, Avc_ChromaSubsampling_format_idc_ColorSpace((*seq_parameter_set_Item)->chroma_format_idc));
930 Fill(Stream_Video, 0, Video_ChromaSubsampling, Avc_ChromaSubsampling_format_idc((*seq_parameter_set_Item)->chroma_format_idc));
931 if ((*seq_parameter_set_Item)->bit_depth_luma_minus8==(*seq_parameter_set_Item)->bit_depth_chroma_minus8)
932 Fill(Stream_Video, 0, Video_BitDepth, (*seq_parameter_set_Item)->bit_depth_luma_minus8+8);
933
934 hdr::iterator EtsiTs103433 = HDR.find(HdrFormat_EtsiTs103433);
935 if (EtsiTs103433 != HDR.end())
936 {
937 for (std::map<video, Ztring>::iterator Item = EtsiTs103433->second.begin(); Item != EtsiTs103433->second.end(); ++Item)
938 {
939 Fill(Stream_Video, 0, Item->first, Item->second);
940 }
941 }
942 hdr::iterator SmpteSt209440 = HDR.find(HdrFormat_SmpteSt209440);
943 if (SmpteSt209440 != HDR.end())
944 {
945 for (std::map<video, Ztring>::iterator Item = SmpteSt209440->second.begin(); Item != SmpteSt209440->second.end(); ++Item)
946 {
947 switch (Item->first)
948 {
949 case Video_MasteringDisplay_ColorPrimaries:
950 case Video_MasteringDisplay_Luminance:
951 if (Retrieve_Const(Stream_Video, 0, Item->first) == Item->second)
952 break;
953 // Fallthrough
954 default:
955 Fill(Stream_Video, 0, Item->first, Item->second);
956 }
957 }
958 }
959 hdr::iterator SmpteSt2086 = HDR.find(HdrFormat_SmpteSt2086);
960 if (SmpteSt2086 != HDR.end())
961 {
962 for (std::map<video, Ztring>::iterator Item = SmpteSt2086->second.begin(); Item != SmpteSt2086->second.end(); ++Item)
963 {
964 bool Ignore;
965 switch (Item->first)
966 {
967 case Video_HDR_Format:
968 Ignore = !Retrieve_Const(Stream_Video, 0, Item->first).empty();
969 break;
970 case Video_MasteringDisplay_ColorPrimaries:
971 case Video_MasteringDisplay_Luminance:
972 Ignore = Retrieve_Const(Stream_Video, 0, Item->first) == Item->second;
973 break;
974 }
975 if (!Ignore)
976 Fill(Stream_Video, 0, Item->first, Item->second);
977 }
978 }
979
980 if (maximum_content_light_level)
981 Fill(Stream_Video, 0, "MaxCLL", Ztring::ToZtring(maximum_content_light_level) + __T(" cd/m2"));
982 if (maximum_frame_average_light_level)
983 Fill(Stream_Video, 0, "MaxFALL", Ztring::ToZtring(maximum_frame_average_light_level) + __T(" cd/m2"));
984 }
985
986 //---------------------------------------------------------------------------
Streams_Fill_subset(const std::vector<seq_parameter_set_struct * >::iterator seq_parameter_set_Item)987 void File_Avc::Streams_Fill_subset(const std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item)
988 {
989 Ztring Profile=Ztring().From_UTF8(Avc_profile_idc((*seq_parameter_set_Item)->profile_idc))+__T("@L")+Ztring().From_Number(((float)(*seq_parameter_set_Item)->level_idc)/10, 1);
990 Ztring Profile_Base=Retrieve(Stream_Video, 0, Video_Format_Profile);
991 Fill(Stream_Video, 0, Video_Format_Profile, Profile, true);
992 if (!Profile_Base.empty())
993 Fill(Stream_Video, 0, Video_Format_Profile, Profile_Base);
994 }
995
996 //---------------------------------------------------------------------------
Streams_Finish()997 void File_Avc::Streams_Finish()
998 {
999 if (PTS_End!=(int64u)-1 && (IsSub || File_Offset+Buffer_Offset+Element_Size==File_Size))
1000 {
1001 if (PTS_End>PTS_Begin)
1002 Fill(Stream_Video, 0, Video_Duration, float64_int64s(((float64)(PTS_End-PTS_Begin))/1000000));
1003 }
1004
1005 //GA94 captions
1006 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
1007 if (GA94_03_Parser && GA94_03_Parser->Status[IsAccepted])
1008 {
1009 Clear(Stream_Text);
1010
1011 Finish(GA94_03_Parser);
1012 Merge(*GA94_03_Parser);
1013
1014 Ztring LawRating=GA94_03_Parser->Retrieve(Stream_General, 0, General_LawRating);
1015 if (!LawRating.empty())
1016 Fill(Stream_General, 0, General_LawRating, LawRating, true);
1017 Ztring Title=GA94_03_Parser->Retrieve(Stream_General, 0, General_Title);
1018 if (!Title.empty() && Retrieve(Stream_General, 0, General_Title).empty())
1019 Fill(Stream_General, 0, General_Title, Title);
1020
1021 for (size_t Pos=0; Pos<Count_Get(Stream_Text); Pos++)
1022 {
1023 Ztring MuxingMode=Retrieve(Stream_Text, Pos, "MuxingMode");
1024 Fill(Stream_Text, Pos, "MuxingMode", __T("SCTE 128 / ")+MuxingMode, true);
1025 }
1026 }
1027 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
1028
1029 #if MEDIAINFO_IBIUSAGE
1030 if (seq_parameter_sets.size()==1 && (*seq_parameter_sets.begin())->vui_parameters && (*seq_parameter_sets.begin())->vui_parameters->timing_info_present_flag && (*seq_parameter_sets.begin())->vui_parameters->fixed_frame_rate_flag)
1031 Ibi_Stream_Finish((*seq_parameter_sets.begin())->vui_parameters->time_scale, (*seq_parameter_sets.begin())->vui_parameters->num_units_in_tick);
1032 #endif //MEDIAINFO_IBIUSAGE
1033 }
1034
1035 //***************************************************************************
1036 // Buffer - File header
1037 //***************************************************************************
1038
1039 //---------------------------------------------------------------------------
FileHeader_Begin()1040 bool File_Avc::FileHeader_Begin()
1041 {
1042 if (!File__Analyze::FileHeader_Begin_0x000001())
1043 return false;
1044
1045 if (!MustSynchronize)
1046 {
1047 Synched_Init();
1048 Buffer_TotalBytes_FirstSynched=0;
1049 File_Offset_FirstSynched=File_Offset;
1050 }
1051
1052 //All should be OK
1053 return true;
1054 }
1055
1056 //***************************************************************************
1057 // Buffer - Synchro
1058 //***************************************************************************
1059
1060 //---------------------------------------------------------------------------
Synchronize()1061 bool File_Avc::Synchronize()
1062 {
1063 //Synchronizing
1064 size_t Buffer_Offset_Min=Buffer_Offset;
1065 while(Buffer_Offset+4<=Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
1066 || Buffer[Buffer_Offset+1]!=0x00
1067 || Buffer[Buffer_Offset+2]!=0x01))
1068 {
1069 Buffer_Offset+=2;
1070 while(Buffer_Offset<Buffer_Size && Buffer[Buffer_Offset]!=0x00)
1071 Buffer_Offset+=2;
1072 if (Buffer_Offset>=Buffer_Size || Buffer[Buffer_Offset-1]==0x00)
1073 Buffer_Offset--;
1074 }
1075 if (Buffer_Offset>Buffer_Offset_Min && Buffer[Buffer_Offset-1]==0x00)
1076 Buffer_Offset--;
1077
1078 //Parsing last bytes if needed
1079 if (Buffer_Offset+4==Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
1080 || Buffer[Buffer_Offset+1]!=0x00
1081 || Buffer[Buffer_Offset+2]!=0x00
1082 || Buffer[Buffer_Offset+3]!=0x01))
1083 Buffer_Offset++;
1084 if (Buffer_Offset+3==Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
1085 || Buffer[Buffer_Offset+1]!=0x00
1086 || Buffer[Buffer_Offset+2]!=0x01))
1087 Buffer_Offset++;
1088 if (Buffer_Offset+2==Buffer_Size && (Buffer[Buffer_Offset ]!=0x00
1089 || Buffer[Buffer_Offset+1]!=0x00))
1090 Buffer_Offset++;
1091 if (Buffer_Offset+1==Buffer_Size && Buffer[Buffer_Offset ]!=0x00)
1092 Buffer_Offset++;
1093
1094 if (Buffer_Offset+4>Buffer_Size)
1095 return false;
1096
1097 //Synched is OK
1098 Synched=true;
1099 return true;
1100 }
1101
1102 //---------------------------------------------------------------------------
Synched_Test()1103 bool File_Avc::Synched_Test()
1104 {
1105 //Must have enough buffer for having header
1106 if (Buffer_Offset+6>Buffer_Size)
1107 return false;
1108
1109 //Quick test of synchro
1110 if (Buffer[Buffer_Offset ]!=0x00
1111 || Buffer[Buffer_Offset+1]!=0x00
1112 || (Buffer[Buffer_Offset+2]!=0x01 && (Buffer[Buffer_Offset+2]!=0x00 || Buffer[Buffer_Offset+3]!=0x01)))
1113 {
1114 Synched=false;
1115 return true;
1116 }
1117
1118 //Quick search
1119 if (!Header_Parser_QuickSearch())
1120 return false;
1121
1122 #if MEDIAINFO_IBIUSAGE
1123 bool zero_byte=Buffer[Buffer_Offset+2]==0x00;
1124 bool RandomAccess=(Buffer[Buffer_Offset+(zero_byte?4:3)]&0x1F)==0x07 || ((Buffer[Buffer_Offset+(zero_byte?4:3)]&0x1F)==0x09 && ((Buffer[Buffer_Offset+(zero_byte?5:4)]&0xE0)==0x00 || (Buffer[Buffer_Offset+(zero_byte?5:4)]&0xE0)==0xA0)); //seq_parameter_set or access_unit_delimiter with value=0 or 5 (3 bits)
1125 if (RandomAccess)
1126 Ibi_Add();
1127 #endif //MEDIAINFO_IBIUSAGE
1128
1129 //We continue
1130 return true;
1131 }
1132
1133 //***************************************************************************
1134 // Buffer - Demux
1135 //***************************************************************************
1136
1137 //---------------------------------------------------------------------------
1138 #if MEDIAINFO_DEMUX
Data_Parse_Iso14496()1139 void File_Avc::Data_Parse_Iso14496()
1140 {
1141 if (Demux_Avc_Transcode_Iso14496_15_to_Iso14496_10)
1142 {
1143 if (Element_Code==0x07)
1144 {
1145 std::vector<seq_parameter_set_struct*>::iterator Data_Item=seq_parameter_sets.begin();
1146 if (Data_Item!=seq_parameter_sets.end() && (*Data_Item))
1147 {
1148 (*Data_Item)->Init_Iso14496_10(0x67, Buffer+Buffer_Offset, Element_Size);
1149 }
1150 }
1151 if (Element_Code==0x08)
1152 {
1153 std::vector<pic_parameter_set_struct*>::iterator Data_Item=pic_parameter_sets.begin();
1154 if (Data_Item!=pic_parameter_sets.end() && (*Data_Item))
1155 {
1156 (*Data_Item)->Init_Iso14496_10(0x68, Buffer+Buffer_Offset, Element_Size);
1157 }
1158 }
1159 if (Element_Code==0x0F)
1160 {
1161 std::vector<seq_parameter_set_struct*>::iterator Data_Item=subset_seq_parameter_sets.begin();
1162 if (Data_Item!=subset_seq_parameter_sets.end() && (*Data_Item))
1163 {
1164 SizeOfNALU_Minus1=0;
1165 (*Data_Item)->Init_Iso14496_10(0x6F, Buffer+Buffer_Offset, Element_Size);
1166 }
1167 }
1168 }
1169 }
1170
1171 //---------------------------------------------------------------------------
Demux_UnpacketizeContainer_Test()1172 bool File_Avc::Demux_UnpacketizeContainer_Test()
1173 {
1174 const int8u* Buffer_Temp=NULL;
1175 size_t Buffer_Temp_Size=0;
1176 bool RandomAccess=true; //Default, in case of problem
1177
1178 if ((MustParse_SPS_PPS || SizedBlocks) && Demux_Avc_Transcode_Iso14496_15_to_Iso14496_10)
1179 {
1180 if (MustParse_SPS_PPS)
1181 return true; //Wait for SPS and PPS
1182
1183 //Random access check
1184 RandomAccess=false;
1185
1186 //Computing final size
1187 size_t TranscodedBuffer_Size=0;
1188 size_t Buffer_Offset_Save=Buffer_Offset;
1189 while (Buffer_Offset+SizeOfNALU_Minus1+1+1<=Buffer_Size)
1190 {
1191 size_t Size;
1192 if (Buffer_Offset+SizeOfNALU_Minus1>Buffer_Size)
1193 {
1194 Size=0;
1195 Buffer_Offset=Buffer_Size;
1196 }
1197 else
1198 switch (SizeOfNALU_Minus1)
1199 {
1200 case 0: Size=Buffer[Buffer_Offset];
1201 TranscodedBuffer_Size+=2;
1202 break;
1203 case 1: Size=BigEndian2int16u(Buffer+Buffer_Offset);
1204 TranscodedBuffer_Size++;
1205 break;
1206 case 2: Size=BigEndian2int24u(Buffer+Buffer_Offset);
1207 break;
1208 case 3: Size=BigEndian2int32u(Buffer+Buffer_Offset);
1209 TranscodedBuffer_Size--;
1210 break;
1211 default: return true; //Problem
1212 }
1213 Size+=SizeOfNALU_Minus1+1;
1214
1215 //Coherency checking
1216 if (Size==0 || Buffer_Offset+Size>Buffer_Size || (Buffer_Offset+Size!=Buffer_Size && Buffer_Offset+Size+SizeOfNALU_Minus1+1>Buffer_Size))
1217 Size=Buffer_Size-Buffer_Offset;
1218
1219 //Random access check
1220 if (!RandomAccess && Buffer_Offset+SizeOfNALU_Minus1+1<Buffer_Size && (Buffer[Buffer_Offset+SizeOfNALU_Minus1+1]&0x1F) && (Buffer[Buffer_Offset+SizeOfNALU_Minus1+1]&0x1F)<=5) //Is a slice
1221 {
1222 int32u slice_type;
1223 Element_Offset=SizeOfNALU_Minus1+1+1;
1224 Element_Size=Size;
1225 BS_Begin();
1226 Skip_UE("first_mb_in_slice");
1227 Get_UE (slice_type, "slice_type");
1228 BS_End();
1229 Element_Offset=0;
1230
1231 switch (slice_type)
1232 {
1233 case 2 :
1234 case 7 :
1235 RandomAccess=true;
1236 }
1237 }
1238
1239 TranscodedBuffer_Size+=Size;
1240 Buffer_Offset+=Size;
1241 }
1242 Buffer_Offset=Buffer_Offset_Save;
1243
1244 //Adding SPS/PPS sizes
1245 if (RandomAccess)
1246 {
1247 for (seq_parameter_set_structs::iterator Data_Item=seq_parameter_sets.begin(); Data_Item!=seq_parameter_sets.end(); ++Data_Item)
1248 TranscodedBuffer_Size+=(*Data_Item)->Iso14496_10_Buffer_Size;
1249 for (seq_parameter_set_structs::iterator Data_Item=subset_seq_parameter_sets.begin(); Data_Item!=subset_seq_parameter_sets.end(); ++Data_Item)
1250 TranscodedBuffer_Size+=(*Data_Item)->Iso14496_10_Buffer_Size;
1251 for (pic_parameter_set_structs::iterator Data_Item=pic_parameter_sets.begin(); Data_Item!=pic_parameter_sets.end(); ++Data_Item)
1252 TranscodedBuffer_Size+=(*Data_Item)->Iso14496_10_Buffer_Size;
1253 }
1254
1255 //Copying
1256 int8u* TranscodedBuffer=new int8u[TranscodedBuffer_Size+100];
1257 size_t TranscodedBuffer_Pos=0;
1258 if (RandomAccess)
1259 {
1260 for (seq_parameter_set_structs::iterator Data_Item=seq_parameter_sets.begin(); Data_Item!=seq_parameter_sets.end(); ++Data_Item)
1261 {
1262 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, (*Data_Item)->Iso14496_10_Buffer, (*Data_Item)->Iso14496_10_Buffer_Size);
1263 TranscodedBuffer_Pos+=(*Data_Item)->Iso14496_10_Buffer_Size;
1264 }
1265 for (seq_parameter_set_structs::iterator Data_Item=subset_seq_parameter_sets.begin(); Data_Item!=subset_seq_parameter_sets.end(); ++Data_Item)
1266 {
1267 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, (*Data_Item)->Iso14496_10_Buffer, (*Data_Item)->Iso14496_10_Buffer_Size);
1268 TranscodedBuffer_Pos+=(*Data_Item)->Iso14496_10_Buffer_Size;
1269 }
1270 for (pic_parameter_set_structs::iterator Data_Item=pic_parameter_sets.begin(); Data_Item!=pic_parameter_sets.end(); ++Data_Item)
1271 {
1272 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, (*Data_Item)->Iso14496_10_Buffer, (*Data_Item)->Iso14496_10_Buffer_Size);
1273 TranscodedBuffer_Pos+=(*Data_Item)->Iso14496_10_Buffer_Size;
1274 }
1275 }
1276 while (Buffer_Offset<Buffer_Size)
1277 {
1278 //Sync layer
1279 TranscodedBuffer[TranscodedBuffer_Pos]=0x00;
1280 TranscodedBuffer_Pos++;
1281 TranscodedBuffer[TranscodedBuffer_Pos]=0x00;
1282 TranscodedBuffer_Pos++;
1283 TranscodedBuffer[TranscodedBuffer_Pos]=0x01;
1284 TranscodedBuffer_Pos++;
1285
1286 //Block
1287 size_t Size;
1288 switch (SizeOfNALU_Minus1)
1289 {
1290 case 0: Size=Buffer[Buffer_Offset];
1291 Buffer_Offset++;
1292 break;
1293 case 1: Size=BigEndian2int16u(Buffer+Buffer_Offset);
1294 Buffer_Offset+=2;
1295 break;
1296 case 2: Size=BigEndian2int24u(Buffer+Buffer_Offset);
1297 Buffer_Offset+=3;
1298 break;
1299 case 3: Size=BigEndian2int32u(Buffer+Buffer_Offset);
1300 Buffer_Offset+=4;
1301 break;
1302 default: //Problem
1303 delete [] TranscodedBuffer;
1304 return false;
1305 }
1306
1307 //Coherency checking
1308 if (Size==0 || Buffer_Offset+Size>Buffer_Size || (Buffer_Offset+Size!=Buffer_Size && Buffer_Offset+Size+SizeOfNALU_Minus1+1>Buffer_Size))
1309 Size=Buffer_Size-Buffer_Offset;
1310
1311 std::memcpy(TranscodedBuffer+TranscodedBuffer_Pos, Buffer+Buffer_Offset, Size);
1312 TranscodedBuffer_Pos+=Size;
1313 Buffer_Offset+=Size;
1314 }
1315 Buffer_Offset=0;
1316
1317 Buffer_Temp=Buffer;
1318 Buffer=TranscodedBuffer;
1319 Buffer_Temp_Size=Buffer_Size;
1320 Buffer_Size=TranscodedBuffer_Size;
1321 Demux_Offset=Buffer_Size;
1322 }
1323 else
1324 {
1325 bool zero_byte=Buffer[Buffer_Offset+2]==0x00;
1326 if (!(((Buffer[Buffer_Offset+(zero_byte?4:3)]&0x1B)==0x01 && (Buffer[Buffer_Offset+(zero_byte?5:4)]&0x80)!=0x80)
1327 || (Buffer[Buffer_Offset+(zero_byte?4:3)]&0x1F)==0x0C))
1328 {
1329 if (Demux_Offset==0)
1330 {
1331 Demux_Offset=Buffer_Offset;
1332 Demux_IntermediateItemFound=false;
1333 }
1334 while (Demux_Offset+6<=Buffer_Size)
1335 {
1336 //Synchronizing
1337 while(Demux_Offset+6<=Buffer_Size && (Buffer[Demux_Offset ]!=0x00
1338 || Buffer[Demux_Offset+1]!=0x00
1339 || Buffer[Demux_Offset+2]!=0x01))
1340 {
1341 Demux_Offset+=2;
1342 while(Demux_Offset<Buffer_Size && Buffer[Buffer_Offset]!=0x00)
1343 Demux_Offset+=2;
1344 if (Demux_Offset>=Buffer_Size || Buffer[Demux_Offset-1]==0x00)
1345 Demux_Offset--;
1346 }
1347
1348 if (Demux_Offset+6>Buffer_Size)
1349 {
1350 if (Config->IsFinishing)
1351 Demux_Offset=Buffer_Size;
1352 break;
1353 }
1354
1355 zero_byte=Buffer[Demux_Offset+2]==0x00;
1356 if (Demux_IntermediateItemFound)
1357 {
1358 if (!(((Buffer[Demux_Offset+(zero_byte?4:3)]&0x1B)==0x01 && (Buffer[Demux_Offset+(zero_byte?5:4)]&0x80)!=0x80)
1359 || (Buffer[Demux_Offset+(zero_byte?4:3)]&0x1F)==0x0C))
1360 break;
1361 }
1362 else
1363 {
1364 if ((Buffer[Demux_Offset+(zero_byte?4:3)]&0x1B)==0x01 && (Buffer[Demux_Offset+(zero_byte?5:4)]&0x80)==0x80)
1365 Demux_IntermediateItemFound=true;
1366 }
1367
1368 Demux_Offset++;
1369 }
1370
1371 if (Demux_Offset+6>Buffer_Size && !FrameIsAlwaysComplete && !Config->IsFinishing)
1372 return false; //No complete frame
1373
1374 if (Demux_Offset && Buffer[Demux_Offset-1]==0x00)
1375 Demux_Offset--;
1376
1377 zero_byte=Buffer[Buffer_Offset+2]==0x00;
1378 size_t Buffer_Offset_Random=Buffer_Offset;
1379 if ((Buffer[Buffer_Offset_Random+(zero_byte?4:3)]&0x1F)==0x09)
1380 {
1381 Buffer_Offset_Random++;
1382 if (zero_byte)
1383 Buffer_Offset_Random++;
1384 while(Buffer_Offset_Random+6<=Buffer_Size && (Buffer[Buffer_Offset_Random ]!=0x00
1385 || Buffer[Buffer_Offset_Random+1]!=0x00
1386 || Buffer[Buffer_Offset_Random+2]!=0x01))
1387 Buffer_Offset_Random++;
1388 zero_byte=Buffer[Buffer_Offset_Random+2]==0x00;
1389 }
1390 RandomAccess=Buffer_Offset_Random+6<=Buffer_Size && (Buffer[Buffer_Offset_Random+(zero_byte?4:3)]&0x1F)==0x07; //seq_parameter_set
1391 }
1392 }
1393
1394 if (!Status[IsAccepted])
1395 {
1396 if (Config->Demux_EventWasSent)
1397 return false;
1398 File_Avc* MI=new File_Avc;
1399 Element_Code=(int64u)-1;
1400 Open_Buffer_Init(MI);
1401 #ifdef MEDIAINFO_EVENTS
1402 MediaInfo_Config_PerPackage* Config_PerPackage_Temp=MI->Config->Config_PerPackage;
1403 MI->Config->Config_PerPackage=NULL;
1404 #endif //MEDIAINFO_EVENTS
1405 Open_Buffer_Continue(MI, Buffer, Buffer_Size);
1406 #ifdef MEDIAINFO_EVENTS
1407 MI->Config->Config_PerPackage=Config_PerPackage_Temp;
1408 #endif //MEDIAINFO_EVENTS
1409 bool IsOk=MI->Status[IsAccepted];
1410 delete MI;
1411 if (!IsOk)
1412 return false;
1413 }
1414
1415 if (IFrame_Count || RandomAccess)
1416 {
1417 bool Frame_Count_NotParsedIncluded_PlusOne=false;
1418 int64u PTS_Temp=FrameInfo.PTS;
1419 if (!IsSub)
1420 FrameInfo.PTS=(int64u)-1;
1421 if (Frame_Count_NotParsedIncluded!=(int64u)-1 && Interlaced_Top!=Interlaced_Bottom)
1422 {
1423 Frame_Count_NotParsedIncluded--;
1424 Frame_Count_NotParsedIncluded_PlusOne=true;
1425 }
1426 Demux_UnpacketizeContainer_Demux(RandomAccess);
1427 if (!IsSub)
1428 FrameInfo.PTS=PTS_Temp;
1429 if (Frame_Count_NotParsedIncluded_PlusOne)
1430 Frame_Count_NotParsedIncluded++;
1431 }
1432 else
1433 Demux_UnpacketizeContainer_Demux_Clear();
1434
1435 if (Buffer_Temp)
1436 {
1437 Demux_TotalBytes-=Buffer_Size;
1438 Demux_TotalBytes+=Buffer_Temp_Size;
1439 delete[] Buffer;
1440 Buffer=Buffer_Temp;
1441 Buffer_Size=Buffer_Temp_Size;
1442 }
1443
1444 return true;
1445 }
1446 #endif //MEDIAINFO_DEMUX
1447
1448 //---------------------------------------------------------------------------
Synched_Init()1449 void File_Avc::Synched_Init()
1450 {
1451 if (!Frame_Count_Valid)
1452 Frame_Count_Valid=Config->ParseSpeed>=0.3?512:2;
1453
1454 //FrameInfo
1455 PTS_End=0;
1456 if (!IsSub)
1457 FrameInfo.DTS=0; //No DTS in container
1458 DTS_Begin=FrameInfo.DTS;
1459 DTS_End=FrameInfo.DTS;
1460
1461 //Temporal references
1462 TemporalReferences_DelayedElement=NULL;
1463 TemporalReferences_Min=0;
1464 TemporalReferences_Max=0;
1465 TemporalReferences_Reserved=0;
1466 TemporalReferences_Offset=0;
1467 TemporalReferences_Offset_pic_order_cnt_lsb_Last=0;
1468 TemporalReferences_pic_order_cnt_Min=0;
1469
1470 //Text
1471 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
1472 GA94_03_IsPresent=false;
1473 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
1474
1475 //File specific
1476 SizeOfNALU_Minus1=(int8u)-1;
1477
1478 //Status
1479 IFrame_Count=0;
1480 prevPicOrderCntMsb=0;
1481 prevPicOrderCntLsb=(int32u)-1;
1482 prevTopFieldOrderCnt=(int32u)-1;
1483 prevFrameNum=(int32u)-1;
1484 prevFrameNumOffset=(int32u)-1;
1485
1486 //Count of a Packets
1487 Block_Count=0;
1488 Interlaced_Top=0;
1489 Interlaced_Bottom=0;
1490 Structure_Field=0;
1491 Structure_Frame=0;
1492
1493 //Temp
1494 FrameRate_Divider=1;
1495 FirstPFrameInGop_IsParsed=false;
1496 Config_IsRepeated=false;
1497 tc=0;
1498 maximum_content_light_level=0;
1499 maximum_frame_average_light_level=0;
1500
1501 //Default values
1502 Streams.resize(0x100);
1503 Streams[0x06].Searching_Payload=true; //sei
1504 Streams[0x07].Searching_Payload=true; //seq_parameter_set
1505 Streams[0x09].Searching_Payload=true; //access_unit_delimiter
1506 Streams[0x0F].Searching_Payload=true; //subset_seq_parameter_set
1507 for (int8u Pos=0xFF; Pos>=0xB9; Pos--)
1508 Streams[Pos].Searching_Payload=true; //Testing MPEG-PS
1509
1510 //Options
1511 Option_Manage();
1512
1513 //Specific cases
1514 #if MEDIAINFO_EVENTS
1515 if (Config->ParseUndecodableFrames_Get())
1516 {
1517 Accept(); //In some case, we must accept the stream very quickly and before the sequence header is detected
1518 Streams[0x01].Searching_Payload=true; //slice_header
1519 Streams[0x05].Searching_Payload=true; //slice_header
1520 }
1521 #endif //MEDIAINFO_EVENTS
1522 #if MEDIAINFO_DEMUX
1523 Demux_Avc_Transcode_Iso14496_15_to_Iso14496_10=Config->Demux_Avc_Transcode_Iso14496_15_to_Iso14496_10_Get();
1524 #endif //MEDIAINFO_DEMUX
1525 }
1526
1527 //***************************************************************************
1528 // Buffer - Global
1529 //***************************************************************************
1530
1531 //---------------------------------------------------------------------------
1532 #if MEDIAINFO_ADVANCED2
Read_Buffer_SegmentChange()1533 void File_Avc::Read_Buffer_SegmentChange()
1534 {
1535 }
1536 #endif //MEDIAINFO_ADVANCED2
1537
1538 //---------------------------------------------------------------------------
Read_Buffer_Unsynched()1539 void File_Avc::Read_Buffer_Unsynched()
1540 {
1541 //Temporal references
1542 Clean_Temp_References();
1543 delete TemporalReferences_DelayedElement; TemporalReferences_DelayedElement=NULL;
1544 TemporalReferences_Min=0;
1545 TemporalReferences_Max=0;
1546 TemporalReferences_Reserved=0;
1547 TemporalReferences_Offset=0;
1548 TemporalReferences_Offset_pic_order_cnt_lsb_Last=0;
1549 TemporalReferences_pic_order_cnt_Min=0;
1550
1551 //Text
1552 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
1553 if (GA94_03_Parser)
1554 GA94_03_Parser->Open_Buffer_Unsynch();
1555 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
1556
1557 //parameter_sets
1558 if (SizedBlocks || !Config_IsRepeated) //If sized blocks, it is not a broadcasted stream so SPS/PPS are only in container header, we must not disable them.
1559 {
1560 //Rebuilding immediatly TemporalReferences
1561 seq_parameter_set_structs* _seq_parameter_sets=!seq_parameter_sets.empty()?&seq_parameter_sets:&subset_seq_parameter_sets; //Some MVC streams have no seq_parameter_sets. TODO: better management of temporal references
1562 for (std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item=(*_seq_parameter_sets).begin(); seq_parameter_set_Item!=(*_seq_parameter_sets).end(); ++seq_parameter_set_Item)
1563 if ((*seq_parameter_set_Item))
1564 {
1565 size_t MaxNumber;
1566 switch ((*seq_parameter_set_Item)->pic_order_cnt_type)
1567 {
1568 case 0 : MaxNumber=(*seq_parameter_set_Item)->MaxPicOrderCntLsb; break;
1569 case 2 : MaxNumber=(*seq_parameter_set_Item)->MaxFrameNum*2; break;
1570 default: Trusted_IsNot("Not supported"); return;
1571 }
1572
1573 TemporalReferences.resize(4*MaxNumber);
1574 TemporalReferences_Reserved=MaxNumber;
1575 }
1576 }
1577 else
1578 {
1579 Clean_Seq_Parameter();
1580 }
1581
1582 //Status
1583 Interlaced_Top=0;
1584 Interlaced_Bottom=0;
1585 prevPicOrderCntMsb=0;
1586 prevPicOrderCntLsb=(int32u)-1;
1587 prevTopFieldOrderCnt=(int32u)-1;
1588 prevFrameNum=(int32u)-1;
1589 prevFrameNumOffset=(int32u)-1;
1590
1591 //Temp
1592 FrameRate_Divider=1;
1593 FirstPFrameInGop_IsParsed=false;
1594 tc=0;
1595
1596 //Impossible to know TimeStamps now
1597 PTS_End=0;
1598 DTS_End=0;
1599 }
1600
1601 //***************************************************************************
1602 // Buffer - Per element
1603 //***************************************************************************
1604
1605 //---------------------------------------------------------------------------
Header_Parse()1606 void File_Avc::Header_Parse()
1607 {
1608 //Specific case
1609 if (MustParse_SPS_PPS)
1610 {
1611 Header_Fill_Size(Element_Size);
1612 Header_Fill_Code((int64u)-1, "Specific");
1613 return;
1614 }
1615
1616 //Parsing
1617 int8u nal_unit_type;
1618 if (!SizedBlocks)
1619 {
1620 if (Buffer[Buffer_Offset+2]==0x00)
1621 Skip_B1( "zero_byte");
1622 Skip_B3( "start_code_prefix_one_3bytes");
1623 BS_Begin();
1624 Mark_0 ();
1625 Get_S1 ( 2, nal_ref_idc, "nal_ref_idc");
1626 Get_S1 ( 5, nal_unit_type, "nal_unit_type");
1627 BS_End();
1628 if (!Header_Parser_Fill_Size())
1629 {
1630 Element_WaitForMoreData();
1631 return;
1632 }
1633 }
1634 else
1635 {
1636 int64u Size;
1637 switch (SizeOfNALU_Minus1)
1638 {
1639 case 0: {
1640 int8u Size_;
1641 Get_B1 (Size_, "size");
1642 Size=Size_;
1643 }
1644 break;
1645 case 1: {
1646 int16u Size_;
1647 Get_B2 (Size_, "size");
1648 Size=Size_;
1649 }
1650 break;
1651 case 2: {
1652 int32u Size_;
1653 Get_B3 (Size_, "size");
1654 Size=Size_;
1655 }
1656 break;
1657 case 3: {
1658 int32u Size_;
1659 Get_B4 (Size_, "size");
1660 Size=Size_;
1661 }
1662 break;
1663 }
1664 Size+=Element_Offset;
1665 if (Size==Element_Offset || Buffer_Offset+Size>Buffer_Size) //If Size is 0 or Size biger than sample size, it is not normal, we skip the complete frame
1666 Size=Buffer_Size-Buffer_Offset;
1667 Header_Fill_Size(Size);
1668 BS_Begin();
1669 Mark_0 ();
1670 Get_S1 ( 2, nal_ref_idc, "nal_ref_idc");
1671 Get_S1 ( 5, nal_unit_type, "nal_unit_type");
1672 BS_End();
1673 }
1674
1675 //Filling
1676 #if MEDIAINFO_TRACE
1677 if (Trace_Activated)
1678 Header_Fill_Code(nal_unit_type, Ztring().From_CC1(nal_unit_type));
1679 else
1680 #endif //MEDIAINFO_TRACE
1681 Header_Fill_Code(nal_unit_type);
1682 }
1683
1684 //---------------------------------------------------------------------------
Header_Parser_Fill_Size()1685 bool File_Avc::Header_Parser_Fill_Size()
1686 {
1687 //Look for next Sync word
1688 if (Buffer_Offset_Temp==0) //Buffer_Offset_Temp is not 0 if Header_Parse_Fill_Size() has already parsed first frames
1689 Buffer_Offset_Temp=Buffer_Offset+4;
1690 while (Buffer_Offset_Temp+5<=Buffer_Size
1691 && CC3(Buffer+Buffer_Offset_Temp)!=0x000001)
1692 {
1693 Buffer_Offset_Temp+=2;
1694 while(Buffer_Offset_Temp<Buffer_Size && Buffer[Buffer_Offset_Temp]!=0x00)
1695 Buffer_Offset_Temp+=2;
1696 if (Buffer_Offset_Temp>=Buffer_Size || Buffer[Buffer_Offset_Temp-1]==0x00)
1697 Buffer_Offset_Temp--;
1698 }
1699
1700 //Must wait more data?
1701 if (Buffer_Offset_Temp+5>Buffer_Size)
1702 {
1703 if (FrameIsAlwaysComplete || Config->IsFinishing)
1704 Buffer_Offset_Temp=Buffer_Size; //We are sure that the next bytes are a start
1705 else
1706 return false;
1707 }
1708
1709 if (Buffer[Buffer_Offset_Temp-1]==0x00)
1710 Buffer_Offset_Temp--;
1711
1712 //OK, we continue
1713 Header_Fill_Size(Buffer_Offset_Temp-Buffer_Offset);
1714 Buffer_Offset_Temp=0;
1715 return true;
1716 }
1717
1718 //---------------------------------------------------------------------------
Header_Parser_QuickSearch()1719 bool File_Avc::Header_Parser_QuickSearch()
1720 {
1721 while ( Buffer_Offset+6<=Buffer_Size
1722 && Buffer[Buffer_Offset ]==0x00
1723 && Buffer[Buffer_Offset+1]==0x00
1724 && (Buffer[Buffer_Offset+2]==0x01
1725 || (Buffer[Buffer_Offset+2]==0x00 && Buffer[Buffer_Offset+3]==0x01)))
1726 {
1727 //Getting start_code
1728 int8u start_code;
1729 if (Buffer[Buffer_Offset+2]==0x00)
1730 start_code=CC1(Buffer+Buffer_Offset+4)&0x1F;
1731 else
1732 start_code=CC1(Buffer+Buffer_Offset+3)&0x1F;
1733
1734 //Searching start
1735 if (Streams[start_code].Searching_Payload
1736 || Streams[start_code].ShouldDuplicate)
1737 return true;
1738
1739 //Synchronizing
1740 Buffer_Offset+=4;
1741 Synched=false;
1742 if (!Synchronize())
1743 {
1744 UnSynched_IsNotJunk=true;
1745 return false;
1746 }
1747
1748 if (Buffer_Offset+6>Buffer_Size)
1749 {
1750 UnSynched_IsNotJunk=true;
1751 return false;
1752 }
1753 }
1754
1755 Trusted_IsNot("AVC, Synchronisation lost");
1756 return Synchronize();
1757 }
1758
1759 //---------------------------------------------------------------------------
Data_Parse()1760 void File_Avc::Data_Parse()
1761 {
1762 //Specific case
1763 if (Element_Code==(int64u)-1)
1764 {
1765 SPS_PPS();
1766 return;
1767 }
1768
1769 //Trailing zeroes
1770 int64u Element_Size_SaveBeforeZeroes=Element_Size;
1771 if (Element_Size)
1772 {
1773 while (Element_Size && Buffer[Buffer_Offset+(size_t)Element_Size-1]==0)
1774 Element_Size--;
1775 }
1776
1777 //Dump of the SPS/PPS - Init
1778 #if MEDIAINFO_ADVANCED2
1779 size_t spspps_Size=0;
1780 if (true) //TODO: add an option for activating this extra piece of information in the output
1781 {
1782 switch (Element_Code)
1783 {
1784 case 0x07 : //seq_parameter_set();
1785 spspps_Size = seq_parameter_sets.size();
1786 break;
1787 case 0x08 : //pic_parameter_set();
1788 spspps_Size = pic_parameter_sets.size();
1789 break;
1790 default: ;
1791 }
1792 }
1793 #endif //MEDIAINFO_ADVANCED2
1794
1795 //svc_extension
1796 bool svc_extension_flag=false;
1797 if (Element_Code==0x0E || Element_Code==0x14)
1798 {
1799 BS_Begin();
1800 Get_SB (svc_extension_flag, "svc_extension_flag");
1801 if (svc_extension_flag)
1802 nal_unit_header_svc_extension();
1803 else
1804 nal_unit_header_mvc_extension();
1805 BS_End();
1806 }
1807
1808 //Searching emulation_prevention_three_byte
1809 int8u* Buffer_3Bytes=NULL;
1810 const int8u* Save_Buffer=Buffer;
1811 int64u Save_File_Offset=File_Offset;
1812 size_t Save_Buffer_Offset=Buffer_Offset;
1813 int64u Save_Element_Size=Element_Size;
1814 size_t Element_Offset_3Bytes=(size_t)Element_Offset;
1815 std::vector<size_t> ThreeByte_List;
1816 while (Element_Offset_3Bytes+3<=Element_Size)
1817 {
1818 if (CC3(Buffer+Buffer_Offset+(size_t)Element_Offset_3Bytes)==0x000003)
1819 ThreeByte_List.push_back(Element_Offset_3Bytes+2);
1820 Element_Offset_3Bytes+=2;
1821 while(Element_Offset_3Bytes<Element_Size && Buffer[Buffer_Offset+(size_t)Element_Offset_3Bytes]!=0x00)
1822 Element_Offset_3Bytes+=2;
1823 if (Element_Offset_3Bytes>=Element_Size || Buffer[Buffer_Offset+(size_t)Element_Offset_3Bytes-1]==0x00)
1824 Element_Offset_3Bytes--;
1825 }
1826
1827 if (!ThreeByte_List.empty())
1828 {
1829 //We must change the buffer for keeping out
1830 Element_Size=Save_Element_Size-ThreeByte_List.size();
1831 File_Offset+=Buffer_Offset;
1832 Buffer_Offset=0;
1833 Buffer_3Bytes=new int8u[(size_t)Element_Size];
1834 for (size_t Pos=0; Pos<=ThreeByte_List.size(); Pos++)
1835 {
1836 size_t Pos0=(Pos==ThreeByte_List.size())?(size_t)Save_Element_Size:(ThreeByte_List[Pos]);
1837 size_t Pos1=(Pos==0)?0:(ThreeByte_List[Pos-1]+1);
1838 size_t Buffer_3bytes_Begin=Pos1-Pos;
1839 size_t Save_Buffer_Begin =Pos1;
1840 size_t Size= Pos0-Pos1;
1841 std::memcpy(Buffer_3Bytes+Buffer_3bytes_Begin, Save_Buffer+Save_Buffer_Offset+Save_Buffer_Begin, Size);
1842 }
1843 Buffer=Buffer_3Bytes;
1844 }
1845
1846 //Parsing
1847 switch (Element_Code)
1848 {
1849 case 0x00 : Element_Name("unspecified"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1850 case 0x01 : slice_layer_without_partitioning_non_IDR(); break;
1851 case 0x02 : Element_Name("slice_data_partition_a_layer"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1852 case 0x03 : Element_Name("slice_data_partition_b_layer"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1853 case 0x04 : Element_Name("slice_data_partition_c_layer"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1854 case 0x05 : slice_layer_without_partitioning_IDR(); break;
1855 case 0x06 : sei(); break;
1856 case 0x07 : seq_parameter_set(); break;
1857 case 0x08 : pic_parameter_set(); break;
1858 case 0x09 : access_unit_delimiter(); break;
1859 case 0x0A : Element_Name("end_of_seq"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1860 case 0x0B : Element_Name("end_of_stream"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1861 case 0x0C : filler_data(); break;
1862 case 0x0D : Element_Name("seq_parameter_set_extension"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1863 case 0x0E : prefix_nal_unit(svc_extension_flag); break;
1864 case 0x0F : subset_seq_parameter_set(); break;
1865 case 0x13 : Element_Name("slice_layer_without_partitioning"); Skip_XX(Element_Size-Element_Offset, "Data"); break;
1866 case 0x14 : slice_layer_extension(svc_extension_flag); break;
1867 default :
1868 if (Element_Code<0x18)
1869 Element_Name("reserved");
1870 else
1871 Element_Name("unspecified");
1872 Skip_XX(Element_Size-Element_Offset, "Data");
1873 }
1874
1875 if (!ThreeByte_List.empty())
1876 {
1877 //We must change the buffer for keeping out
1878 Element_Size=Save_Element_Size;
1879 File_Offset=Save_File_Offset;
1880 Buffer_Offset=Save_Buffer_Offset;
1881 delete[] Buffer; Buffer=Save_Buffer;
1882 Buffer_3Bytes=NULL; //Same as Buffer...
1883 Element_Offset+=ThreeByte_List.size();
1884 }
1885
1886 //Duplicate
1887 #if MEDIAINFO_DUPLICATE
1888 if (!Streams.empty() && Streams[(size_t)Element_Code].ShouldDuplicate)
1889 File__Duplicate_Write(Element_Code);
1890 #endif //MEDIAINFO_DUPLICATE
1891
1892 #if MEDIAINFO_DEMUX
1893 Data_Parse_Iso14496();
1894 #endif //MEDIAINFO_DEMUX
1895
1896 //Dump of the SPS/PPS - Fill
1897 #if MEDIAINFO_ADVANCED2
1898 if (false) //TODO: add an option for activating this extra piece of information in the output
1899 {
1900 switch (Element_Code)
1901 {
1902 case 0x07 : //seq_parameter_set();
1903 if (spspps_Size != seq_parameter_sets.size() && !Status[IsFilled])
1904 {
1905 std::string Data_Raw((const char*)(Buffer+(size_t)(Buffer_Offset-1)), (size_t)(Element_Size+1)); //Including the last byte in the header
1906 Dump_SPS.push_back(Base64::encode(Data_Raw));
1907 }
1908 break;
1909 case 0x08 : //pic_parameter_set();
1910 if (spspps_Size != pic_parameter_sets.size() && !Status[IsFilled])
1911 {
1912 std::string Data_Raw((const char*)(Buffer+(size_t)(Buffer_Offset-1)), (size_t)(Element_Size+1)); //Including the last byte in the header
1913 Dump_PPS.push_back(Base64::encode(Data_Raw));
1914 }
1915 break;
1916 default: ;
1917 }
1918 }
1919 #endif //MEDIAINFO_ADVANCED2
1920
1921 #if MEDIAINFO_DEMUX
1922 Data_Parse_Iso14496();
1923 #endif //MEDIAINFO_DEMUX
1924
1925 //Trailing zeroes
1926 Element_Size=Element_Size_SaveBeforeZeroes;
1927 }
1928
1929 //***************************************************************************
1930 // Elements
1931 //***************************************************************************
1932
1933 //---------------------------------------------------------------------------
1934 // Packet "01"
slice_layer_without_partitioning_non_IDR()1935 void File_Avc::slice_layer_without_partitioning_non_IDR()
1936 {
1937 Element_Name("slice_layer_without_partitioning (non-IDR)");
1938
1939 //Parsing
1940 BS_Begin();
1941 slice_header();
1942 slice_data(true);
1943 BS_End();
1944 }
1945
1946 //---------------------------------------------------------------------------
1947 // Packet "05"
slice_layer_without_partitioning_IDR()1948 void File_Avc::slice_layer_without_partitioning_IDR()
1949 {
1950 Element_Name("slice_layer_without_partitioning (IDR)");
1951
1952 //Parsing
1953 BS_Begin();
1954 slice_header();
1955 slice_data(true);
1956 BS_End();
1957
1958 FILLING_BEGIN_PRECISE();
1959 //NextCode
1960 for (int8u Pos=0x01; Pos<=0x05; Pos++)
1961 NextCode_Add(Pos);
1962 FILLING_END();
1963 }
1964
1965 //---------------------------------------------------------------------------
1966 //
slice_header()1967 void File_Avc::slice_header()
1968 {
1969 //Encryption management
1970 if (CA_system_ID_MustSkipSlices)
1971 {
1972 //Is not decodable
1973 Skip_BS(Data_BS_Remain(), "Data");
1974 Finish("AVC");
1975 return;
1976 }
1977
1978 Element_Begin1("slice_header");
1979
1980 //Parsing
1981 int32u slice_type, pic_order_cnt_lsb=(int32u)-1;
1982 int32u first_mb_in_slice, pic_parameter_set_id, frame_num, num_ref_idx_l0_active_minus1, num_ref_idx_l1_active_minus1, disable_deblocking_filter_idc;
1983
1984 int32s delta_pic_order_cnt_bottom=0;
1985 bool field_pic_flag=false, bottom_field_flag=false;
1986 Get_UE (first_mb_in_slice, "first_mb_in_slice");
1987 Get_UE (slice_type, "slice_type"); Param_Info1C((slice_type<10), Avc_slice_type[slice_type]);
1988 #if MEDIAINFO_EVENTS
1989 if (!first_mb_in_slice)
1990 {
1991 switch(Element_Code)
1992 {
1993 case 5 : // This is an IDR frame
1994 if (Config->Config_PerPackage) // First slice of an IDR frame
1995 {
1996 // IDR
1997 Config->Config_PerPackage->FrameForAlignment(this, true);
1998 Config->Config_PerPackage->IsClosedGOP(this);
1999 }
2000 break;
2001 default : ; // This is not an IDR frame
2002 }
2003
2004 EVENT_BEGIN (Video, SliceInfo, 0)
2005 Event.FieldPosition=Field_Count;
2006 Event.SlicePosition=Element_IsOK()?first_mb_in_slice:(int64u)-1;
2007 switch (slice_type)
2008 {
2009 case 0 :
2010 case 3 :
2011 case 5 :
2012 case 8 :
2013 Event.SliceType=1; break;
2014 case 1 :
2015 case 6 :
2016 Event.SliceType=2; break;
2017 case 2 :
2018 case 4 :
2019 case 7 :
2020 case 9 :
2021 Event.SliceType=0; break;
2022 default:
2023 Event.SliceType=(int8u)-1;
2024 }
2025 Event.Flags=0;
2026 EVENT_END ()
2027 }
2028 #endif //MEDIAINFO_EVENTS
2029 if (slice_type>=10)
2030 {
2031 Skip_BS(Data_BS_Remain(), "Data");
2032 Element_End0();
2033 return;
2034 }
2035 Get_UE (pic_parameter_set_id, "pic_parameter_set_id");
2036 std::vector<pic_parameter_set_struct*>::iterator pic_parameter_set_Item;
2037 if (pic_parameter_set_id>=pic_parameter_sets.size() || (*(pic_parameter_set_Item=pic_parameter_sets.begin()+pic_parameter_set_id))==NULL)
2038 {
2039 //Not yet present
2040 Skip_BS(Data_BS_Remain(), "Data (pic_parameter_set is missing)");
2041 Element_End0();
2042 return;
2043 }
2044 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
2045 if ((*pic_parameter_set_Item)->seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+(*pic_parameter_set_Item)->seq_parameter_set_id))==NULL)
2046 {
2047 if ((*pic_parameter_set_Item)->seq_parameter_set_id>=subset_seq_parameter_sets.size() || (*(seq_parameter_set_Item=subset_seq_parameter_sets.begin()+(*pic_parameter_set_Item)->seq_parameter_set_id))==NULL)
2048 {
2049 //Not yet present
2050 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
2051 Element_End0();
2052 return;
2053 }
2054 }
2055 if ((*seq_parameter_set_Item)->separate_colour_plane_flag==1)
2056 Skip_S1(2, "color_plane_id");
2057 num_ref_idx_l0_active_minus1=(*pic_parameter_set_Item)->num_ref_idx_l0_default_active_minus1; //Default
2058 num_ref_idx_l1_active_minus1=(*pic_parameter_set_Item)->num_ref_idx_l1_default_active_minus1; //Default
2059 Get_BS ((*seq_parameter_set_Item)->log2_max_frame_num_minus4+4, frame_num, "frame_num");
2060 if (!(*seq_parameter_set_Item)->frame_mbs_only_flag)
2061 {
2062 TEST_SB_GET(field_pic_flag, "field_pic_flag");
2063 Get_SB (bottom_field_flag, "bottom_field_flag");
2064 TEST_SB_END();
2065 }
2066 if (Element_Code==5) //IdrPicFlag
2067 Skip_UE( "idr_pic_id");
2068 if ((*seq_parameter_set_Item)->pic_order_cnt_type==0)
2069 {
2070 Get_BS ((*seq_parameter_set_Item)->log2_max_pic_order_cnt_lsb_minus4+4, pic_order_cnt_lsb, "pic_order_cnt_lsb");
2071 if ((*pic_parameter_set_Item)->bottom_field_pic_order_in_frame_present_flag && !field_pic_flag)
2072 Get_SE (delta_pic_order_cnt_bottom, "delta_pic_order_cnt_bottom");
2073 }
2074 if ((*seq_parameter_set_Item)->pic_order_cnt_type==1 && !(*seq_parameter_set_Item)->delta_pic_order_always_zero_flag )
2075 {
2076 Skip_SE( "delta_pic_order_cnt[0]");
2077 if((*pic_parameter_set_Item)->bottom_field_pic_order_in_frame_present_flag && !field_pic_flag)
2078 Skip_SE( "delta_pic_order_cnt[1]");
2079 }
2080 if((*pic_parameter_set_Item)->redundant_pic_cnt_present_flag)
2081 Skip_UE( "redundant_pic_cnt");
2082 if (slice_type==1 || slice_type==6) //B-Frame
2083 Skip_SB( "direct_spatial_mv_pred_flag");
2084 switch (slice_type)
2085 {
2086 case 0 : //P-Frame
2087 case 1 : //B-Frame
2088 case 3 : //SP-Frame
2089 case 5 : //P-Frame
2090 case 6 : //B-Frame
2091 case 8 : //SP-Frame
2092 TEST_SB_SKIP( "num_ref_idx_active_override_flag");
2093 Get_UE (num_ref_idx_l0_active_minus1, "num_ref_idx_l0_active_minus1");
2094 switch (slice_type)
2095 {
2096 case 1 : //B-Frame
2097 case 6 : //B-Frame
2098 Get_UE (num_ref_idx_l1_active_minus1, "num_ref_idx_l1_active_minus1");
2099 break;
2100 default: ;
2101 }
2102 TEST_SB_END();
2103 break;
2104 default: ;
2105 }
2106 ref_pic_list_modification(slice_type, Element_Code==20); //nal_unit_type==20 --> ref_pic_list_mvc_modification()
2107 if (((*pic_parameter_set_Item)->weighted_pred_flag && (slice_type==0 || slice_type==3 || slice_type==5 || slice_type==8))
2108 || ((*pic_parameter_set_Item)->weighted_bipred_idc==1 && (slice_type==1 || slice_type==6)))
2109 pred_weight_table(slice_type, num_ref_idx_l0_active_minus1, num_ref_idx_l1_active_minus1, (*seq_parameter_set_Item)->ChromaArrayType());
2110 std::vector<int8u> memory_management_control_operations;
2111 if (nal_ref_idc)
2112 dec_ref_pic_marking(memory_management_control_operations);
2113
2114 if ((*pic_parameter_set_Item)->entropy_coding_mode_flag &&
2115 (slice_type!=2 && slice_type!=7 && //I-Frames
2116 slice_type!=4 && slice_type!=9)) //SI-Frames
2117 Skip_UE( "cabac_init_idc");
2118 Skip_SE( "slice_qp_delta");
2119 switch (slice_type)
2120 {
2121 case 3 : //SP-Frame
2122 case 4 : //SI-Frame
2123 case 8 : //SP-Frame
2124 case 9 : //SI-Frame
2125 switch (slice_type)
2126 {
2127 case 3 : //SP-Frame
2128 case 8 : //SP-Frame
2129 Skip_SB( "sp_for_switch_flag");
2130 break;
2131 default: ;
2132 }
2133 Skip_SE ( "slice_qs_delta");
2134 break;
2135 default: ;
2136 }
2137 if ((*pic_parameter_set_Item)->deblocking_filter_control_present_flag)
2138 {
2139 Get_UE(disable_deblocking_filter_idc, "disable_deblocking_filter_idc");
2140 if (disable_deblocking_filter_idc!=1)
2141 {
2142 Skip_SE( "slice_alpha_c0_offset_div2");
2143 Skip_SE( "slice_beta_offset_div2");
2144 }
2145 }
2146
2147 Element_End0();
2148
2149 FILLING_BEGIN();
2150 //Count of I-Frames
2151 if (first_mb_in_slice==0 && Element_Code!=20 && (slice_type==2 || slice_type==7)) //Not slice_layer_extension, I-Frame
2152 IFrame_Count++;
2153
2154 //pic_struct
2155 if (field_pic_flag && (*seq_parameter_set_Item)->pic_struct_FirstDetected==(int8u)-1)
2156 (*seq_parameter_set_Item)->pic_struct_FirstDetected=bottom_field_flag?2:1; //2=BFF, 1=TFF
2157
2158 //Saving some info
2159 int32s TemporalReferences_Offset_pic_order_cnt_lsb_Diff=0;
2160 if ((*seq_parameter_set_Item)->pic_order_cnt_type!=1 && first_mb_in_slice==0 && (Element_Code!=0x14 || seq_parameter_sets.empty())) //Not slice_layer_extension except if MVC only
2161 {
2162 if (field_pic_flag)
2163 {
2164 Structure_Field++;
2165 if (bottom_field_flag)
2166 Interlaced_Bottom++;
2167 else
2168 Interlaced_Top++;
2169 }
2170 else
2171 Structure_Frame++;
2172
2173 //Frame order detection
2174 int64s pic_order_cnt=0;
2175 switch ((*seq_parameter_set_Item)->pic_order_cnt_type)
2176 {
2177 case 0 :
2178 {
2179 if (Element_Code==5) //IDR
2180 {
2181 prevPicOrderCntMsb=0;
2182 prevPicOrderCntLsb=0;
2183 TemporalReferences_Offset=TemporalReferences_Max;
2184 if (TemporalReferences_Offset%2)
2185 TemporalReferences_Offset++;
2186 TemporalReferences_pic_order_cnt_Min=0;
2187 }
2188 else
2189 {
2190 const bool Has5 = std::find(memory_management_control_operations.begin(), memory_management_control_operations.end(), 5) != memory_management_control_operations.end();
2191 if (Has5)
2192 {
2193 prevPicOrderCntMsb=0;
2194 if (bottom_field_flag)
2195 prevPicOrderCntLsb=0;
2196 else
2197 prevPicOrderCntLsb=prevTopFieldOrderCnt;
2198 }
2199 }
2200 int32s PicOrderCntMsb;
2201 if (prevPicOrderCntLsb==(int32u)-1)
2202 {
2203 PicOrderCntMsb=0;
2204 if ((int32u)(2*((*seq_parameter_set_Item)->max_num_ref_frames+3))<pic_order_cnt_lsb)
2205 TemporalReferences_Min=pic_order_cnt_lsb-2*((*seq_parameter_set_Item)->max_num_ref_frames+3);
2206 }
2207 else if (pic_order_cnt_lsb<prevPicOrderCntLsb && prevPicOrderCntLsb-pic_order_cnt_lsb>=(*seq_parameter_set_Item)->MaxPicOrderCntLsb/2)
2208 PicOrderCntMsb=prevPicOrderCntMsb+(*seq_parameter_set_Item)->MaxPicOrderCntLsb;
2209 else if (pic_order_cnt_lsb>prevPicOrderCntLsb && pic_order_cnt_lsb-prevPicOrderCntLsb>(*seq_parameter_set_Item)->MaxPicOrderCntLsb/2)
2210 PicOrderCntMsb=prevPicOrderCntMsb-(*seq_parameter_set_Item)->MaxPicOrderCntLsb;
2211 else
2212 PicOrderCntMsb=prevPicOrderCntMsb;
2213
2214 int32s TopFieldOrderCnt=PicOrderCntMsb+pic_order_cnt_lsb;
2215 int32s BottomFieldOrderCnt;
2216 if (field_pic_flag)
2217 BottomFieldOrderCnt=TopFieldOrderCnt+delta_pic_order_cnt_bottom;
2218 else
2219 BottomFieldOrderCnt=PicOrderCntMsb+pic_order_cnt_lsb;
2220
2221 prevPicOrderCntMsb=PicOrderCntMsb;
2222 prevPicOrderCntLsb=pic_order_cnt_lsb;
2223 prevTopFieldOrderCnt=TopFieldOrderCnt;
2224
2225 pic_order_cnt=bottom_field_flag?BottomFieldOrderCnt:TopFieldOrderCnt;
2226 }
2227 break;
2228 case 2 :
2229 {
2230 const bool Has5 = std::find(memory_management_control_operations.begin(), memory_management_control_operations.end(),5) != memory_management_control_operations.end();
2231 if (Has5)
2232 prevFrameNumOffset=0;
2233 int32u FrameNumOffset;
2234
2235 if (Element_Code==5) //IdrPicFlag
2236 {
2237 TemporalReferences_Offset=TemporalReferences_Max;
2238 if (TemporalReferences_Offset%2)
2239 TemporalReferences_Offset++;
2240 FrameNumOffset=0;
2241 }
2242 else if (prevFrameNumOffset==(int32u)-1)
2243 FrameNumOffset=0;
2244 else if (prevFrameNum>frame_num)
2245 FrameNumOffset=prevFrameNumOffset+(*seq_parameter_set_Item)->MaxFrameNum;
2246 else
2247 FrameNumOffset=prevFrameNumOffset;
2248
2249 int32u tempPicOrderCnt;
2250 if (Element_Code==5) //IdrPicFlag
2251 tempPicOrderCnt=0;
2252 else
2253 {
2254 tempPicOrderCnt=2*(FrameNumOffset+frame_num);
2255 if (!nal_ref_idc && tempPicOrderCnt) //Note: if nal_ref_idc is 0, tempPicOrderCnt is not expected to be 0 but it may be the case with invalid streams
2256 tempPicOrderCnt--;
2257 }
2258
2259 pic_order_cnt=tempPicOrderCnt;
2260
2261 prevFrameNum=frame_num;
2262 prevFrameNumOffset=FrameNumOffset;
2263
2264 pic_order_cnt_lsb=frame_num;
2265 }
2266 break;
2267 default: ;
2268 }
2269
2270 if (pic_order_cnt<TemporalReferences_pic_order_cnt_Min)
2271 {
2272 if (pic_order_cnt<0)
2273 {
2274 size_t Base=(size_t)(TemporalReferences_Offset+TemporalReferences_pic_order_cnt_Min);
2275 size_t ToInsert=(size_t)(TemporalReferences_pic_order_cnt_Min-pic_order_cnt);
2276 if (Base+ToInsert>=4*TemporalReferences_Reserved || Base>=4*TemporalReferences_Reserved || ToInsert+TemporalReferences_Max>=4*TemporalReferences_Reserved || TemporalReferences_Max>=4*TemporalReferences_Reserved || TemporalReferences_Max-Base>=4*TemporalReferences_Reserved)
2277 {
2278 Trusted_IsNot("Problem in temporal references");
2279 return;
2280 }
2281 Element_Info1(__T("Offset of ")+Ztring::ToZtring(ToInsert));
2282 TemporalReferences.insert(TemporalReferences.begin()+Base, ToInsert, NULL);
2283 TemporalReferences_Offset+=ToInsert;
2284 TemporalReferences_Offset_pic_order_cnt_lsb_Last += ToInsert;
2285 TemporalReferences_Max+=ToInsert;
2286 TemporalReferences_pic_order_cnt_Min=pic_order_cnt;
2287 }
2288 else if (TemporalReferences_Min>(size_t)(TemporalReferences_Offset+pic_order_cnt))
2289 TemporalReferences_Min=(size_t)(TemporalReferences_Offset+pic_order_cnt);
2290 }
2291
2292 if (pic_order_cnt<0 && TemporalReferences_Offset<(size_t)(-pic_order_cnt)) //Found in playreadyEncryptedBlowUp.ts without encryption test
2293 {
2294 Trusted_IsNot("Problem in temporal references");
2295 return;
2296 }
2297
2298 if ((size_t)(TemporalReferences_Offset+pic_order_cnt)>=3*TemporalReferences_Reserved)
2299 {
2300 size_t Offset=TemporalReferences_Max-TemporalReferences_Offset;
2301 if (Offset%2)
2302 Offset++;
2303 if (Offset>=TemporalReferences_Reserved && pic_order_cnt>=(int64s)TemporalReferences_Reserved)
2304 {
2305 TemporalReferences_Offset+=TemporalReferences_Reserved;
2306 pic_order_cnt-=TemporalReferences_Reserved;
2307 TemporalReferences_pic_order_cnt_Min-=TemporalReferences_Reserved/2;
2308 switch ((*seq_parameter_set_Item)->pic_order_cnt_type)
2309 {
2310 case 0 :
2311 prevPicOrderCntMsb-=(int32u)TemporalReferences_Reserved;
2312 break;
2313 case 2 :
2314 prevFrameNumOffset-=(int32u)TemporalReferences_Reserved/2;
2315 break;
2316 default:;
2317 }
2318 }
2319 while (TemporalReferences_Offset+pic_order_cnt>=3*TemporalReferences_Reserved)
2320 {
2321 for (size_t Pos=0; Pos<TemporalReferences_Reserved; Pos++)
2322 {
2323 if (TemporalReferences[Pos])
2324 {
2325 if ((Pos%2)==0)
2326 PictureTypes_PreviousFrames+=Avc_slice_type[TemporalReferences[Pos]->slice_type];
2327 delete TemporalReferences[Pos];
2328 TemporalReferences[Pos] = NULL;
2329 }
2330 else if (!PictureTypes_PreviousFrames.empty()) //Only if stream already started
2331 {
2332 if ((Pos%2)==0)
2333 PictureTypes_PreviousFrames+=' ';
2334 }
2335 }
2336 if (PictureTypes_PreviousFrames.size()>=8*TemporalReferences.size())
2337 PictureTypes_PreviousFrames.erase(PictureTypes_PreviousFrames.begin(), PictureTypes_PreviousFrames.begin()+PictureTypes_PreviousFrames.size()-TemporalReferences.size());
2338 TemporalReferences.erase(TemporalReferences.begin(), TemporalReferences.begin()+TemporalReferences_Reserved);
2339 TemporalReferences.resize(4*TemporalReferences_Reserved);
2340 if (TemporalReferences_Reserved<TemporalReferences_Offset)
2341 TemporalReferences_Offset-=TemporalReferences_Reserved;
2342 else
2343 TemporalReferences_Offset=0;
2344 if (TemporalReferences_Reserved<TemporalReferences_Min)
2345 TemporalReferences_Min-=TemporalReferences_Reserved;
2346 else
2347 TemporalReferences_Min=0;
2348 if (TemporalReferences_Reserved<TemporalReferences_Max)
2349 TemporalReferences_Max-=TemporalReferences_Reserved;
2350 else
2351 TemporalReferences_Max=0;
2352 if (TemporalReferences_Reserved<TemporalReferences_Offset_pic_order_cnt_lsb_Last)
2353 TemporalReferences_Offset_pic_order_cnt_lsb_Last-=TemporalReferences_Reserved;
2354 else
2355 TemporalReferences_Offset_pic_order_cnt_lsb_Last=0;
2356 }
2357 }
2358
2359 TemporalReferences_Offset_pic_order_cnt_lsb_Diff=(int32s)((int32s)(TemporalReferences_Offset+pic_order_cnt)-TemporalReferences_Offset_pic_order_cnt_lsb_Last);
2360 TemporalReferences_Offset_pic_order_cnt_lsb_Last=(size_t)(TemporalReferences_Offset+pic_order_cnt);
2361 if (field_pic_flag && (*seq_parameter_set_Item)->pic_order_cnt_type==2 && TemporalReferences_Offset_pic_order_cnt_lsb_Last<TemporalReferences.size() && TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last])
2362 TemporalReferences_Offset_pic_order_cnt_lsb_Last++;
2363 if (TemporalReferences_Max<=TemporalReferences_Offset_pic_order_cnt_lsb_Last)
2364 TemporalReferences_Max=TemporalReferences_Offset_pic_order_cnt_lsb_Last+((*seq_parameter_set_Item)->frame_mbs_only_flag?2:1);
2365 if (TemporalReferences_Min>TemporalReferences_Offset_pic_order_cnt_lsb_Last)
2366 TemporalReferences_Min=TemporalReferences_Offset_pic_order_cnt_lsb_Last;
2367 if (TemporalReferences_DelayedElement)
2368 {
2369 delete TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]; TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]=TemporalReferences_DelayedElement;
2370 }
2371 if (TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]==NULL)
2372 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]=new temporal_reference();
2373 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->frame_num=frame_num;
2374 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->slice_type=(int8u)slice_type;
2375 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->IsTop=!bottom_field_flag;
2376 TemporalReferences[TemporalReferences_Offset_pic_order_cnt_lsb_Last]->IsField=field_pic_flag;
2377 if (TemporalReferences_DelayedElement)
2378 {
2379 TemporalReferences_DelayedElement=NULL;
2380 sei_message_user_data_registered_itu_t_t35_GA94_03_Delayed((*pic_parameter_set_Item)->seq_parameter_set_id);
2381 }
2382 }
2383
2384 if ((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->timing_info_present_flag && (*seq_parameter_set_Item)->vui_parameters->num_units_in_tick)
2385 tc=float64_int64s(((float64)1000000000)/((float64)(*seq_parameter_set_Item)->vui_parameters->time_scale/(*seq_parameter_set_Item)->vui_parameters->num_units_in_tick/((*seq_parameter_set_Item)->pic_order_cnt_type==2?1:2)/FrameRate_Divider)/((!(*seq_parameter_set_Item)->frame_mbs_only_flag && field_pic_flag)?2:1));
2386 if (first_mb_in_slice==0)
2387 {
2388 if (Frame_Count==0)
2389 {
2390 if (FrameInfo.PTS==(int64u)-1)
2391 FrameInfo.PTS=FrameInfo.DTS+tc*(TemporalReferences_Offset_pic_order_cnt_lsb_Diff?2:1)*((!(*seq_parameter_set_Item)->frame_mbs_only_flag && field_pic_flag)?2:1); //No PTS in container
2392 PTS_Begin=FrameInfo.PTS;
2393 }
2394 #if MEDIAINFO_ADVANCED2
2395 if (PTS_Begin_Segment==(int64u)-1 && File_Offset>=Config->File_Current_Offset)
2396 {
2397 PTS_Begin_Segment=FrameInfo.PTS;
2398 }
2399 #endif //MEDIAINFO_ADVANCED2
2400 if (slice_type==2 || slice_type==7) //IFrame
2401 FirstPFrameInGop_IsParsed=false;
2402 }
2403 else
2404 {
2405 if (FrameInfo.PTS!=(int64u)-1)
2406 FrameInfo.PTS-=tc;
2407 if (FrameInfo.DTS!=(int64u)-1)
2408 FrameInfo.DTS-=tc;
2409 }
2410
2411 //Frame pos
2412 if (Frame_Count!=(int64u)-1 && Frame_Count && ((!(*seq_parameter_set_Item)->frame_mbs_only_flag && Interlaced_Top==Interlaced_Bottom && field_pic_flag) || first_mb_in_slice!=0 || (Element_Code==0x14 && !seq_parameter_sets.empty())))
2413 {
2414 Frame_Count--;
2415 if (IFrame_Count && Frame_Count_NotParsedIncluded!=(int64u)-1)
2416 Frame_Count_NotParsedIncluded--;
2417 Frame_Count_InThisBlock--;
2418 }
2419 else if (first_mb_in_slice==0)
2420 {
2421 if ((*seq_parameter_set_Item)->pic_order_cnt_type!=1 && (Element_Code!=0x14 || seq_parameter_sets.empty())) //Not slice_layer_extension except if MVC only
2422 {
2423 if ((!IsSub || Frame_Count_InThisBlock) && TemporalReferences_Offset_pic_order_cnt_lsb_Diff && TemporalReferences_Offset_pic_order_cnt_lsb_Diff!=2)
2424 FrameInfo.PTS+=(TemporalReferences_Offset_pic_order_cnt_lsb_Diff-(field_pic_flag?1:2))/((!(*seq_parameter_set_Item)->frame_mbs_only_flag && field_pic_flag)?1:2)*(int64s)tc;
2425 }
2426
2427 if (!FirstPFrameInGop_IsParsed && (slice_type==0 || slice_type==5)) //P-Frame
2428 {
2429 FirstPFrameInGop_IsParsed=true;
2430
2431 //Testing if we have enough to test GOP
2432 if (Frame_Count<=Frame_Count_Valid)
2433 {
2434 std::string PictureTypes(PictureTypes_PreviousFrames);
2435 PictureTypes.reserve(TemporalReferences.size());
2436 for (size_t Pos=0; Pos<TemporalReferences.size(); Pos++)
2437 if (TemporalReferences[Pos])
2438 {
2439 if ((Pos%2)==0)
2440 PictureTypes+=Avc_slice_type[TemporalReferences[Pos]->slice_type];
2441 }
2442 else if (!PictureTypes.empty()) //Only if stream already started
2443 {
2444 if ((Pos%2)==0)
2445 PictureTypes+=' ';
2446 }
2447 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2448 if (!GOP_Detect(PictureTypes).empty() && !GA94_03_IsPresent)
2449 Frame_Count_Valid=Frame_Count; //We have enough frames
2450 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2451 }
2452 }
2453 }
2454
2455 #if MEDIAINFO_TRACE
2456 if (Trace_Activated)
2457 {
2458 Element_Info1(TemporalReferences_Offset_pic_order_cnt_lsb_Last);
2459 Element_Info1((((*seq_parameter_set_Item)->frame_mbs_only_flag || !field_pic_flag)?__T("Frame "):(bottom_field_flag?__T("Field (Bottom) "):__T("Field (Top) ")))+Ztring::ToZtring(Frame_Count));
2460 if (slice_type<9)
2461 Element_Info1(__T("slice_type ")+Ztring().From_UTF8(Avc_slice_type[slice_type]));
2462 Element_Info1(__T("frame_num ")+Ztring::ToZtring(frame_num));
2463 if ((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->fixed_frame_rate_flag)
2464 {
2465 if (FrameInfo.PCR!=(int64u)-1)
2466 Element_Info1(__T("PCR ")+Ztring().Duration_From_Milliseconds(float64_int64s(((float64)FrameInfo.PCR)/1000000)));
2467 if (FrameInfo.DTS!=(int64u)-1)
2468 Element_Info1(__T("DTS ")+Ztring().Duration_From_Milliseconds(float64_int64s(((float64)FrameInfo.DTS)/1000000)));
2469 if (FrameInfo.PTS!=(int64u)-1)
2470 Element_Info1(__T("PTS ")+Ztring().Duration_From_Milliseconds(float64_int64s(((float64)FrameInfo.PTS)/1000000)));
2471 }
2472 if ((*seq_parameter_set_Item)->pic_order_cnt_type==0)
2473 Element_Info1(__T("pic_order_cnt_lsb ")+Ztring::ToZtring(pic_order_cnt_lsb));
2474 if (first_mb_in_slice)
2475 Element_Info1(__T("first_mb_in_slice ")+Ztring::ToZtring(first_mb_in_slice));
2476 }
2477 #endif //MEDIAINFO_TRACE
2478
2479 //Counting
2480 if (Frame_Count!=(int64u)-1)
2481 {
2482 if (File_Offset+Buffer_Offset+Element_Size==File_Size)
2483 Frame_Count_Valid=Frame_Count; //Finish frames in case of there are less than Frame_Count_Valid frames
2484 Frame_Count++;
2485 if (IFrame_Count && Frame_Count_NotParsedIncluded!=(int64u)-1)
2486 Frame_Count_NotParsedIncluded++;
2487 Frame_Count_InThisBlock++;
2488 }
2489 if ((*seq_parameter_set_Item)->pic_order_cnt_type==0 && field_pic_flag)
2490 {
2491 Field_Count++;
2492 Field_Count_InThisBlock++;
2493 }
2494 if (FrameInfo.PTS!=(int64u)-1)
2495 FrameInfo.PTS+=tc;
2496 if (FrameInfo.DTS!=(int64u)-1)
2497 FrameInfo.DTS+=tc;
2498 if (FrameInfo.PTS!=(int64u)-1 && (FrameInfo.PTS>PTS_End || (PTS_End>1000000000 && FrameInfo.PTS<=PTS_End-1000000000))) //More than current PTS_End or less than current PTS_End minus 1 second (there is a problem?)
2499 PTS_End=FrameInfo.PTS;
2500
2501 #if MEDIAINFO_DUPLICATE
2502 if (Streams[(size_t)Element_Code].ShouldDuplicate)
2503 File__Duplicate_Write(Element_Code, (*seq_parameter_set_Item)->pic_order_cnt_type==0?pic_order_cnt_lsb:frame_num);
2504 #endif //MEDIAINFO_DUPLICATE
2505
2506 //Filling only if not already done
2507 if (Frame_Count==1 && !Status[IsAccepted])
2508 Accept("AVC");
2509 if (!Status[IsFilled])
2510 {
2511 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2512 if (!GA94_03_IsPresent && IFrame_Count>=8)
2513 Frame_Count_Valid=Frame_Count; //We have enough frames
2514 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2515 if (Frame_Count>=Frame_Count_Valid)
2516 {
2517 Fill("AVC");
2518 if (!IsSub && !Streams[(size_t)Element_Code].ShouldDuplicate && Config->ParseSpeed<1.0)
2519 Finish("AVC");
2520 }
2521 }
2522 FILLING_END();
2523 }
2524
2525 //---------------------------------------------------------------------------
2526 //
slice_data(bool AllCategories)2527 void File_Avc::slice_data(bool AllCategories)
2528 {
2529 Element_Begin1("slice_data");
2530
2531 Skip_BS(Data_BS_Remain(), "(ToDo)");
2532
2533 Element_End0();
2534 }
2535
2536 //---------------------------------------------------------------------------
2537 //
ref_pic_list_modification(int32u slice_type,bool mvc)2538 void File_Avc::ref_pic_list_modification(int32u slice_type, bool mvc)
2539 {
2540 if ((slice_type%5)!=2 && (slice_type%5)!=4)
2541 {
2542 TEST_SB_SKIP( "ref_pic_list_modification_flag_l0");
2543 int32u modification_of_pic_nums_idc;
2544 do
2545 {
2546 Get_UE (modification_of_pic_nums_idc, "modification_of_pic_nums_idc");
2547 if (modification_of_pic_nums_idc<2)
2548 Skip_UE( "abs_diff_pic_num_minus1");
2549 else if (modification_of_pic_nums_idc==2)
2550 Skip_UE( "long_term_pic_num");
2551 else if (mvc && (modification_of_pic_nums_idc==4 || modification_of_pic_nums_idc==5)) //ref_pic_list_mvc_modification only
2552 Skip_UE( "abs_diff_view_idx_minus1");
2553 else if (modification_of_pic_nums_idc!=3)
2554 {
2555 Trusted_IsNot("ref_pic_list_modification_flag_l0");
2556 Skip_BS(Data_BS_Remain(), "(Remaining bits)");
2557 }
2558 }
2559 while (modification_of_pic_nums_idc!=3 && Data_BS_Remain());
2560 TEST_SB_END();
2561 }
2562 if ((slice_type%5)==1)
2563 {
2564 TEST_SB_SKIP( "ref_pic_list_modification_flag_l1");
2565 int32u modification_of_pic_nums_idc;
2566 do
2567 {
2568 Get_UE (modification_of_pic_nums_idc, "modification_of_pic_nums_idc");
2569 if (modification_of_pic_nums_idc<2)
2570 Skip_UE( "abs_diff_pic_num_minus1");
2571 else if (modification_of_pic_nums_idc==2)
2572 Skip_UE( "long_term_pic_num");
2573 else if (mvc && (modification_of_pic_nums_idc==4 || modification_of_pic_nums_idc==5)) //ref_pic_list_mvc_modification only
2574 Skip_UE( "abs_diff_view_idx_minus1");
2575 else if (modification_of_pic_nums_idc!=3)
2576 {
2577 Trusted_IsNot("ref_pic_list_modification_flag_l1");
2578 Skip_BS(Data_BS_Remain(), "(Remaining bits)");
2579 }
2580 }
2581 while (modification_of_pic_nums_idc!=3 && Data_BS_Remain());
2582 TEST_SB_END();
2583 }
2584 }
2585
2586 //---------------------------------------------------------------------------
2587 //
pred_weight_table(int32u slice_type,int32u num_ref_idx_l0_active_minus1,int32u num_ref_idx_l1_active_minus1,int8u ChromaArrayType)2588 void File_Avc::pred_weight_table(int32u slice_type, int32u num_ref_idx_l0_active_minus1, int32u num_ref_idx_l1_active_minus1, int8u ChromaArrayType)
2589 {
2590 // 7.3.3.2 Prediction weight table syntax
2591 Skip_UE( "luma_log2_weight_denom");
2592 if (ChromaArrayType)
2593 Skip_UE( "chroma_log2_weight_denom");
2594 for(int32u i=0; i<=num_ref_idx_l0_active_minus1; i++)
2595 {
2596 TEST_SB_SKIP( "luma_weight_l0_flag");
2597 Skip_SE( "luma_weight_l0");
2598 Skip_SE( "luma_offset_l0");
2599 TEST_SB_END();
2600 if (ChromaArrayType)
2601 {
2602 TEST_SB_SKIP( "chroma_weight_l0_flag");
2603 Skip_SE( "chroma_weight_l0");
2604 Skip_SE( "chroma_offset_l0");
2605 Skip_SE( "chroma_weight_l0");
2606 Skip_SE( "chroma_offset_l0");
2607 TEST_SB_END();
2608 }
2609 }
2610 if (slice_type % 5 == 1)
2611 {
2612 for (int32u i = 0; i <= num_ref_idx_l1_active_minus1; i++)
2613 {
2614 TEST_SB_SKIP("luma_weight_l1_flag");
2615 Skip_SE("luma_weight_l1");
2616 Skip_SE("luma_offset_l1");
2617 TEST_SB_END();
2618 if (ChromaArrayType)
2619 {
2620 TEST_SB_SKIP("chroma_weight_l1_flag");
2621 Skip_SE("chroma_weight_l1");
2622 Skip_SE("chroma_offset_l1");
2623 Skip_SE("chroma_weight_l1");
2624 Skip_SE("chroma_offset_l1");
2625 TEST_SB_END();
2626 }
2627 }
2628 }
2629 }
2630
2631 //---------------------------------------------------------------------------
2632 //
dec_ref_pic_marking(std::vector<int8u> & memory_management_control_operations)2633 void File_Avc::dec_ref_pic_marking(std::vector<int8u> &memory_management_control_operations)
2634 {
2635 if (Element_Code==5) //IdrPicFlag
2636 {
2637 Skip_SB( "no_output_of_prior_pics_flag");
2638 Skip_SB( "long_term_reference_flag");
2639 }
2640 else
2641 {
2642 TEST_SB_SKIP( "adaptive_ref_pic_marking_mode_flag");
2643 int32u memory_management_control_operation;
2644 do
2645 {
2646 Get_UE (memory_management_control_operation, "memory_management_control_operation");
2647 switch (memory_management_control_operation)
2648 {
2649 case 1 :
2650 Skip_UE( "difference_of_pic_nums_minus1");
2651 break;
2652 case 2 :
2653 Skip_UE( "long_term_pic_num");
2654 break;
2655 case 3 :
2656 Skip_UE( "difference_of_pic_nums_minus1");
2657 //break; 3 --> difference_of_pic_nums_minus1 then long_term_frame_idx
2658 case 6 :
2659 Skip_UE( "long_term_frame_idx");
2660 break;
2661 case 4 :
2662 Skip_UE( "max_long_term_frame_idx_plus1");
2663 break;
2664 }
2665 memory_management_control_operations.push_back((int8u)memory_management_control_operation);
2666 }
2667 while (Data_BS_Remain() && memory_management_control_operation);
2668 TEST_SB_END()
2669 }
2670 }
2671
2672 //---------------------------------------------------------------------------
2673 // Packet "06"
sei()2674 void File_Avc::sei()
2675 {
2676 Element_Name("sei");
2677
2678 //Parsing
2679 int32u seq_parameter_set_id=(int32u)-1;
2680 while(Element_Offset+1<Element_Size)
2681 {
2682 Element_Begin1("sei message");
2683 sei_message(seq_parameter_set_id);
2684 Element_End0();
2685 }
2686 BS_Begin();
2687 Mark_1( );
2688 BS_End();
2689 }
2690
2691 //---------------------------------------------------------------------------
sei_message(int32u & seq_parameter_set_id)2692 void File_Avc::sei_message(int32u &seq_parameter_set_id)
2693 {
2694 //Parsing
2695 int32u payloadType=0, payloadSize=0;
2696 int8u payload_type_byte, payload_size_byte;
2697 Element_Begin1("sei message header");
2698 do
2699 {
2700 Get_B1 (payload_type_byte, "payload_type_byte");
2701 payloadType+=payload_type_byte;
2702 }
2703 while(payload_type_byte==0xFF);
2704 do
2705 {
2706 Get_B1 (payload_size_byte, "payload_size_byte");
2707 payloadSize+=payload_size_byte;
2708 }
2709 while(payload_size_byte==0xFF);
2710 Element_End0();
2711
2712 int64u Element_Offset_Save=Element_Offset+payloadSize;
2713 if (Element_Offset_Save>Element_Size)
2714 {
2715 Trusted_IsNot("Wrong size");
2716 Skip_XX(Element_Size-Element_Offset, "unknown");
2717 return;
2718 }
2719 int64u Element_Size_Save=Element_Size;
2720 Element_Size=Element_Offset_Save;
2721 switch (payloadType)
2722 {
2723 case 0 : sei_message_buffering_period(seq_parameter_set_id); break;
2724 case 1 : sei_message_pic_timing(payloadSize, seq_parameter_set_id); break;
2725 case 4 : sei_message_user_data_registered_itu_t_t35(); break;
2726 case 5 : sei_message_user_data_unregistered(payloadSize); break;
2727 case 6 : sei_message_recovery_point(); break;
2728 case 32 : sei_message_mainconcept(payloadSize); break;
2729 case 147: sei_alternative_transfer_characteristics(); break;
2730 case 137: sei_message_mastering_display_colour_volume(); break;
2731 case 144: sei_message_light_level(); break;
2732 default :
2733 Element_Info1("unknown");
2734 Skip_XX(payloadSize, "data");
2735 }
2736 Element_Offset=Element_Offset_Save; //Positionning in the right place.
2737 Element_Size=Element_Size_Save; //Positionning in the right place.
2738 }
2739
2740 //---------------------------------------------------------------------------
2741 // SEI - 0
sei_message_buffering_period(int32u & seq_parameter_set_id)2742 void File_Avc::sei_message_buffering_period(int32u &seq_parameter_set_id)
2743 {
2744 Element_Info1("buffering_period");
2745
2746 //Parsing
2747 if (Element_Offset==Element_Size)
2748 return; //Nothing to do
2749 BS_Begin();
2750 Get_UE (seq_parameter_set_id, "seq_parameter_set_id");
2751 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
2752 if (seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+seq_parameter_set_id))==NULL)
2753 {
2754 //Not yet present
2755 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
2756 BS_End();
2757 return;
2758 }
2759 if ((*seq_parameter_set_Item)->NalHrdBpPresentFlag())
2760 sei_message_buffering_period_xxl((*seq_parameter_set_Item)->vui_parameters->NAL);
2761 if ((*seq_parameter_set_Item)->VclHrdBpPresentFlag())
2762 sei_message_buffering_period_xxl((*seq_parameter_set_Item)->vui_parameters->VCL);
2763 BS_End();
2764 }
2765
sei_message_buffering_period_xxl(seq_parameter_set_struct::vui_parameters_struct::xxl * xxl)2766 void File_Avc::sei_message_buffering_period_xxl(seq_parameter_set_struct::vui_parameters_struct::xxl* xxl)
2767 {
2768 if (xxl==NULL)
2769 return;
2770 for (int32u SchedSelIdx=0; SchedSelIdx<xxl->SchedSel.size(); SchedSelIdx++)
2771 {
2772 //Get_S4 (xxl->initial_cpb_removal_delay_length_minus1+1, xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay, "initial_cpb_removal_delay"); Param_Info2(xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay/90, " ms");
2773 //Get_S4 (xxl->initial_cpb_removal_delay_length_minus1+1, xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay_offset, "initial_cpb_removal_delay_offset"); Param_Info2(xxl->SchedSel[SchedSelIdx].initial_cpb_removal_delay_offset/90, " ms");
2774 Info_S4 (xxl->initial_cpb_removal_delay_length_minus1+1, initial_cpb_removal_delay, "initial_cpb_removal_delay"); Param_Info2(initial_cpb_removal_delay/90, " ms");
2775 Info_S4 (xxl->initial_cpb_removal_delay_length_minus1+1, initial_cpb_removal_delay_offset, "initial_cpb_removal_delay_offset"); Param_Info2(initial_cpb_removal_delay_offset/90, " ms");
2776 }
2777 }
2778
2779 //---------------------------------------------------------------------------
2780 // SEI - 1
sei_message_pic_timing(int32u,int32u seq_parameter_set_id)2781 void File_Avc::sei_message_pic_timing(int32u /*payloadSize*/, int32u seq_parameter_set_id)
2782 {
2783 Element_Info1("pic_timing");
2784
2785 //Testing if we can parsing it now. TODO: handle case seq_parameter_set_id is unknown (buffering of message, decoding in slice parsing)
2786 if (seq_parameter_set_id==(int32u)-1 && seq_parameter_sets.size()==1)
2787 seq_parameter_set_id=0;
2788 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
2789 if (seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+seq_parameter_set_id))==NULL)
2790 {
2791 //Not yet present
2792 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
2793 return;
2794 }
2795
2796 //Parsing
2797 int8u pic_struct=(int8u)-1;
2798 BS_Begin();
2799 if ((*seq_parameter_set_Item)->CpbDpbDelaysPresentFlag())
2800 {
2801 int8u cpb_removal_delay_length_minus1=(*seq_parameter_set_Item)->vui_parameters->NAL?(*seq_parameter_set_Item)->vui_parameters->NAL->cpb_removal_delay_length_minus1:(*seq_parameter_set_Item)->vui_parameters->VCL->cpb_removal_delay_length_minus1; //Spec is not precise, I am not sure
2802 int8u dpb_output_delay_length_minus1=(*seq_parameter_set_Item)->vui_parameters->NAL?(*seq_parameter_set_Item)->vui_parameters->NAL->dpb_output_delay_length_minus1:(*seq_parameter_set_Item)->vui_parameters->VCL->dpb_output_delay_length_minus1; //Spec is not precise, I am not sure
2803 Skip_S4(cpb_removal_delay_length_minus1+1, "cpb_removal_delay");
2804 Skip_S4(dpb_output_delay_length_minus1+1, "dpb_output_delay");
2805 }
2806 if ((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->pic_struct_present_flag)
2807 {
2808 Get_S1 (4, pic_struct, "pic_struct");
2809 switch (pic_struct)
2810 {
2811 case 0 :
2812 case 1 :
2813 case 2 :
2814 case 3 :
2815 case 4 :
2816 case 5 :
2817 case 6 : FrameRate_Divider=1; break;
2818 case 7 : FrameRate_Divider=2; break;
2819 case 8 : FrameRate_Divider=3; break;
2820 default : Param_Info1("Reserved"); return; //NumClockTS is unknown
2821 }
2822 Param_Info1(Avc_pic_struct[pic_struct]);
2823 int8u NumClockTS=Avc_NumClockTS[pic_struct];
2824 int8u seconds_value=0, minutes_value=0, hours_value=0; //Here because theses values can be reused in later ClockTSs.
2825 for (int8u i=0; i<NumClockTS; i++)
2826 {
2827 Element_Begin1("ClockTS");
2828 TEST_SB_SKIP( "clock_timestamp_flag");
2829 Ztring TimeStamp;
2830 int32u time_offset=0;
2831 int8u n_frames;
2832 bool full_timestamp_flag, nuit_field_based_flag;
2833 Info_S1(2, ct_type, "ct_type"); Param_Info1(Avc_ct_type[ct_type]);
2834 Get_SB ( nuit_field_based_flag, "nuit_field_based_flag");
2835 Skip_S1(5, "counting_type");
2836 Get_SB ( full_timestamp_flag, "full_timestamp_flag");
2837 Skip_SB( "discontinuity_flag");
2838 Skip_SB( "cnt_dropped_flag");
2839 Get_S1 (8, n_frames, "n_frames");
2840 if (full_timestamp_flag)
2841 {
2842 Get_S1 (6, seconds_value, "seconds_value");
2843 Get_S1 (6, minutes_value, "minutes_value");
2844 Get_S1 (5, hours_value, "hours_value");
2845 }
2846 else
2847 {
2848 TEST_SB_SKIP( "seconds_flag");
2849 Get_S1 (6, seconds_value, "seconds_value");
2850 TEST_SB_SKIP( "minutes_flag");
2851 Get_S1 (6, minutes_value, "minutes_value");
2852 TEST_SB_SKIP( "hours_flag");
2853 Get_S1 (5, hours_value, "hours_value");
2854 TEST_SB_END();
2855 TEST_SB_END();
2856 TEST_SB_END();
2857 }
2858 TimeStamp=Ztring::ToZtring(hours_value)+__T(':')+Ztring::ToZtring(minutes_value)+__T(':')+Ztring::ToZtring(seconds_value);
2859 if ((*seq_parameter_set_Item)->CpbDpbDelaysPresentFlag())
2860 {
2861 int8u time_offset_length=(*seq_parameter_set_Item)->vui_parameters->NAL?(*seq_parameter_set_Item)->vui_parameters->NAL->time_offset_length:(*seq_parameter_set_Item)->vui_parameters->VCL->time_offset_length; //Spec is not precise, I am not sure
2862 if (time_offset_length)
2863 Get_S4 (time_offset_length, time_offset, "time_offset");
2864 }
2865 if ((*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->timing_info_present_flag && (*seq_parameter_set_Item)->vui_parameters->time_scale)
2866 {
2867 float32 Milliseconds=((float32)(n_frames*((*seq_parameter_set_Item)->vui_parameters->num_units_in_tick*(1+(nuit_field_based_flag?1:0)))+time_offset))/(*seq_parameter_set_Item)->vui_parameters->time_scale;
2868 TimeStamp+=__T('.');
2869 TimeStamp+=Ztring::ToZtring(Milliseconds);
2870 }
2871 Element_Info1(TimeStamp);
2872 TEST_SB_END();
2873 Element_End0();
2874 }
2875 }
2876 BS_End();
2877
2878 FILLING_BEGIN_PRECISE();
2879 if ((*seq_parameter_set_Item)->pic_struct_FirstDetected==(int8u)-1 && (*seq_parameter_set_Item)->vui_parameters && (*seq_parameter_set_Item)->vui_parameters->pic_struct_present_flag)
2880 (*seq_parameter_set_Item)->pic_struct_FirstDetected=pic_struct;
2881 FILLING_END();
2882 }
2883
2884 //---------------------------------------------------------------------------
2885 // SEI - 5
sei_message_user_data_registered_itu_t_t35()2886 void File_Avc::sei_message_user_data_registered_itu_t_t35()
2887 {
2888 Element_Info1("user_data_registered_itu_t_t35");
2889
2890 //Parsing
2891 int8u itu_t_t35_country_code;
2892 Get_B1 (itu_t_t35_country_code, "itu_t_t35_country_code");
2893 if (itu_t_t35_country_code==0xFF)
2894 Skip_B1( "itu_t_t35_country_code_extension_byte");
2895 if (itu_t_t35_country_code!=0xB5 || Element_Offset+2>=Element_Size)
2896 {
2897 if (Element_Size-Element_Offset)
2898 Skip_XX(Element_Size-Element_Offset, "Unknown");
2899 return;
2900 }
2901
2902 //United-States
2903 int16u id;
2904 Get_B2 (id, "id?");
2905 if (id!=0x0031 || Element_Offset+4>=Element_Size)
2906 {
2907 if (Element_Size-Element_Offset)
2908 Skip_XX(Element_Size-Element_Offset, "Unknown");
2909 return;
2910 }
2911
2912 int32u Identifier;
2913 Peek_B4(Identifier);
2914 switch (Identifier)
2915 {
2916 case 0x44544731 : sei_message_user_data_registered_itu_t_t35_DTG1(); return;
2917 case 0x47413934 : sei_message_user_data_registered_itu_t_t35_GA94(); return;
2918 default : if (Element_Size-Element_Offset)
2919 Skip_XX(Element_Size-Element_Offset, "Unknown");
2920 }
2921 }
2922
2923 //---------------------------------------------------------------------------
2924 // SEI - 5 - DTG1
sei_message_user_data_registered_itu_t_t35_DTG1()2925 void File_Avc::sei_message_user_data_registered_itu_t_t35_DTG1()
2926 {
2927 Element_Info1("Active Format Description");
2928
2929 //Parsing
2930 bool active_format_flag;
2931 Skip_C4( "afd_identifier");
2932 BS_Begin();
2933 Mark_0();
2934 Get_SB (active_format_flag, "active_format_flag");
2935 Mark_0_NoTrustError();
2936 Mark_0_NoTrustError();
2937 Mark_0_NoTrustError();
2938 Mark_0_NoTrustError();
2939 Mark_0_NoTrustError();
2940 Mark_1_NoTrustError();
2941 if (active_format_flag)
2942 {
2943 Mark_1_NoTrustError();
2944 Mark_1_NoTrustError();
2945 Mark_1_NoTrustError();
2946 Mark_1_NoTrustError();
2947 Info_S1(4, active_format, "active_format"); Param_Info1(Avc_user_data_DTG1_active_format[active_format]);
2948 }
2949 BS_End();
2950 }
2951
2952 //---------------------------------------------------------------------------
2953 // SEI - 5 - GA94
sei_message_user_data_registered_itu_t_t35_GA94()2954 void File_Avc::sei_message_user_data_registered_itu_t_t35_GA94()
2955 {
2956 //Parsing
2957 int8u user_data_type_code;
2958 Skip_B4( "GA94_identifier");
2959 Get_B1 (user_data_type_code, "user_data_type_code");
2960 switch (user_data_type_code)
2961 {
2962 case 0x03 : sei_message_user_data_registered_itu_t_t35_GA94_03(); break;
2963 case 0x06 : sei_message_user_data_registered_itu_t_t35_GA94_06(); break;
2964 default : Skip_XX(Element_Size-Element_Offset, "GA94_reserved_user_data");
2965 }
2966 }
2967
2968 //---------------------------------------------------------------------------
2969 // SEI - 5 - GA94 - 0x03
sei_message_user_data_registered_itu_t_t35_GA94_03()2970 void File_Avc::sei_message_user_data_registered_itu_t_t35_GA94_03()
2971 {
2972 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2973 GA94_03_IsPresent=true;
2974 MustExtendParsingDuration=true;
2975 Buffer_TotalBytes_Fill_Max=(int64u)-1; //Disabling this feature for this format, this is done in the parser
2976
2977 Element_Info1("DTVCC Transport");
2978
2979 //Coherency
2980 delete TemporalReferences_DelayedElement; TemporalReferences_DelayedElement=new temporal_reference();
2981
2982 TemporalReferences_DelayedElement->GA94_03=new buffer_data(Buffer+Buffer_Offset+(size_t)Element_Offset,(size_t)(Element_Size-Element_Offset));
2983
2984 //Parsing
2985 Skip_XX(Element_Size-Element_Offset, "CC data");
2986 #else //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2987 Skip_XX(Element_Size-Element_Offset, "DTVCC Transport data");
2988 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
2989 }
2990
sei_message_user_data_registered_itu_t_t35_GA94_03_Delayed(int32u seq_parameter_set_id)2991 void File_Avc::sei_message_user_data_registered_itu_t_t35_GA94_03_Delayed(int32u seq_parameter_set_id)
2992 {
2993 // Skipping missing frames
2994 if (TemporalReferences_Max-TemporalReferences_Min>(size_t)(4*(seq_parameter_sets[seq_parameter_set_id]->max_num_ref_frames+3))) // max_num_ref_frames ref frame maximum
2995 {
2996 size_t TemporalReferences_Min_New=TemporalReferences_Max-4*(seq_parameter_sets[seq_parameter_set_id]->max_num_ref_frames+3);
2997 while (TemporalReferences_Min_New>TemporalReferences_Min && TemporalReferences[TemporalReferences_Min_New-1])
2998 TemporalReferences_Min_New--;
2999 TemporalReferences_Min=TemporalReferences_Min_New;
3000 while (TemporalReferences[TemporalReferences_Min]==NULL)
3001 TemporalReferences_Min++;
3002 }
3003
3004 // Parsing captions
3005 while (TemporalReferences[TemporalReferences_Min] && TemporalReferences_Min+2*seq_parameter_sets[seq_parameter_set_id]->max_num_ref_frames<TemporalReferences_Max)
3006 {
3007 #if defined(MEDIAINFO_DTVCCTRANSPORT_YES)
3008 Element_Begin1("Reordered DTVCC Transport");
3009
3010 //Parsing
3011 #if MEDIAINFO_DEMUX
3012 int64u Element_Code_Old=Element_Code;
3013 Element_Code=0x4741393400000003LL;
3014 #endif //MEDIAINFO_DEMUX
3015 if (GA94_03_Parser==NULL)
3016 {
3017 GA94_03_Parser=new File_DtvccTransport;
3018 Open_Buffer_Init(GA94_03_Parser);
3019 ((File_DtvccTransport*)GA94_03_Parser)->Format=File_DtvccTransport::Format_A53_4_GA94_03;
3020 }
3021 if (((File_DtvccTransport*)GA94_03_Parser)->AspectRatio==0)
3022 {
3023 float64 PixelAspectRatio=1;
3024 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item=seq_parameter_sets.begin();
3025 for (; seq_parameter_set_Item!=seq_parameter_sets.end(); ++seq_parameter_set_Item)
3026 if ((*seq_parameter_set_Item))
3027 break;
3028 if (seq_parameter_set_Item!=seq_parameter_sets.end())
3029 {
3030 if (((*seq_parameter_set_Item)->vui_parameters) && ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_info_present_flag))
3031 {
3032 if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc<Avc_PixelAspectRatio_Size)
3033 PixelAspectRatio=Avc_PixelAspectRatio[(*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc];
3034 else if ((*seq_parameter_set_Item)->vui_parameters->aspect_ratio_idc==0xFF && (*seq_parameter_set_Item)->vui_parameters->sar_height)
3035 PixelAspectRatio=((float64)(*seq_parameter_set_Item)->vui_parameters->sar_width)/(*seq_parameter_set_Item)->vui_parameters->sar_height;
3036 }
3037 const int32u Width =((*seq_parameter_set_Item)->pic_width_in_mbs_minus1 +1)*16;
3038 const int32u Height=((*seq_parameter_set_Item)->pic_height_in_map_units_minus1+1)*16*(2-(*seq_parameter_set_Item)->frame_mbs_only_flag);
3039 if(Height)
3040 ((File_DtvccTransport*)GA94_03_Parser)->AspectRatio=Width*PixelAspectRatio/Height;
3041 }
3042 }
3043 if (GA94_03_Parser->PTS_DTS_Needed)
3044 {
3045 GA94_03_Parser->FrameInfo.PCR=FrameInfo.PCR;
3046 GA94_03_Parser->FrameInfo.PTS=FrameInfo.PTS;
3047 GA94_03_Parser->FrameInfo.DTS=FrameInfo.DTS;
3048 }
3049 #if MEDIAINFO_DEMUX
3050 if (TemporalReferences[TemporalReferences_Min]->GA94_03)
3051 {
3052 int8u Demux_Level_Save=Demux_Level;
3053 Demux_Level=8; //Ancillary
3054 Demux(TemporalReferences[TemporalReferences_Min]->GA94_03->Data, TemporalReferences[TemporalReferences_Min]->GA94_03->Size, ContentType_MainStream);
3055 Demux_Level=Demux_Level_Save;
3056 }
3057 Element_Code=Element_Code_Old;
3058 #endif //MEDIAINFO_DEMUX
3059 if (TemporalReferences[TemporalReferences_Min]->GA94_03)
3060 {
3061 #if defined(MEDIAINFO_EIA608_YES) || defined(MEDIAINFO_EIA708_YES)
3062 GA94_03_Parser->ServiceDescriptors=ServiceDescriptors;
3063 #endif
3064 Open_Buffer_Continue(GA94_03_Parser, TemporalReferences[TemporalReferences_Min]->GA94_03->Data, TemporalReferences[TemporalReferences_Min]->GA94_03->Size);
3065 }
3066
3067 Element_End0();
3068 #endif //defined(MEDIAINFO_DTVCCTRANSPORT_YES)
3069
3070 TemporalReferences_Min+=((seq_parameter_sets[seq_parameter_set_id]->frame_mbs_only_flag | !TemporalReferences[TemporalReferences_Min]->IsField)?2:1);
3071 }
3072 }
3073
3074 //---------------------------------------------------------------------------
3075 // SEI - 5 - GA94 - 0x03
sei_message_user_data_registered_itu_t_t35_GA94_06()3076 void File_Avc::sei_message_user_data_registered_itu_t_t35_GA94_06()
3077 {
3078 Element_Info1("Bar data");
3079
3080 //Parsing
3081 bool top_bar_flag, bottom_bar_flag, left_bar_flag, right_bar_flag;
3082 BS_Begin();
3083 Get_SB (top_bar_flag, "top_bar_flag");
3084 Get_SB (bottom_bar_flag, "bottom_bar_flag");
3085 Get_SB (left_bar_flag, "left_bar_flag");
3086 Get_SB (right_bar_flag, "right_bar_flag");
3087 Mark_1_NoTrustError();
3088 Mark_1_NoTrustError();
3089 Mark_1_NoTrustError();
3090 Mark_1_NoTrustError();
3091 BS_End();
3092 if (top_bar_flag)
3093 {
3094 Mark_1();
3095 Mark_1();
3096 Skip_S2(14, "line_number_end_of_top_bar");
3097 }
3098 if (bottom_bar_flag)
3099 {
3100 Mark_1();
3101 Mark_1();
3102 Skip_S2(14, "line_number_start_of_bottom_bar");
3103 }
3104 if (left_bar_flag)
3105 {
3106 Mark_1();
3107 Mark_1();
3108 Skip_S2(14, "pixel_number_end_of_left_bar");
3109 }
3110 if (right_bar_flag)
3111 {
3112 Mark_1();
3113 Mark_1();
3114 Skip_S2(14, "pixel_number_start_of_right_bar");
3115 }
3116 Mark_1();
3117 Mark_1();
3118 Mark_1();
3119 Mark_1();
3120 Mark_1();
3121 Mark_1();
3122 Mark_1();
3123 Mark_1();
3124 BS_End();
3125
3126 if (Element_Size-Element_Offset)
3127 Skip_XX(Element_Size-Element_Offset, "additional_bar_data");
3128 }
3129
3130 //---------------------------------------------------------------------------
3131 // SEI - 5
sei_message_user_data_unregistered(int32u payloadSize)3132 void File_Avc::sei_message_user_data_unregistered(int32u payloadSize)
3133 {
3134 Element_Info1("user_data_unregistered");
3135
3136 //Parsing
3137 int128u uuid_iso_iec_11578;
3138 Get_UUID(uuid_iso_iec_11578, "uuid_iso_iec_11578");
3139
3140 switch (uuid_iso_iec_11578.hi)
3141 {
3142 case 0xDC45E9BDE6D948B7LL : Element_Info1("x264");
3143 sei_message_user_data_unregistered_x264(payloadSize-16); break;
3144 case 0xFB574A60AC924E68LL : Element_Info1("eavc");
3145 sei_message_user_data_unregistered_x264(payloadSize-16); break;
3146 case 0x17EE8C60F84D11D9LL : Element_Info1("Blu-ray");
3147 sei_message_user_data_unregistered_bluray(payloadSize-16); break;
3148 default :
3149 Element_Info1("unknown");
3150 Skip_XX(payloadSize-16, "data");
3151 }
3152 }
3153
3154 //---------------------------------------------------------------------------
3155 // SEI - 5 - x264
sei_message_user_data_unregistered_x264(int32u payloadSize)3156 void File_Avc::sei_message_user_data_unregistered_x264(int32u payloadSize)
3157 {
3158 //Parsing
3159 string Data;
3160 Peek_String(payloadSize, Data);
3161 if (Data.size()!=payloadSize && Data.size()+1!=payloadSize)
3162 {
3163 Skip_XX(payloadSize, "Unknown");
3164 return; //This is not a text string
3165 }
3166 size_t Data_Pos_Before=0;
3167 size_t Loop=0;
3168 do
3169 {
3170 size_t Data_Pos=Data.find(" - ", Data_Pos_Before);
3171 if (Data_Pos==std::string::npos)
3172 Data_Pos=Data.size();
3173 if (Data.find("options: ", Data_Pos_Before)==Data_Pos_Before)
3174 {
3175 Element_Begin1("options");
3176 size_t Options_Pos_Before=Data_Pos_Before;
3177 Encoded_Library_Settings.clear();
3178 do
3179 {
3180 size_t Options_Pos=Data.find(__T(' '), Options_Pos_Before);
3181 if (Options_Pos==std::string::npos)
3182 Options_Pos=Data.size();
3183 string option;
3184 Get_String (Options_Pos-Options_Pos_Before, option, "option");
3185 Options_Pos_Before=Options_Pos;
3186 do
3187 {
3188 string Separator;
3189 Peek_String(1, Separator);
3190 if (Separator==" ")
3191 {
3192 Skip_UTF8(1, "separator");
3193 Options_Pos_Before+=1;
3194 }
3195 else
3196 break;
3197 }
3198 while (Options_Pos_Before!=Data.size());
3199
3200 //Filling
3201 if (option!="options:")
3202 {
3203 if (!Encoded_Library_Settings.empty())
3204 Encoded_Library_Settings+=__T(" / ");
3205 Encoded_Library_Settings+=Ztring().From_UTF8(option.c_str());
3206 if (option.find("bitrate=")==0)
3207 BitRate_Nominal.From_UTF8(option.substr(8)+"000"); //After "bitrate="
3208 }
3209 }
3210 while (Options_Pos_Before!=Data.size());
3211 Element_End0();
3212 }
3213 else
3214 {
3215 string Value;
3216 Get_String(Data_Pos-Data_Pos_Before, Value, "data");
3217
3218 //Saving
3219 if (Loop==0)
3220 {
3221 //Cleaning a little the value
3222 while (!Value.empty() && Value[0]<0x30)
3223 Value.erase(Value.begin());
3224 while (!Value.empty() && Value[Value.size()-1]<0x30)
3225 Value.erase(Value.end()-1);
3226 Encoded_Library.From_UTF8(Value.c_str());
3227 }
3228 if (Loop==1 && Encoded_Library.find(__T("x264"))==0)
3229 {
3230 Encoded_Library+=__T(" - ");
3231 Encoded_Library+=Ztring().From_UTF8(Value.c_str());
3232 }
3233 }
3234 Data_Pos_Before=Data_Pos;
3235 if (Data_Pos_Before+3<=Data.size())
3236 {
3237 Skip_UTF8(3, "separator");
3238 Data_Pos_Before+=3;
3239 }
3240
3241 Loop++;
3242 }
3243 while (Data_Pos_Before!=Data.size());
3244
3245 //Encoded_Library
3246 if (Encoded_Library.find(__T("eavc "))==0)
3247 {
3248 Encoded_Library_Name=__T("eavc");
3249 Encoded_Library_Version=Encoded_Library.SubString(__T("eavc "), __T(""));
3250 }
3251 else if (Encoded_Library.find(__T("x264 - "))==0)
3252 {
3253 Encoded_Library_Name=__T("x264");
3254 Encoded_Library_Version=Encoded_Library.SubString(__T("x264 - "), __T(""));
3255 }
3256 else if (Encoded_Library.find(__T("SUPER(C) by eRightSoft "))==0)
3257 {
3258 Encoded_Library_Name=__T("SUPER(C) by eRightSoft");
3259 Encoded_Library_Date=Ztring(__T("UTC "))+Encoded_Library.SubString(__T("2000-"), __T(" "));
3260 }
3261 else
3262 Encoded_Library_Name=Encoded_Library;
3263 }
3264
3265 //---------------------------------------------------------------------------
3266 // SEI - 5 - x264
sei_message_user_data_unregistered_bluray(int32u payloadSize)3267 void File_Avc::sei_message_user_data_unregistered_bluray(int32u payloadSize)
3268 {
3269 if (payloadSize<4)
3270 {
3271 Skip_XX(payloadSize, "Unknown");
3272 return;
3273 }
3274 int32u Identifier;
3275 Get_B4 (Identifier, "Identifier");
3276 switch (Identifier)
3277 {
3278 case 0x47413934 : sei_message_user_data_registered_itu_t_t35_GA94_03(); return;
3279 case 0x4D44504D : sei_message_user_data_unregistered_bluray_MDPM(Element_Size-Element_Offset); return;
3280 default : Skip_XX(Element_Size-Element_Offset, "Unknown");
3281 }
3282 }
3283
3284 //---------------------------------------------------------------------------
3285 // SEI - 5 - bluray - MDPM
sei_message_user_data_unregistered_bluray_MDPM(int32u payloadSize)3286 void File_Avc::sei_message_user_data_unregistered_bluray_MDPM(int32u payloadSize)
3287 {
3288 if (payloadSize<1)
3289 {
3290 Skip_XX(payloadSize, "Unknown");
3291 return;
3292 }
3293
3294 Element_Info1("Modified Digital Video Pack Metadata");
3295
3296 Skip_B1( "Count");
3297 payloadSize--;
3298 string DateTime0, DateTime1, DateTime2, Model0, Model1, Model2;
3299 int16u MakeName=(int16u)-1;
3300 Ztring IrisFNumber;
3301 while (payloadSize >= 5)
3302 {
3303 Element_Begin0();
3304 int8u ID;
3305 Get_B1(ID, "ID"); Element_Name(MDPM(ID));
3306 switch (ID)
3307 {
3308 case 0x18:
3309 {
3310 int16u Year;
3311 int8u MM, Zone_Hours;
3312 bool Zone_Sign, Zone_Minutes;
3313 BS_Begin();
3314 Mark_0();
3315 Skip_SB( "DST flag");
3316 Get_SB (Zone_Sign, "Time zone sign");
3317 Get_S1 (4, Zone_Hours, "Time zone hours");
3318 Get_SB (Zone_Minutes, "Time zone half-hour flag");
3319 BS_End();
3320 Get_B2 (Year, "Year");
3321 Get_B1 (MM, "Month");
3322 DateTime0+='0'+(Year>>12);
3323 DateTime0+='0'+((Year&0xF00)>>8);
3324 DateTime0+='0'+((Year&0xF0)>>4);
3325 DateTime0+='0'+(Year&0xF);
3326 DateTime0+='-';
3327 DateTime0+='0'+((MM&0xF0)>>4);
3328 DateTime0+='0'+(MM&0xF);
3329 DateTime0+='-';
3330 Element_Info1(DateTime0);
3331 DateTime2+=Zone_Sign?'-':'+';
3332 DateTime2+='0'+Zone_Hours/10;
3333 DateTime2+='0'+Zone_Hours%10;
3334 DateTime2+=':';
3335 DateTime2+=Zone_Minutes?'3':'0';
3336 DateTime2+='0';
3337 Element_Info1(DateTime2);
3338 }
3339 break;
3340 case 0x19:
3341 {
3342 int8u DD, hh, mm, ss;
3343 Get_B1 (DD, "Day");
3344 Get_B1 (hh, "Hour");
3345 Get_B1 (mm, "Minute");
3346 Get_B1 (ss, "Second");
3347 DateTime1+='0'+(DD>>4);
3348 DateTime1+='0'+(DD&0xF);
3349 DateTime1+=' ';
3350 DateTime1+='0'+(hh>>4);
3351 DateTime1+='0'+(hh&0xF);
3352 DateTime1+=':';
3353 DateTime1+='0'+(mm>>4);
3354 DateTime1+='0'+(mm&0xF);
3355 DateTime1+=':';
3356 DateTime1+='0'+(ss>>4);
3357 DateTime1+='0'+(ss&0xF);
3358 Element_Info1(DateTime1);
3359 }
3360 break;
3361 case 0x70:
3362 consumer_camera_1();
3363 break;
3364 case 0x71:
3365 consumer_camera_2();
3366 break;
3367 case 0xA1:
3368 {
3369 int16u D, N;
3370 Get_B2 (D, "D");
3371 Get_B2 (N, "N");
3372 IrisFNumber.From_Number(((float64)D)/N, 6);
3373 Element_Info1(IrisFNumber);
3374 }
3375 break;
3376 case 0xE0:
3377 {
3378 Get_B2 (MakeName, "Name");
3379 Skip_B2( "Category");
3380 Element_Info1(MDPM_MakeName(MakeName));
3381 }
3382 break;
3383 case 0xE4:
3384 Get_String(4, Model0, "Data"); Element_Info1(Model0);
3385 break;
3386 case 0xE5:
3387 Get_String(4, Model1, "Data"); Element_Info1(Model1);
3388 break;
3389 case 0xE6:
3390 Get_String(4, Model2, "Data");
3391 Model2.erase(Model2.find_last_not_of('\0')+1);
3392 Element_Info1(Model2);
3393 break;
3394 default: Skip_B4("Data");
3395 }
3396 Element_End0();
3397 payloadSize -= 5;
3398 }
3399 if (payloadSize)
3400 Skip_XX(payloadSize, "Unknown");
3401
3402 FILLING_BEGIN();
3403 if (!Frame_Count && !seq_parameter_sets.empty() && !pic_parameter_sets.empty())
3404 {
3405 if (!DateTime0.empty() && !DateTime1.empty())
3406 Fill(Stream_General, 0, General_Recorded_Date, DateTime0+DateTime1+DateTime2);
3407 if (MDPM_MakeName(MakeName)[0] || !Model0.empty())
3408 {
3409 string Model;
3410 if (MDPM_MakeName(MakeName)[0])
3411 {
3412 Model=MDPM_MakeName(MakeName);
3413 Fill(Stream_General, 0, General_Encoded_Application_CompanyName, Model);
3414 if (!Model0.empty())
3415 Model+=' ';
3416 }
3417 Fill(Stream_General, 0, General_Encoded_Application, Model+Model0+Model1+Model2);
3418 Fill(Stream_General, 0, General_Encoded_Application_Name, Model0+Model1+Model2);
3419 }
3420 Fill(Stream_Video, 0, "IrisFNumber", IrisFNumber);
3421 }
3422 FILLING_END();
3423 }
3424
3425 //---------------------------------------------------------------------------
consumer_camera_1()3426 void File_Avc::consumer_camera_1()
3427 {
3428 //Parsing
3429 BS_Begin();
3430 int8u ae_mode, wb_mode, white_balance, fcm;
3431 Mark_1_NoTrustError();
3432 Mark_1_NoTrustError();
3433 Skip_S1(6, "iris");
3434 Get_S1 (4, ae_mode, "ae mode"); Param_Info1(Dv_consumer_camera_1_ae_mode[ae_mode]);
3435 Skip_S1(4, "agc(Automatic Gain Control)");
3436 Get_S1 (3, wb_mode, "wb mode (white balance mode)"); Param_Info1(Dv_consumer_camera_1_wb_mode[wb_mode]);
3437 Get_S1 (5, white_balance, "white balance"); Param_Info1(Dv_consumer_camera_1_white_balance(white_balance));
3438 Get_S1 (1, fcm, "fcm (Focus mode)"); Param_Info1(Dv_consumer_camera_1_fcm[fcm]);
3439 Skip_S1(7, "focus (focal point)");
3440 BS_End();
3441
3442 /* TODO: need some tweaking
3443 FILLING_BEGIN();
3444 if (!Frame_Count)
3445 {
3446 Ztring Settings;
3447 if (ae_mode<0x0F) Settings+=__T("ae mode=")+Ztring(Dv_consumer_camera_1_ae_mode[ae_mode])+__T(", ");
3448 if (wb_mode<0x08) Settings+=__T("wb mode=")+Ztring(Dv_consumer_camera_1_wb_mode[wb_mode])+__T(", ");
3449 if (wb_mode<0x1F) Settings+=__T("white balance=")+Ztring(Dv_consumer_camera_1_white_balance(white_balance))+__T(", ");
3450 Settings+=__T("fcm=")+Ztring(Dv_consumer_camera_1_fcm[fcm]);
3451 Fill(Stream_Video, 0, "Camera_Settings", Settings);
3452 }
3453 FILLING_END();
3454 */
3455 }
3456
3457 //---------------------------------------------------------------------------
consumer_camera_2()3458 void File_Avc::consumer_camera_2()
3459 {
3460 //Parsing
3461 BS_Begin();
3462 Mark_1_NoTrustError();
3463 Mark_1_NoTrustError();
3464 Skip_S1(1, "vpd");
3465 Skip_S1(5, "vertical panning speed");
3466 Skip_S1(1, "is");
3467 Skip_S1(1, "hpd");
3468 Skip_S1(6, "horizontal panning speed");
3469 Skip_S1(8, "focal length");
3470 Skip_S1(1, "zen");
3471 Info_S1(3, zoom_U, "units of e-zoom");
3472 Info_S1(4, zoom_D, "1/10 of e-zoom"); /*if (zoom_D!=0xF)*/ Param_Info1(__T("zoom=")+Ztring().From_Number(zoom_U+((float32)zoom_U)/10, 2));
3473 BS_End();
3474 }
3475
3476 //---------------------------------------------------------------------------
sei_message_mastering_display_colour_volume()3477 void File_Avc::sei_message_mastering_display_colour_volume()
3478 {
3479 Element_Info1("mastering_display_colour_volume");
3480
3481 std::map<video, Ztring>& SmpteSt2086 = HDR[HdrFormat_SmpteSt2086];
3482 Ztring& HDR_Format = SmpteSt2086[Video_HDR_Format];
3483 if (HDR_Format.empty())
3484 {
3485 HDR_Format = __T("SMPTE ST 2086");
3486 SmpteSt2086[Video_HDR_Format_Compatibility] = "HDR10";
3487 }
3488 Get_MasteringDisplayColorVolume(SmpteSt2086[Video_MasteringDisplay_ColorPrimaries], SmpteSt2086[Video_MasteringDisplay_Luminance]);
3489 }
3490 //---------------------------------------------------------------------------
sei_message_light_level()3491 void File_Avc::sei_message_light_level()
3492 {
3493 Element_Info1("light_level");
3494
3495 //Parsing
3496 Get_B2(maximum_content_light_level, "maximum_content_light_level");
3497 Get_B2(maximum_frame_average_light_level, "maximum_frame_average_light_level");
3498 }
3499
3500 //---------------------------------------------------------------------------
3501 // SEI - 6
sei_message_recovery_point()3502 void File_Avc::sei_message_recovery_point()
3503 {
3504 Element_Info1("recovery_point");
3505
3506 //Parsing
3507 BS_Begin();
3508 Skip_UE( "recovery_frame_cnt");
3509 Skip_SB( "exact_match_flag");
3510 Skip_SB( "broken_link_flag");
3511 Skip_S1(2, "changing_slice_group_idc");
3512 BS_End();
3513 }
3514
3515 //---------------------------------------------------------------------------
3516 // SEI - 32
sei_message_mainconcept(int32u payloadSize)3517 void File_Avc::sei_message_mainconcept(int32u payloadSize)
3518 {
3519 Element_Info1("MainConcept text");
3520
3521 //Parsing
3522 string Text;
3523 Get_String(payloadSize, Text, "text");
3524
3525 if (Text.find("produced by MainConcept H.264/AVC Codec v")!=std::string::npos)
3526 {
3527 Encoded_Library=Ztring().From_UTF8(Text).SubString(__T("produced by "), __T(" MainConcept AG"));
3528 Encoded_Library_Name=__T("MainConcept H.264/AVC Codec");
3529 Encoded_Library_Version= Ztring().From_UTF8(Text).SubString(__T("produced by MainConcept H.264/AVC Codec v"), __T(" (c) "));
3530 Encoded_Library_Date=MediaInfoLib::Config.Library_Get(InfoLibrary_Format_MainConcept_Avc, Encoded_Library_Version, InfoLibrary_Date);
3531 }
3532 }
3533
3534 //---------------------------------------------------------------------------
sei_alternative_transfer_characteristics()3535 void File_Avc::sei_alternative_transfer_characteristics()
3536 {
3537 Element_Info1("alternative_transfer_characteristics");
3538
3539 //Parsing
3540 Get_B1(preferred_transfer_characteristics, "preferred_transfer_characteristics"); Param_Info1(Mpegv_transfer_characteristics(preferred_transfer_characteristics));
3541 }
3542
3543 //---------------------------------------------------------------------------
3544 // Packet "07"
seq_parameter_set()3545 void File_Avc::seq_parameter_set()
3546 {
3547 Element_Name("seq_parameter_set");
3548
3549 //parsing
3550 int32u seq_parameter_set_id;
3551 seq_parameter_set_struct* Data_Item_New=seq_parameter_set_data(seq_parameter_set_id);
3552 if (!Data_Item_New)
3553 return;
3554 Mark_1( );
3555 size_t BS_bits=Data_BS_Remain()%8;
3556 while (BS_bits)
3557 {
3558 Mark_0( );
3559 BS_bits--;
3560 }
3561 BS_End();
3562
3563 //Hack for 00003.m2ts: There is a trailing 0x89, why?
3564 if (Element_Offset+1==Element_Size)
3565 {
3566 int8u ToTest;
3567 Peek_B1(ToTest);
3568 if (ToTest==0x98)
3569 Skip_B1( "Unknown");
3570
3571 }
3572
3573 //Hack for : There is a trailing data, why?
3574 if (Element_Offset+4==Element_Size)
3575 {
3576 int32u ToTest;
3577 Peek_B4(ToTest);
3578 if (ToTest==0xE30633C0)
3579 Skip_B4( "Unknown");
3580 }
3581
3582 //NULL bytes
3583 while (Element_Offset<Element_Size)
3584 {
3585 int8u Null;
3586 Get_B1 (Null, "NULL byte");
3587 if (Null)
3588 Trusted_IsNot("Should be NULL byte");
3589 }
3590
3591 FILLING_BEGIN_PRECISE();
3592 //NextCode
3593 NextCode_Clear();
3594 NextCode_Add(0x08);
3595
3596 //Add
3597 seq_parameter_set_data_Add(seq_parameter_sets, seq_parameter_set_id, Data_Item_New);
3598
3599 //Autorisation of other streams
3600 Streams[0x08].Searching_Payload=true; //pic_parameter_set
3601 if (Streams[0x07].ShouldDuplicate)
3602 Streams[0x08].ShouldDuplicate=true; //pic_parameter_set
3603 Streams[0x0A].Searching_Payload=true; //end_of_seq
3604 if (Streams[0x07].ShouldDuplicate)
3605 Streams[0x0A].ShouldDuplicate=true; //end_of_seq
3606 Streams[0x0B].Searching_Payload=true; //end_of_stream
3607 if (Streams[0x07].ShouldDuplicate)
3608 Streams[0x0B].ShouldDuplicate=true; //end_of_stream
3609 FILLING_ELSE();
3610 delete Data_Item_New;
3611 FILLING_END();
3612 }
3613
seq_parameter_set_data_Add(std::vector<seq_parameter_set_struct * > & Data,const int32u Data_id,seq_parameter_set_struct * Data_Item_New)3614 void File_Avc::seq_parameter_set_data_Add(std::vector<seq_parameter_set_struct*> &Data, const int32u Data_id, seq_parameter_set_struct* Data_Item_New)
3615 {
3616 //Creating Data
3617 if (Data_id>=Data.size())
3618 Data.resize(Data_id+1);
3619 else
3620 FirstPFrameInGop_IsParsed=true;
3621 std::vector<seq_parameter_set_struct*>::iterator Data_Item=Data.begin()+Data_id;
3622 delete *Data_Item; *Data_Item=Data_Item_New;
3623
3624 //Computing values (for speed)
3625 size_t MaxNumber;
3626 switch (Data_Item_New->pic_order_cnt_type)
3627 {
3628 case 0 :
3629 MaxNumber=Data_Item_New->MaxPicOrderCntLsb;
3630 break;
3631 case 1 :
3632 case 2 :
3633 MaxNumber=Data_Item_New->MaxFrameNum*2;
3634 break;
3635 default:
3636 MaxNumber = 0;
3637 }
3638
3639 if (MaxNumber>TemporalReferences_Reserved)
3640 {
3641 TemporalReferences.resize(4*MaxNumber);
3642 TemporalReferences_Reserved=MaxNumber;
3643 }
3644 }
3645
3646 //---------------------------------------------------------------------------
3647 // Packet "08"
pic_parameter_set()3648 void File_Avc::pic_parameter_set()
3649 {
3650 Element_Name("pic_parameter_set");
3651
3652 //Parsing
3653 int32u pic_parameter_set_id, seq_parameter_set_id, num_slice_groups_minus1, num_ref_idx_l0_default_active_minus1, num_ref_idx_l1_default_active_minus1, slice_group_map_type=0;
3654 int8u weighted_bipred_idc=0;
3655 bool entropy_coding_mode_flag,bottom_field_pic_order_in_frame_present_flag, redundant_pic_cnt_present_flag, weighted_pred_flag, deblocking_filter_control_present_flag;
3656 BS_Begin();
3657 Get_UE (pic_parameter_set_id, "pic_parameter_set_id");
3658 Get_UE (seq_parameter_set_id, "seq_parameter_set_id");
3659 std::vector<seq_parameter_set_struct*>::iterator seq_parameter_set_Item;
3660 if (seq_parameter_set_id>=seq_parameter_sets.size() || (*(seq_parameter_set_Item=seq_parameter_sets.begin()+seq_parameter_set_id))==NULL)
3661 {
3662 if (seq_parameter_set_id>=subset_seq_parameter_sets.size() || (*(seq_parameter_set_Item=subset_seq_parameter_sets.begin()+seq_parameter_set_id))==NULL)
3663 {
3664 //Not yet present
3665 Skip_BS(Data_BS_Remain(), "Data (seq_parameter_set is missing)");
3666 return;
3667 }
3668 }
3669 Get_SB (entropy_coding_mode_flag, "entropy_coding_mode_flag");
3670 Get_SB (bottom_field_pic_order_in_frame_present_flag, "bottom_field_pic_order_in_frame_present_flag");
3671 Get_UE (num_slice_groups_minus1, "num_slice_groups_minus1");
3672 if (num_slice_groups_minus1>7)
3673 {
3674 Trusted_IsNot("num_slice_groups_minus1 too high");
3675 num_slice_groups_minus1=0;
3676 }
3677 if (num_slice_groups_minus1>0)
3678 {
3679 Get_UE (slice_group_map_type, "slice_group_map_type");
3680 if (slice_group_map_type==0)
3681 {
3682 for (int32u Pos=0; Pos<=num_slice_groups_minus1; Pos++)
3683 Skip_UE( "run_length_minus1");
3684 }
3685 else if (slice_group_map_type==2)
3686 {
3687 for (int32u Pos=0; Pos<num_slice_groups_minus1; Pos++)
3688 {
3689 Skip_UE( "top_left");
3690 Skip_UE( "bottom_right");
3691 }
3692 }
3693 else if (slice_group_map_type==3
3694 || slice_group_map_type==4
3695 || slice_group_map_type==5)
3696 {
3697 Skip_SB( "slice_group_change_direction_flag");
3698 Skip_UE( "slice_group_change_rate_minus1");
3699 }
3700 else if (slice_group_map_type==6)
3701 {
3702 int32u pic_size_in_map_units_minus1;
3703 Get_UE (pic_size_in_map_units_minus1, "pic_size_in_map_units_minus1");
3704 if(pic_size_in_map_units_minus1>((*seq_parameter_set_Item)->pic_width_in_mbs_minus1+1)*((*seq_parameter_set_Item)->pic_height_in_map_units_minus1+1))
3705 {
3706 Trusted_IsNot("pic_size_in_map_units_minus1 too high");
3707 return;
3708 }
3709 #if defined (__mips__) || defined (__mipsel__)
3710 int32u slice_group_id_Size=(int32u)(std::ceil(std::log((double)(num_slice_groups_minus1+1))/std::log((double)10))); //std::log is natural logarithm
3711 #else
3712 int32u slice_group_id_Size=(int32u)(std::ceil(std::log((float32)(num_slice_groups_minus1+1))/std::log((float32)10))); //std::log is natural logarithm
3713 #endif
3714 for (int32u Pos=0; Pos<=pic_size_in_map_units_minus1; Pos++)
3715 Skip_BS(slice_group_id_Size, "slice_group_id");
3716 }
3717 }
3718 Get_UE (num_ref_idx_l0_default_active_minus1, "num_ref_idx_l0_default_active_minus1");
3719 Get_UE (num_ref_idx_l1_default_active_minus1, "num_ref_idx_l1_default_active_minus1");
3720 Get_SB (weighted_pred_flag, "weighted_pred_flag");
3721 Get_S1 (2, weighted_bipred_idc, "weighted_bipred_idc");
3722 Skip_SE( "pic_init_qp_minus26");
3723 Skip_SE( "pic_init_qs_minus26");
3724 Skip_SE( "chroma_qp_index_offset");
3725 Get_SB (deblocking_filter_control_present_flag, "deblocking_filter_control_present_flag");
3726 Skip_SB( "constrained_intra_pred_flag");
3727 Get_SB (redundant_pic_cnt_present_flag, "redundant_pic_cnt_present_flag");
3728 bool more_rbsp_data=false;
3729 if (Element_Size)
3730 {
3731 int64u Offset=Element_Size-1;
3732 while (Offset && Buffer[Buffer_Offset+(size_t)Offset]==0x00) //Searching if there are NULL bytes at the end of the data
3733 Offset--;
3734 size_t Bit_Pos=7;
3735 while (Bit_Pos && !(Buffer[Buffer_Offset+(size_t)Offset]&(1<<(7-Bit_Pos))))
3736 Bit_Pos--;
3737 if (Data_BS_Remain()>1+(7-Bit_Pos)+(Element_Size-Offset-1)*8)
3738 more_rbsp_data=true;
3739 }
3740 if (more_rbsp_data)
3741 {
3742 bool transform_8x8_mode_flag;
3743 Get_SB (transform_8x8_mode_flag, "transform_8x8_mode_flag");
3744 TEST_SB_SKIP( "pic_scaling_matrix_present_flag");
3745 for (int8u Pos=0; Pos<6+(transform_8x8_mode_flag?((*seq_parameter_set_Item)->chroma_format_idc!=3?2:6):0); Pos++ )
3746 {
3747 TEST_SB_SKIP( "pic_scaling_list_present_flag");
3748 scaling_list(Pos<6?16:64);
3749 TEST_SB_END();
3750 }
3751 TEST_SB_END();
3752 Skip_SE( "second_chroma_qp_index_offset");
3753 }
3754 Mark_1( );
3755 BS_End();
3756
3757 while (Element_Offset<Element_Size) //Not always removed from the stream, ie in MPEG-4
3758 {
3759 int8u Padding;
3760 Peek_B1(Padding);
3761 if (!Padding)
3762 Skip_B1( "Padding");
3763 else
3764 break;
3765 }
3766
3767 FILLING_BEGIN_PRECISE();
3768 //Integrity
3769 if (pic_parameter_set_id>=256)
3770 {
3771 Trusted_IsNot("pic_parameter_set_id not valid");
3772 return; //Problem, not valid
3773 }
3774 if (seq_parameter_set_id>=32)
3775 {
3776 Trusted_IsNot("seq_parameter_set_id not valid");
3777 return; //Problem, not valid
3778 }
3779
3780 //NextCode
3781 NextCode_Clear();
3782 NextCode_Add(0x05);
3783 NextCode_Add(0x06);
3784 if (!subset_seq_parameter_sets.empty())
3785 NextCode_Add(0x14); //slice_layer_extension
3786
3787 //Filling
3788 if (pic_parameter_set_id>=pic_parameter_sets.size())
3789 pic_parameter_sets.resize(pic_parameter_set_id+1);
3790 std::vector<pic_parameter_set_struct*>::iterator pic_parameter_sets_Item=pic_parameter_sets.begin()+pic_parameter_set_id;
3791 delete *pic_parameter_sets_Item; *pic_parameter_sets_Item = new pic_parameter_set_struct(
3792 (int8u)seq_parameter_set_id,
3793 (int8u)num_ref_idx_l0_default_active_minus1,
3794 (int8u)num_ref_idx_l1_default_active_minus1,
3795 weighted_bipred_idc,
3796 num_slice_groups_minus1,
3797 slice_group_map_type,
3798 entropy_coding_mode_flag,
3799 bottom_field_pic_order_in_frame_present_flag,
3800 weighted_pred_flag,
3801 redundant_pic_cnt_present_flag,
3802 deblocking_filter_control_present_flag
3803 );
3804
3805 //Autorisation of other streams
3806 if (!seq_parameter_sets.empty())
3807 {
3808 for (int8u Pos=0x01; Pos<=0x06; Pos++)
3809 {
3810 Streams[Pos].Searching_Payload=true; //Coded slice...
3811 if (Streams[0x08].ShouldDuplicate)
3812 Streams[Pos].ShouldDuplicate=true;
3813 }
3814 }
3815 if (!subset_seq_parameter_sets.empty())
3816 {
3817 Streams[0x14].Searching_Payload=true; //slice_layer_extension
3818 if (Streams[0x08].ShouldDuplicate)
3819 Streams[0x14].ShouldDuplicate=true; //slice_layer_extension
3820 }
3821
3822 //Setting as OK
3823 if (!Status[IsAccepted])
3824 Accept("AVC");
3825 FILLING_END();
3826 }
3827
3828 //---------------------------------------------------------------------------
3829 // Packet "09"
access_unit_delimiter()3830 void File_Avc::access_unit_delimiter()
3831 {
3832 Element_Name("access_unit_delimiter");
3833
3834 int8u primary_pic_type;
3835 BS_Begin();
3836 Get_S1 ( 3, primary_pic_type, "primary_pic_type"); Param_Info1(Avc_primary_pic_type[primary_pic_type]);
3837 Mark_1_NoTrustError( ); //Found 1 file without this bit
3838 BS_End();
3839 }
3840
3841 //---------------------------------------------------------------------------
3842 // Packet "09"
filler_data()3843 void File_Avc::filler_data()
3844 {
3845 Element_Name("filler_data");
3846
3847 while (Element_Offset<Element_Size)
3848 {
3849 int8u FF;
3850 Peek_B1(FF);
3851 if (FF!=0xFF)
3852 break;
3853 Element_Offset++;
3854 }
3855 BS_Begin();
3856 Mark_1( );
3857 BS_End();
3858 }
3859
3860 //---------------------------------------------------------------------------
3861 // Packet "0E"
prefix_nal_unit(bool svc_extension_flag)3862 void File_Avc::prefix_nal_unit(bool svc_extension_flag)
3863 {
3864 Element_Name("prefix_nal_unit");
3865
3866 //Parsing
3867 if (svc_extension_flag)
3868 {
3869 Skip_XX(Element_Size-Element_Offset, "prefix_nal_unit_svc");
3870 }
3871 }
3872
3873 //---------------------------------------------------------------------------
3874 // Packet "0F"
subset_seq_parameter_set()3875 void File_Avc::subset_seq_parameter_set()
3876 {
3877 Element_Name("subset_seq_parameter_set");
3878
3879 //Parsing
3880 int32u subset_seq_parameter_set_id;
3881 seq_parameter_set_struct* Data_Item_New=seq_parameter_set_data(subset_seq_parameter_set_id);
3882 if (!Data_Item_New)
3883 return;
3884 if (Data_Item_New->profile_idc==83 || Data_Item_New->profile_idc==86)
3885 {
3886 //bool svc_vui_parameters_present_flag;
3887 seq_parameter_set_svc_extension();
3888 /* The rest is not yet implemented
3889 Get_SB (svc_vui_parameters_present_flag, "svc_vui_parameters_present_flag");
3890 if (svc_vui_parameters_present_flag)
3891 svc_vui_parameters_extension();
3892 */
3893 }
3894 else if (Data_Item_New->profile_idc==118 || Data_Item_New->profile_idc==128)
3895 {
3896 //bool mvc_vui_parameters_present_flag, additional_extension2_flag;
3897 Mark_1();
3898 seq_parameter_set_mvc_extension(Data_Item_New);
3899 /* The rest is not yet implemented
3900 Get_SB (mvc_vui_parameters_present_flag, "mvc_vui_parameters_present_flag");
3901 if (mvc_vui_parameters_present_flag)
3902 mvc_vui_parameters_extension();
3903 Get_SB (additional_extension2_flag, "additional_extension2_flag");
3904 if (additional_extension2_flag)
3905 {
3906 //Not handled, should skip all bits except 1
3907 BS_End();
3908 return;
3909 }
3910 */
3911 }
3912 /* The rest is not yet implemented
3913 Mark_1( );
3914 */
3915 BS_End();
3916
3917 FILLING_BEGIN();
3918 //NextCode
3919 NextCode_Clear();
3920 NextCode_Add(0x08);
3921
3922 //Add
3923 seq_parameter_set_data_Add(subset_seq_parameter_sets, subset_seq_parameter_set_id, Data_Item_New);
3924
3925 //Autorisation of other streams
3926 Streams[0x08].Searching_Payload=true; //pic_parameter_set
3927 if (Streams[0x0F].ShouldDuplicate)
3928 Streams[0x08].ShouldDuplicate=true; //pic_parameter_set
3929 Streams[0x0A].Searching_Payload=true; //end_of_seq
3930 if (Streams[0x0F].ShouldDuplicate)
3931 Streams[0x0A].ShouldDuplicate=true; //end_of_seq
3932 Streams[0x0B].Searching_Payload=true; //end_of_stream
3933 if (Streams[0x0F].ShouldDuplicate)
3934 Streams[0x0B].ShouldDuplicate=true; //end_of_stream
3935 FILLING_END();
3936 }
3937
3938 //---------------------------------------------------------------------------
3939 // Packet "14"
slice_layer_extension(bool svc_extension_flag)3940 void File_Avc::slice_layer_extension(bool svc_extension_flag)
3941 {
3942 Element_Name("slice_layer_extension");
3943
3944 //Parsing
3945 if (svc_extension_flag)
3946 {
3947 Skip_XX(Element_Size-Element_Offset, "slice_header_in_scalable_extension + slice_data_in_scalable_extension");
3948 }
3949 else
3950 {
3951 BS_Begin();
3952 slice_header();
3953 slice_data(true);
3954 BS_End();
3955 }
3956 }
3957
3958 //***************************************************************************
3959 // SubElements
3960 //***************************************************************************
3961
3962 //---------------------------------------------------------------------------
seq_parameter_set_data(int32u & Data_id)3963 File_Avc::seq_parameter_set_struct* File_Avc::seq_parameter_set_data(int32u &Data_id)
3964 {
3965 //Parsing
3966 seq_parameter_set_struct::vui_parameters_struct* vui_parameters_Item=NULL;
3967 int32u chroma_format_idc=1, bit_depth_luma_minus8=0, bit_depth_chroma_minus8=0, log2_max_frame_num_minus4, pic_order_cnt_type, log2_max_pic_order_cnt_lsb_minus4=(int32u)-1, max_num_ref_frames, pic_width_in_mbs_minus1, pic_height_in_map_units_minus1, frame_crop_left_offset=0, frame_crop_right_offset=0, frame_crop_top_offset=0, frame_crop_bottom_offset=0;
3968 int8u profile_idc, level_idc;
3969 bool constraint_set3_flag, separate_colour_plane_flag=false, delta_pic_order_always_zero_flag=false, frame_mbs_only_flag, mb_adaptive_frame_field_flag=false;
3970 Get_B1 (profile_idc, "profile_idc");
3971 BS_Begin();
3972 Element_Begin1("constraints");
3973 Skip_SB( "constraint_set0_flag");
3974 Skip_SB( "constraint_set1_flag");
3975 Skip_SB( "constraint_set2_flag");
3976 Get_SB (constraint_set3_flag, "constraint_set3_flag");
3977 Skip_SB( "constraint_set4_flag");
3978 Skip_SB( "constraint_set5_flag");
3979 Skip_BS(2, "reserved_zero_2bits");
3980 Element_End0();
3981 Get_S1 ( 8, level_idc, "level_idc");
3982 Get_UE ( Data_id, "seq_parameter_set_id");
3983 switch (profile_idc)
3984 {
3985 case 100 :
3986 case 110 :
3987 case 122 :
3988 case 244 :
3989 case 44 :
3990 case 83 :
3991 case 86 :
3992 case 118 :
3993 case 128 : //High profiles
3994 case 138 :
3995 Element_Begin1("high profile specific");
3996 Get_UE (chroma_format_idc, "chroma_format_idc"); Param_Info1C((chroma_format_idc<3), Avc_ChromaSubsampling_format_idc(chroma_format_idc));
3997 if (chroma_format_idc==3)
3998 Get_SB (separate_colour_plane_flag, "separate_colour_plane_flag");
3999 Get_UE (bit_depth_luma_minus8, "bit_depth_luma_minus8");
4000 Get_UE (bit_depth_chroma_minus8, "bit_depth_chroma_minus8");
4001 Skip_SB( "qpprime_y_zero_transform_bypass_flag");
4002 TEST_SB_SKIP( "seq_scaling_matrix_present_flag");
4003 for (int32u Pos=0; Pos<(int32u)((chroma_format_idc!=3) ? 8 : 12); Pos++)
4004 {
4005 TEST_SB_SKIP( "seq_scaling_list_present_flag");
4006 scaling_list(Pos<6?16:64);
4007 TEST_SB_END();
4008 }
4009 TEST_SB_END();
4010 Element_End0();
4011 break;
4012 default : ;
4013 }
4014 Get_UE (log2_max_frame_num_minus4, "log2_max_frame_num_minus4");
4015 Get_UE (pic_order_cnt_type, "pic_order_cnt_type");
4016 if (pic_order_cnt_type==0)
4017 Get_UE (log2_max_pic_order_cnt_lsb_minus4, "log2_max_pic_order_cnt_lsb_minus4");
4018 else if (pic_order_cnt_type==1)
4019 {
4020 int32u num_ref_frames_in_pic_order_cnt_cycle;
4021 Get_SB (delta_pic_order_always_zero_flag, "delta_pic_order_always_zero_flag");
4022 Skip_SE( "offset_for_non_ref_pic");
4023 Skip_SE( "offset_for_top_to_bottom_field");
4024 Get_UE (num_ref_frames_in_pic_order_cnt_cycle, "num_ref_frames_in_pic_order_cnt_cycle");
4025 if (num_ref_frames_in_pic_order_cnt_cycle>=256)
4026 {
4027 Trusted_IsNot("num_ref_frames_in_pic_order_cnt_cycle too high");
4028 return NULL;
4029 }
4030 for(int32u Pos=0; Pos<num_ref_frames_in_pic_order_cnt_cycle; Pos++)
4031 Skip_SE( "offset_for_ref_frame");
4032 }
4033 else if (pic_order_cnt_type > 2)
4034 {
4035 Trusted_IsNot("pic_order_cnt_type not supported");
4036 return NULL;
4037 }
4038 Get_UE (max_num_ref_frames, "max_num_ref_frames");
4039 Skip_SB( "gaps_in_frame_num_value_allowed_flag");
4040 Get_UE (pic_width_in_mbs_minus1, "pic_width_in_mbs_minus1");
4041 Get_UE (pic_height_in_map_units_minus1, "pic_height_in_map_units_minus1");
4042 Get_SB (frame_mbs_only_flag, "frame_mbs_only_flag");
4043 if (!frame_mbs_only_flag)
4044 Get_SB (mb_adaptive_frame_field_flag, "mb_adaptive_frame_field_flag");
4045 Skip_SB( "direct_8x8_inference_flag");
4046 TEST_SB_SKIP( "frame_cropping_flag");
4047 Get_UE (frame_crop_left_offset, "frame_crop_left_offset");
4048 Get_UE (frame_crop_right_offset, "frame_crop_right_offset");
4049 Get_UE (frame_crop_top_offset, "frame_crop_top_offset");
4050 Get_UE (frame_crop_bottom_offset, "frame_crop_bottom_offset");
4051 TEST_SB_END();
4052 TEST_SB_SKIP( "vui_parameters_present_flag");
4053 vui_parameters(vui_parameters_Item);
4054 TEST_SB_END();
4055
4056 FILLING_BEGIN();
4057 //Integrity
4058 if (Data_id>=32)
4059 {
4060 Trusted_IsNot("seq_parameter_set_id not valid");
4061 delete (seq_parameter_set_struct::vui_parameters_struct*)vui_parameters_Item;
4062 return NULL; //Problem, not valid
4063 }
4064 if (pic_order_cnt_type==0 && log2_max_pic_order_cnt_lsb_minus4>12)
4065 {
4066 Trusted_IsNot("log2_max_pic_order_cnt_lsb_minus4 not valid");
4067 delete (seq_parameter_set_struct::vui_parameters_struct*)vui_parameters_Item;
4068 return NULL; //Problem, not valid
4069 }
4070 if (log2_max_frame_num_minus4>12)
4071 {
4072 Trusted_IsNot("log2_max_frame_num_minus4 not valid");
4073 delete (seq_parameter_set_struct::vui_parameters_struct*)vui_parameters_Item;
4074 return NULL; //Problem, not valid
4075 }
4076
4077 //Creating Data
4078 return new seq_parameter_set_struct(
4079 vui_parameters_Item,
4080 pic_width_in_mbs_minus1,
4081 pic_height_in_map_units_minus1,
4082 frame_crop_left_offset,
4083 frame_crop_right_offset,
4084 frame_crop_top_offset,
4085 frame_crop_bottom_offset,
4086 (int8u)chroma_format_idc,
4087 profile_idc,
4088 level_idc,
4089 (int8u)bit_depth_luma_minus8,
4090 (int8u)bit_depth_chroma_minus8,
4091 (int8u)log2_max_frame_num_minus4,
4092 (int8u)pic_order_cnt_type,
4093 (int8u)log2_max_pic_order_cnt_lsb_minus4,
4094 (int8u)max_num_ref_frames,
4095 constraint_set3_flag,
4096 separate_colour_plane_flag,
4097 delta_pic_order_always_zero_flag,
4098 frame_mbs_only_flag,
4099 mb_adaptive_frame_field_flag
4100 );
4101 FILLING_ELSE();
4102 delete vui_parameters_Item; //vui_parameters_Item=NULL;
4103 return NULL;
4104 FILLING_END();
4105 }
4106
4107 //---------------------------------------------------------------------------
scaling_list(int32u ScalingList_Size)4108 void File_Avc::scaling_list(int32u ScalingList_Size)
4109 {
4110 //From http://mpeg4ip.cvs.sourceforge.net/mpeg4ip/mpeg4ip/util/h264/main.cpp?revision=1.17&view=markup
4111 int32u lastScale=8, nextScale=8;
4112 for (int32u Pos=0; Pos<ScalingList_Size; Pos++)
4113 {
4114 if (nextScale!=0)
4115 {
4116 int32s delta_scale;
4117 Get_SE (delta_scale, "scale_delta");
4118 nextScale=(lastScale+delta_scale+256)%256;
4119 }
4120 if (nextScale)
4121 lastScale=nextScale;
4122 }
4123 }
4124
4125 //---------------------------------------------------------------------------
vui_parameters(seq_parameter_set_struct::vui_parameters_struct * & vui_parameters_Item_)4126 void File_Avc::vui_parameters(seq_parameter_set_struct::vui_parameters_struct* &vui_parameters_Item_)
4127 {
4128 //Parsing
4129 seq_parameter_set_struct::vui_parameters_struct::xxl *NAL=NULL, *VCL=NULL;
4130 int32u num_units_in_tick=(int32u)-1, time_scale=(int32u)-1;
4131 int16u sar_width=(int16u)-1, sar_height=(int16u)-1;
4132 int8u aspect_ratio_idc=0, video_format=5, video_full_range_flag = 0, colour_primaries=2, transfer_characteristics=2, matrix_coefficients=2;
4133 bool aspect_ratio_info_present_flag, video_signal_type_present_flag, colour_description_present_flag=false, timing_info_present_flag, fixed_frame_rate_flag=false, nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag, pic_struct_present_flag;
4134 TEST_SB_GET (aspect_ratio_info_present_flag, "aspect_ratio_info_present_flag");
4135 Get_S1 (8, aspect_ratio_idc, "aspect_ratio_idc"); Param_Info1C((aspect_ratio_idc<Avc_PixelAspectRatio_Size), Avc_PixelAspectRatio[aspect_ratio_idc]);
4136 if (aspect_ratio_idc==0xFF)
4137 {
4138 Get_S2 (16, sar_width, "sar_width");
4139 Get_S2 (16, sar_height, "sar_height");
4140 }
4141 TEST_SB_END();
4142 TEST_SB_SKIP( "overscan_info_present_flag");
4143 Skip_SB( "overscan_appropriate_flag");
4144 TEST_SB_END();
4145 TEST_SB_GET (video_signal_type_present_flag, "video_signal_type_present_flag");
4146 Get_S1 (3, video_format, "video_format"); Param_Info1(Avc_video_format[video_format]);
4147 Get_S1 (1, video_full_range_flag, "video_full_range_flag"); Param_Info1(Avc_video_full_range[video_full_range_flag]);
4148 TEST_SB_GET (colour_description_present_flag, "colour_description_present_flag");
4149 Get_S1 (8, colour_primaries, "colour_primaries"); Param_Info1(Mpegv_colour_primaries(colour_primaries));
4150 Get_S1 (8, transfer_characteristics, "transfer_characteristics"); Param_Info1(Mpegv_transfer_characteristics(transfer_characteristics));
4151 Get_S1 (8, matrix_coefficients, "matrix_coefficients"); Param_Info1(Mpegv_matrix_coefficients(matrix_coefficients));
4152 TEST_SB_END();
4153 TEST_SB_END();
4154 TEST_SB_SKIP( "chroma_loc_info_present_flag");
4155 Skip_UE( "chroma_sample_loc_type_top_field");
4156 Skip_UE( "chroma_sample_loc_type_bottom_field");
4157 TEST_SB_END();
4158 TEST_SB_GET (timing_info_present_flag, "timing_info_present_flag");
4159 Get_S4 (32, num_units_in_tick, "num_units_in_tick");
4160 Get_S4 (32, time_scale, "time_scale");
4161 Get_SB ( fixed_frame_rate_flag, "fixed_frame_rate_flag");
4162 TEST_SB_END();
4163 TEST_SB_GET (nal_hrd_parameters_present_flag, "nal_hrd_parameters_present_flag");
4164 hrd_parameters(NAL);
4165 TEST_SB_END();
4166 TEST_SB_GET (vcl_hrd_parameters_present_flag, "vcl_hrd_parameters_present_flag");
4167 hrd_parameters(VCL);
4168 TEST_SB_END();
4169 if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
4170 Skip_SB( "low_delay_hrd_flag");
4171 Get_SB ( pic_struct_present_flag, "pic_struct_present_flag");
4172 TEST_SB_SKIP( "bitstream_restriction_flag");
4173 int32u max_num_reorder_frames;
4174 Skip_SB( "motion_vectors_over_pic_boundaries_flag");
4175 Skip_UE( "max_bytes_per_pic_denom");
4176 Skip_UE( "max_bits_per_mb_denom");
4177 Skip_UE( "log2_max_mv_length_horizontal");
4178 Skip_UE( "log2_max_mv_length_vertical");
4179 Get_UE (max_num_reorder_frames, "max_num_reorder_frames");
4180 Skip_UE( "max_dec_frame_buffering");
4181 TEST_SB_END();
4182
4183 FILLING_BEGIN();
4184 vui_parameters_Item_=new seq_parameter_set_struct::vui_parameters_struct(
4185 NAL,
4186 VCL,
4187 num_units_in_tick,
4188 time_scale,
4189 sar_width,
4190 sar_height,
4191 aspect_ratio_idc,
4192 video_format,
4193 video_full_range_flag,
4194 colour_primaries,
4195 transfer_characteristics,
4196 matrix_coefficients,
4197 aspect_ratio_info_present_flag,
4198 video_signal_type_present_flag,
4199 colour_description_present_flag,
4200 timing_info_present_flag,
4201 fixed_frame_rate_flag,
4202 pic_struct_present_flag
4203 );
4204 FILLING_ELSE();
4205 delete NAL; NAL=NULL;
4206 delete VCL; VCL=NULL;
4207 FILLING_END();
4208 }
4209
4210 //---------------------------------------------------------------------------
hrd_parameters(seq_parameter_set_struct::vui_parameters_struct::xxl * & hrd_parameters_Item_)4211 void File_Avc::hrd_parameters(seq_parameter_set_struct::vui_parameters_struct::xxl* &hrd_parameters_Item_)
4212 {
4213 //Parsing
4214 int32u cpb_cnt_minus1;
4215 int8u bit_rate_scale, cpb_size_scale, initial_cpb_removal_delay_length_minus1, cpb_removal_delay_length_minus1, dpb_output_delay_length_minus1, time_offset_length;
4216 Get_UE ( cpb_cnt_minus1, "cpb_cnt_minus1");
4217 Get_S1 (4, bit_rate_scale, "bit_rate_scale");
4218 Get_S1 (4, cpb_size_scale, "cpb_size_scale");
4219 if (cpb_cnt_minus1>31)
4220 {
4221 Trusted_IsNot("cpb_cnt_minus1 too high");
4222 cpb_cnt_minus1=0;
4223 }
4224 vector<seq_parameter_set_struct::vui_parameters_struct::xxl::xxl_data> SchedSel;
4225 SchedSel.reserve(cpb_cnt_minus1+1);
4226 for (int8u SchedSelIdx = 0; SchedSelIdx <= cpb_cnt_minus1; ++SchedSelIdx)
4227 {
4228 Element_Begin1("ShedSel");
4229 int64u bit_rate_value, cpb_size_value;
4230 int32u bit_rate_value_minus1, cpb_size_value_minus1;
4231 bool cbr_flag;
4232 Get_UE (bit_rate_value_minus1, "bit_rate_value_minus1");
4233 bit_rate_value=(int64u)((bit_rate_value_minus1+1)*pow(2.0, 6+bit_rate_scale)); Param_Info2(bit_rate_value, " bps");
4234 Get_UE (cpb_size_value_minus1, "cpb_size_value_minus1");
4235 cpb_size_value=(int64u)((cpb_size_value_minus1+1)*pow(2.0, 4+cpb_size_scale)); Param_Info2(cpb_size_value, " bits");
4236 Get_SB (cbr_flag, "cbr_flag");
4237 Element_End0();
4238
4239 FILLING_BEGIN();
4240 SchedSel.push_back(seq_parameter_set_struct::vui_parameters_struct::xxl::xxl_data(
4241 bit_rate_value,
4242 cpb_size_value,
4243 cbr_flag
4244 ));
4245 FILLING_END();
4246 }
4247 Get_S1 (5, initial_cpb_removal_delay_length_minus1, "initial_cpb_removal_delay_length_minus1");
4248 Get_S1 (5, cpb_removal_delay_length_minus1, "cpb_removal_delay_length_minus1");
4249 Get_S1 (5, dpb_output_delay_length_minus1, "dpb_output_delay_length_minus1");
4250 Get_S1 (5, time_offset_length, "time_offset_length");
4251
4252 //Validity test
4253 if (!Element_IsOK() || (SchedSel.size() == 1 && SchedSel[0].bit_rate_value == 64))
4254 {
4255 return; //We do not trust this kind of data
4256 }
4257
4258 //Filling
4259 hrd_parameters_Item_=new seq_parameter_set_struct::vui_parameters_struct::xxl(
4260 SchedSel,
4261 initial_cpb_removal_delay_length_minus1,
4262 cpb_removal_delay_length_minus1,
4263 dpb_output_delay_length_minus1,
4264 time_offset_length
4265 );
4266 }
4267
4268 //---------------------------------------------------------------------------
nal_unit_header_svc_extension()4269 void File_Avc::nal_unit_header_svc_extension()
4270 {
4271 //Parsing
4272 Element_Begin1("nal_unit_header_svc_extension");
4273 Skip_SB( "idr_flag");
4274 Skip_S1( 6, "priority_id");
4275 Skip_SB( "no_inter_layer_pred_flag");
4276 Skip_S1( 3, "dependency_id");
4277 Skip_S1( 4, "quality_id");
4278 Skip_S1( 3, "temporal_id");
4279 Skip_SB( "use_ref_base_pic_flag");
4280 Skip_SB( "discardable_flag");
4281 Skip_SB( "output_flag");
4282 Skip_S1( 2, "reserved_three_2bits");
4283 Element_End0();
4284 }
4285
4286 //---------------------------------------------------------------------------
nal_unit_header_mvc_extension()4287 void File_Avc::nal_unit_header_mvc_extension()
4288 {
4289 //Parsing
4290 Element_Begin1("nal_unit_header_mvc_extension");
4291 Skip_SB( "non_idr_flag");
4292 Skip_S1( 6, "priority_id");
4293 Skip_S1(10, "view_id");
4294 Skip_S1( 3, "temporal_id");
4295 Skip_SB( "anchor_pic_flag");
4296 Skip_SB( "inter_view_flag");
4297 Skip_SB( "reserved_one_bit");
4298 Element_End0();
4299 }
4300
4301 //---------------------------------------------------------------------------
seq_parameter_set_svc_extension()4302 void File_Avc::seq_parameter_set_svc_extension()
4303 {
4304 //Parsing
4305 Element_Begin1("seq_parameter_set_svc_extension");
4306 //Skip_SB( "");
4307 Element_End0();
4308 }
4309
4310 //---------------------------------------------------------------------------
svc_vui_parameters_extension()4311 void File_Avc::svc_vui_parameters_extension()
4312 {
4313 //Parsing
4314 Element_Begin1("svc_vui_parameters_extension");
4315 //Skip_SB( "");
4316 Element_End0();
4317 }
4318
4319 //---------------------------------------------------------------------------
seq_parameter_set_mvc_extension(seq_parameter_set_struct * Data_Item)4320 void File_Avc::seq_parameter_set_mvc_extension(seq_parameter_set_struct* Data_Item)
4321 {
4322 //Parsing
4323 Element_Begin1("seq_parameter_set_mvc_extension");
4324 int32u num_views_minus1;
4325 Get_UE (num_views_minus1, "num_views_minus1");
4326 //(Not implemented)
4327 Element_End0();
4328
4329 FILLING_BEGIN();
4330 Data_Item->num_views_minus1 = (int16u)num_views_minus1;
4331 FILLING_END();
4332 }
4333
4334 //---------------------------------------------------------------------------
mvc_vui_parameters_extension()4335 void File_Avc::mvc_vui_parameters_extension()
4336 {
4337 //Parsing
4338 Element_Begin1("mvc_vui_parameters_extension");
4339 Skip_SB( "");
4340 Element_End0();
4341 }
4342
4343 //***************************************************************************
4344 // Specific
4345 //***************************************************************************
4346
4347 //---------------------------------------------------------------------------
SPS_PPS()4348 void File_Avc::SPS_PPS()
4349 {
4350 //Parsing
4351 int8u Profile, Level, seq_parameter_set_count, pic_parameter_set_count;
4352 if (SizedBlocks)
4353 Skip_B1( "configurationVersion");
4354 Get_B1 (Profile, "AVCProfileIndication");
4355 Skip_B1( "profile_compatibility");
4356 Get_B1 (Level, "AVCLevelIndication");
4357 BS_Begin();
4358 Skip_S1(6, "reserved");
4359 Get_S1 (2, SizeOfNALU_Minus1, "lengthSizeMinusOne");
4360 Skip_S1(3, "reserved");
4361 Get_S1 (5, seq_parameter_set_count, "numOfSequenceParameterSets");
4362 BS_End();
4363 for (int8u Pos=0; Pos<seq_parameter_set_count; Pos++)
4364 {
4365 Element_Begin1("seq_parameter_set");
4366 int16u Size;
4367 Get_B2 (Size, "sequenceParameterSetLength");
4368 BS_Begin();
4369 Mark_0 ();
4370 Skip_S1( 2, "nal_ref_idc");
4371 Skip_S1( 5, "nal_unit_type");
4372 BS_End();
4373 if (Element_Offset+Size-1>Element_Size)
4374 {
4375 Trusted_IsNot("Size is wrong");
4376 break; //There is an error
4377 }
4378 int64u Element_Offset_Save=Element_Offset;
4379 int64u Element_Size_Save=Element_Size;
4380 Buffer_Offset+=(size_t)Element_Offset_Save;
4381 Element_Offset=0;
4382 Element_Size=Size-(Size?1:0);
4383 Element_Code=0x07; //seq_parameter_set
4384 Data_Parse();
4385 Buffer_Offset-=(size_t)Element_Offset_Save;
4386 Element_Offset=Element_Offset_Save+Size-1;
4387 Element_Size=Element_Size_Save;
4388 Element_End0();
4389 }
4390 Get_B1 (pic_parameter_set_count, "numOfPictureParameterSets");
4391 for (int8u Pos=0; Pos<pic_parameter_set_count; Pos++)
4392 {
4393 Element_Begin1("pic_parameter_set");
4394 int16u Size;
4395 Get_B2 (Size, "pictureParameterSetLength");
4396 BS_Begin();
4397 Mark_0 ();
4398 Skip_S1( 2, "nal_ref_idc");
4399 Skip_S1( 5, "nal_unit_type");
4400 BS_End();
4401 int64u Element_Offset_Save=Element_Offset;
4402 int64u Element_Size_Save=Element_Size;
4403 Buffer_Offset+=(size_t)Element_Offset_Save;
4404 Element_Offset=0;
4405 Element_Size=Size-1;
4406 if (Element_Size>Element_Size_Save-Element_Offset_Save)
4407 break; //There is an error
4408 Element_Code=0x08; //pic_parameter_set
4409 Data_Parse();
4410 Buffer_Offset-=(size_t)Element_Offset_Save;
4411 Element_Offset=Element_Offset_Save+Size-1;
4412 Element_Size=Element_Size_Save;
4413 Element_End0();
4414 }
4415 if (Element_Offset<Element_Size)
4416 {
4417 switch (Profile)
4418 {
4419 case 100:
4420 case 110:
4421 case 122:
4422 case 144:
4423 {
4424 int8u numOfSequenceParameterSetExt;
4425 BS_Begin();
4426 Skip_S1( 6, "reserved");
4427 Skip_S1( 2, "chroma_format");
4428 Skip_S1( 5, "reserved");
4429 Skip_S1( 3, "bit_depth_luma_minus8");
4430 Skip_S1( 5, "reserved");
4431 Skip_S1( 3, "bit_depth_chroma_minus8");
4432 BS_End();
4433 Get_B1 (numOfSequenceParameterSetExt, "numOfSequenceParameterSetExt");
4434 for (int8u Pos=0; Pos<numOfSequenceParameterSetExt; Pos++)
4435 {
4436 Element_Begin1("sequenceParameterSetExtNALUnit");
4437 int16u Size;
4438 Get_B2 (Size, "sequenceParameterSetExtLength");
4439 BS_Begin();
4440 Mark_0 ();
4441 Skip_S1( 2, "nal_ref_idc");
4442 Skip_S1( 5, "nal_unit_type");
4443 BS_End();
4444 int64u Element_Offset_Save=Element_Offset;
4445 int64u Element_Size_Save=Element_Size;
4446 Buffer_Offset+=(size_t)Element_Offset_Save;
4447 Element_Offset=0;
4448 Element_Size=Size-1;
4449 if (Element_Size>Element_Size_Save-Element_Offset_Save)
4450 break; //There is an error
4451 Element_Code=0x0F; //subset_seq_parameter_set
4452 Data_Parse();
4453 Buffer_Offset-=(size_t)Element_Offset_Save;
4454 Element_Offset=Element_Offset_Save+Size-1;
4455 Element_Size=Element_Size_Save;
4456 Element_End0();
4457 }
4458 }
4459 default:;
4460 }
4461 }
4462 if (Element_Offset<Element_Size)
4463 Skip_XX(Element_Size-Element_Offset, "Padding?");
4464
4465 //Filling
4466 FILLING_BEGIN_PRECISE();
4467 //Detection of some bugs in the file
4468 if (!seq_parameter_sets.empty() && seq_parameter_sets[0] && (Profile!=seq_parameter_sets[0]->profile_idc || Level!=seq_parameter_sets[0]->level_idc))
4469 MuxingMode=Ztring("Container profile=")+Ztring().From_UTF8(Avc_profile_idc(Profile))+__T("@")+Ztring().From_Number(((float)Level)/10, 1);
4470
4471 MustParse_SPS_PPS=false;
4472 if (!Status[IsAccepted])
4473 Accept("AVC");
4474 FILLING_END();
4475 }
4476
4477 //***************************************************************************
4478 // Helpers
4479 //***************************************************************************
4480
4481 //---------------------------------------------------------------------------
GOP_Detect(std::string PictureTypes)4482 std::string File_Avc::GOP_Detect (std::string PictureTypes)
4483 {
4484 //Finding a string without blanks
4485 size_t PictureTypes_Limit=PictureTypes.find(' ');
4486 if (PictureTypes_Limit!=string::npos)
4487 {
4488 if (PictureTypes_Limit>PictureTypes.size()/2)
4489 PictureTypes.resize(PictureTypes_Limit);
4490 else
4491 {
4492 //Trim
4493 size_t TrimPos;
4494 TrimPos=PictureTypes.find_first_not_of(' ');
4495 if (TrimPos!=string::npos)
4496 PictureTypes.erase(0, TrimPos);
4497 TrimPos=PictureTypes.find_last_not_of(' ');
4498 if (TrimPos!=string::npos)
4499 PictureTypes.erase(TrimPos+1);
4500
4501 //Finding the longest string
4502 ZtringList List; List.Separator_Set(0, __T(" "));
4503 List.Write(Ztring().From_UTF8(PictureTypes));
4504 size_t MaxLength=0;
4505 size_t MaxLength_Pos=0;
4506 for (size_t Pos=0; Pos<List.size(); Pos++)
4507 if (List[Pos].size()>MaxLength)
4508 {
4509 MaxLength=List[Pos].size();
4510 MaxLength_Pos=Pos;
4511 }
4512 PictureTypes=List[MaxLength_Pos].To_UTF8();
4513
4514 }
4515 }
4516
4517 //Creating all GOP values
4518 std::vector<Ztring> GOPs;
4519 size_t GOP_Frame_Count=0;
4520 size_t GOP_BFrames_Max=0;
4521 size_t I_Pos1=PictureTypes.find('I');
4522 while (I_Pos1!=std::string::npos)
4523 {
4524 size_t I_Pos2=PictureTypes.find('I', I_Pos1+1);
4525 if (I_Pos2!=std::string::npos)
4526 {
4527 std::vector<size_t> P_Positions;
4528 size_t P_Position=I_Pos1;
4529 do
4530 {
4531 P_Position=PictureTypes.find('P', P_Position+1);
4532 if (P_Position<I_Pos2)
4533 P_Positions.push_back(P_Position);
4534 }
4535 while (P_Position<I_Pos2);
4536 if (P_Positions.size()>1 && P_Positions[0]>I_Pos1+1 && P_Positions[P_Positions.size()-1]==I_Pos2-1)
4537 P_Positions.resize(P_Positions.size()-1); //Removing last P-Frame for next test, this is often a terminating P-Frame replacing a B-Frame
4538 Ztring GOP;
4539 bool IsOK=true;
4540 if (!P_Positions.empty())
4541 {
4542 size_t Delta=P_Positions[0]-I_Pos1;
4543 for (size_t Pos=1; Pos<P_Positions.size(); Pos++)
4544 if (P_Positions[Pos]-P_Positions[Pos-1]!=Delta)
4545 {
4546 IsOK=false;
4547 break;
4548 }
4549 if (IsOK)
4550 {
4551 GOP+=__T("M=")+Ztring::ToZtring(P_Positions[0]-I_Pos1)+__T(", ");
4552 if (P_Positions[0]-I_Pos1>GOP_BFrames_Max)
4553 GOP_BFrames_Max=P_Positions[0]-I_Pos1;
4554 }
4555 }
4556 if (IsOK)
4557 {
4558 GOP+=__T("N=")+Ztring::ToZtring(I_Pos2-I_Pos1);
4559 GOPs.push_back(GOP);
4560 }
4561 else
4562 GOPs.push_back(Ztring()); //There is a problem, blank
4563 GOP_Frame_Count+=I_Pos2-I_Pos1;
4564 }
4565 I_Pos1=I_Pos2;
4566 }
4567
4568 //Some clean up
4569 if (GOP_Frame_Count+GOP_BFrames_Max>Frame_Count && !GOPs.empty())
4570 GOPs.resize(GOPs.size()-1); //Removing the last one, there may have uncomplete B-frame filling
4571 if (GOPs.size()>4)
4572 GOPs.erase(GOPs.begin()); //Removing the first one, it is sometime different and we have enough to deal with
4573
4574 //Filling
4575 if (GOPs.size()>=4)
4576 {
4577 bool IsOK=true;
4578 for (size_t Pos=1; Pos<GOPs.size(); Pos++)
4579 if (GOPs[Pos]!=GOPs[0])
4580 {
4581 IsOK=false;
4582 break;
4583 }
4584 if (IsOK)
4585 return GOPs[0].To_UTF8();
4586 }
4587
4588 return string();
4589 }
4590
4591 //---------------------------------------------------------------------------
ScanOrder_Detect(std::string ScanOrders)4592 std::string File_Avc::ScanOrder_Detect (std::string ScanOrders)
4593 {
4594 //Finding a string without blanks
4595 size_t ScanOrders_Limit=ScanOrders.find(' ');
4596 if (ScanOrders_Limit!=string::npos)
4597 {
4598 if (ScanOrders_Limit>ScanOrders.size()/2)
4599 ScanOrders.resize(ScanOrders_Limit);
4600 else
4601 {
4602 //Trim
4603 size_t TrimPos;
4604 TrimPos=ScanOrders.find_first_not_of(' ');
4605 if (TrimPos!=string::npos)
4606 ScanOrders.erase(0, TrimPos);
4607 TrimPos=ScanOrders.find_last_not_of(' ');
4608 if (TrimPos!=string::npos)
4609 ScanOrders.erase(TrimPos+1);
4610
4611 //Finding the longest string
4612 ZtringList List; List.Separator_Set(0, __T(" "));
4613 List.Write(Ztring().From_UTF8(ScanOrders));
4614 size_t MaxLength=0;
4615 size_t MaxLength_Pos=0;
4616 for (size_t Pos=0; Pos<List.size(); Pos++)
4617 if (List[Pos].size()>MaxLength)
4618 {
4619 MaxLength=List[Pos].size();
4620 MaxLength_Pos=Pos;
4621 }
4622 ScanOrders=List[MaxLength_Pos].To_UTF8();
4623
4624 }
4625 }
4626
4627 //Filling
4628 if (ScanOrders.find("TBTBTBTB")==0)
4629 return ("TFF");
4630 if (ScanOrders.find("BTBTBTBT")==0)
4631 return ("BFF");
4632 return string();
4633 }
4634
4635 } //NameSpace
4636
4637 #endif //MEDIAINFO_AVC_YES
4638