//---------------------------------------------------------------------------
void File_Als::FileHeader_Parse()
{
//Parsing
int32u SampleRate, Samples;
int16u Channels;
int8u BitsPerSample, FileType;
Skip_C4( "signature");
Get_B4 (SampleRate, "sample rate");
Get_B4 (Samples, "samples");
Get_B2 (Channels, "channels-1"); Param_Info2(Channels+1, " channel(s)");
BS_Begin();
Get_S1 (3, FileType, "file type"); // WAV, RIFF, AIFF
Get_S1 (3, BitsPerSample, "bits per sample"); Param_Info2((BitsPerSample+1)*8, " bits");
Skip_SB( "floating point");
Skip_SB( "samples are big-endian");
BS_End();
FILLING_BEGIN();
if (!CalcDurationUncompressedSize(Samples, SampleRate, (BitsPerSample+1)*8, Channels))
return;
File__Tags_Helper::Accept("ALS");
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "ALS");
Fill(Stream_Audio, 0, Audio_Codec, "ALS");
Fill(Stream_Audio, 0, Audio_BitDepth, (BitsPerSample+1)*8);
Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, Channels+1);
Fill(Stream_Audio, StreamPos_Last, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Duration, Duration);
//No more need data
File__Tags_Helper::Finish("ALS");
FILLING_END();
}
//---------------------------------------------------------------------------
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_Pcm_M2ts::Read_Buffer_Continue()
{
if (Buffer_Size==0)
return;
//Parsing
int16u audio_data_payload_size;
Get_B2 ( audio_data_payload_size, "audio_data_payload_size");
BS_Begin();
Get_S1 (4, channel_assignment, "channel_assignment"); Param_Info2(Pcm_M2TS_channel_assignment[channel_assignment], " channel(s)");
Get_S1 (4, sampling_frequency, "sampling_frequency"); Param_Info2(Pcm_M2TS_sampling_frequency[sampling_frequency], " Hz");
Get_S1 (2, bits_per_sample, "bits_per_sample"); Param_Info2(Pcm_M2TS_bits_per_sample[bits_per_sample], " bits");
Skip_SB( "start_flag");
Skip_S1(5, "reserved");
BS_End();
Skip_XX(audio_data_payload_size, "audio_data_payload");
FILLING_BEGIN_PRECISE();
if (!Status[IsAccepted])
{
Accept();
Finish();
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_DvbSubtitle::region_composition_segment()
{
Element_Name("region composition segment");
//Parsing
int16u region_width, region_height;
int8u region_id, region_depth;
Get_B1 ( region_id, "region_id");
BS_Begin();
Skip_S1(4, "region_version_number");
Skip_S1(1, "region_fill_flag");
Skip_S1(3, "reserved");
BS_End();
Get_B2 ( region_width, "region_width");
Get_B2 ( region_height, "region_height");
BS_Begin();
Skip_S1(3, "region_level_of_compatibility");
Get_S1 (3, region_depth, "region_depth"); Param_Info2(DvbSubtitle_region_depth[region_depth], " bits");
Skip_S1(2, "reserved");
BS_End();
Skip_B1( "CLUT_id");
Skip_B1( "region_8-bit_pixel_code");
BS_Begin();
Skip_S1(4, "region_4-bit_pixel-code");
Skip_S1(2, "region_2-bit_pixel-code");
Skip_S1(2, "reserved");
BS_End();
while(Element_Offset<Element_Size)
{
Element_Begin1("Object");
int8u object_type;
Skip_B2( "object_id");
BS_Begin();
Get_S1 ( 2, object_type, "object_type");
Skip_S1( 2, "object_provider_flag");
Skip_S1(12, "object_horizontal_position");
Skip_S1( 4, "reserved");
Skip_S1(12, "object_vertical_position");
BS_End();
switch (object_type)
{
case 0x01 :
case 0x02 :
Skip_B2( "foreground_pixel_code");
Skip_B2( "background_pixel_code");
break;
default : ;
}
Element_End0();
}
FILLING_BEGIN();
region_data& region = subtitle_streams[subtitle_stream_id].pages[page_id].regions[region_id];
region.region_composition_segment=true;
region.region_width=region_width;
region.region_height=region_height;
region.region_depth=region_depth;
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();
}
//---------------------------------------------------------------------------
// 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_Info1(AvsV_aspect_ratio[aspect_ratio]);
Get_S1 ( 4, frame_rate_code, "frame_rate_code"); Param_Info1(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_Info2(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_Flac::STREAMINFO()
{
//Parsing
int64u Samples;
int32u FrameSize_Min, FrameSize_Max, SampleRate;
int8u Channels, BitPerSample;
Skip_B2( "BlockSize_Min"); //The minimum block size (in samples) used in the stream.
Skip_B2( "BlockSize_Max"); //The maximum block size (in samples) used in the stream. (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
Get_B3 ( FrameSize_Min, "FrameSize_Min"); //The minimum frame size (in bytes) used in the stream. May be 0 to imply the value is not known.
Get_B3 ( FrameSize_Max, "FrameSize_Max"); //The maximum frame size (in bytes) used in the stream. May be 0 to imply the value is not known.
BS_Begin();
Get_S3 (20, SampleRate, "SampleRate"); //Sample rate in Hz. Though 20 bits are available, the maximum sample rate is limited by the structure of frame headers to 1048570Hz. Also, a value of 0 is invalid.
Get_S1 ( 3, Channels, "Channels"); Param_Info2(Channels+1, " channels"); //(number of channels)-1. FLAC supports from 1 to 8 channels
Get_S1 ( 5, BitPerSample, "BitPerSample"); Param_Info2(BitPerSample+1, " bits"); //(bits per sample)-1. FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.
Get_S5 (36, Samples, "Samples");
BS_End();
Skip_B16( "MD5 signature of the unencoded audio data");
FILLING_BEGIN()
if (SampleRate==0)
return;
File__Tags_Helper::Accept("FLAC");
File__Tags_Helper::Streams_Fill();
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "FLAC");
Fill(Stream_Audio, 0, Audio_Codec, "FLAC");
if (FrameSize_Min==FrameSize_Max && FrameSize_Min!=0 ) // 0 means it is unknown
Fill(Stream_Audio, 0, Audio_BitRate_Mode, "CBR");
else
Fill(Stream_Audio, 0, Audio_BitRate_Mode, "VBR");
Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Channel_s_, Channels+1);
Fill(Stream_Audio, 0, Audio_BitDepth, BitPerSample+1);
if (!IsSub)
Fill(Stream_Audio, 0, Audio_Duration, Samples*1000/SampleRate);
Buffer_MaximumSize=4*1024*1024;
FILLING_END();
}
//---------------------------------------------------------------------------
void File_La::FileHeader_Parse()
{
//Parsing
Ztring Major, Minor;
int32u SampleRate, Samples, BytesPerSecond, UnCompSize, WAVEChunk, FmtSize, FmtChunk, CRC32;
int16u RawFormat, Channels, BytesPerSample, BitsPerSample;
Skip_Local(2, "signature");
Get_Local (1, Major, "major_version");
Get_Local (1, Minor, "minor_version");
Get_L4 (UnCompSize, "uncompressed_size");
Get_L4 (WAVEChunk, "chunk");
Skip_L4( "fmt_size");
Get_L4 (FmtChunk, "fmt_chunk");
Get_L4 (FmtSize, "fmt_size");
Get_L2 (RawFormat, "raw_format");
Get_L2 (Channels, "channels"); Param_Info2(Channels, " channel(s)");
Get_L4 (SampleRate, "sample_rate");
Get_L4 (BytesPerSecond, "bytes_per_second");
Get_L2 (BytesPerSample, "bytes_per_sample");
Get_L2 (BitsPerSample, "bits_per_sample");
Get_L4 (Samples, "samples");
Skip_L1( "flags");
Get_L4 (CRC32, "crc");
FILLING_BEGIN()
if (SampleRate==0)
return;
Duration=((int64u)Samples/Channels)*1000/SampleRate; // Seems that it's samples per channels otherwise Duration is doubled ??!!
if (Duration==0)
return;
UncompressedSize=(Samples)*Channels*(BitsPerSample/8);
if (UncompressedSize==0)
return;
File__Tags_Helper::Accept("LA");
Fill(Stream_General, 0, General_Format_Version, Major+__T('.')+Minor);
File__Tags_Helper::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_Format, "LA");
Fill(Stream_Audio, 0, Audio_Codec, "LA");
Fill(Stream_Audio, 0, Audio_Format_Version, Major+__T('.')+Minor);
Fill(Stream_Audio, 0, Audio_BitDepth, BitsPerSample);
Fill(Stream_Audio, 0, Audio_Channel_s_, Channels);
Fill(Stream_Audio, 0, Audio_SamplingRate, SampleRate);
Fill(Stream_Audio, 0, Audio_Duration, Duration);
//No more need data
File__Tags_Helper::Finish("LA");
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Dpg::FileHeader_Parse()
{
//Parsing
int32u FrameCount, FrameRate, SamplingRate;
Skip_C4( "Signature");
Get_L4 (FrameCount, "Frame count");
Get_L4 (FrameRate, "Frame rate"); Param_Info2(FrameRate/0x100, " fps");
Get_L4 (SamplingRate, "Sampling rate");
Skip_L4( "0x00000000");
Get_L4 (Audio_Offset, "Audio Offset");
Get_L4 (Audio_Size, "Audio Size");
Get_L4 (Video_Offset, "Video Offset");
Get_L4 (Video_Size, "Video Size");
FILLING_BEGIN();
Accept("DPG");
Fill(Stream_General, 0, General_Format, "DPG");
Stream_Prepare(Stream_Video);
Fill(Stream_Video, 0, Video_FrameRate, (float)(FrameRate/0x100), 3);
Fill(Stream_Video, 0, Video_FrameCount, FrameCount);
Fill(Stream_Video, 0, Video_StreamSize, Video_Size);
Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, 0, Audio_SamplingRate, SamplingRate);
Fill(Stream_Audio, 0, Audio_StreamSize, Audio_Size);
//Positionning
#if defined(MEDIAINFO_MPEGA_YES)
Parser=new File_Mpega();
Open_Buffer_Init(Parser);
GoTo(Audio_Offset, "DPG");
#elif defined(MEDIAINFO_MPEGV_YES)
Audio_Size=0;
Parser=new File_Mpegv();
Open_Buffer_Init(Parser);
GoTo(Video_Offset, "DPG");
#else
Finish("DPG");
#endif
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Jpeg::COD()
{
//Parsing
int16u Levels;
int8u Style, Style2, MultipleComponentTransform;
bool PrecinctUsed;
Get_B1 (Style, "Scod - Style");
Get_Flags (Style, 0, PrecinctUsed, "Precinct used");
Skip_Flags(Style, 1, "Use SOP (start of packet)");
Skip_Flags(Style, 2, "Use EPH (end of packet header)");
Skip_B1( "Number of decomposition levels");
Skip_B1( "Progression order");
Get_B2 (Levels, "Number of layers");
Info_B1(DimX, "Code-blocks dimensions X (2^(n+2))"); Param_Info2(1<<(DimX+2), " pixels");
Info_B1(DimY, "Code-blocks dimensions Y (2^(n+2))"); Param_Info2(1<<(DimY+2), " pixels");
Get_B1 (Style2, "Style of the code-block coding passes");
Skip_Flags(Style, 0, "Selective arithmetic coding bypass");
Skip_Flags(Style, 1, "MQ states for all contexts");
Skip_Flags(Style, 2, "Regular termination");
Skip_Flags(Style, 3, "Vertically stripe-causal context formation");
Skip_Flags(Style, 4, "Error resilience info is embedded on MQ termination");
Skip_Flags(Style, 5, "Segmentation marker is to be inserted at the end of each normalization coding pass");
Skip_B1( "Transform");
Get_B1(MultipleComponentTransform, "Multiple component transform");
if (PrecinctUsed)
{
BS_Begin();
Skip_S1(4, "LL sub-band width");
Skip_S1(4, "LL sub-band height");
BS_End();
for (int16u Pos=0; Pos<Levels; Pos++)
{
Element_Begin1("Decomposition level");
BS_Begin();
Skip_S1(4, "decomposition level width");
Skip_S1(4, "decomposition level height");
BS_End();
Element_End0();
}
}
FILLING_BEGIN();
if (Frame_Count==0 && Field_Count==0)
{
switch (MultipleComponentTransform)
{
case 0x01 : Fill(StreamKind_Last, 0, "Compression_Mode", "Lossless"); break;
case 0x02 : Fill(StreamKind_Last, 0, "Compression_Mode", "Lossy"); break;
default : ;
}
}
FILLING_END();
}
//---------------------------------------------------------------------------
void File_Iso9660::Primary_Volume_Descriptor()
{
int32u Volume_Space_Size;
Element_Begin1("Volume_Descriptor");
Skip_B1("Volume Descriptor Type");
Skip_Local(5,"Standard Identifier");
Skip_B1("Volume Descriptor Version");
Skip_B1("Unused field");
Skip_Local(32,"System Identifier");
Skip_Local(32,"Volume Identifier");
Skip_XX(8,"Unused field");
Get_D4(Volume_Space_Size, "Volume Space Size"); Param_Info2(Volume_Space_Size*(int64u)2048, " bytes");
Skip_XX(32,"Unused field");
Skip_B4("Volume Set Size");
Skip_B4("Volume Sequence Number");
Skip_B4("Logical Block Size");
Skip_B8("Path Table Size");
Skip_B4("Location of Occurrence of Type L Path Table");
Skip_B4("Location of Optional Occurrence of Type L Path Table");
Skip_B4("Location of Occurrence of Type M Path Table");
Skip_B4("Location of Optional Occurrence of Type M Path Table");
Skip_Local(34,"Directory Record for Root Directory");
Skip_Local(128,"Volume Set Identifier");
Skip_Local(128,"Publisher Identifier");
Skip_Local(128,"Data Preparer Identifier");
Skip_Local(128,"Application Identifier");
Skip_Local(37,"Copyright File Identifier");
Skip_Local(37,"Abstract File Identifier");
Skip_Local(37,"Bibliographic File Identifier");
Skip_XX(17,"Volume Creation Date and Time");
Element_End0();
}
//---------------------------------------------------------------------------
void File_Aac::ALSSpecificConfig()
{
//Not in spec, but something weird in the example I have
int32u Junk;
while (Data_BS_Remain())
{
Peek_S4(32, Junk);
if (Junk!=0x414C5300)
{
Skip_SB( "Unknown");
}
else
break;
}
if (Data_BS_Remain()==0)
return; //There is a problem
Element_Begin1("ALSSpecificConfig");
bool chan_config,chan_sort,crc_enabled,aux_data_enabled;
int32u samp_freq, samples;
int16u channels,frame_length;
int8u ra_flag,random_access, file_type;
Skip_BS(32,"als_id");
Get_BS (32, samp_freq, "samp_freq");
Get_BS (32, samples, "samples");
Get_S2 (16, channels, "channels"); Param_Info2(channels+1, " channel(s)");
Get_S1 (3, file_type, "file_type");
Skip_S1(3,"resolution");
Skip_SB("floating");
Skip_SB("msb_first");
Get_S2 (16,frame_length,"frame_length");
Get_S1 (8,random_access,"random_access");
Get_S1 (2,ra_flag,"ra_flag");
Skip_SB("adapt_order");
Skip_S1(2,"coef_table");
Skip_SB("long_term_prediction");
Skip_S2(10,"max_order");
Skip_S1(2,"block_switching");
Skip_SB("bgmc_mode");
Skip_SB("sb_part");
Skip_SB("joint_stereo");
Skip_SB("mc_coding");
Get_SB (chan_config,"chan_config");
Get_SB (chan_sort,"chan_sort");
Get_SB (crc_enabled,"crc_enabled");
Skip_SB("RLSLMS");
Skip_BS(5,"(reserved)");
Get_SB (aux_data_enabled,"aux_data_enabled");
if (chan_config)
Skip_S2(16,"chan_config_info");
if (chan_sort)
{
int16u ChBits=(int16u)ceil(log((double)(channels+1))/log((double)2));
for (int8u c=0; c<=channels; c++)
Skip_BS(ChBits, "chan_pos[c]");
}
if(Data_BS_Remain()%8)
Skip_S1(Data_BS_Remain()%8, "byte_align");
BS_End();
int32u header_size,trailer_size;
Get_B4(header_size, "header_size");
Get_B4(trailer_size, "trailer_size");
#ifdef MEDIAINFO_RIFF_YES
if (file_type==1) //WAVE file
{
Element_Begin1("orig_header");
File_Riff MI;
Open_Buffer_Init(&MI);
Open_Buffer_Continue(&MI, Buffer+Buffer_Offset+(size_t)Element_Offset, header_size);
Element_Offset+=header_size;
File__Analyze::Finish(&MI); //No merge of data, only for trace information, because this is the data about the decoded stream, not the encoded stream
Element_End0();
}
else
#endif //MEDIAINFO_RIFF_YES
Skip_XX(header_size, "orig_header[]");
Skip_XX(trailer_size, "orig_trailer[]");
if (crc_enabled)
Skip_B4( "crc");
if ((ra_flag == 2) && (random_access > 0))
for (int32u f=0; f<((samples-1)/(frame_length+1))+1; f++)
Skip_B4( "ra_unit_size[f]");
if (aux_data_enabled)
{
int32u aux_size;
Get_B4(aux_size, "aux_size");
Skip_XX(aux_size, "aux_data[]");
}
Element_End0();
BS_Begin(); //To be in sync with other objectTypes
FILLING_BEGIN();
//Filling
File__Analyze::Stream_Prepare(Stream_Audio);
Fill(Stream_Audio, StreamPos_Last, Audio_Channel_s_, channels+1);
//Forcing default confignuration (something weird in the example I have)
channelConfiguration=0;
sampling_frequency_index=(int8u)-1;
sampling_frequency=samp_freq;
FILLING_END();
}
//---------------------------------------------------------------------------
void File_HuffYuv::FrameHeader()
{
//Version
if (Element_Size<4)
{
Reject();
return;
}
int8u Version;
if (Buffer[3]==0)
{
Version=Element_Size>4?2:1;
}
else
Version=3;
//Parsing
int8u bpp_override=0, chroma_v_shift=0, chroma_h_shift=0, interlace;
bool alpha=false, chroma=false, rgb=false;
Element_Begin1("method");
BS_Begin();
Skip_SB( "unknown");
Skip_SB( "decorrelate");
Skip_S1(6, "predictor");
Element_End0();
if (Version<=2)
{
Get_S1 (8, bpp_override, "bpp_override");
}
else
{
Get_S1 (4, bpp_override, "bit_depth"); Param_Info2(bpp_override+1, "bits");
Get_S1 (2, chroma_v_shift, "chroma_v_shift");
Get_S1 (2, chroma_h_shift, "chroma_h_shift");
}
Skip_SB( "unknown");
Skip_SB( "context");
Get_S1 (2, interlace, "interlace");
if (Version<=2)
{
Skip_S1(4, "unknown");
Skip_S1(8, "zero");
}
else
{
Skip_SB( "unknown");
Get_SB ( alpha, "alpha");
Get_SB ( rgb, "rgb");
if (rgb)
Skip_SB( "unused");
else
Get_SB ( chroma, "chroma");
Skip_S1(7, "unused");
Skip_SB( "version 3+ indicator");
}
BS_End();
if (Frame_Count==0)
{
if (Version==2)
{
//BiCount;
if (bpp_override)
BitCount=bpp_override;
Fill(Stream_Video, 0, Video_BitDepth, 8);
}
else
{
Fill(Stream_Video, 0, Video_BitDepth, bpp_override+1);
}
Fill(Stream_Video, 0, Video_Format_Version, __T("Version ")+Ztring::ToZtring(Version));
if (Version==2)
{
Fill(Stream_Video, 0, Video_ColorSpace, HuffYUV_ColorSpace(BitCount));
Fill(Stream_Video, 0, Video_ChromaSubsampling, HuffYUV_ChromaSubsampling(BitCount));
}
else
{
Fill(Stream_Video, 0, Video_ColorSpace, HuffYUV_ColorSpace(rgb, chroma, alpha));
string ChromaSubsampling;
if (chroma)
{
switch (chroma_h_shift)
{
case 0 :
switch (chroma_v_shift)
{
case 0 : ChromaSubsampling="4:4:4"; break;
default: ;
}
break;
case 1 :
switch (chroma_v_shift)
{
case 0 : ChromaSubsampling="4:2:2"; break;
case 1 : ChromaSubsampling="4:2:0"; break;
default: ;
}
break;
case 2 :
switch (chroma_v_shift)
{
case 0 : ChromaSubsampling="4:1:1"; break;
case 1 : ChromaSubsampling="4:1:0"; break;
case 2 : ChromaSubsampling="4:1:0 (4x4)"; break;
default: ;
}
break;
default: ;
}
}
if (!ChromaSubsampling.empty() && alpha)
ChromaSubsampling+=":4";
Fill(Stream_Video, 0, Video_ChromaSubsampling, ChromaSubsampling);
}
switch (interlace)
{
case 0 :
if (Version<=2 && Height)
Fill(Stream_Video, 0, Video_ScanType, Height>288?"Interlaced":"Progressive");
break;
case 1 :
Fill(Stream_Video, 0, Video_ScanType, "Interlaced");
break;
case 2 :
Fill(Stream_Video, 0, Video_ScanType, "Progressive");
break;
default:;
}
}
}
//---------------------------------------------------------------------------
void File_H263::Data_Parse()
{
//Parsing
int8u Temporal_Reference_Temp;
BS_Begin();
Skip_S3(22, "Picture Start Code (PSC)");
Get_S1 ( 8, Temporal_Reference_Temp, "Temporal Reference (TR)");
if (!Temporal_Reference_IsValid)
{
Temporal_Reference=Temporal_Reference_Temp;
Temporal_Reference_IsValid=true;
}
else
Temporal_Reference++;
if (Temporal_Reference_Temp!=Temporal_Reference)
{
Trusted_IsNot("Out of Order");
Open_Buffer_Unsynch();
return;
}
Element_Begin1("Type Information (PTYPE)");
Mark_1();
Mark_0();
Skip_SB( "Split screen indicator");
Skip_SB( "Document camera indicator");
Skip_SB( "Full Picture Freeze Release");
Get_S1 (3, Source_Format, "Source Format"); Param_Info1(H263_Source_Format[Source_Format]);
if (Source_Format!=7)
{
Skip_SB( "Picture Coding Type");
Skip_SB( "Unrestricted Motion Vector mode");
Skip_SB( "Syntax-based Arithmetic Coding mode");
Skip_SB( "Advanced Prediction mode");
Skip_SB( "PB-frames mode");
}
Element_End0();
if (Source_Format==7) // Extended PTYPE
{
Element_Begin1("Plus PTYPE (PLUSPTYPE)");
int8u Ufep, PixelAspectRatioCode=0, Width=0, Height=0;
Get_S1 ( 3, Ufep, "Update Full Extended PTYPE (UFEP)");
switch (Ufep)
{
case 0 :
break;
case 1 :
Element_Begin1("Optional Part of PLUSPTYPE (OPPTYPE)");
Get_S1 (3, Source_Format, "Source Format"); Param_Info1(H263_Source_Format[Source_Format]);
Skip_SB( "Custom PCF");
Skip_SB( "Unrestricted Motion Vector (UMV) mode");
Skip_SB( "Syntax-based Arithmetic Coding (SAC) mode");
Skip_SB( "Advanced Prediction (AP) mode");
Skip_SB( "Advanced INTRA Coding (AIC) mode");
Skip_SB( "Deblocking Filter (DF) mode");
Skip_SB( "Slice Structured (SS) mode");
Skip_SB( "Reference Picture Selection (RPS) mode");
Skip_SB( "Independent Segment Decoding (ISD) mode");
Skip_SB( "Alternative INTER VLC (AIV) mode");
Skip_SB( "Modified Quantization (MQ) mode");
Mark_1();
Mark_0();
Mark_0();
Mark_0();
Element_End0();
break;
default :
BS_End();
Skip_XX(Element_Size-Element_Offset, "Unknown");
return; //TODO: frame count...
}
Element_Begin1("mandatory part of PLUSPTYPE when PLUSPTYPE present (MPPTYPE)");
Skip_S1(3, "Picture Type Code");
Skip_SB( "Reference Picture Resampling (RPR) mode");
Skip_SB( "Reduced-Resolution Update (RRU) mode");
Skip_SB( "Rounding Type (RTYPE)");
Mark_0();
Mark_0();
Mark_1();
Element_End0();
Element_End0();
Skip_SB( "CPM");
Skip_S1(2, "PSBI");
Element_Begin1("Custom Picture Format (CPFMT)");
Get_S1 (4, PixelAspectRatioCode, "Pixel Aspect Ratio Code");
Get_S1 (4, Width, "Picture Width Indication");
Width++; Width<<=2; Param_Info2(Width, " pixels");
Mark_1();
Get_S1 (4, Height, "Picture Height Indication");
Height<<=2; Param_Info2(Height, " pixels");
Element_End0();
if (PixelAspectRatioCode==0xF)
{
Element_Begin1("Extended Pixel Aspect Ratio (EPAR)");
Get_S1 (8, PAR_W, "PAR Width");
Get_S1 (8, PAR_H, "PAR Height");
Element_End0();
}
else
{
PAR_W=H263_PAR_W[PixelAspectRatioCode];
PAR_H=H263_PAR_H[PixelAspectRatioCode];
}
}
BS_End();
Skip_XX(Element_Size-Element_Offset, "Other data");
FILLING_BEGIN();
Element_Info1(Frame_Count);
Frame_Count++;
//Filling
if (!Status[IsFilled] && Frame_Count>=Frame_Count_Valid)
{
Accept("H.263");
Finish("H.263");
}
FILLING_END();
}