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