//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_03()
{
//Parsing
bool streamDependenceFlag, URL_Flag, OCRstreamFlag;
Get_B2 (ES_ID, "ES_ID");
BS_Begin();
Get_SB ( streamDependenceFlag, "streamDependenceFlag");
Get_SB ( URL_Flag, "URL_Flag");
Get_SB ( OCRstreamFlag, "OCRstreamFlag");
Skip_S1(5, "streamPriority");
BS_End();
if (streamDependenceFlag)
Skip_B2( "dependsOn_ES_ID");
if (URL_Flag)
{
int8u URLlength;
Get_B1 (URLlength, "URLlength");
Skip_UTF8(URLlength, "URLstring");
}
if (OCRstreamFlag)
Skip_B2( "OCR_ES_Id");
FILLING_BEGIN();
Element_ThisIsAList();
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Aac::ErrorResilientCelpSpecificConfig ()
{
Element_Begin1("ErrorResilientCelpSpecificConfig");
bool isBaseLayer;
Get_SB(isBaseLayer, "isBaseLayer");
if (isBaseLayer)
{
ER_SC_CelpHeader ();
}
else
{
bool isBWSLayer;
Get_SB(isBWSLayer, "isBWSLayer");
if (isBWSLayer)
{
//~ CelpBWSenhHeader ()
//~ {
Skip_S1(2, "BWS_configuration");
//~ }
}
else
{
Skip_S1(2, "CELP-BRS-id");
}
}
Element_End0();
}
//---------------------------------------------------------------------------
void File_Dts::Header_Parse()
{
//Parsing
int16u Primary_Frame_Byte_Size_minus_1;
int8u EncoderSoftwareRevision;
bool crc_present;
Skip_B4( "Sync");
BS_Begin();
Info_SB( FrameType, "Frame Type"); Param_Info(DTS_FrameType[FrameType]);
Skip_S1( 5, "Deficit Sample Count");
Get_SB ( crc_present, "CRC Present");
Skip_S1( 7, "Number of PCM Sample Blocks");
Get_S2 (14, Primary_Frame_Byte_Size_minus_1, "Primary Frame Byte Size minus 1");
Primary_Frame_Byte_Size_minus_1+=1;
if (!Word) Primary_Frame_Byte_Size_minus_1=Primary_Frame_Byte_Size_minus_1*8/14*2; Param_Info(Ztring::ToZtring(Primary_Frame_Byte_Size_minus_1)+_T(" bytes")); //Word is on 14 bits!
Get_S1 ( 6, channel_arrangement, "Audio Channel Arrangement"); Param_Info(Ztring::ToZtring(DTS_Channels[channel_arrangement])+_T(" channels"));
Get_S1 ( 4, sample_frequency, "Core Audio Sampling Frequency"); Param_Info(Ztring::ToZtring(DTS_SamplingRate[sample_frequency])+_T(" Hz"));
Get_S1 ( 5, bit_rate, "Transmission Bit Rate"); Param_Info(Ztring::ToZtring(DTS_BitRate[bit_rate])+_T(" bps"));
Skip_SB( "Embedded Down Mix Enabled");
Skip_SB( "Embedded Dynamic Range");
Skip_SB( "Embedded Time Stamp");
Skip_SB( "Auxiliary Data");
Skip_SB( "HDCD");
Get_S1 ( 3, ExtensionAudioDescriptor, "Extension Audio Descriptor"); Param_Info(DTS_ExtensionAudioDescriptor[ExtensionAudioDescriptor]);
Get_SB ( ExtendedCoding, "Extended Coding");
Skip_SB( "Audio Sync Word Insertion");
Get_S1 ( 2, lfe_effects, "Low Frequency Effects");
Skip_SB( "Predictor History");
if (crc_present)
Skip_S2(16, "Header CRC Check");
Skip_SB( "Multirate Interpolator");
Get_S1 ( 4, EncoderSoftwareRevision, "Encoder Software Revision");
Skip_S1( 2, "Copy History");
Get_S1 ( 2, bits_per_sample, "Source PCM Resolution"); Param_Info(Ztring::ToZtring(DTS_Resolution[bits_per_sample])+_T(" bits"));
Skip_SB( "ES");
Skip_SB( "Front Sum/Difference");
Skip_SB( "Surrounds Sum/Difference");
Skip_S1( 4, "Dialog Normalisation Parameter");
switch (EncoderSoftwareRevision)
{
case 6 :
Skip_S1( 4, "Dialog Normalisation Parameter");
break;
case 7 :
Skip_S1( 4, "Dialog Normalisation Parameter");
break;
default :
Skip_S1( 4, "Unspecified");
break;
}
BS_End();
//Filling
Header_Fill_Size(Primary_Frame_Byte_Size_minus_1+DTS_HD_Unknown_Size); //TODO: change this, for DTS-HD
Header_Fill_Code(0, "Frame");
}
//---------------------------------------------------------------------------
// Packet "B0"
void File_AvsV::video_sequence_start()
{
Element_Name("video_sequence_start");
//Parsing
int32u bit_rate_upper, bit_rate_lower;
Get_B1 ( profile_id, "profile_id");
Get_B1 ( level_id, "level_id");
BS_Begin();
Get_SB ( progressive_sequence, "progressive_sequence");
Get_S2 (14, horizontal_size, "horizontal_size");
Get_S2 (14, vertical_size, "vertical_size");
Get_S1 ( 2, chroma_format, "chroma_format");
Skip_S1( 3, "sample_precision");
Get_S1 ( 4, aspect_ratio, "aspect_ratio"); Param_Info(AvsV_aspect_ratio[aspect_ratio]);
Get_S1 ( 4, frame_rate_code, "frame_rate_code"); Param_Info(AvsV_frame_rate[frame_rate_code]);
Get_S3 (18, bit_rate_lower, "bit_rate_lower");
Mark_1 ();
Get_S3 (12, bit_rate_upper, "bit_rate_upper");
bit_rate=(bit_rate_upper<<18)+bit_rate_lower; Param_Info(bit_rate*8, " bps");
Get_SB ( low_delay, "low_delay");
Mark_1 ();
Skip_S3(18, "bbv_buffer_size");
Skip_SB( "reserved");
Skip_SB( "reserved");
Skip_SB( "reserved");
BS_End();
//Not sure, but the 3 first official files have this
if (Element_Size-Element_Offset)
{
BS_Begin();
Mark_1();
BS_End();
}
FILLING_BEGIN();
//NextCode
NextCode_Clear();
NextCode_Add(0xB2); //user_data_start
NextCode_Add(0xB3); //picture_start (I)
NextCode_Add(0xB5); //extension_start
//Autorisation of other streams
Streams[0xB1].Searching_Payload=true, //video_sequence_end
Streams[0xB2].Searching_Payload=true; //user_data_start
Streams[0xB3].Searching_Payload=true, //picture_start (I)
Streams[0xB4].Searching_Payload=true, //reserved
Streams[0xB5].Searching_Payload=true; //extension_start
Streams[0xB6].Searching_Payload=true, //picture_start (P or B)
Streams[0xB7].Searching_Payload=true; //video_edit
Streams[0xB8].Searching_Payload=true, //reserved
video_sequence_start_IsParsed=true;
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Cdp::ccsvcinfo_section()
{
//Parsing
int8u svc_count;
Element_Begin1("ccsvcinfo_section");
Skip_B1( "ccsvcinfo_id");
BS_Begin();
Skip_SB( "reserved");
Skip_SB( "svc_info_start");
Skip_SB( "svc_info_change");
Skip_SB( "svc_info_complete");
Get_S1 (4, svc_count, "svc_count");
BS_End();
for (int8u Pos=0; Pos<svc_count; Pos++)
{
Element_Begin1("svc");
bool csn_size;
BS_Begin();
Skip_SB( "reserved");
Get_SB ( csn_size, "csn_size");
if (csn_size)
{
Skip_SB( "reserved");
Skip_S1(5, "caption_service_number");
}
else
Skip_S1(6, "caption_service_number");
BS_End();
//svc_data_byte - caption_service_descriptor
Element_Begin1("service");
Ztring language;
bool digital_cc;
Get_Local(3, language, "language");
BS_Begin();
Get_SB (digital_cc, "digital_cc");
Skip_SB( "reserved");
if (digital_cc) //line21
{
Skip_S1(5, "reserved");
Skip_SB( "line21_field");
}
else
Skip_S1(6, "caption_service_number");
Skip_SB( "easy_reader");
Skip_SB( "wide_aspect_ratio");
Skip_S2(14, "reserved");
BS_End();
Element_End0();
Element_End0();
}
Element_End0();
}
//---------------------------------------------------------------------------
// Packet "0E"
void File_Vc1::EntryPointHeader()
{
Element_Name("EntryPointHeader");
//Parsing
bool extended_mv;
BS_Begin();
Skip_SB( "broken_link");
Skip_SB( "closed_entry");
Get_SB ( panscan_flag, "panscan_flag");
Skip_SB( "refdist_flag");
Skip_SB( "loopfilter");
Skip_SB( "fastuvmc");
Get_SB ( extended_mv, "extended_mv");
Skip_S1( 2, "dquant");
Skip_SB( "vstransform");
Skip_SB( "overlap");
Skip_S1( 2, "quantizer");
if (hrd_param_flag)
for (int8u Pos=0; Pos<hrd_num_leaky_buckets; Pos++)
{
Element_Begin("leaky_bucket");
Skip_S2( 8, "hrd_full");
Element_End();
}
TEST_SB_SKIP( "coded_size_flag");
Info_S2(12, coded_width, "coded_width"); Param_Info((coded_width+1)*2, " pixels");
Info_S2(12, coded_height, "coded_height"); Param_Info((coded_height+1)*2, " pixels");
TEST_SB_END();
if (extended_mv)
Skip_SB( "extended_dmv");
TEST_SB_SKIP( "luma_sampling");
Skip_S1( 3, "y_range");
TEST_SB_END();
TEST_SB_SKIP( "chroma_sampling");
Skip_S1( 3, "uv_range");
TEST_SB_END();
BS_End();
FILLING_BEGIN();
//NextCode
NextCode_Test();
NextCode_Clear();
NextCode_Add(0x0D);
//Autorisation of other streams
Streams[0x0D].Searching_Payload=true;
EntryPoint_Parsed=true;
FILLING_END();
}
//---------------------------------------------------------------------------
// AAC in ES, SBR part, 3+ bytes
void File_Mpeg4_AudioSpecificConfig::SBR ()
{
//Parsing
int16u syncExtensionType;
int8u samplingFrequencyIndex;
Element_Begin("SBR");
Get_S2 (11, syncExtensionType, "syncExtensionType");
if (syncExtensionType!=0x2B7)
{
Element_End();
return;
}
Get_S1 (5, extensionAudioObjectType, "extensionAudioObjectType");
if (extensionAudioObjectType==0x05)
{
Get_SB ( sbrPresentFlag, "sbrPresentFlag");
if (sbrPresentFlag)
{
Get_S1 (4, samplingFrequencyIndex, "extensionSamplingFrequencyIndex"); Param_Info(MP4_SamplingRate[samplingFrequencyIndex]);
if (samplingFrequencyIndex>=0xF)
{
Get_S3 (24, samplingFrequency, "extensionSamplingFrequency");
}
else
samplingFrequency=MP4_SamplingRate[samplingFrequencyIndex];
}
}
Element_End();
//PS stuff
if (Data_Remain())
PS();
}
//---------------------------------------------------------------------------
void File_MpcSv8::SH()
{
//Parsing
int64u SampleCount;
int8u Version, SampleFrequency, ChannelCount;
bool MidSideStereo;
Skip_B4( "CRC32");
Get_B1 (Version, "Version");
Get_VS (SampleCount, "Sample count");
Skip_VS( "Beginning silence");
BS_Begin();
Get_S1 (3, SampleFrequency, "Sample frequency"); Param_Info(Mpc_SampleFreq[SampleFrequency]);
Skip_S1(5, "Max used bands");
Get_S1 (4, ChannelCount, "Channel count");
Get_SB ( MidSideStereo, "Mid side stereo used");
Skip_S1(3, "Audio block frames");
BS_End();
//Filling
FILLING_BEGIN();
Fill(Stream_Audio, 0, Audio_SamplingRate, Mpc_SampleFreq[SampleFrequency]);
if (SampleCount)
{
Fill(Stream_Audio, 0, Audio_SamplingCount, SampleCount);
Fill(Stream_Audio, 0, Audio_Duration, SampleCount*1000/Mpc_SampleFreq[SampleFrequency]);
Fill(Stream_Audio, 0, Audio_BitRate, File_Size*8*Mpc_SampleFreq[SampleFrequency]/SampleCount); //Should be more precise...
}
Fill(Stream_Audio, 0, Audio_Resolution, 16); //MPC support only 16 bits
FILLING_END();
}
//---------------------------------------------------------------------------
// AAC in ES, PS part, 2 bytes
// Format is unknown
void File_Mpeg4_AudioSpecificConfig::PS ()
{
//Parsing
Element_Begin("PS");
int16u syncExtensionType;
Get_S2 (11, syncExtensionType, "syncExtensionType");
if (syncExtensionType!=0x548)
{
Element_End();
return;
}
Get_SB (psPresentFlag, "psPresentFlag");
Element_End();
//BSAC stuff
//if (extensionAudioObjectType==22)
// BSAC();
//if ( extensionAudioObjectType == 22 ) {
// sbrPresentFlag;
// if (sbrPresentFlag == 1) {
// extensionSamplingFrequencyIndex;
// if ( extensionSamplingFrequencyIndex == 0xf )
// extensionSamplingFrequency;
// }
// extensionChannelConfiguration
//}
}
//---------------------------------------------------------------------------
void File_Vc3::CodingControlA()
{
//Parsing
Element_Begin("Coding Control A", 3);
BS_Begin();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Info_S1(2, FFC, "Field/Frame Count"); Param_Info(Vc3_FFC[FFC]);
Mark_1();
Mark_0();
Mark_0();
Get_SB ( CRCF, "CRC flag");
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_1();
Mark_0();
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
BS_End();
Element_End();
}
//---------------------------------------------------------------------------
void File_Mpeg4_Descriptors::Descriptor_02()
{
//Parsing
bool URL_Flag;
BS_Begin();
Skip_S2(10, "ObjectDescriptorID");
Get_SB ( URL_Flag, "URL_Flag");
Skip_SB( "includeInlineProfileLevelFlag");
Skip_S1( 4, "reserved");
BS_End();
if (URL_Flag)
{
int8u URLlength;
Get_B1 (URLlength, "URLlength");
Skip_UTF8(URLlength, "URLstring");
}
Info_B1(ODProfileLevel, "ODProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_ODProfileLevelIndication(ODProfileLevel));
Info_B1(SceneProfileLevel, "sceneProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_SceneProfileLevelIndication(SceneProfileLevel));
Info_B1(AudioProfileLevel, "audioProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_AudioProfileLevelIndication(AudioProfileLevel));
Info_B1(VisualProfileLevel, "visualProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_VisualProfileLevelIndication(VisualProfileLevel));
Info_B1(GraphicsProfileLevel, "graphicsProfileLevelIndication"); Param_Info(Mpeg4_Descriptors_GraphicsProfileLevelIndication(GraphicsProfileLevel));
FILLING_BEGIN();
Element_ThisIsAList();
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Vc3::TimeCode()
{
//Parsing
Element_Begin1("Time Code");
bool TCP;
BS_Begin();
Get_SB ( TCP, "TCP: Time Code Present");
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
BS_End();
if (TCP)
{
Skip_B8( "Time Code");
}
else
Skip_B8( "Junk");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Vc3::ImageGeometry()
{
//Parsing
Element_Begin("Image Geometry", 11);
Get_B2 (ALPF, "Active lines-per-frame");
Get_B2 (SPL, "Samples-per-line");
Skip_B1( "Zero");
Skip_B2( "Number of active lines");
Skip_B2( "Zero");
BS_Begin();
Get_S1 (3, SBD, "Sample bit depth");
Mark_1();
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Mark_1();
Get_SB ( SST, "Source scan type");
Mark_0();
Mark_0();
BS_End();
Element_End();
}
//---------------------------------------------------------------------------
void File_Latm::StreamMuxConfig()
{
Element_Begin("StreamMuxConfig");
bool audioMuxVersion;
Get_SB (audioMuxVersion, "audioMuxVersion");
if (audioMuxVersion)
Get_SB (audioMuxVersionA, "audioMuxVersionA");
else
audioMuxVersionA=false;
if (!audioMuxVersionA)
{
if (audioMuxVersion==1)
{
//taraBufferFullness=LatmGetValue();
}
Skip_SB( "allStreamsSameTimeFraming");
Skip_S1(6, "numSubFrames");
Skip_S1(4, "numProgram");
/* for (int8u prog=0; prog<=numProgram; prog++)
{
int8u numLayer;
Get_S1(3, "numLayer");
for (lay = 0; lay <= numLayer; lay++) {
progSIndx[streamCnt] = prog; laySIndx[streamCnt] = lay;
streamID [ prog][ lay] = streamCnt++;
if (prog == 0 && lay == 0) {
useSameConfig = 0;
} else {
useSameConfig; 1 uimsbf
}
if (! useSameConfig) {
if ( audioMuxVersion == 0 ) {
AudioSpecificConfig();
}
else {
ascLen = LatmGetValue();
ascLen -= AudioSpecificConfig(); Note 1
fillBits; ascLen bslbf
}
}
*/
}
Element_End();
}
//---------------------------------------------------------------------------
void File_Aac::HvxcSpecificConfig()
{
Element_Begin1("HvxcSpecificConfig");
bool isBaseLayer;
Get_SB(isBaseLayer, "isBaseLayer");
if (isBaseLayer)
HVXCconfig();
Element_End0();
}
//---------------------------------------------------------------------------
void File_Aac::ErrorResilientHvxcSpecificConfig() {
Element_Begin1("ErrorResilientHvxcSpecificConfig");
bool isBaseLayer;
Get_SB(isBaseLayer,"isBaseLayer");
if (isBaseLayer) {
ErHVXCconfig();
}
Element_End0();
}
//---------------------------------------------------------------------------
void File_Aac::HILNenexConfig()
{
Element_Begin1("HILNenexConfig");
bool HILNenhaLayer;
Get_SB(HILNenhaLayer, "HILNenhaLayer");
if (HILNenhaLayer)
Skip_S1(2, "HILNenhaQuantMode");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Bpg::Read_Buffer_Continue()
{
//Parsing
Ztring Version;
int64u Width, Height;
int8u pixelformat, BitsDepth, ColorSpace;
bool Alpha1_flag, Alpha2_flag, ReservedZeros, limited_range_flag, ExtensionPresentFlag;
Element_Begin1("File header");
Skip_C4( "Magic"); // File Magic
BS_Begin();
Get_S1 (3, pixelformat, "pixel_format"); Param_Info1(Bpg_Pixel_format(pixelformat));
Get_SB (Alpha1_flag, "Alpha1 Present Flag");
Get_S1 (4, BitsDepth, "bit_depth_minus_8");
Get_S1(4, ColorSpace, "color_space"); Param_Info1(Bpg_ColorSpace(ColorSpace)); Param_Info1(Bpg_colour_primaries(ColorSpace));
Get_SB (ExtensionPresentFlag, "Extension Present Flag");
Get_SB (Alpha2_flag, "Alpha2 Present Flag");
Get_SB (limited_range_flag, "limited_range_flag");
Get_SB (ReservedZeros, "Reserved");
BS_End();
Get_VS(Width, "Picture Width");
Get_VS(Height, "Picture Height");
Element_End0();
FILLING_BEGIN();
Accept("BPG");
Stream_Prepare(Stream_Image);
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_Format, __T("BPG"));
Fill(Stream_Image, 0, Image_ChromaSubsampling, Bpg_Pixel_format(pixelformat));
Fill(Stream_Image, 0, Image_ColorSpace, Bpg_ColorSpace(ColorSpace));
Fill(Stream_Image, 0, Image_colour_primaries, Bpg_colour_primaries(ColorSpace));
Fill(Stream_Image, 0, Image_BitDepth, BitsDepth + 8);
Fill(Stream_Image, 0, Image_Codec, __T("BPG"));
FILLING_END();
Finish("BPG");
}
//---------------------------------------------------------------------------
void File_OpenMG::FileHeader_Parse()
{
//Parsing
int16u Size, FrameSize=0;
int8u Flags, CodecID, SamplingRate_Code=0, Channels_Code=0;
bool JointStereo=false;
Skip_C3( "Code");
Get_B1 (Flags, "Flags");
Get_B2 (Size, "Size");
Skip_XX(26, "Unknown");
Get_B1 (CodecID, "Coded ID"); Param_Info1(OpenMG_CodecID_Format(CodecID));
if (CodecID<=1) //Atrac3
{
BS_Begin();
Skip_S1(7, "Unknown");
Get_SB ( JointStereo, "Joint Stereo");
Get_S1 (3, SamplingRate_Code, "Sampling Rate"); Param_Info2(OpenMG_SamplingRate(SamplingRate_Code), " Hz");
Get_S1 (3, Channels_Code, "Channels"); Param_Info2(OpenMG_Channels(Channels_Code), " channel(s)");
Get_S2 (10, FrameSize, "Frame size");
BS_End();
}
Skip_XX(Size-Element_Offset, "Unknown");
FILLING_BEGIN();
if (!Status[IsAccepted])
{
File__Tags_Helper::Accept();
Fill(Stream_Audio, 0, Audio_Format, OpenMG_CodecID_Format(CodecID));
Fill(Stream_Audio, 0, Audio_Encryption, OpenMG_CodecID_Encryption(CodecID));
int64u StreamSize=(int64u)-1;
if (File_Size!=(int64u)-1)
{
StreamSize=File_Size-(Buffer_Offset+Element_Size);
Fill(Stream_Audio, 0, Audio_StreamSize, StreamSize);
}
if (CodecID<=1) // Atrac3
{
Fill(Stream_Audio, 0, Audio_Channel_s_, OpenMG_Channels(Channels_Code));
Fill(Stream_Audio, 0, Audio_ChannelPositions, OpenMG_ChannelPositions(Channels_Code));
if (Channels_Code==1 && JointStereo)
Fill(Stream_Audio, 0, Audio_Format_Settings_Mode, "Joint Stereo");
Fill(Stream_Audio, 0, Audio_SamplingRate, OpenMG_SamplingRate(SamplingRate_Code));
if (CodecID==1) //Protected
FrameSize++; //Not sure
FrameSize<<=3; //8-byte blocks
int64u BitRate=OpenMG_SamplingRate(SamplingRate_Code)*FrameSize/256;
Fill(Stream_Audio, 0, Audio_BitRate, BitRate);
if (StreamSize!=(int64u)-1 && BitRate)
Fill(Stream_Audio, 0, Audio_Duration, StreamSize*8*1000/BitRate);
}
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Aac::ParametricSpecificConfig()
{
Element_Begin1("ParametricSpecificConfig");
bool isBaseLayer;
Get_SB(isBaseLayer, "isBaseLayer");
if (isBaseLayer)
PARAconfig();
else
HILNenexConfig();
Element_End0();
}
//---------------------------------------------------------------------------
void File_Aac::ErHVXCconfig()
{
Element_Begin1("ErHVXCconfig");
bool extensionFlag;
Skip_SB( "HVXCvarMode");
Skip_S1(2, "HVXCrateMode");
Get_SB (extensionFlag, "extensionFlag");
if (extensionFlag) {
Skip_SB( "var_ScalableFlag");
}
Element_End0();
}
//---------------------------------------------------------------------------
void File_MpcSv8::EI()
{
//Parsing
int8u Quality, Version1, Version2, Version3;
bool PNS;
BS_Begin();
Get_S1 (7, Quality, "Quality");
Get_SB ( PNS, "PNS");
BS_End();
Get_B1 (Version1, "Major version");
Get_B1 (Version2, "Minor version");
Get_B1 (Version3, "Build");
}
//---------------------------------------------------------------------------
void File_Gif::Read_Buffer_Continue()
{
//Parsing
Ztring Version;
int16u Width, Height;
int8u BackgroundColorIndex, PixelAspectRatio, Resolution, GCT_Size;
bool GCT_Flag, Sort;
Skip_Local(3, "Header");
Get_Local (3, Version, "Version");
Get_L2 (Width, "Logical Screen Width");
Get_L2 (Height, "Logical Screen Height");
BS_Begin();
Get_SB ( GCT_Flag, "Global Color Table Flag");
Get_S1 (3, Resolution, "Color Resolution");
Get_SB ( Sort, "Sort Flag to Global Color Table");
Get_S1 (3, GCT_Size, "Size of Global Color Table"); Param_Info(Ztring::ToZtring((int16u)pow(2.0, 1+GCT_Size)));
BS_End();
Get_L1 (BackgroundColorIndex, "Background Color Index");
Get_L1 (PixelAspectRatio, "Pixel Aspect Ratio");
if (GCT_Flag)
Skip_XX((int16u)pow(2.0, 1+GCT_Size)*3, "Global Color Table");
Element_End();
FILLING_BEGIN();
Accept("GIF");
Stream_Prepare(Stream_Image);
Fill(Stream_Image, 0, Image_Width, Width);
Fill(Stream_Image, 0, Image_Height, Height);
Fill(Stream_Image, 0, Image_Format, _T("GIF"));
Fill(Stream_Image, 0, Image_Format_Profile, Version);
Fill(Stream_Image, 0, Image_Codec, _T("GIF")+Version);
Finish("GIF");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Flac::Header_Parse()
{
//Parsing
int32u Length;
int8u BLOCK_TYPE;
BS_Begin();
Get_SB ( Last_metadata_block, "Last-metadata-block");
Get_S1 (7, BLOCK_TYPE, "BLOCK_TYPE");
BS_End();
Get_B3 (Length, "Length");
//Filling
Header_Fill_Code(BLOCK_TYPE, Ztring().From_CC1(BLOCK_TYPE));
Header_Fill_Size(Element_Offset+Length);
}
//---------------------------------------------------------------------------
void File_Aac::PARAconfig()
{
Element_Begin1("PARAconfig");
int8u PARAmode;
Get_S1(2,PARAmode, "PARAmode");
if (PARAmode != 1)
ErHVXCconfig();
if (PARAmode != 0)
HILNconfig();
bool PARAextensionFlag;
Get_SB(PARAextensionFlag, "PARAextensionFlag");
if (PARAextensionFlag) {
/* to be defined in MPEG-4 Phase 3 */
}
Element_End0();
}
//---------------------------------------------------------------------------
// AAC in ES, SBR part, 3+ bytes
void File_Mpeg4_AudioSpecificConfig::SBR ()
{
//Parsing
int16u syncExtensionType;
int8u samplingFrequencyIndex;
Element_Begin("SBR");
Get_S2 (11, syncExtensionType, "syncExtensionType");
if (syncExtensionType!=0x2B7)
{
Element_End();
return;
}
Get_S1 (5, extensionAudioObjectType, "extensionAudioObjectType");
if (extensionAudioObjectType==0x05)
{
Get_SB ( sbrPresentFlag, "sbrPresentFlag");
if (sbrPresentFlag)
{
Get_S1 (4, samplingFrequencyIndex, "extensionSamplingFrequencyIndex"); Param_Info(MP4_SamplingRate[samplingFrequencyIndex]);
if (samplingFrequencyIndex==0xF)
{
Get_S3 (24, samplingFrequency, "extensionSamplingFrequency");
}
else
samplingFrequency=MP4_SamplingRate[samplingFrequencyIndex];
}
}
Element_End();
FILLING_BEGIN();
//Filling
if (sbrPresentFlag)
{
Fill(Stream_Audio, StreamPos_Last, Audio_Format_Settings, "SBR");
Fill(Stream_Audio, StreamPos_Last, Audio_Format_Settings_SBR, "Yes", Unlimited, true, true);
Fill(Stream_Audio, StreamPos_Last, Audio_Format_Settings_PS, "No");
Ztring Codec=Retrieve(Stream_Audio, StreamPos_Last, Audio_Codec);
Fill(Stream_Audio, StreamPos_Last, Audio_Codec, Codec+_T("/SBR"), true);
Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, samplingFrequency, 10, true);
}
//PS stuff
if (Data_Remain())
PS();
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Tak::STREAMINFO()
{
//Parsing
int32u num_samples_hi, samplerate;
int8u num_samples_lo, framesizecode, samplesize;
bool channels;
Skip_L1 ( "unknown");
BS_Begin();
Get_S1 ( 2, num_samples_lo, "num_samples (lo)");
Get_S1 ( 3, framesizecode, "framesizecode");
Skip_S1( 2, "unknown");
BS_End();
Get_L4 (num_samples_hi, "num_samples (hi)"); Param_Info2((((int64u)num_samples_hi)<<2 | num_samples_lo), " samples");
Get_L3 (samplerate, "samplerate"); Param_Info2((samplerate/16)+6000, " Hz");
BS_Begin();
Skip_S1( 4, "unknown");
Get_SB ( channels, "channels"); Param_Info1(channels?"Stereo":"Mono");
Get_S1 ( 2, samplesize, "samplesize"); Param_Info1(Tak_samplesize[samplesize]);
Skip_SB( "unknown");
BS_End();
Skip_L3( "crc");
FILLING_BEGIN()
//Coherency
if (samplerate==0)
return;
//Computing
int64u Samples=((int64u)num_samples_hi)<<2 | num_samples_lo;
int32u SamplingRate=(samplerate/16)+6000;
//Filling
File__Tags_Helper::Accept("TAK");
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "TAK");
Fill(Stream_Audio, 0, Audio_Codec, "TAK");
Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);
Fill(Stream_Audio, 0, Audio_Channel_s_, channels?2:1);
if (Tak_samplesize[samplesize])
Fill(Stream_Audio, 0, Audio_BitDepth, Tak_samplesize[samplesize]);
Fill(Stream_Audio, 0, Audio_Duration, Samples*1000/SamplingRate);
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Aac::ER_SC_CelpHeader ()
{
Element_Begin1("ER_SC_CelpHeader");
bool ExcitationMode;
Get_SB(ExcitationMode, "ExcitationMode");
Skip_SB( "SampleRateMode");
Skip_SB( "FineRateControl");
Skip_SB( "SilenceCompression");
if (ExcitationMode == 1/*RPE*/) {
Skip_S1(3, "RPE_Configuration");
}
if (ExcitationMode == 0/*MPE*/) {
Skip_S1(5, "MPE_Configuration");
Skip_S1(2, "NumEnhLayers");
Skip_SB( "BandwidthScalabilityMode");
}
Element_End0();
}
//---------------------------------------------------------------------------
void File_Vc3::CodingControlA()
{
//Parsing
Element_Begin1("Coding Control A");
BS_Begin();
int8u FFC;
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Get_S1 (2, FFC, "Field/Frame Count"); Param_Info1(Vc3_FFC[FFC]);
Mark_1();
Mark_0();
Mark_0();
Get_SB ( CRCF, "CRC flag");
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_1();
Mark_0();
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
Mark_0();
BS_End();
Element_End0();
FILLING_BEGIN();
if (FFC_FirstFrame==(int8u)-1)
FFC_FirstFrame=FFC;
FILLING_END();
}
//---------------------------------------------------------------------------
// AAC in ES, SBR part, 2 bytes?
// Format is unknown
void File_Mpeg4_AudioSpecificConfig::PS ()
{
//Parsing
Element_Begin("PS");
bool PS;
Skip_S1(11, "Unknown");
Get_SB ( PS, "PS present");
Element_End();
FILLING_BEGIN();
if (PS)
{
Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, 2, 10, true);
Fill(Stream_Audio, StreamPos_Last, Audio_Format_Settings, "PS");
Fill(Stream_Audio, StreamPos_Last, Audio_Format_Settings_PS, "Yes", Unlimited, true, true);
Ztring Codec=Retrieve(Stream_Audio, StreamPos_Last, Audio_Codec);
Fill(Stream_Audio, StreamPos_Last, Audio_Codec, Codec+_T("/PS"), true);
Fill(Stream_Audio, StreamPos_Last, Audio_ChannelPositions, "", Unlimited, true, true);
}
FILLING_END();
}
