1 /* Copyright (c) MediaArea.net SARL. All Rights Reserved.
2 *
3 * Use of this source code is governed by a BSD-style license that can
4 * be found in the License.html file in the root of the source tree.
5 */
6
7 //---------------------------------------------------------------------------
8 // Pre-compilation
9 #include "MediaInfo/PreComp.h"
10 #ifdef __BORLANDC__
11 #pragma hdrstop
12 #endif
13 //---------------------------------------------------------------------------
14
15 //---------------------------------------------------------------------------
16 #include "MediaInfo/Setup.h"
17 //---------------------------------------------------------------------------
18
19 //---------------------------------------------------------------------------
20 #if defined(MEDIAINFO_AAC_YES)
21 //---------------------------------------------------------------------------
22
23 //---------------------------------------------------------------------------
24 #include "MediaInfo/Audio/File_Aac.h"
25 #include "MediaInfo/Audio/File_Aac_GeneralAudio.h"
26 using namespace std;
27 //---------------------------------------------------------------------------
28
29 namespace MediaInfoLib
30 {
31
32 //***************************************************************************
33 // Infos
34 //***************************************************************************
35
36 //---------------------------------------------------------------------------
37 extern const int32u Aac_sampling_frequency[];
38 extern const char* Aac_audioObjectType(int8u audioObjectType);
39 extern const char* Aac_Format_Profile(int8u ID);
40
41 //---------------------------------------------------------------------------
42 static const char* Aac_id_syn_ele[8]=
43 {
44 "SCE - single_channel_element",
45 "CPE - channel_pair_element",
46 "CCE - coupling_channel_element",
47 "LFE - lfe_channel_element",
48 "DSE - data_stream_element",
49 "PCE - program_config_element",
50 "FIL - fill_element",
51 "END - End"
52 };
53
54 //---------------------------------------------------------------------------
55 static const char* Aac_window_sequence[4]=
56 {
57 "ONLY_LONG_SEQUENCE",
58 "LONG_START_SEQUENCE",
59 "EIGHT_SHORT_SEQUENCE",
60 "LONG_STOP_SEQUENCE"
61 };
62
63 //***************************************************************************
64 // Elements - Decoder configuration
65 //***************************************************************************
66
67 //---------------------------------------------------------------------------
GASpecificConfig()68 void File_Aac::GASpecificConfig ()
69 {
70 //Parsing
71 Element_Begin1("GASpecificConfig");
72 bool frameLengthFlag, dependsOnCoreCoder, extensionFlag;
73 Get_SB ( frameLengthFlag, "frameLengthFlag");
74 frame_length=frameLengthFlag==0?1024:960; Param_Info2(frame_length, " bytes");
75 Get_SB ( dependsOnCoreCoder, "dependsOnCoreCoder");
76 if (dependsOnCoreCoder)
77 Skip_S2(14, "coreCoderDelay");
78 Get_SB ( extensionFlag, "extensionFlag");
79 if (channelConfiguration==0)
80 program_config_element();
81 if (audioObjectType==06 || audioObjectType==20)
82 Skip_S1(3, "layerNr");
83 if (extensionFlag)
84 {
85 bool extensionFlag3;
86 if (audioObjectType==22)
87 {
88 Skip_S1( 5, "numOfSubFrame");
89 Skip_S2(11, "layer_length");
90 }
91 if (audioObjectType==17
92 || audioObjectType==19
93 || audioObjectType==20
94 || audioObjectType==23)
95 {
96 Skip_SB( "aacSectionDataResilienceFlag");
97 Skip_SB( "aacScalefactorDataResilienceFlag");
98 Skip_SB( "aacSpectralDataResilienceFlag");
99 }
100 Get_SB ( extensionFlag3, "extensionFlag3");
101 if (extensionFlag3)
102 {
103 Skip_BS(Data_BS_Remain(), "Not implemented");
104 }
105 }
106 Element_End0();
107 }
108
109 //---------------------------------------------------------------------------
program_config_element()110 void File_Aac::program_config_element()
111 {
112 Element_Begin1("program_config_element");
113 Ztring comment_field_data;
114 int8u Channels=0, Channels_Front=0, Channels_Side=0, Channels_Back=0, Channels_LFE=0;
115 int8u num_front_channel_elements, num_side_channel_elements, num_back_channel_elements, num_lfe_channel_elements, num_assoc_data_elements, num_valid_cc_elements, comment_field_bytes;
116 int8u audioObjectType_Temp, sampling_frequency_index_Temp;
117 Skip_S1(4, "element_instance_tag");
118 Get_S1 (2, audioObjectType_Temp, "object_type"); audioObjectType_Temp++; Param_Info1(Aac_audioObjectType(audioObjectType_Temp));
119 Get_S1 (4, sampling_frequency_index_Temp, "sampling_frequency_index"); Param_Info1(Aac_sampling_frequency[sampling_frequency_index_Temp]);
120 Get_S1 (4, num_front_channel_elements, "num_front_channel_elements");
121 Get_S1 (4, num_side_channel_elements, "num_side_channel_elements");
122 Get_S1 (4, num_back_channel_elements, "num_back_channel_elements");
123 Get_S1 (2, num_lfe_channel_elements, "num_lfe_channel_elements");
124 Get_S1 (3, num_assoc_data_elements, "num_assoc_data_elements");
125 Get_S1 (4, num_valid_cc_elements, "num_valid_cc_elements");
126 TEST_SB_SKIP( "mono_mixdown_present");
127 Skip_S1(4, "mono_mixdown_element_number");
128 TEST_SB_END();
129 TEST_SB_SKIP( "stereo_mixdown_present");
130 Skip_S1(4, "stereo_mixdown_element_number");
131 TEST_SB_END();
132 TEST_SB_SKIP( "matrix_mixdown_idx_present");
133 Skip_S1(2, "matrix_mixdown_idx");
134 Skip_SB( "pseudo_surround_enable");
135 TEST_SB_END();
136 bool front1_element_is_cpe=false;
137 if (!num_side_channel_elements && num_back_channel_elements && num_back_channel_elements<3) // Hack: e.g. in case of 5.1, 7.1
138 {
139 num_side_channel_elements=1;
140 num_back_channel_elements--;
141 }
142 for (int8u Pos=0; Pos<num_front_channel_elements; Pos++)
143 {
144 Element_Begin1("front_element");
145 bool front_element_is_cpe;
146 Get_SB ( front_element_is_cpe, "front_element_is_cpe");
147 Skip_S1(4, "front_element_tag_select");
148 if (front_element_is_cpe)
149 {
150 Channels_Front+=2;
151 Channels+=2;
152 if (Pos==0)
153 front1_element_is_cpe=true;
154 }
155 else
156 {
157 Channels_Front++;
158 Channels++;
159 }
160 Element_End0();
161 }
162 for (int8u Pos=0; Pos<num_side_channel_elements; Pos++)
163 {
164 Element_Begin1("side_element");
165 bool side_element_is_cpe;
166 Get_SB ( side_element_is_cpe, "side_element_is_cpe");
167 Skip_S1(4, "side_element_tag_select");
168 if (side_element_is_cpe)
169 {
170 Channels_Side+=2;
171 Channels+=2;
172 }
173 else
174 {
175 Channels_Side++;
176 Channels++;
177 }
178 Element_End0();
179 }
180 for (int8u Pos=0; Pos<num_back_channel_elements; Pos++)
181 {
182 Element_Begin1("back_element");
183 bool back_element_is_cpe;
184 Get_SB ( back_element_is_cpe, "back_element_is_cpe");
185 Skip_S1(4, "back_element_tag_select");
186 if (back_element_is_cpe)
187 {
188 Channels_Back+=2;
189 Channels+=2;
190 }
191 else
192 {
193 Channels_Back++;
194 Channels++;
195 }
196 Element_End0();
197 }
198 for (int8u Pos=0; Pos<num_lfe_channel_elements; Pos++)
199 {
200 Element_Begin1("lfe_element");
201 Skip_S1(4, "lfe_element_tag_select");
202 Channels_LFE++;
203 Channels++;
204 Element_End0();
205 }
206 for (int8u Pos=0; Pos<num_assoc_data_elements; Pos++)
207 {
208 Element_Begin1("assoc_data_element");
209 Skip_S1(4, "assoc_data_element_tag_select");
210 Element_End0();
211 }
212 for (int8u Pos=0; Pos<num_valid_cc_elements; Pos++)
213 {
214 Element_Begin1("valid_cc_element");
215 Skip_SB( "cc_element_is_ind_sw");
216 Skip_S1(4, "valid_cc_element_tag_select");
217 Element_End0();
218 }
219 BS_End(); //Byte align
220 Get_B1 (comment_field_bytes, "comment_field_bytes");
221 if (comment_field_bytes)
222 Get_UTF8(comment_field_bytes, comment_field_data, "comment_field_data");
223 BS_Begin(); //The stream needs continuity in the bitstream
224 Element_End0();
225
226 //Filling
227 Ztring Channels_Positions, Channels_Positions2, ChannelLayout;
228 switch (Channels_Front)
229 {
230 case 0 : break;
231 case 1 : Channels_Positions+=__T("Front: C"); ChannelLayout+=__T("C "); break;
232 case 2 : Channels_Positions+=__T("Front: L R"); ChannelLayout+=__T("L R "); break;
233 case 3 : Channels_Positions+=__T("Front: L C R"); ChannelLayout+=num_front_channel_elements==2?(front1_element_is_cpe?__T("L R C "):__T("C L R ")):__T("? ? ? "); break;
234 case 5 : Channels_Positions+=__T("Front: L C R Lw Rw"); ChannelLayout+=num_front_channel_elements==3?(front1_element_is_cpe?__T("L R C Lw Rw "):__T("C L R Lw Rw ")):__T("? ? ? ? ? "); break;
235 default : Channels_Positions+=__T("Front:"); Channels_Positions+=Ztring::ToZtring(Channels_Side); for (size_t i=0; i<Channels_Front; i++) ChannelLayout+=__T("? "); //Which config?
236 }
237 switch (Channels_Side)
238 {
239 case 0 : break;
240 case 1 : Channels_Positions+=__T(", Side: C"); ChannelLayout+=__T("Cs "); break;
241 case 2 : Channels_Positions+=__T(", Side: L R"); ChannelLayout+=__T("Ls Rs "); break;
242 case 3 : Channels_Positions+=__T(", Side: L C R"); ChannelLayout+=__T("? ? ? "); break;
243 default : Channels_Positions+=__T(", Side: "); Channels_Positions+=Ztring::ToZtring(Channels_Side); for (size_t i=0; i< Channels_Side; i++) ChannelLayout+=__T("? "); //Which config?
244 }
245 switch (Channels_Back)
246 {
247 case 0 : break;
248 case 1 : Channels_Positions+=__T(", Back: C"); ChannelLayout+=__T("Cs "); break;
249 case 2 : Channels_Positions+=__T(", Back: L R"); ChannelLayout+=__T("Lrs Rrs "); break;
250 case 3 : Channels_Positions+=__T(", Back: L C R"); ChannelLayout+=__T("Lrs Rrs Cs "); break;
251 default : Channels_Positions+=__T(", Back: "); Channels_Positions+=Ztring::ToZtring(Channels_Back); for (size_t i=0; i< Channels_Back; i++) ChannelLayout+=__T("? "); //Which config?
252 }
253 switch (Channels_LFE)
254 {
255 case 0 : break;
256 case 1 : Channels_Positions+=__T(", LFE"); ChannelLayout+=__T("LFE "); break;
257 case 2 : Channels_Positions+=__T(", LFE LFE2"); ChannelLayout+=__T("LFE LFE2"); break;
258 default : Channels_Positions+=__T(", LFE: "); Channels_Positions+=Ztring::ToZtring(Channels_LFE); ChannelLayout+=__T("LFE "); for (size_t i=1; i<Channels_LFE; i++) ChannelLayout+=__T("? "); //Which config?
259 }
260 Channels_Positions2=Ztring::ToZtring(Channels_Front)+__T('/')
261 +Ztring::ToZtring(Channels_Side)+__T('/')
262 +Ztring::ToZtring(Channels_Back)
263 +(Channels_LFE?__T(".1"):__T(""));
264 if (!ChannelLayout.empty())
265 ChannelLayout.resize(ChannelLayout.size()-1);
266
267 FILLING_BEGIN();
268 //Integrity test
269 if (Aac_sampling_frequency[sampling_frequency_index_Temp]==0 || Channels>24) // TODO: full_2023548870.mp4 is buggy
270 {
271 Trusted_IsNot("sampling frequency / channels");
272 Skip_BS(Data_BS_Remain(), "(Unknown frequency)");
273 return;
274 }
275
276 if (audioObjectType==(int8u)-1)
277 audioObjectType=audioObjectType_Temp;
278 if (sampling_frequency_index==(int8u)-1)
279 sampling_frequency_index=sampling_frequency_index_Temp;
280
281 Infos_General["Comment"]=comment_field_data;
282
283 Infos["CodecID"].From_Number(audioObjectType);
284 Infos["Format"].From_UTF8("AAC");
285 Infos["Format_Profile"].From_UTF8(Aac_Format_Profile(audioObjectType));
286 Infos["Codec"].From_UTF8(Aac_audioObjectType(audioObjectType));
287 Infos["SamplingRate"].From_Number(Aac_sampling_frequency[sampling_frequency_index]);
288 Infos["Channel(s)"].From_Number(Channels);
289 Infos["ChannelPositions"]=Channels_Positions;
290 Infos["ChannelPositions/String2"]=Channels_Positions2;
291 Infos["ChannelLayout"]=ChannelLayout;
292
293 if (!Infos["Format_Settings_SBR"].empty())
294 {
295 const Ztring SamplingRate=Infos["SamplingRate"];
296 Infos["Format_Profile"]=__T("HE-AAC");
297 Infos["SamplingRate"].From_Number((extension_sampling_frequency_index==(int8u)-1)?(Frequency_b*2):extension_sampling_frequency, 10);
298 if (MediaInfoLib::Config.LegacyStreamDisplay_Get())
299 {
300 Infos["Format_Profile"]+=__T(" / LC");
301 Infos["SamplingRate"]+=__T(" / ")+SamplingRate;
302 }
303 Infos["Format_Settings"]=__T("NBC"); // "Not Backward Compatible"
304 Infos["Format_Settings_SBR"]=__T("Yes (NBC)"); // "Not Backward Compatible"
305 Infos["Codec"]=Ztring().From_UTF8(Aac_audioObjectType(audioObjectType))+__T("-SBR");
306 }
307
308 if (!Infos["Format_Settings_PS"].empty())
309 FillInfosHEAACv2(__T("NBC"));
310 FILLING_END();
311 }
312
313 //***************************************************************************
314 // Elements - GA bitstream
315 //***************************************************************************
316
317 //---------------------------------------------------------------------------
raw_data_block()318 void File_Aac::raw_data_block()
319 {
320 raw_data_block_Pos=0;
321
322 if (audioObjectType!=2)
323 {
324 Skip_BS(Data_BS_Remain(), "Data");
325 Frame_Count++;
326 return; //We test only AAC LC
327 }
328
329 if (sampling_frequency_index>=13)
330 {
331 Trusted_IsNot("(Problem)");
332 Skip_BS(Data_BS_Remain(), "(Problem)");
333 return;
334 }
335
336 //Parsing
337 Element_Begin1("raw_data_block");
338 int8u id_syn_ele=0, id_syn_ele_Previous;
339 do
340 {
341 Element_Begin0();
342 id_syn_ele_Previous=id_syn_ele;
343 Get_S1 (3, id_syn_ele, "id_syn_ele"); Param_Info1(Aac_id_syn_ele[id_syn_ele]); Element_Name(Aac_id_syn_ele[id_syn_ele]);
344
345 #if MEDIAINFO_TRACE
346 bool Trace_Activated_Save=Trace_Activated;
347 if (id_syn_ele!=0x05)
348 Trace_Activated=false; //It is too big, disabling trace for now for full AAC parsing
349 #endif //MEDIAINFO_TRACE
350
351 switch (id_syn_ele)
352 {
353 case 0x00 : single_channel_element(); break; //ID_SCE
354 case 0x01 : channel_pair_element(); break; //ID_CPE
355 case 0x02 : coupling_channel_element(); break; //ID_CCE
356 case 0x03 : lfe_channel_element(); break; //ID_LFE
357 case 0x04 : data_stream_element(); break; //ID_DSE
358 case 0x05 : program_config_element(); break; //ID_PCE
359 case 0x06 : fill_element(id_syn_ele_Previous); break; //ID_FIL
360 case 0x07 : break; //ID_END
361 default : ; //Can not happen
362 }
363 if (id_syn_ele<4) // All "content" element
364 raw_data_block_Pos++;
365
366 #if MEDIAINFO_TRACE
367 Trace_Activated=Trace_Activated_Save;
368 #endif //MEDIAINFO_TRACE
369
370 Element_End0();
371 }
372 while(Element_IsOK() && Data_BS_Remain() && id_syn_ele!=0x07); //ID_END
373 if (Element_IsOK() && id_syn_ele!=0x07)
374 Trusted_IsNot("Not ending by END element");
375 if (Element_IsOK() && Data_BS_Remain()%8)
376 Skip_S1(Data_BS_Remain()%8, "byte_alignment");
377 Element_End0();
378 }
379
380 //---------------------------------------------------------------------------
single_channel_element()381 void File_Aac::single_channel_element()
382 {
383 //Parsing
384 Skip_S1 (4, "element_instance_tag");
385 individual_channel_stream(false, false);
386 }
387
388 //---------------------------------------------------------------------------
channel_pair_element()389 void File_Aac::channel_pair_element()
390 {
391 //Parsing
392 Skip_S1(4, "element_instance_tag");
393 Get_SB (common_window, "common_window");
394 if (common_window)
395 {
396 int8u ms_mask_present;
397 ics_info();
398 Get_S1(2, ms_mask_present, "ms_mask_present");
399 if (ms_mask_present==1)
400 {
401 Element_Begin1("ms_mask");
402 for (int8u g=0; g<num_window_groups; g++)
403 {
404 Element_Begin1("window");
405 for (int8u sfb=0; sfb<max_sfb; sfb++)
406 Skip_SB( "ms_used[g][sfb]");
407 Element_End0();
408 }
409 Element_End0();
410 }
411 }
412 individual_channel_stream(common_window, false);
413 if (!Element_IsOK())
414 {
415 Skip_BS(Data_BS_Remain(), "(Problem)");
416 return;
417 }
418 individual_channel_stream(common_window, false);
419 }
420
421 //---------------------------------------------------------------------------
ics_info()422 void File_Aac::ics_info()
423 {
424 //Parsing
425 Element_Begin1("ics_info");
426 Skip_SB( "ics_reserved_bit");
427 Get_S1 (2, window_sequence, "window_sequence"); Param_Info1(Aac_window_sequence[window_sequence]);
428 Skip_SB( "window_shape");
429 if (window_sequence==2) //EIGHT_SHORT_SEQUENCE
430 {
431 Get_S1 (4, max_sfb, "max_sfb");
432 Get_S1 (7, scale_factor_grouping, "scale_factor_grouping");
433 }
434 else
435 {
436 bool predictor_data_present;
437 Get_S1 (6, max_sfb, "max_sfb");
438 Get_SB ( predictor_data_present, "predictor_data_present");
439 if (predictor_data_present)
440 {
441 if (audioObjectType==1) //AAC Main
442 {
443 bool predictor_reset;
444 Get_SB (predictor_reset, "predictor_reset");
445 if (predictor_reset)
446 Skip_S1(5, "predictor_reset_group_number");
447 int8u PRED_SFB_MAX=max_sfb;
448 if (PRED_SFB_MAX>Aac_PRED_SFB_MAX[sampling_frequency_index])
449 PRED_SFB_MAX=Aac_PRED_SFB_MAX[sampling_frequency_index];
450 for (int8u sfb=0; sfb<PRED_SFB_MAX; sfb++)
451 Skip_SB( "prediction_used[sfb]");
452 }
453 else
454 {
455 bool ltp_data_present;
456 Get_SB (ltp_data_present, "ltp_data_present");
457 if (ltp_data_present)
458 ltp_data();
459 if (common_window)
460 {
461 Get_SB (ltp_data_present, "ltp_data_present");
462 if (ltp_data_present)
463 ltp_data();
464 }
465 }
466 }
467 }
468 Element_End0();
469
470 //Calculation of windows
471 switch (window_sequence)
472 {
473 case 0 : //ONLY_LONG_SEQUENCE
474 case 1 : //LONG_START_SEQUENCE
475 case 3 : //LONG_STOP_SEQUENCE
476 num_windows=1;
477 num_window_groups=1;
478 window_group_length[0]=1;
479 num_swb=Aac_swb_offset_long_window[sampling_frequency_index]->num_swb;
480 for (int8u i=0; i<num_swb+1; i++)
481 {
482 if (Aac_swb_offset_long_window[sampling_frequency_index]->swb_offset[i]<frame_length)
483 swb_offset[i]=Aac_swb_offset_long_window[sampling_frequency_index]->swb_offset[i];
484 else
485 swb_offset[i]=frame_length;
486 sect_sfb_offset[0][i]=swb_offset[i];
487 }
488 break;
489 case 2 : //EIGHT_SHORT_SEQUENCE
490 num_windows=8;
491 num_window_groups=1;
492 window_group_length[0]=1;
493 num_swb=Aac_swb_offset_short_window[sampling_frequency_index]->num_swb;
494 for (int8u i=0; i<num_swb + 1; i++)
495 swb_offset[i] = Aac_swb_offset_short_window[sampling_frequency_index]->swb_offset[i];
496 swb_offset[num_swb] = frame_length/8;
497 for (int8u i=0; i<num_windows-1; i++)
498 {
499 if (!(scale_factor_grouping&(1<<(6-i))))
500 {
501 num_window_groups++;
502 window_group_length[num_window_groups-1]=1;
503 }
504 else
505 window_group_length[num_window_groups-1]++;
506 }
507 for (int g = 0; g < num_window_groups; g++)
508 {
509 int8u sect_sfb = 0;
510 int16u offset = 0;
511 for (int8u i=0; i<num_swb; i++)
512 {
513 int16u width = Aac_swb_offset_short_window[sampling_frequency_index]->swb_offset[i+1] - Aac_swb_offset_short_window[sampling_frequency_index]->swb_offset[i];
514 width *= window_group_length[g];
515 sect_sfb_offset[g][sect_sfb++] = offset;
516 offset += width;
517 }
518 sect_sfb_offset[g][sect_sfb] = offset;
519 }
520 break;
521 default: ;
522 }
523 }
524
525 //---------------------------------------------------------------------------
pulse_data()526 void File_Aac::pulse_data()
527 {
528 //Parsing
529 int8u number_pulse;
530 Get_S1(2,number_pulse, "number_pulse");
531 Skip_S1(6, "pulse_start_sfb");
532 for (int i = 0; i < number_pulse+1; i++)
533 {
534 Skip_S1(5, "pulse_offset[i]");
535 Skip_S1(4, "pulse_amp[i]");
536 }
537 }
538
539 //---------------------------------------------------------------------------
coupling_channel_element()540 void File_Aac::coupling_channel_element()
541 {
542 //Parsing
543 int8u num_coupled_elements;
544 bool ind_sw_cce_flag;
545 Skip_S1(4, "element_instance_tag");
546 Get_SB ( ind_sw_cce_flag, "ind_sw_cce_flag");
547 Get_S1 (3, num_coupled_elements, "num_coupled_elements");
548 size_t num_gain_element_lists=0;
549 for (int8u c=0; c<num_coupled_elements+1; c++)
550 {
551 num_gain_element_lists++;
552 bool cc_target_is_cpe;
553 Get_SB ( cc_target_is_cpe, "cc_target_is_cpe[c]");
554 Skip_S1(4, "cc_target_tag_select[c]");
555 if (cc_target_is_cpe)
556 {
557 bool cc_l, cc_r;
558 Get_SB (cc_l, "cc_l[c]");
559 Get_SB (cc_r, "cc_r[c]");
560 if (cc_l && cc_r)
561 num_gain_element_lists++;
562 }
563 }
564 Skip_SB( "cc_domain");
565 Skip_SB( "gain_element_sign");
566 Skip_S1(2, "gain_element_scale");
567 individual_channel_stream(false, false);
568 if (!Element_IsOK())
569 {
570 Skip_BS(Data_BS_Remain(), "(Problem)");
571 return;
572 }
573 bool cge;
574 for (size_t c=1; c<num_gain_element_lists; c++)
575 {
576 if (ind_sw_cce_flag)
577 cge = true;
578 else
579 Get_SB (cge, "common_gain_element_present[c]");
580 if (cge)
581 hcod_sf( "hcod_sf[common_gain_element[c]]");
582 else
583 {
584 for (int g = 0; g < num_window_groups; g++)
585 {
586 for (int sfb=0; sfb<max_sfb; sfb++)
587 {
588 if (sfb_cb[g][sfb]) //Not ZERO_HCB
589 hcod_sf( "hcod_sf[dpcm_gain_element[c][g][sfb]]");
590 }
591 }
592 }
593 }
594 }
595
596 //---------------------------------------------------------------------------
lfe_channel_element()597 void File_Aac::lfe_channel_element()
598 {
599 Skip_S1(4, "element_instance_tag");
600 individual_channel_stream(false, false);
601 }
602
603 //---------------------------------------------------------------------------
data_stream_element()604 void File_Aac::data_stream_element()
605 {
606 bool data_byte_align_flag;
607 int16u cnt;
608 int8u count;
609 Skip_S1(4, "element_instance_tag");
610 Get_SB ( data_byte_align_flag, "data_byte_align_flag");
611 Get_S1 (8, count, "count");
612 cnt=count;
613 if (cnt==255)
614 {
615 Get_S1(8, count, "esc_count");
616 cnt+=count;
617 }
618 if (data_byte_align_flag)
619 {
620 if (Data_BS_Remain()%8)
621 Skip_S1(Data_BS_Remain()%8, "byte_alignment");
622 }
623 Element_Begin1("data_stream_byte[element_instance_tag]");
624 for (int16u i=0; i<cnt; i++)
625 Skip_S1(8, "[i]");
626 Element_End0();
627 }
628
629 //---------------------------------------------------------------------------
fill_element(int8u id_syn_ele)630 void File_Aac::fill_element(int8u id_syn_ele)
631 {
632 //Parsing
633 int8u count;
634 Get_S1 (4, count, "count");
635 size_t cnt=count;
636 if (count==15)
637 {
638 int8u esc_count;
639 Get_S1 (8, esc_count, "esc_count");
640 cnt+=esc_count-1;
641 }
642 if (cnt)
643 {
644 if (Data_BS_Remain()>=8*cnt)
645 {
646 size_t End=Data_BS_Remain()-8*cnt;
647 extension_payload(End, id_syn_ele);
648 }
649 else
650 Skip_BS(Data_BS_Remain(), "(Error)");
651 }
652 }
653
654 //---------------------------------------------------------------------------
gain_control_data()655 void File_Aac::gain_control_data()
656 {
657 int8u max_band, adjust_num, aloc_bits, aloc_bits0;
658 int8u wd_max=0;
659 switch(window_sequence)
660 {
661 case 0 : //ONLY_LONG_SEQUENCE
662 wd_max = 1;
663 aloc_bits0 = 5;
664 aloc_bits = 5;
665 break;
666 case 1 : //LONG_START_SEQUENCE
667 wd_max = 2;
668 aloc_bits0 = 4;
669 aloc_bits = 2;
670 break;
671 case 2 : //EIGHT_SHORT_SEQUENCE
672 wd_max = 8;
673 aloc_bits0 = 2;
674 aloc_bits = 2;
675 break;
676 case 3 : //LONG_STOP_SEQUENCE
677 wd_max = 2;
678 aloc_bits0 = 4;
679 aloc_bits = 5;
680 break;
681 default: return; //Never happens but makes compiler happy
682 }
683 Get_S1 (2, max_band, "max_band");
684 for (int8u bd=1; bd<=max_band; bd++)
685 {
686 for (int8u wd=0; wd<wd_max; wd++)
687 {
688 Get_S1(3, adjust_num, "adjust_num[bd][wd]");
689 for (int8u ad=0; ad<adjust_num; ad++)
690 {
691 Skip_S1(4, "alevcode[bd][wd][ad]");
692 Skip_S1(wd==0?aloc_bits0:aloc_bits, "aloccode[bd][wd][ad]");
693 }
694 }
695 }
696 }
697
698 //***************************************************************************
699 // Elements - Subsidiary
700 //***************************************************************************
701
702 //---------------------------------------------------------------------------
individual_channel_stream(bool common_window,bool scale_flag)703 void File_Aac::individual_channel_stream (bool common_window, bool scale_flag)
704 {
705 Element_Begin1("individual_channel_stream");
706 Skip_S1(8, "global_gain");
707 if (!common_window && !scale_flag)
708 ics_info();
709 if (!Element_IsOK())
710 {
711 Skip_BS(Data_BS_Remain(), "(Problem)");
712 Element_End0();
713 return;
714 }
715 section_data();
716 if (!Element_IsOK())
717 {
718 Skip_BS(Data_BS_Remain(), "?");
719 Element_End0();
720 return;
721 }
722 scale_factor_data();
723 if (!Element_IsOK())
724 {
725 Skip_BS(Data_BS_Remain(), "(Problem)");
726 Element_End0();
727 return;
728 }
729 if (!scale_flag)
730 {
731 bool pulse_data_present;
732 Get_SB (pulse_data_present, "pulse_data_present");
733 if (pulse_data_present)
734 pulse_data ();
735 bool tns_data_present;
736 Get_SB(tns_data_present, "tns_data_present");
737 if (tns_data_present)
738 tns_data ();
739 bool gain_control_data_present;
740 Get_SB(gain_control_data_present, "gain_control_data_present");
741 if (gain_control_data_present)
742 gain_control_data ();
743 }
744 if (!aacSpectralDataResilienceFlag)
745 spectral_data ();
746 else
747 {
748 Skip_BS(Data_BS_Remain(), "Not implemented");
749 //~ length_of_reordered_spectral_data;
750 //~ length_of_longest_codeword;
751 //~ reordered_spectral_data ();
752 }
753 Element_End0();
754 }
755
756 //---------------------------------------------------------------------------
section_data()757 void File_Aac::section_data()
758 {
759 Element_Begin1("section_data");
760 int8u sect_esc_val;
761 if (window_sequence==2) //EIGHT_SHORT_SEQUENCE
762 sect_esc_val=(1<<3)-1;
763 else
764 sect_esc_val=(1<<5)-1;
765 for (int8u g=0; g<num_window_groups; g++)
766 {
767 if (num_window_groups>1)
768 Element_Begin1("windows");
769 int8u k=0;
770 int8u i=0;
771 while (k<max_sfb)
772 {
773 if (aacSectionDataResilienceFlag)
774 Get_S1(5, sect_cb[g][i], "sect_cb[g][i]");
775 else
776 Get_S1(4, sect_cb[g][i], "sect_cb[g][i]");
777 int8u sect_len=0;
778 int8u sect_len_incr;
779 if (!aacSectionDataResilienceFlag || sect_cb[g][i]<11 || (sect_cb[g][i]>11 && sect_cb[g][i]<16))
780 {
781 for (;;)
782 {
783 if (Data_BS_Remain()==0)
784 {
785 Trusted_IsNot("Size is wrong");
786 if (num_window_groups>1)
787 Element_End0();
788 Element_End0();
789 return; //Error
790 }
791 Get_S1 ((window_sequence==2?3:5), sect_len_incr, "sect_len_incr"); // (window_sequence == EIGHT_SHORT_SEQUENCE) => 3
792 if (sect_len_incr!=sect_esc_val)
793 break;
794 sect_len+=sect_esc_val;
795 }
796 }
797 else
798 sect_len_incr=1;
799 sect_len+=sect_len_incr;
800 sect_start[g][i]=k;
801 sect_end[g][i]=k+sect_len;
802 for (int16u sfb=k; sfb<k+sect_len; sfb++)
803 sfb_cb[g][sfb]=sect_cb[g][i];
804 k+= sect_len;
805 i++;
806 if (i>64)
807 {
808 Trusted_IsNot("Increment is wrong");
809 if (num_window_groups>1)
810 Element_End0();
811 Element_End0();
812 return; //Error
813 }
814 }
815 num_sec[g]=i;
816 if (num_window_groups>1)
817 Element_End0();
818 }
819 Element_End0();
820 }
821
822 //---------------------------------------------------------------------------
scale_factor_data()823 void File_Aac::scale_factor_data()
824 {
825 Element_Begin1("scale_factor_data");
826 if (!aacScalefactorDataResilienceFlag)
827 {
828 bool noise_pcm_flag=true;
829 for (int g=0; g<num_window_groups; g++)
830 {
831 for (int8u sfb=0; sfb<max_sfb; sfb++)
832 {
833 if (sfb_cb[g][sfb]) //Not ZERO_HCB
834 {
835 if (is_intensity( g, sfb))
836 hcod_sf( "hcod_sf[dpcm_is_position[g][sfb]]");
837 else
838 {
839 if (is_noise(g, sfb))
840 {
841 if (noise_pcm_flag)
842 {
843 noise_pcm_flag = 0;
844 Skip_S2(9, "dpcm_noise_nrg[g][sfb]");
845 }
846 else
847 hcod_sf( "hcod_sf[dpcm_noise_nrg[g][sfb]]");
848 }
849 else
850 hcod_sf( "hcod_sf[dpcm_sf[g][sfb]]");
851 }
852 }
853 }
854 }
855 }
856 else
857 {
858 //scale_factor_data - part not implemented
859 Skip_BS(Data_BS_Remain(), "Not implemented");
860 //~ intensity_used = 0;
861 //~ noise_used = 0;
862 //~ sf_concealment;
863 //~ rev_global_gain;
864 //~ length_of_rvlc_sf;
865 //~ for ( g = 0; g < num_window_groups; g++ ) {
866 //~ for ( sfb=0; sfb < max_sfb; sfb++ ) {
867 //~ if ( sfb_cb[g][sfb] ) { //Not ZERO_HCB
868 //~ if ( is_intensity ( g, sfb) ) {
869 //~ intensity_used = 1;
870 //~ rvlc_cod_sf[dpcm_is_position[g][sfb]];
871 //~ } else {
872 //~ if ( is_noise(g,sfb) ) {
873 //~ if ( ! noise_used ) {
874 //~ noise_used = 1;
875 //~ dpcm_noise_nrg[g][sfb];
876 //~ } else {
877 //~ rvlc_cod_sf[dpcm_noise_nrg[g][sfb]];
878 //~ }
879 //~ } else {
880 //~ rvlc_cod_sf[dpcm_sf[g][sfb]];
881 //~ }
882 //~ }
883 //~ }
884 //~ }
885 //~ }
886 //~ if ( intensity_used ) {
887 //~ rvlc_cod_sf[dpcm_is_last_position];
888 //~ }
889 //~ noise_used = 0;
890 //~ sf_escapes_present;
891 //~ if ( sf_escapes_present ) {
892 //~ length_of_rvlc_escapes;
893 //~ for ( g = 0; g < num_window_groups; g++ ) {
894 //~ for ( sfb = 0; sfb < max_sfb; sfb++ ) {
895 //~ if ( sfb_cb[g][sfb]) { //Not ZERO_HCB
896 //~ if ( is_intensity ( g, sfb ) && dpcm_is_position[g][sfb] == ESC_FLAG ) {
897 //~ rvlc_esc_sf[dpcm_is_position[g][sfb]];
898 //~ } else {
899 //~ if ( is_noise ( g, sfb ) {
900 //~ if ( ! noise_used ) {
901 //~ noise_used = 1;
902 //~ } else {
903 //~ if (dpcm_noise_nrg[g][sfb] == ESC_FLAG ) {
904 //~ rvlc_esc_sf[dpcm_noise_nrg[g][sfb]];
905 //~ }
906 //~ }
907 //~ } else {
908 //~ if (dpcm_sf[g][sfb] == ESC_FLAG ) {
909 //~ rvlc_esc_sf[dpcm_sf[g][sfb]];
910 //~ }
911 //~ }
912 //~ }
913 //~ }
914 //~ }
915 //~ }
916 //~ if ( intensity_used && dpcm_is_last_position == ESC_FLAG ) {
917 //~ rvlc_esc_sf[dpcm_is_last_position];
918 //~ }
919 //~ }
920 //~ if ( noise_used ) {
921 //~ dpcm_noise_last_position;
922 //~ }
923 }
924 Element_End0();
925 }
926
927 //---------------------------------------------------------------------------
tns_data()928 void File_Aac::tns_data()
929 {
930 int8u n_filt_bits=2;
931 int8u length_bits=6;
932 int8u order_bits=5;
933
934 if (window_sequence==2) //EIGHT_SHORT_SEQUENCE
935 {
936 n_filt_bits=1;
937 length_bits=4;
938 order_bits=3;
939 }
940
941 for (int8u w=0; w<num_windows; w++)
942 {
943 int8u start_coef_bits, n_filt;
944 Get_S1(n_filt_bits, n_filt, "n_filt[w]");
945 if (n_filt)
946 {
947 bool coef_res;
948 Get_SB (coef_res, "coef_res[w]");
949 start_coef_bits=coef_res?4:3;
950
951 for (int8u filt=0; filt<n_filt; filt++)
952 {
953 int8u order;
954 Skip_S1(length_bits, "length[w][filt]");
955 Get_S1 (order_bits, order, "order[w][filt]");
956 if (order)
957 {
958 bool coef_compress;
959 Skip_SB( "direction[w][filt]");
960 Get_SB (coef_compress, "coef_compress[w][filt]");
961 int8u coef_bits=start_coef_bits-(coef_compress?1:0);
962 for (int8u i=0; i<order; i++)
963 Skip_S1(coef_bits, "coef[w][filt][i]");
964 }
965 }
966 }
967 }
968 }
969
970 //---------------------------------------------------------------------------
ltp_data()971 void File_Aac::ltp_data()
972 {
973 Element_Begin1("ltp_data");
974 //int sfb;
975 //bool ltp_lag_update;
976 //if (AudioObjectType == ER_AAC_LD ) {
977 //~ Get_SB(ltp_lag_update,"ltp_lag_update");
978 //~ if ( ltp_lag_update ) {
979 //~ Get_S2(10,ltp_lag,"ltp_lag");
980 //~ } else {
981 //~ //ltp_lag = ltp_prev_lag;
982 //~ }
983 //~ Skip_S1(3,"ltp_coef");
984 //~ for (sfb = 0; sfb <(max_sfb<MAX_LTP_LONG_SFB?max_sfb:MAX_LTP_LONG_SFB);& sfb++ ) {
985 //~ Skip_SB("ltp_long_used[sfb]");
986 //~ }
987 //} else {
988 Get_S2(11,ltp_lag, "ltp_lag");
989 Skip_S1(3, "ltp_coef");
990 if(window_sequence!=2) //EIGHT_SHORT_SEQUENCE
991 {
992 for (int8u sfb=0; sfb<(max_sfb<40?max_sfb:40); sfb++ ) //MAX_LTP_LONG_SFB=40
993 Skip_SB("ltp_long_used[sfb]");
994 }
995 //}
996 Element_End0();
997 }
998
999 //---------------------------------------------------------------------------
spectral_data()1000 void File_Aac::spectral_data()
1001 {
1002 Element_Begin1("spectral_data");
1003 for (int g = 0; g < num_window_groups; g++)
1004 {
1005 if (num_window_groups>1)
1006 Element_Begin1("windows");
1007 for (int8u i=0; i<num_sec[g]; i++)
1008 {
1009 switch (sect_cb[g][i])
1010 {
1011 case 0 : //ZERO_HCB
1012 case 13 : //NOISE_HCB
1013 case 14 : //INTENSITY_HCB2
1014 case 15 : //INTENSITY_HCB
1015 break;
1016 default :
1017 if (sect_end[g][i]>=num_swb+1)
1018 {
1019 Trusted_IsNot("(Problem)");
1020 Skip_BS(Data_BS_Remain(), "(Problem)");
1021 if (num_window_groups>1)
1022 Element_End0();
1023 Element_End0();
1024 return;
1025 }
1026 for (int16u k=sect_sfb_offset[g][sect_start[g][i]]; k<sect_sfb_offset[g][sect_end[g][i]]; k+=(sect_cb[g][i]<5?4:2))
1027 {
1028 hcod(sect_cb[g][i], "sect_cb");
1029 if (!Element_IsOK())
1030 {
1031 Skip_BS(Data_BS_Remain(), "(Problem)");
1032 if (num_window_groups>1)
1033 Element_End0();
1034 Element_End0();
1035 return;
1036 }
1037 }
1038 }
1039 }
1040 if (num_window_groups>1)
1041 Element_End0();
1042 }
1043 Element_End0();
1044 }
1045
1046 //---------------------------------------------------------------------------
extension_payload(size_t End,int8u id_aac)1047 void File_Aac::extension_payload(size_t End, int8u id_aac)
1048 {
1049 Element_Begin1("extension_payload");
1050 int8u extension_type;
1051 Get_S1 (4, extension_type, "extension_type");
1052 switch(extension_type)
1053 {
1054 case 11 : dynamic_range_info(); break; //EXT_DYNAMIC_RANGE
1055 case 12 : sac_extension_data(End); break; //EXT_SAC_DATA
1056 case 13 : sbr_extension_data(End, id_aac, 0); break; //EXT_SBR_DATA
1057 case 14 : sbr_extension_data(End, id_aac, 1); break; //EXT_SBR_DATA_CRC
1058 case 1 : //EXT_FILL_DATA
1059 Skip_S1(4, "fill_nibble"); Param_Info1("must be 0000");
1060 if (Data_BS_Remain()>End)
1061 {
1062 Element_Begin1("fill_byte");
1063 while (Data_BS_Remain()>End)
1064 Skip_S1(8, "fill_byte[i]"); Param_Info1("must be 10100101");
1065 Element_End0();
1066 }
1067 break;
1068 case 2 : //EXT_DATA_ELEMENT
1069 int8u data_element_version;
1070 Get_S1 (4,data_element_version, "data_element_version");
1071 switch(data_element_version)
1072 {
1073 case 0 : //ANC_DATA
1074 {
1075 int16u dataElementLength=0;
1076 int8u dataElementLengthPart;
1077 do
1078 {
1079 Get_S1 (8, dataElementLengthPart, "dataElementLengthPart");
1080 dataElementLength+=dataElementLengthPart;
1081 }
1082 while (dataElementLengthPart==255);
1083 Skip_BS(8*dataElementLength, "data_element_byte[i]");
1084 }
1085 break;
1086 default: ;
1087 }
1088 break;
1089 case 0 : //EXT_FILL
1090 default:
1091 Skip_BS(Data_BS_Remain()-End, "other_bits");
1092 }
1093
1094 Element_End0();
1095 if (End<Data_BS_Remain())
1096 Skip_BS(Data_BS_Remain()-End, "padding");
1097 if (Data_BS_Remain()!=End)
1098 {
1099 Skip_BS(Data_BS_Remain(), "Wrong size");
1100 Trusted_IsNot("Wrong size");
1101 }
1102 }
1103
1104 //---------------------------------------------------------------------------
dynamic_range_info()1105 void File_Aac::dynamic_range_info()
1106 {
1107 Element_Begin1("dynamic_range_info");
1108 int8u drc_num_bands=1;
1109 bool present;
1110 Get_SB (present, "pce_tag_present");
1111 if (present)
1112 {
1113 Skip_S1(4, "pce_ instance_tag");
1114 Skip_S1(4, "drc_tag_reserved_bits");
1115 }
1116 Skip_SB( "excluded_chns_present");
1117 Get_SB (present, "drc_bands_present");
1118 if (present)
1119 {
1120 int8u drc_band_incr;
1121 Get_S1 (4, drc_band_incr, "drc_band_incr");
1122 Skip_S1(4, "drc_interpolation_scheme");
1123 drc_num_bands+=drc_band_incr;
1124 for (int8u i=0; i<drc_num_bands; i++)
1125 {
1126 Skip_S1(8, "drc_band_top[i]");
1127 }
1128 }
1129 Get_SB (present, "prog_ref_level_present");
1130 if (present)
1131 {
1132 Skip_S1(7, "prog_ref_level");
1133 Skip_S1(1, "prog_ref_level_reserved_bits");
1134 }
1135 for (int8u i=0; i<drc_num_bands; i++)
1136 {
1137 Skip_S1(1, "dyn_rng_sgn[i]");
1138 Skip_S1(7, "dyn_rng_ctl[i]");
1139 }
1140 Element_End0();
1141 }
1142
1143 //---------------------------------------------------------------------------
sac_extension_data(size_t End)1144 void File_Aac::sac_extension_data(size_t End)
1145 {
1146 Element_Begin1("sac_extension_data");
1147 Skip_S1(2, "ancType");
1148 Skip_SB( "ancStart");
1149 Skip_SB( "ancStop");
1150 Element_Begin1("ancDataSegmentByte");
1151 while (Data_BS_Remain()>End)
1152 Skip_S1(8, "ancDataSegmentByte[i]");
1153 Element_End0();
1154 Element_End0();
1155 }
1156
1157 //***************************************************************************
1158 // Elements - Perceptual noise substitution (PNS)
1159 //***************************************************************************
1160
1161 //---------------------------------------------------------------------------
is_intensity(size_t group,size_t sfb)1162 int File_Aac::is_intensity(size_t group, size_t sfb)
1163 {
1164 switch (sfb_cb[group][sfb])
1165 {
1166 case 15 : return 1;
1167 case 14 : return -1;
1168 default : return 0;
1169 }
1170 }
1171
1172 //---------------------------------------------------------------------------
is_noise(size_t group,size_t sfb)1173 bool File_Aac::is_noise(size_t group, size_t sfb)
1174 {
1175 return (sfb_cb[group][sfb]==13);
1176 }
1177 //---------------------------------------------------------------------------
hcod_sf(const char * Name)1178 void File_Aac::hcod_sf(const char* Name)
1179 {
1180 Element_Begin1(Name);
1181 int16u Pos=0;
1182
1183 while (huffman_sf[Pos][1])
1184 {
1185 bool h;
1186 Get_SB (h, "huffman");
1187 Pos+=huffman_sf[Pos][h];
1188
1189 if (Pos>240)
1190 {
1191 Skip_BS(Data_BS_Remain(), "Error");
1192 Element_End0();
1193 return;
1194 }
1195 }
1196 Element_Info1(huffman_sf[Pos][0]-60);
1197 Element_End0();
1198
1199 return;
1200 }
1201
1202 //---------------------------------------------------------------------------
hcod_2step(int8u CodeBook,int8s * Values,int8u Values_Count)1203 void File_Aac::hcod_2step(int8u CodeBook, int8s* Values, int8u Values_Count)
1204 {
1205 int8u CodeWord;
1206 int8u ToRead=hcb_2step_Bytes[CodeBook];
1207 if ((size_t)ToRead>Data_BS_Remain())
1208 ToRead=(int8u)Data_BS_Remain(); //Read a maximum of remaining bytes
1209 Peek_S1(ToRead, CodeWord);
1210 int16u Offset=hcb_2step[CodeBook][CodeWord].Offset;
1211 int8u Extra=hcb_2step[CodeBook][CodeWord].Extra;
1212
1213 if (Extra)
1214 {
1215 Skip_BS(hcb_2step_Bytes[CodeBook], "extra");
1216 int8u Offset_inc;
1217 Peek_S1(Extra, Offset_inc);
1218 Offset+=Offset_inc;
1219 if(hcb_table[CodeBook][Offset][0]-hcb_2step_Bytes[CodeBook])
1220 Skip_BS(hcb_table[CodeBook][Offset][0]-hcb_2step_Bytes[CodeBook],"extra");
1221 }
1222 else
1223 {
1224 Skip_BS(hcb_table[CodeBook][Offset][0], "bits");
1225 }
1226
1227 if (Offset>=hcb_table_size[CodeBook])
1228 {
1229 Skip_BS(Data_BS_Remain(), "Error");
1230 return;
1231 }
1232
1233 for (int8u Pos=0; Pos<Values_Count; Pos++)
1234 Values[Pos]=hcb_table[CodeBook][Offset][Pos+1];
1235 }
1236
1237 //---------------------------------------------------------------------------
hcod_binary(int8u CodeBook,int8s * Values,int8u Values_Count)1238 void File_Aac::hcod_binary(int8u CodeBook, int8s* Values, int8u Values_Count)
1239 {
1240 int16u Offset=0;
1241 while (!hcb_table[CodeBook][Offset][0])
1242 {
1243 bool b;
1244 Get_SB(b, "huffman binary");
1245 Offset+=hcb_table[CodeBook][Offset][1+(b?1:0)];
1246 }
1247
1248 if (Offset>=hcb_table_size[CodeBook])
1249 {
1250 Skip_BS(Data_BS_Remain(), "Error");
1251 return;
1252 }
1253
1254 for (int8u Pos=0; Pos<Values_Count; Pos++)
1255 Values[Pos]=hcb_table[CodeBook][Offset][Pos+1];
1256 }
1257
1258
1259
1260 //***************************************************************************
1261 // Elements - Enhanced Low Delay Codec
1262 //***************************************************************************
1263
1264
1265 //---------------------------------------------------------------------------
ELDSpecificConfig()1266 void File_Aac::ELDSpecificConfig ()
1267 {
1268 Element_Begin1("ELDSpecificConfig");
1269 Skip_SB("frameLengthFlag");
1270 Skip_SB("aacSectionDataResilienceFlag");
1271 Skip_SB("aacScalefactorDataResilienceFlag");
1272 Skip_SB("aacSpectralDataResilienceFlag");
1273
1274 bool ldSbrPresentFlag;
1275 Get_SB(ldSbrPresentFlag,"ldSbrPresentFlag");
1276 if (ldSbrPresentFlag)
1277 {
1278 Skip_SB("ldSbrSamplingRate");
1279 Skip_SB("ldSbrCrcFlag");
1280 ld_sbr_header();
1281 }
1282
1283 int8u eldExtType;
1284 for (;;)
1285 {
1286 Get_S1(4,eldExtType,"eldExtType");
1287 if (eldExtType == 0/*ELDEXT_TERM*/)
1288 break;
1289
1290 int8u eldExtLen,eldExtLenAdd=0;
1291 int16u eldExtLenAddAdd;
1292 Get_S1(4,eldExtLen,"eldExtLen");
1293 int32u len = eldExtLen;
1294 if (eldExtLen == 15)
1295 {
1296 Get_S1(8,eldExtLenAdd,"eldExtLenAdd");
1297 len += eldExtLenAdd;
1298 }
1299 if (eldExtLenAdd==255)
1300 {
1301 Get_S2(16,eldExtLenAddAdd,"eldExtLenAddAdd");
1302 len += eldExtLenAdd;
1303 }
1304 //~ switch (eldExtType) {
1305 /* add future eld extension configs here */
1306 //~ default:
1307 for(int32u cnt=0; cnt<len; cnt++)
1308 Skip_S1(8,"other_byte");
1309 //~ break;
1310 //~ }
1311
1312 }
1313 Element_End0();
1314 }
1315
1316 //---------------------------------------------------------------------------
ld_sbr_header()1317 void File_Aac::ld_sbr_header()
1318 {
1319 int8u numSbrHeader;
1320 switch (channelConfiguration)
1321 {
1322 case 1:
1323 case 2:
1324 numSbrHeader = 1;
1325 break;
1326 case 3:
1327 numSbrHeader = 2;
1328 break;
1329 case 4:
1330 case 5:
1331 case 6:
1332 numSbrHeader = 3;
1333 break;
1334 case 7:
1335 numSbrHeader = 4;
1336 break;
1337 default:
1338 numSbrHeader = 0;
1339 break;
1340 }
1341
1342 for (int el=0; el<numSbrHeader; el++) {
1343 //~ sbr_header();
1344 Element_Begin1("not implemented");
1345 Element_End0();
1346 }
1347 }
1348
1349 //***************************************************************************
1350 // Helpers
1351 //***************************************************************************
1352
1353 //---------------------------------------------------------------------------
hcod(int8u sect_cb,const char * Name)1354 void File_Aac::hcod(int8u sect_cb, const char* Name)
1355 {
1356 int8s Values[4];
1357
1358 Element_Begin1(Name);
1359 switch (sect_cb)
1360 {
1361 case 1 :
1362 case 2 :
1363 case 4 : //4-values, 2-step method
1364 hcod_2step(sect_cb, Values, 4);
1365 break;
1366 case 3 : //4-values, binary search method
1367 hcod_binary(sect_cb, Values, 4);
1368 break;
1369 case 5 :
1370 case 7 :
1371 case 9 : //2-values, binary search method
1372 hcod_binary(sect_cb, Values, 2);
1373 break;
1374 case 6 :
1375 case 8 :
1376 case 10 :
1377 case 11 : //2-values, 2-step method
1378 hcod_2step(sect_cb, Values, 2);
1379 break;
1380 default: Trusted_IsNot("(Problem)");
1381 Element_End0();
1382 return;
1383 }
1384
1385 switch (sect_cb)
1386 {
1387 case 1 :
1388 case 2 :
1389 case 5 :
1390 case 6 :
1391 break;
1392 default : //With sign
1393 for(int i=0; i<((sect_cb<5)?4:2); i++)
1394 if(Values[i])
1395 Skip_SB( "sign");
1396 }
1397
1398 switch (sect_cb)
1399 {
1400 case 11 : //With hcod_esc
1401 for (int i=0; i<2; i++)
1402 if (Values[i]==16 || Values[i] == -16)
1403 {
1404 Element_Begin1("hcod_esc");
1405 bool Escape;
1406 int BitCount=3;
1407 do
1408 {
1409 BitCount++;
1410 Get_SB(Escape, "bit count");
1411 }
1412 while (Escape);
1413
1414
1415 Skip_BS(BitCount, "value");
1416 Element_End0();
1417
1418 }
1419 break;
1420 default: ;
1421 }
1422
1423 Element_End0();
1424 }
1425
1426
1427 //---------------------------------------------------------------------------
FillInfosHEAACv2(const Ztring & Format_Settings)1428 void File_Aac::FillInfosHEAACv2(const Ztring& Format_Settings)
1429 {
1430 Infos["Format_Profile"] = __T("HE-AACv2");
1431 const Ztring Channels = Infos["Channel(s)"];
1432 const Ztring ChannelPositions = Infos["ChannelPositions"];
1433 Infos["Channel(s)"] = __T("2");
1434 Infos["ChannelPositions"] = __T("Front: L R");
1435 if (MediaInfoLib::Config.LegacyStreamDisplay_Get())
1436 {
1437 const Ztring SamplingRate_Previous = Infos["SamplingRate"];
1438 Infos["Format_Profile"] += __T(" / HE-AAC / LC");
1439 Infos["Channel(s)"] += __T(" / ") + Channels + __T(" / ") + Channels;
1440 Infos["ChannelPositions"] += __T(" / ") + ChannelPositions + __T(" / ") + ChannelPositions;
1441 const int32u SamplingRate = (extension_sampling_frequency_index == (int8u)-1) ? (((int32u)Frequency_b) * 2) : extension_sampling_frequency;
1442 if (SamplingRate)
1443 Infos["SamplingRate"] = Ztring().From_Number(SamplingRate, 10) + __T(" / ") + SamplingRate_Previous;
1444 }
1445 if (Infos["Format_Settings"] != Format_Settings)
1446 {
1447 if (!Infos["Format_Settings"].empty())
1448 Infos["Format_Settings"].insert(0, __T(" / "));
1449 Infos["Format_Settings"].insert(0, Format_Settings);
1450 }
1451 Infos["Format_Settings_PS"] = __T("Yes (") + Format_Settings + __T(")");
1452 Infos["Codec"] = Ztring().From_UTF8(Aac_audioObjectType(audioObjectType)) + __T("-SBR-PS");
1453 }
1454
1455 //***************************************************************************
1456 // C++
1457 //***************************************************************************
1458
1459 } //NameSpace
1460
1461 #endif //MEDIAINFO_AAC_YES
1462