//---------------------------------------------------------------------------
// Write
void ZtringListList::Write(const Ztring &ToWrite)
{
clear();
if (!&ToWrite || !ToWrite.size())
return;
size_type PosC=0;
bool Fini=false;
Ztring C1;
ZtringList ZL1;
ZL1.Separator_Set(0, Separator[1]);
ZL1.Quote_Set(Quote);
ZL1.Max_Set(0, Max[1]);
do
{
C1=ToWrite.SubString(_T(""), Separator[0], PosC, Ztring_AddLastItem);
ZL1.Write(C1);
push_back(ZL1);
PosC+=C1.size()+Separator[0].size();
if (PosC>=ToWrite.size())
Fini=true;
}
while (!Fini);
}
//---------------------------------------------------------------------------
// Write
void ZtringList::Write(const Ztring &ToWrite)
{
clear();
if (ToWrite.empty())
return;
size_type PosC=0;
bool Fini=false;
Ztring C1;
Ztring DelimiterL;
Ztring DelimiterR;
do
{
//Searching quotes
if (ToWrite[PosC]==Quote[0])
{
size_t Pos_End=PosC+1;
while (Pos_End<ToWrite.size())
{
if (ToWrite[Pos_End]==Quote[0] && Pos_End+1<ToWrite.size() && ToWrite[Pos_End+1]==Quote[0])
Pos_End+=2; //Double quote, skipping
else
{
if (ToWrite[Pos_End]==Quote[0])
break;
Pos_End++;
}
}
C1=ToWrite.substr(PosC+Quote.size(), Pos_End-PosC);
PosC+=C1.size()+Quote.size();
if (C1.size()>0 && C1[C1.size()-1]==Quote[0])
{
C1.resize(C1.size()-1);
PosC+=Quote.size();
}
}
else //Normal
{
C1=ToWrite.SubString(tstring(), Separator[0], PosC, Ztring_AddLastItem);
PosC+=C1.size()+Separator[0].size();
}
C1.FindAndReplace(Quote+Quote, Quote, 0, Ztring_Recursive);
if (size()<Max[0])
push_back(C1);
if (PosC>=ToWrite.size())
Fini=true;
}
while (!Fini);
return;
}
void MediaInfo_Config_MediaInfo::Event_Send (const int8u* Data_Content, size_t Data_Size, const Ztring &File_Name)
{
CriticalSectionLocker CSL(CS);
if (Event_CallBackFunction)
Event_CallBackFunction ((unsigned char*)Data_Content, Data_Size, Event_UserHandler);
else
{
MediaInfo_Event_Generic* Event_Generic=(MediaInfo_Event_Generic*)Data_Content;
if ((Event_Generic->EventCode&0x00FFFF00)==(MediaInfo_Event_Global_Demux<<8))
{
if (!MediaInfoLib::Config.Demux_Get())
return;
if (File_Name.empty())
return;
MediaInfo_Event_Global_Demux_0* Event=(MediaInfo_Event_Global_Demux_0*)Data_Content;
Ztring File_Name_Final(File_Name);
bool AddRawExtension=false;
for (size_t Pos=0; Pos<Event->StreamIDs_Size; Pos++)
{
if (Event->StreamIDs_Width[Pos]==17)
{
Ztring ID;
ID.From_CC4((int32u)Event->StreamIDs[Pos]);
File_Name_Final+=_T('.')+ID;
}
else if (Event->StreamIDs_Width[Pos] && Event->StreamIDs_Width[Pos]<=16)
{
Ztring ID;
ID.From_Number(Event->StreamIDs[Pos], 16);
while (ID.size()<Event->StreamIDs_Width[Pos])
ID.insert(0, 1, _T('0'));
if (ID.size()>Event->StreamIDs_Width[Pos])
ID.erase(0, ID.size()-Event->StreamIDs_Width[Pos]);
File_Name_Final+=_T('.')+ID;
}
else
AddRawExtension=true;
}
if (AddRawExtension)
File_Name_Final+=_T(".raw");
File F;
F.Open(File_Name_Final, File::Access_Write_Append);
F.Write(Event->Content, Event->Content_Size);
}
}
}
//---------------------------------------------------------------------------
// Nettoyage
bool ZtringListListF::NettoyerEspaces (Ztring &ANettoyer)
{
size_t Debut=0;
while (Debut<ANettoyer.size() && ANettoyer[Debut]==__T(' '))
Debut++;
size_t Fin=ANettoyer.size()-1;
while (Fin!=(size_t)-2 && ANettoyer[Fin]==__T(' '))
Fin--;
if (Fin>=Debut)
ANettoyer=ANettoyer.substr(Debut, Fin-Debut+1);
else
ANettoyer=Ztring();
return true;
}
Ztring ZtringListList::Read1 (size_type Pos1) const
{
Ztring ToReturn;
size_type Size=size()-1;
for (size_type Pos=0; Pos<Size; Pos++)
ToReturn+=operator[](Pos).Read(Pos1)+Separator[0];
ToReturn+=operator[](Size).Read(Pos1);
//Delete all useless separators at the end
if(ToReturn(ToReturn.size()-1)==Separator[0][Separator[0].size()-1]) //Optimize speed
while (ToReturn.find(Separator[0].c_str(), ToReturn.size()-Separator[0].size())!=std::string::npos)
ToReturn.resize(ToReturn.size()-Separator[0].size());
return ToReturn;
}
//---------------------------------------------------------------------------
// Load CSV
bool ZtringListListF::CSV_Charger ()
{
//Read file
File F;
if (!F.Open(Name))
return false;
int8u* Buffer=new int8u[(size_t)F.Size_Get()+1];
size_t BytesCount=F.Read(Buffer, (size_t)F.Size_Get());
F.Close();
if (BytesCount==Error)
{
delete[] Buffer; //Buffer=NULL;
return false;
}
Buffer[(int32u)BytesCount]=(int8u)'\0';
//Convert file in UTF-8 or Local
Ztring File;
if (!Local)
{
//UTF-8
File.From_UTF8((char*)Buffer, 0, BytesCount);
#ifdef _DEBUG
if (File.size()==0)
File.From_Local((char*)Buffer, 0, BytesCount);
#endif //_DEBUG
}
if (File.size()==0)
//Local of UTF-8 failed
File.From_Local((char*)Buffer, 0, BytesCount);
//Separators
if (Separator[0]==__T("(Default)"))
Separator[0]=EOL;
Ztring SeparatorT=Separator[1];
Separator[1]=__T(";");
//Writing
Write(File);
//Separators
Separator[1]=SeparatorT;
delete[] Buffer; //Buffer=NULL;
return true;
}
void MemoryDebug::ReportLeaks()
{
Ztring m_File;
//std::ofstream m_File ("Debug_MemoryLeak.txt"); // Fichier de sortie
// Détail des fuites
std::size_t TotalSize = 0;
for (TBlockMap::iterator i = m_Blocks.begin(); i != m_Blocks.end(); ++i)
{
// Ajout de la taille du bloc au cumul
TotalSize += i->second.Size;
// Inscription dans le fichier des informations sur le bloc courant
/*
m_File << "-> 0x" << std::hex << i->first << std::dec
<< " | " << std::setw(7) << std::setfill(' ') << static_cast<int>(i->second.Size) << " bytes"
<< " | " << i->second.File.c_str() << " (" << i->second.Line << ")" << std::endl;
*/
m_File.append(_T("-> 0x"));
m_File.append(Ztring::ToZtring((size_t)i->first, 16));
m_File.append(_T(" | "));
Ztring Temp;
Temp.From_Number(static_cast<int>(i->second.Size));
while(Temp.size()<7)
Temp=_T(" ")+Temp;
m_File.append(Temp);
m_File.append(_T(" bytes"));
m_File.append(_T(" | "));
m_File.append(Ztring().From_Local(i->second.File.c_str()));
m_File.append(_T(" ("));
m_File.append(Ztring::ToZtring(i->second.Line));
m_File.append(_T(")"));
m_File.append(EOL);
}
// Affichage du cumul des fuites
/*
m_File << std::endl << std::endl << "-- "
<< static_cast<int>(m_Blocks.size()) << " non-released blocs, "
<< static_cast<int>(TotalSize) << " bytes --"
<< std::endl;
*/
m_File.append(EOL);
m_File.append(EOL);
m_File.append(_T("-- "));
m_File.append(Ztring::ToZtring(static_cast<int>(m_Blocks.size())));
m_File.append(_T(" non-released blocs, "));
m_File.append(Ztring::ToZtring(static_cast<int>(TotalSize)));
m_File.append(_T(" bytes --"));
m_File.append(EOL);
std::string ToWrite=m_File.To_Local().c_str();
int m_File_sav=open("Debug_MemoryLeak.txt", O_BINARY|O_RDWR |O_CREAT); // Fichier de sortie
write(m_File_sav, (int8u*)ToWrite.c_str(), ToWrite.size());
close(m_File_sav);
}
//---------------------------------------------------------------------------
// Read
Ztring ZtringListList::Read () const
{
//Integrity
if (size()==0)
return _T("");
Ztring ToReturn;
size_type Size=size()-1;
for (size_type Pos0=0; Pos0<Size; Pos0++)
ToReturn+=Read(Pos0)+Separator[0];
ToReturn+=Read(Size);
//Delete all useless separators at the end
if(ToReturn.size()>0 && Separator[0].size() && ToReturn(ToReturn.size()-1)==Separator[0][Separator[0].size()-1]) //Optimize speed
while (ToReturn.find(Separator[0].c_str(), ToReturn.size()-Separator[0].size())!=std::string::npos)
ToReturn.resize(ToReturn.size()-Separator[0].size());
return ToReturn;
}
//---------------------------------------------------------------------------
// Read
Ztring ZtringList::Read () const
{
//Integrity
if (size()==0)
return _T("");
Ztring Retour;
for (size_type Pos=0; Pos<size(); Pos++)
{
if (operator[](Pos).find(Separator[0])==std::string::npos)
Retour+=operator[](Pos)+Separator[0];
else
Retour+=Quote+operator[](Pos)+Quote+Separator[0];
}
//delete all useless separators at the end
while (Retour.find(Separator[0].c_str(), Retour.size()-Separator[0].size())!=std::string::npos)
Retour.resize(Retour.size()-Separator[0].size());
return Retour;
}
//---------------------------------------------------------------------------
void PBCore_Transform__Common_End(Ztring &ToReturn, MediaInfo_Internal &MI, stream_t StreamKind, size_t StreamPos)
{
//essenceTrackAnnotation - all fields (except *_String*) separated by |
Ztring Temp;
for (size_t Pos=0; Pos<MI.Count_Get(StreamKind, StreamPos); Pos++)
if (MI.Get(StreamKind, StreamPos, Pos, Info_Name).find(__T("String"))==std::string::npos && !MI.Get(StreamKind, StreamPos, Pos).empty())
Temp+=MI.Get(StreamKind, StreamPos, Pos, Info_Name)+__T(": ")+MI.Get(StreamKind, StreamPos, Pos)+__T('|');
if (!Temp.empty())
{
Temp.resize(Temp.size()-1);
ToReturn+=__T("\t\t\t<essenceTrackAnnotation>"); ToReturn+=Temp; ToReturn+=__T("</essenceTrackAnnotation>\n");
}
}
//---------------------------------------------------------------------------
// Read
Ztring ZtringList::Read () const
{
//Integrity
if (size()==0)
return Ztring();
Ztring Retour;
Ztring ToFind=Separator[0]+Quote[0]+__T("\r\n");
for (size_type Pos=0; Pos<size(); Pos++)
{
if (operator[](Pos).find_first_of(ToFind)==std::string::npos)
Retour+=operator[](Pos)+Separator[0];
else if (operator[](Pos).find(Separator[0])==std::string::npos
&& operator[](Pos).find(Quote)==std::string::npos
&& operator[](Pos).find('\r')==std::string::npos
&& operator[](Pos).find('\n')==std::string::npos)
Retour+=operator[](Pos)+Separator[0];
else
{
if (operator[](Pos).find(Quote)==std::string::npos)
Retour+=Quote+operator[](Pos)+Quote+Separator[0];
else
{
Ztring Value=operator[](Pos);
Value.FindAndReplace(Quote, Quote+Quote, 0, Ztring_Recursive);
Retour+=Quote+Value+Quote+Separator[0];
}
}
}
//delete all useless separators at the end
//while (Retour.find(Separator[0].c_str(), Retour.size()-Separator[0].size())!=std::string::npos)
if (Retour.find(Separator[0].c_str(), Retour.size()-Separator[0].size())!=std::string::npos)
Retour.resize(Retour.size()-Separator[0].size());
return Retour;
}
//---------------------------------------------------------------------------
// Write
void ZtringList::Write(const Ztring &ToWrite)
{
clear();
if (!&ToWrite || !ToWrite.size())
return;
size_type PosC=0;
bool Fini=false;
Ztring C1;
Ztring DelimiterL;
Ztring DelimiterR;
do
{
if (ToWrite.size()>PosC && Quote.size()>0 && ToWrite[PosC]==Quote[0] && ToWrite.substr(PosC, Quote.size())==Quote) //Quote found (ToWrite[PosC]==Quote[0] is here for optimization
{
DelimiterL=Quote;
DelimiterR=Quote+Separator[0];
}
else
{
DelimiterL.clear();
DelimiterR=Separator[0];
}
C1=ToWrite.SubString(DelimiterL, DelimiterR, PosC, Ztring_AddLastItem);
if (DelimiterR.size()>Separator[0].size() && C1.size()==ToWrite.size()-Quote.size()-PosC) //This is the last item of the line, we must suppress the Quote at the end
C1.resize(C1.size()-Quote.size());
if (size()<Max[0])
push_back(C1);
else
{
//No more adding is permit, we add to the last element (with the separator)
at(size()-1)+=Separator[0];
at(size()-1)+=C1;
}
PosC+=C1.size()+DelimiterL.size()+DelimiterR.size();
if (PosC>=ToWrite.size())
Fini=true;
}
while (!Fini);
return;
}
//---------------------------------------------------------------------------
// Packet "B2", User defined size, this is often used of library name
void File_AvsV::user_data_start()
{
Element_Name("user_data_start");
//Rejecting junk from the end
size_t Library_End_Offset=(size_t)Element_Size;
while (Library_End_Offset>0
&& (Buffer[Buffer_Offset+Library_End_Offset-1]<0x20
|| Buffer[Buffer_Offset+Library_End_Offset-1]>0x7D
|| (Buffer[Buffer_Offset+Library_End_Offset-1]>=0x3A
&& Buffer[Buffer_Offset+Library_End_Offset-1]<=0x40)))
Library_End_Offset--;
if (Library_End_Offset==0)
return; //No good info
//Accepting good data after junk
size_t Library_Start_Offset=Library_End_Offset-1;
while (Library_Start_Offset>0 && (Buffer[Buffer_Offset+Library_Start_Offset-1]>=0x20 && Buffer[Buffer_Offset+Library_Start_Offset-1]<=0x7D))
Library_Start_Offset--;
//But don't accept non-alpha caracters at the beginning (except for "3ivx")
if (Library_End_Offset-Library_Start_Offset!=4 || CC4(Buffer+Buffer_Offset+Library_Start_Offset)!=0x33697678) //3ivx
while (Library_Start_Offset<Element_Size && Buffer[Buffer_Offset+Library_Start_Offset]<=0x40)
Library_Start_Offset++;
//Parsing
Ztring Temp;
if (Library_Start_Offset>0)
Skip_XX(Library_Start_Offset, "junk");
if (Library_End_Offset-Library_Start_Offset)
Get_Local(Library_End_Offset-Library_Start_Offset, Temp,"data");
if (Element_Offset<Element_Size)
Skip_XX(Element_Size-Element_Offset, "junk");
FILLING_BEGIN();
//NextCode
NextCode_Test();
if (Temp.size()>=4)
Library=Temp;
FILLING_END();
}
//---------------------------------------------------------------------------
// Set
void Translation::Write(const Ztring &NewLanguage)
{
clear();
if (!&NewLanguage || !NewLanguage.size())
return;
size_t Pos1=0, Pos2_EOL=0, Pos2_Separator=0;
while (Pos2_EOL!=(size_t)-1)
{
Pos2_EOL=NewLanguage.find(__T('\n'), Pos1);
Pos2_Separator=NewLanguage.find(__T(';'), Pos1);
if (Pos2_Separator<Pos2_EOL)
{
operator[](NewLanguage.substr(Pos1, Pos2_Separator-Pos1))=NewLanguage.substr(Pos2_Separator+1, Pos2_EOL-Pos2_Separator-1);
}
Pos1=Pos2_EOL+1;
}
}
int Test_Version(char* FileName_, char* Begin, char* End)
{
wxString FileName=Ztring().From_Local(FileName_).c_str();
//Opening File
F.Open(FileName);
I=F.Read(C, 1000000);
if (!I)
{
ToShow+=__T("Error opening ")+FileName;
return -1;
}
//Getting information
C[I]=0;
Z.From_Local(C);
Z=Z.SubString(Ztring().From_Local(Begin), Ztring().From_Local(End));
//deleting extra bytes
if (Z[Z.size()-1]=='\n')
Z.resize(Z.size()-1);
if (Z[Z.size()-1]=='\r')
Z.resize(Z.size()-1);
//Testing validity
if (Z.size()!=3 && Z.size()!=7) //non long, no short
{
ToShow+=__T("Error reading ")+FileName;
return -2;
}
//Reformtation information
Z.FindAndReplace(__T(","), __T("."), 0, Ztring_Recursive);
if (Z!=Version && Z!=Version_Short)
{
ToShow+=FileName;
ToShow+=__T(" is not good : version is marked ");
ToShow+=Z;
ToShow+=__T("\r\n");
}
return 0;
}
//---------------------------------------------------------------------------
void GUI_Main_Core_Table::contextMenuEvent (QContextMenuEvent* Event)
{
//Retrieving data
QTableWidgetItem* Item=itemAt(Event->pos());
if (Item==NULL)
return;
string FileName=FileName_Before+item(Item->row(), 0)->text().toLocal8Bit().data();
string Field=horizontalHeaderItem(Item->column())->text().toLocal8Bit().data();
ZtringList History; History.Write(C->History(FileName, Field));
Ztring Date;
if (Field=="OriginationDate" || Field=="OriginationTime" || Field=="ICRD")
{
Date=C->FileDate_Get(FileName);
if (Date.size()>=10+1+8)
{
if (Date.size()>=10+1+8)
Date.resize(10+1+8);
if (Field=="ICRD")
Date.insert(0, "&Set ICRD to file creation timestamp ("); //If you change this, change at the end of method too
else
Date.insert(0, "&Set originationDate and Time to file creation timestamp ("); //If you change this, change at the end of method too
Date.append(")");
}
else
Date.clear();
}
//Creating menu
QMenu menu(this);
//Handling AllFiles display
{
menu.addAction(new QAction("Fill all open files with this field value", this)); //If you change this, change the test text too
menu.addSeparator();
}
//Handling Clear display
if (!item(Item->row(), Item->column())->text().isEmpty() && C->IsValid(FileName, Field, string()))
{
menu.addAction(new QAction("Clear this value", this)); //If you change this, change the test text too
menu.addSeparator();
}
//Handling date display
if (!Date.empty())
{
menu.addAction(new QAction(QString().fromUtf8(Date.To_Local().c_str()), this));
menu.addSeparator();
}
//Handling history display
size_t Pos=History.size();
if (!History.empty())
do
{
Pos--;
QString Text=QString().fromUtf8(History[Pos].To_Local().c_str());
if (!Text.isEmpty())
{
QAction* Action=new QAction(Text, this);
menu.addAction(Action);
}
}
while (Pos>0);
//Displaying
QAction* Action=menu.exec(Event->globalPos());
if (Action==NULL)
return;
//Retrieving data
QString Text=Action->text();
//Special cases
if (Text=="Fill all open files with this field value") //If you change this, change the creation text too
{
for (int Row=0; Row<rowCount(); Row++)
{
item(Row, Item->column())->setText(QString().fromUtf8(Ztring(C->Get(FileName, Field)).To_Local().c_str()));
dataChanged(indexFromItem(item(Row, Item->column())), indexFromItem(item(Row, Item->column())));
//Special cases
if (Field=="UMID" || Field=="LoudnessValue" || Field=="LoudnessRange" || Field=="MaxTruePeakLevel" || Field=="MaxMomentaryLoudness" || Field=="MaxShortTermLoudness")
{
//Changing BextVersion Enabled value
SetText (*Item, "BextVersion");
SetEnabled(*Item, "BextVersion");
}
}
return;
}
if (Text=="Clear this value") //If you change this, change the creation text too
Text.clear();
//Filling
if (Text.contains("&Set ")) //If you change this, change the creation text too
{
Text=Text.remove("&Set ICRD to file creation timestamp ("); //If you change this, change the creation text too
Text=Text.remove("&Set originationDate and Time to file creation timestamp ("); //If you change this, change the creation text too
Text=Text.remove(")"); //If you change this, change the creation text too
if (horizontalHeaderItem(Item->column())->text()==QString().fromUtf8("ICRD"))
{
item(Item->row(), Item->column())->setText(Text);
dataChanged(indexFromItem(item(Item->row(), Item->column())), indexFromItem(item(Item->row(), Item->column())));
}
else
{
QString Date=Text;
Date.remove(10, 1+12);
QString Time=Text;
Time.remove(0, 10+1);
Time.remove(8, 4);
int Date_Pos=Item->column()+(horizontalHeaderItem(Item->column())->text()==QString().fromUtf8("OriginationDate")?0:-1);
int Time_Pos=Item->column()+(horizontalHeaderItem(Item->column())->text()==QString().fromUtf8("OriginationTime")?0:1);
item(Item->row(), Date_Pos)->setText(Date);
dataChanged(indexFromItem(item(Item->row(), Date_Pos)), indexFromItem(item(Item->row(), Date_Pos)));
item(Item->row(), Time_Pos)->setText(Time);
dataChanged(indexFromItem(item(Item->row(), Time_Pos)), indexFromItem(item(Item->row(), Time_Pos)));
}
}
else
{
item(Item->row(), Item->column())->setText(Text);
dataChanged(indexFromItem(item(Item->row(), Item->column())), indexFromItem(item(Item->row(), Item->column())));
}
//Menu
Main->Menu_Update();
}
//---------------------------------------------------------------------------
void File_Jpeg::SIZ()
{
//Parsing
vector<float> SamplingFactors;
vector<int8u> BitDepths;
int8u SamplingFactors_Max=0;
int32u Xsiz, Ysiz;
int16u Count;
Skip_B2( "Rsiz - Capability of the codestream");
Get_B4 (Xsiz, "Xsiz - Image size X");
Get_B4 (Ysiz, "Ysiz - Image size Y");
Skip_B4( "XOsiz - Image offset X");
Skip_B4( "YOsiz - Image offset Y");
Skip_B4( "tileW - Size of tile W");
Skip_B4( "tileH - Size of tile H");
Skip_B4( "XTOsiz - Upper-left tile offset X");
Skip_B4( "YTOsiz - Upper-left tile offset Y");
Get_B2 (Count, "Components and initialize related arrays");
for (int16u Pos=0; Pos<Count; Pos++)
{
Element_Begin1("Initialize related array");
int8u BitDepth = 0, compSubsX = 0, compSubsY = 0;
BS_Begin();
Skip_SB( "Signed");
Get_S1 (7, BitDepth, "BitDepth"); Param_Info1(1+BitDepth); Element_Info1(1+BitDepth);
BS_End();
Get_B1 ( compSubsX, "compSubsX"); Element_Info1(compSubsX);
Get_B1 ( compSubsY, "compSubsY"); Element_Info1(compSubsY);
Element_End0();
//Filling list of HiVi
if (compSubsX)
{
SamplingFactors.push_back(((float)compSubsY)/compSubsX);
if (((float)compSubsY)/compSubsX>SamplingFactors_Max)
SamplingFactors_Max=(int8u)((float)compSubsY)/compSubsX;
}
if (BitDepths.empty() || BitDepth!=BitDepths[0])
BitDepths.push_back(BitDepth);
}
FILLING_BEGIN_PRECISE();
if (Frame_Count==0 && Field_Count==0)
{
Accept("JPEG 2000");
if (Count_Get(StreamKind_Last)==0)
Stream_Prepare(StreamKind_Last);
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "JPEG 2000");
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Codec), "JPEG 2000");
if (StreamKind_Last==Stream_Image)
Fill(Stream_Image, 0, Image_Codec_String, "JPEG 2000", Unlimited, true, true); //To Avoid automatic filling
Fill(StreamKind_Last, 0, StreamKind_Last==Stream_Image?(size_t)Image_Width:(size_t)Video_Width, Xsiz);
Fill(StreamKind_Last, 0, StreamKind_Last==Stream_Image?(size_t)Image_Height:(size_t)Video_Height, Ysiz*(Interlaced?2:1)); //If image is from interlaced content, must multiply height by 2
if (BitDepths.size()==1)
Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_BitDepth), 1+BitDepths[0]);
//Chroma subsampling
if (SamplingFactors_Max)
while (SamplingFactors_Max<4)
{
for (size_t Pos=0; Pos<SamplingFactors.size(); Pos++)
SamplingFactors[Pos]*=2;
SamplingFactors_Max*=2;
}
while (SamplingFactors.size()<3)
SamplingFactors.push_back(0);
Ztring ChromaSubsampling;
for (size_t Pos=0; Pos<SamplingFactors.size(); Pos++)
ChromaSubsampling+=Ztring::ToZtring(SamplingFactors[Pos], 0)+__T(':');
if (!ChromaSubsampling.empty())
{
ChromaSubsampling.resize(ChromaSubsampling.size()-1);
Fill(StreamKind_Last, 0, "ChromaSubsampling", ChromaSubsampling);
}
}
FILLING_END();
}
void File_OtherText::Read_Buffer_Continue()
{
if (Buffer_Size<0x200)
{
Element_WaitForMoreData();
return;
}
Element_Offset=File_Size-(File_Offset+Buffer_Offset);
Ztring Format, FormatMore, Codec;
Ztring File;
ZtringList Lines;
//Feed File and Lines
File.From_UTF8((const char*)Buffer, Buffer_Size>65536?65536:Buffer_Size);
if (File.empty())
File.From_Local((const char*)Buffer, Buffer_Size>65536?65536:Buffer_Size); // Trying from local code page
if (File.size()<0x100)
{
File.From_Unicode((wchar_t*)Buffer, 0, Buffer_Size/sizeof(wchar_t)); //Unicode with BOM
//TODO: Order of bytes (big or Little endian)
if (File.size()<0x100)
{
Reject("Other text");
return;
}
}
if (File.size()>0x1000)
File.resize(0x1000); //Do not work on too big
File.FindAndReplace(__T("\r\n"), __T("\n"), 0, Ztring_Recursive);
File.FindAndReplace(__T("\r"), __T("\n"), 0, Ztring_Recursive);
Lines.Separator_Set(0, __T("\n"));
Lines.Write(File);
Lines.resize(0x20);
if (Lines[0]==__T("[Script Info]")
&& (Lines.Find(__T("ScriptType: v4.00"))!=Error || Lines.Find(__T("Script Type: V4.00"))!=Error)
&& Lines.Find(__T("[V4 Styles]"))!=Error
)
{
Format=__T("SSA");
FormatMore=__T("SubStation Alpha");
Codec=__T("SSA");
}
else if (Lines[0]==__T("[Script Info]")
&& (Lines.Find(__T("ScriptType: v4.00+"))!=Error || Lines.Find(__T("Script Type: V4.00+"))!=Error)
&& Lines.Find(__T("[V4+ Styles]"))!=Error
)
{
Format=__T("ASS");
FormatMore=__T("Advanced SubStation Alpha");
Codec=__T("ASS");
}
else if (Lines[0].size()>24
&& Lines[0][ 0]==__T('0') && Lines[0][ 1]==__T('0')
&& Lines[0][ 2]==__T(':') && Lines[0][ 5]==__T(':') && Lines[0][ 8]==__T(':')
&& Lines[0][11]==__T(' ')
&& Lines[0][12]==__T('0') && Lines[0][13]==__T('0')
&& Lines[0][14]==__T(':') && Lines[0][17]==__T(':') && Lines[0][20]==__T(':')
&& Lines[0][23]==__T(' ')
)
{
Format=__T("Adobe encore DVD");
Codec=__T("Adobe");
}
else if (Lines[0].size()==11
&& Lines[0][0]==__T('-') && Lines[0][1]==__T('-') && Lines[0][2]==__T('>') && Lines[0][3]==__T('>') && Lines[0][4]==__T(' ')
&& Lines[0][5]==__T('0')
&& Lines[1].empty()!=true
)
{
Format=__T("AQTitle");
Codec=__T("AQTitle");
}
else if (Lines[0].size()>28
&& Lines[0][ 0]==__T('0') && Lines[0][ 1]==__T('0')
&& Lines[0][ 2]==__T(':') && Lines[0][ 5]==__T(':') && Lines[0][ 8]==__T(':')
&& Lines[0][11]==__T(' ') && Lines[0][12]==__T(',') && Lines[0][13]==__T(' ')
&& Lines[0][14]==__T('0') && Lines[0][15]==__T('0')
&& Lines[0][16]==__T(':') && Lines[0][19]==__T(':') && Lines[0][22]==__T(':')
&& Lines[0][25]==__T(' ') && Lines[0][16]==__T(',') && Lines[0][27]==__T(' ')
)
{
Format=__T("Captions 32");
Codec=__T("Caption 32");
}
else if (Lines[0].size()==23
&& Lines[0]==__T("*Timecode type: PAL/EBU")
&& Lines[1].empty()
&& Lines[2].size()==23
&& Lines[2][ 0]==__T('0') && Lines[2][ 1]==__T('0')
&& Lines[2][ 2]==__T(':') && Lines[2][ 5]==__T(':') && Lines[2][ 8]==__T(':')
&& Lines[2][11]==__T(' ')
&& Lines[2][12]==__T('0') && Lines[2][13]==__T('0')
&& Lines[2][14]==__T(':') && Lines[2][17]==__T(':') && Lines[2][20]==__T(':')
&& Lines[2].size()>0
)
{
Format=__T("Captions Inc");
Codec=__T("Captions inc");
}
else if (Lines[0].size()>1
&& Lines[0][0]==__T('*')
&& Lines.Find(__T("** Caption Number 1"))!=Error
)
{
Format=__T("Cheeta");
}
else if (Lines[0].size()>10
&& Lines[0][0]==__T('~') && Lines[0][1]==__T('C') && Lines[0][2]==__T('P') && Lines[0][3]==__T('C') && Lines[0][9]==__T('~')
&& Lines[1][ 0]==__T('0') && Lines[1][ 1]==__T('0')
&& Lines[1][ 2]==__T(':') && Lines[1][ 5]==__T(':') && Lines[1][ 8]==__T(':')
)
{
Format=__T("CPC Captioning");
Codec=__T("CPC Captioning");
}
else if (Lines[0].find(__T("<SAMI>"))==0)
{
Format=__T("SAMI");
}
else
return;
if (Format.empty())
return;
Accept("Other text");
if (!IsSub)
{
Fill(Stream_General, 0, General_Format, Format);
Fill(Stream_General, 0, General_Format_Info, FormatMore, true);
}
Stream_Prepare(Stream_Text);
Fill(Stream_Text, 0, Text_Format, Format);
Fill(Stream_Text, 0, Text_Codec, Codec);
//No more need data
Element_Begin1(Format);
Element_End0();
Finish("Other text");
}
//---------------------------------------------------------------------------
bool File_Hls::FileHeader_Begin()
{
//Element_Size
if (File_Size>1024*1024 || File_Size<10)
{
Reject("HLS");
return false; //HLS files are not big
}
if (Buffer_Size<File_Size)
return false; //Wait for complete file
Ztring Document; Document.From_UTF8((char*)Buffer, Buffer_Size);
ZtringList Lines;
size_t LinesSeparator_Pos=Document.find_first_of(__T("\r\n"));
if (LinesSeparator_Pos>File_Size-1)
{
Reject("HLS");
return false;
}
Ztring LinesSeparator;
if (Document[LinesSeparator_Pos]==__T('\r') && LinesSeparator_Pos+1<Document.size() && Document[LinesSeparator_Pos+1]==__T('\n'))
LinesSeparator=__T("\r\n");
else if (Document[LinesSeparator_Pos]==__T('\r'))
LinesSeparator=__T("\r");
else if (Document[LinesSeparator_Pos]==__T('\n'))
LinesSeparator=__T("\n");
else
{
Reject("HLS");
return false;
}
Lines.Separator_Set(0, LinesSeparator);
Lines.Write(Document);
if (Lines(0)!=__T("#EXTM3U"))
{
Reject("HLS");
return false;
}
Accept("HLS");
Fill(Stream_General, 0, General_Format, "HLS");
ReferenceFiles=new File__ReferenceFilesHelper(this, Config);
if (!IsSub)
ReferenceFiles->ContainerHasNoId=true;
File__ReferenceFilesHelper::reference ReferenceFile;
bool IsGroup=false;
for (size_t Line=0; Line<Lines.size(); Line++)
{
if (!Lines[Line].empty())
{
if (Lines[Line].find(__T("#EXT-X-STREAM-INF"))==0)
IsGroup=true;
else if (Lines[Line][0]==__T('#'))
;
else
{
if (IsGroup)
{
File__ReferenceFilesHelper::reference ReferenceStream;
ReferenceStream.FileNames.push_back(Lines[Line]);
ReferenceStream.StreamID=ReferenceFiles->References.size()+1;
ReferenceFiles->References.push_back(ReferenceStream);
IsGroup=false;
#if MEDIAINFO_EVENTS
ParserIDs[0]=MediaInfo_Parser_HlsIndex;
StreamIDs_Width[0]=sizeof(size_t)*2;
#endif //MEDIAINFO_EVENTS
}
else
ReferenceFile.FileNames.push_back(Lines[Line]);
}
}
}
if (ReferenceFiles->References.empty())
{
ReferenceFiles->References.push_back(ReferenceFile);
ReferenceFiles->TestContinuousFileNames=true;
}
Element_Offset=File_Size;
//All should be OK...
return true;
}
//---------------------------------------------------------------------------
void PBCore_Transform(Ztring &ToReturn, MediaInfo_Internal &MI, stream_t StreamKind, size_t StreamPos)
{
//Menu: only if TimeCode
if (StreamKind==Stream_Menu && MI.Get(Stream_Menu, StreamPos, Menu_Format)!=__T("TimeCode"))
return;
//essenceTrackType
Ztring essenceTrackType;
switch (StreamKind)
{
case Stream_Video:
essenceTrackType=__T("Video");
break;
case Stream_Audio:
essenceTrackType=__T("Audio");
break;
case Stream_Text:
{
Ztring Format=MI.Get(Stream_Text, StreamPos, Text_Format);
if (Format==__T("EIA-608") || Format==__T("EIA-708"))
essenceTrackType=__T("CC");
else
essenceTrackType=__T("Text");
}
break;
case Stream_Menu:
if (MI.Get(Stream_Menu, StreamPos, Menu_Format)==__T("TimeCode"))
{
essenceTrackType=__T("TimeCode");
break;
}
else
return; //Not supported
default: return; //Not supported
}
ToReturn+=__T("\t\t<pbcoreEssenceTrack>\n");
ToReturn+=__T("\t\t\t<essenceTrackType>")+essenceTrackType+__T("</essenceTrackType>\n");
//essenceTrackIdentifier
if (!MI.Get(StreamKind, StreamPos, __T("ID")).empty())
{
ToReturn+=__T("\t\t\t<essenceTrackIdentifier>")+MI.Get(StreamKind, StreamPos, __T("ID"))+__T("</essenceTrackIdentifier>\n");
ToReturn+=__T("\t\t\t<essenceTrackIdentifierSource>ID (Mediainfo)</essenceTrackIdentifierSource>\n");
}
else if (!MI.Get(StreamKind, StreamPos, __T("UniqueID")).empty())
{
ToReturn+=__T("\t\t\t<essenceTrackIdentifier>")+MI.Get(StreamKind, StreamPos, __T("UniqueID"))+__T("</essenceTrackIdentifier>\n");
ToReturn+=__T("\t\t\t<essenceTrackIdentifierSource>UniqueID (Mediainfo)</essenceTrackIdentifierSource>\n");
}
else if (!MI.Get(StreamKind, StreamPos, __T("StreamKindID")).empty())
{
ToReturn+=__T("\t\t\t<essenceTrackIdentifier>")+MI.Get(StreamKind, StreamPos, __T("StreamKindID"))+__T("</essenceTrackIdentifier>\n");
ToReturn+=__T("\t\t\t<essenceTrackIdentifierSource>StreamKindID (Mediainfo)</essenceTrackIdentifierSource>\n");
}
//essenceTrackStandard
if (StreamKind==Stream_Video && !MI.Get(Stream_Video, StreamPos, Video_Standard).empty())
ToReturn+=__T("\t\t\t<essenceTrackStandard>")+MI.Get(Stream_Video, StreamPos, Video_Standard)+__T("</essenceTrackStandard>\n");
//essenceTrackEncoding
if (!MI.Get(StreamKind, StreamPos, __T("Format")).empty())
{
ToReturn+=__T("\t\t\t<essenceTrackEncoding>");
ToReturn+=MI.Get(StreamKind, StreamPos, __T("Format"));
if (!MI.Get(StreamKind, StreamPos, __T("Format_Profile")).empty()) ToReturn+=__T(' ')+MI.Get(StreamKind, StreamPos, __T("Format_Profile"));
if (!MI.Get(StreamKind, StreamPos, __T("CodecID")).empty()) ToReturn+=__T(" (")+MI.Get(StreamKind, StreamPos, __T("CodecID"))+__T(')');
ToReturn+=__T("</essenceTrackEncoding>\n");
}
//essenceTrackDataRate
if (!MI.Get(StreamKind, StreamPos, __T("BitRate")).empty())
{
ToReturn+=__T("\t\t\t<essenceTrackDataRate>");
ToReturn+=MI.Get(StreamKind, StreamPos, __T("BitRate"));
if (!MI.Get(StreamKind, StreamPos, __T("BitRate_Mode")).empty())
ToReturn+=__T(' ')+MI.Get(StreamKind, StreamPos, __T("BitRate_Mode"));
ToReturn+=__T("</essenceTrackDataRate>\n");
}
//essenceTrackFrameRate
if (StreamKind==Stream_Video && !MI.Get(Stream_Video, StreamPos, Video_FrameRate).empty())
{
ToReturn+=__T("\t\t\t<essenceTrackFrameRate>");
ToReturn+=MI.Get(Stream_Video, StreamPos, Video_FrameRate);
if (!MI.Get(Stream_Video, StreamPos, Video_FrameRate_Mode).empty())
ToReturn+=__T(' ')+MI.Get(Stream_Video, StreamPos, Video_FrameRate_Mode);
ToReturn+=__T("</essenceTrackFrameRate>\n");
}
//essenceTrackSamplingRate
if (StreamKind==Stream_Audio && !MI.Get(Stream_Audio, StreamPos, Audio_SamplingRate).empty())
ToReturn+=__T("\t\t\t<essenceTrackSamplingRate>")+MI.Get(Stream_Audio, StreamPos, Audio_SamplingRate)+__T("</essenceTrackSamplingRate>\n");
//essenceTrackBitDepth
if (!MI.Get(StreamKind, StreamPos, __T("BitDepth")).empty())
ToReturn+=__T("\t\t\t<essenceTrackBitDepth version=\"PBCoreXSD_Ver_1.2_D1\">")+MI.Get(StreamKind, StreamPos, __T("BitDepth"))+__T("</essenceTrackBitDepth>\n");
//essenceTrackFrameSize
if (StreamKind==Stream_Video && !MI.Get(Stream_Video, StreamPos, Video_Width).empty())
ToReturn+=__T("\t\t\t<essenceTrackFrameSize>")+MI.Get(Stream_Video, StreamPos, Video_Width)+__T('x')+MI.Get(Stream_Video, StreamPos, Video_Height)+__T("</essenceTrackFrameSize>\n");
//essenceTrackAspectRatio
if (StreamKind==Stream_Video && !MI.Get(Stream_Video, StreamPos, Video_DisplayAspectRatio).empty())
ToReturn+=__T("\t\t\t<essenceTrackAspectRatio>")+MI.Get(Stream_Video, StreamPos, Video_DisplayAspectRatio)+__T("</essenceTrackAspectRatio>\n");
//essenceTrackDuration
if (!MI.Get(StreamKind, StreamPos, __T("Duration")).empty())
ToReturn+=__T("\t\t\t<essenceTrackDuration>")+MI.Get(StreamKind, StreamPos, __T("Duration"))+__T("</essenceTrackDuration>\n");
//essenceTrackLanguage
if (!MI.Get(StreamKind, StreamPos, __T("Language")).empty())
ToReturn+=__T("\t\t\t<essenceTrackLanguage>")+MediaInfoLib::Config.Iso639_2_Get(MI.Get(StreamKind, StreamPos, __T("Language")))+__T("</essenceTrackLanguage>\n");
//essenceTrackAnnotation - all fields (except *_String*) separated by |
Ztring Temp;
for (size_t Pos=0; Pos<MI.Count_Get(StreamKind, StreamPos); Pos++)
if (MI.Get(StreamKind, StreamPos, Pos, Info_Name).find(__T("String"))==std::string::npos && !MI.Get(StreamKind, StreamPos, Pos).empty())
Temp+=MI.Get(StreamKind, StreamPos, Pos, Info_Name)+__T(": ")+MI.Get(StreamKind, StreamPos, Pos)+__T('|');
if (!Temp.empty())
{
Temp.resize(Temp.size()-1);
ToReturn+=__T("\t\t\t<essenceTrackAnnotation>"); ToReturn+=Temp; ToReturn+=__T("</essenceTrackAnnotation>\n");
}
ToReturn+=__T("\t\t</pbcoreEssenceTrack>\n");
}
//---------------------------------------------------------------------------
void PBCore_Transform(Node *Parent, MediaInfo_Internal &MI, stream_t StreamKind, size_t StreamPos)
{
//Menu: only if TimeCode
if (StreamKind==Stream_Menu && MI.Get(Stream_Menu, StreamPos, Menu_Format)!=__T("TimeCode"))
return;
//essenceTrackType
Ztring essenceTrackType;
switch (StreamKind)
{
case Stream_Video:
essenceTrackType=__T("Video");
break;
case Stream_Audio:
essenceTrackType=__T("Audio");
break;
case Stream_Text:
{
Ztring Format=MI.Get(Stream_Text, StreamPos, Text_Format);
if (Format==__T("EIA-608") || Format==__T("EIA-708"))
essenceTrackType=__T("CC");
else
essenceTrackType=__T("Text");
}
break;
case Stream_Menu:
if (MI.Get(Stream_Menu, StreamPos, Menu_Format)==__T("TimeCode"))
{
essenceTrackType=__T("TimeCode");
break;
}
else
return; //Not supported
default: return; //Not supported
}
Node* Node_EssenceTrack=Parent->Add_Child("pbcoreEssenceTrack");
Node_EssenceTrack->Add_Child("essenceTrackType", essenceTrackType);
//essenceTrackIdentifier
if (!MI.Get(StreamKind, StreamPos, __T("ID")).empty())
{
Node_EssenceTrack->Add_Child("essenceTrackIdentifier", MI.Get(StreamKind, StreamPos, __T("ID")));
Node_EssenceTrack->Add_Child("essenceTrackIdentifierSource", "ID (Mediainfo)");
}
else if (!MI.Get(StreamKind, StreamPos, __T("UniqueID")).empty())
{
Node_EssenceTrack->Add_Child("essenceTrackIdentifier", MI.Get(StreamKind, StreamPos, __T("UniqueID")));
Node_EssenceTrack->Add_Child("essenceTrackIdentifierSource", "UniqueID (Mediainfo)");
}
else if (!MI.Get(StreamKind, StreamPos, __T("StreamKindID")).empty())
{
Node_EssenceTrack->Add_Child("essenceTrackIdentifier", MI.Get(StreamKind, StreamPos, __T("StreamKindID")));
Node_EssenceTrack->Add_Child("essenceTrackIdentifierSource", "StreamKindID (Mediainfo)");
}
//essenceTrackStandard
if (StreamKind==Stream_Video)
Node_EssenceTrack->Add_Child_IfNotEmpty(MI, Stream_Video, StreamPos, Video_Standard, "essenceTrackStandard");
//essenceTrackEncoding
if (!MI.Get(StreamKind, StreamPos, __T("Format")).empty())
{
Ztring Format=MI.Get(StreamKind, StreamPos, __T("Format"));
if (!MI.Get(StreamKind, StreamPos, __T("Format_Profile")).empty())
Format+=__T(' ')+MI.Get(StreamKind, StreamPos, __T("Format_Profile"));
if (!MI.Get(StreamKind, StreamPos, __T("CodecID")).empty())
Format+=__T(" (")+MI.Get(StreamKind, StreamPos, __T("CodecID"))+__T(')');
Node_EssenceTrack->Add_Child("essenceTrackEncoding", Format);
}
//essenceTrackDataRate
if (!MI.Get(StreamKind, StreamPos, __T("BitRate")).empty())
{
Ztring BitRate=MI.Get(StreamKind, StreamPos, __T("BitRate"));
if (!MI.Get(StreamKind, StreamPos, __T("BitRate_Mode")).empty())
BitRate+=__T(' ')+MI.Get(StreamKind, StreamPos, __T("BitRate_Mode"));
Node_EssenceTrack->Add_Child("essenceTrackDataRate", BitRate);
}
//essenceTrackFrameRate
if (StreamKind==Stream_Video && !MI.Get(Stream_Video, StreamPos, Video_FrameRate).empty())
{
Ztring FrameRate=MI.Get(Stream_Video, StreamPos, Video_FrameRate);
if (!MI.Get(Stream_Video, StreamPos, Video_FrameRate_Mode).empty())
FrameRate+=__T(' ')+MI.Get(Stream_Video, StreamPos, Video_FrameRate_Mode);
Node_EssenceTrack->Add_Child("essenceTrackFrameRate", FrameRate);
}
//essenceTrackSamplingRate
if (StreamKind==Stream_Audio)
Node_EssenceTrack->Add_Child_IfNotEmpty(MI, Stream_Audio, StreamPos, Audio_SamplingRate, "essenceTrackSamplingRate");
//essenceTrackBitDepth
Node_EssenceTrack->Add_Child_IfNotEmpty(MI, StreamKind, StreamPos, "BitDepth", "essenceTrackBitDepth", "version", std::string("PBCoreXSD_Ver_1.2_D1"));
//essenceTrackFrameSize
if (StreamKind==Stream_Video && !MI.Get(Stream_Video, StreamPos, Video_Width).empty())
Node_EssenceTrack->Add_Child("essenceTrackFrameSize", MI.Get(Stream_Video, StreamPos, Video_Width)+__T('x')+MI.Get(Stream_Video, StreamPos, Video_Height));
//essenceTrackAspectRatio
if (StreamKind==Stream_Video)
Node_EssenceTrack->Add_Child_IfNotEmpty(MI, Stream_Video, StreamPos, Video_DisplayAspectRatio, "essenceTrackAspectRatio");
//essenceTrackDuration
Node_EssenceTrack->Add_Child_IfNotEmpty(MI, StreamKind, StreamPos, "Duration", "essenceTrackDuration");
//essenceTrackLanguage
if (!MI.Get(StreamKind, StreamPos, __T("Language")).empty())
Node_EssenceTrack->Add_Child("essenceTrackLanguage", MediaInfoLib::Config.Iso639_2_Get(MI.Get(StreamKind, StreamPos, __T("Language"))));
//essenceTrackAnnotation - all fields (except *_String*) separated by |
Ztring Temp;
for (size_t Pos=0; Pos<MI.Count_Get(StreamKind, StreamPos); Pos++)
if (MI.Get(StreamKind, StreamPos, Pos, Info_Name).find(__T("String"))==std::string::npos && !MI.Get(StreamKind, StreamPos, Pos).empty())
Temp+=MI.Get(StreamKind, StreamPos, Pos, Info_Name)+__T(": ")+MI.Get(StreamKind, StreamPos, Pos)+__T('|');
if (!Temp.empty())
{
Temp.resize(Temp.size()-1);
Node_EssenceTrack->Add_Child("essenceTrackAnnotation", Temp);
}
}
//---------------------------------------------------------------------------
bool File_Hls::FileHeader_Begin()
{
//Element_Size
if (File_Size>1024*1024 || File_Size<10)
{
Reject("HLS");
return false; //HLS files are not big
}
if (Buffer_Size<File_Size)
return false; //Wait for complete file
Ztring Document; Document.From_UTF8((char*)Buffer, Buffer_Size);
ZtringList Lines;
size_t LinesSeparator_Pos=Document.find_first_of(__T("\r\n"));
if (LinesSeparator_Pos>File_Size-1)
{
Reject("HLS");
return false;
}
Ztring LinesSeparator;
if (Document[LinesSeparator_Pos]==__T('\r') && LinesSeparator_Pos+1<Document.size() && Document[LinesSeparator_Pos+1]==__T('\n'))
LinesSeparator=__T("\r\n");
else if (Document[LinesSeparator_Pos]==__T('\r'))
LinesSeparator=__T("\r");
else if (Document[LinesSeparator_Pos]==__T('\n'))
LinesSeparator=__T("\n");
else
{
Reject("HLS");
return false;
}
Lines.Separator_Set(0, LinesSeparator);
Lines.Write(Document);
if (Lines(0)!=__T("#EXTM3U"))
{
Reject("HLS");
return false;
}
Accept("HLS");
Fill(Stream_General, 0, General_Format, "HLS");
ReferenceFiles=new File__ReferenceFilesHelper(this, Config);
if (!IsSub)
ReferenceFiles->ContainerHasNoId=true;
File__ReferenceFilesHelper::reference ReferenceFile;
bool IsGroup=false;
for (size_t Line=0; Line<Lines.size(); Line++)
{
if (!Lines[Line].empty())
{
if (Lines[Line].find(__T("#EXT-X-KEY:"))==0)
{
ZtringListList List;
List.Separator_Set(0, __T(","));
List.Separator_Set(1, __T("="));
List.Write(Lines[Line].substr(11, string::npos));
for (size_t Pos=0; Pos<List.size(); ++Pos)
{
if (List[Pos](0)==__T("METHOD"))
{
if (List[Pos](1).find(__T("AES-128"))==0)
{
Fill(Stream_General, 0, General_Encryption_Format, "AES");
Fill(Stream_General, 0, General_Encryption_Length, "128");
Fill(Stream_General, 0, General_Encryption_Method, "Segment");
Fill(Stream_General, 0, General_Encryption_Mode, "CBC");
Fill(Stream_General, 0, General_Encryption_Padding, "PKCS7");
Fill(Stream_General, 0, General_Encryption_InitializationVector, "Sequence number");
#if MEDIAINFO_AES
//Trying to get the key from FileName.FileExt.key
if (Config->Encryption_Key_Get().empty())
{
File KeyFile;
if (KeyFile.Open(File_Name+__T(".key")))
{
if (KeyFile.Size_Get()==16)
{
int8u Key[16];
if (KeyFile.Read(Key, 16)==16)
Config->Encryption_Key_Set(Key, 16);
}
else
Fill(Stream_General, 0, "Encryption_Key_Problem", KeyFile.Size_Get());
}
}
#endif
}
Fill(Stream_General, 0, General_Encryption, List[Pos](1));
}
}
}
else if (Lines[Line].find(__T("#EXT-X-STREAM-INF:"))==0)
{
IsGroup=true;
}
else if (Lines[Line][0]==__T('#'))
;
else
{
if (IsGroup)
{
ReferenceFile.FileNames.push_back(Lines[Line]);
ReferenceFile.StreamID=ReferenceFiles->References.size()+1;
ReferenceFiles->References.push_back(ReferenceFile);
IsGroup=false;
ReferenceFile=File__ReferenceFilesHelper::reference();
#if MEDIAINFO_EVENTS
ParserIDs[0]=MediaInfo_Parser_HlsIndex;
StreamIDs_Width[0]=sizeof(size_t);
#endif //MEDIAINFO_EVENTS
}
else
ReferenceFile.FileNames.push_back(Lines[Line]);
}
}
}
if (!ReferenceFile.FileNames.empty())
{
ReferenceFiles->References.push_back(ReferenceFile);
Fill(Stream_General, 0, General_Format_Profile, "Media");
}
else
{
Fill(Stream_General, 0, General_Format_Profile, "Master");
}
Element_Offset=File_Size;
//All should be OK...
return true;
}
//---------------------------------------------------------------------------
bool File_SequenceInfo::FileHeader_Begin()
{
XMLDocument document;
if (!FileHeader_Begin_XML(document))
return false;
{
XMLElement* Root=document.FirstChildElement("SEQUENCEINFO");
if (Root)
{
Accept("SequenceInfo");
Fill(Stream_General, 0, General_Format, "SequenceInfo");
ReferenceFiles=new File__ReferenceFilesHelper(this, Config);
sequence* Sequence=new sequence;
Sequence->StreamKind=Stream_Video;
FileName FN(File_Name);
Ztring Base=FN.Path_Get();
size_t Pos=Base.rfind(PathSeparator);
if (Pos!=string::npos)
{
Ztring ToAdd=Base.substr(Pos, string::npos);
Ztring DirectoryBase=Base;
DirectoryBase+=ToAdd;
DirectoryBase+=__T('_');
size_t DirNumberCount=1;
Ztring Directory=DirectoryBase;
for (; DirNumberCount<9; DirNumberCount++)
{
Directory+=__T('0');
if (Dir::Exists(Directory))
break;
}
if (DirNumberCount<9)
{
int32u DirNumber=0;
do
{
Ztring Number=Ztring::ToZtring(DirNumber);
if (Number.size()<DirNumberCount)
Number.insert(0, DirNumberCount-Number.size(), __T('0'));
Directory=DirectoryBase;
Directory+=Number;
if (!Dir::Exists(Directory))
break;
Ztring FileBase=Directory;
FileBase+=ToAdd;
FileBase+=__T('_');
FileBase+=__T('.');
size_t FileNumberCount=1;
Ztring FullFile=FileBase;
Ztring Extension;
for (; FileNumberCount<10; FileNumberCount++)
{
FullFile.insert(FullFile.begin()+FullFile.size()-Extension.size()-1, __T('0'));
if (Extension.empty())
{
ZtringList List=Dir::GetAllFileNames(FullFile+__T('*'));
if (List.size()>=2)
{
FileNumberCount=(size_t)-1; //Problem, which one to choose?
break;
}
else if (List.size()==1)
{
FileName Temp(List[0]);
Extension=Temp.Extension_Get();
FileBase+=Extension;
FullFile=FileBase;
break;
}
}
else if (File::Exists(FullFile))
break;
}
bool FromZero=true;
if (FileNumberCount>=9)
{
//Trying with consecutive file numbers betweens dirs
Number=Ztring::ToZtring(Sequence->FileNames.size());
FullFile=FileBase;
FullFile.insert(FullFile.size()-Extension.size()-1, Number);
FileNumberCount=Number.size();
if (!File::Exists(FullFile))
{
FileNumberCount++;
for (; FileNumberCount<10; FileNumberCount++)
{
FullFile.insert(FullFile.begin()+FullFile.size()-Extension.size()-Number.size()-1, __T('0'));
if (File::Exists(FullFile))
{
FromZero=false;
break;
}
}
}
else
FromZero=false;
}
if (FileNumberCount<9)
{
size_t FileNumber=FromZero?0:Sequence->FileNames.size();
do
{
Number=Ztring::ToZtring(FileNumber);
if (Number.size()<FileNumberCount)
Number.insert(0, FileNumberCount-Number.size(), __T('0'));
FullFile=FileBase;
FullFile.insert(FullFile.size()-Extension.size()-1, Number);
if (!File::Exists(FullFile))
break;
Sequence->AddFileName(FullFile);
FileNumber++;
}
while (FileNumber<1000000000);
}
DirNumber++;
}
while (DirNumber<1000000000);
ReferenceFiles->AddSequence(Sequence);
}
}
}
else
{
Reject("SequenceInfo");
return false;
}
}
Element_Offset=File_Size;
//All should be OK...
return true;
}
//---------------------------------------------------------------------------
void File_Ptx::Read_Buffer_Continue()
{
if (File_Offset || Buffer_Offset)
{
if (Buffer_Size)
Reject(); //Problem
return;
}
//Parsing
ZtringList Names;
Ztring LibraryName, LibraryVersion, Format, Directory;
int32u LibraryName_Length, LibraryVersion_Length, LibraryRelease_Length, Format_Length, Platform_Length, Info_Count, Names_Count, Info_Length, Name_Length, FileName_Count, Directory_Length;
int32u Unknown_Length;
int16u Audio_Count;
Element_Begin1("Header");
Skip_B1( "Magic");
Skip_Local(16, "Magic");
Skip_L2( "0x0500");
Skip_L1( "Unknown");
Skip_L1( "0x5A");
Skip_L2( "0x0001");
Skip_L2( "0x0004");
Skip_L2( "0x0000");
Skip_L4( "Unknown");
Skip_L2( "0x035A");
Skip_L2( "0x6400");
Skip_L2( "0x0000");
Skip_L2( "0x0300");
Skip_L2( "0x0000");
Get_L4 (LibraryName_Length, "WritingLibrary name length");
Get_UTF8(LibraryName_Length, LibraryName, "Library name");
Skip_L4( "0x00000003");
Skip_L4( "Library version, major");
Skip_L4( "Library version, minor");
Skip_L4( "Library version, revision");
Get_L4 (LibraryVersion_Length, "Library version length");
Get_UTF8(LibraryVersion_Length, LibraryVersion, "Library version");
Skip_L1( "0x01");
Get_L4 (LibraryRelease_Length, "Library release length");
Skip_UTF8(LibraryRelease_Length, "Library release");
Skip_L1( "0x00");
Get_L4 (Format_Length, "Format length");
Get_UTF8(Format_Length, Format, "Format");
if (Format!=__T("Pro Tools Session File"))
{
Element_End();
Reject("Ptx");
return;
}
Skip_L2( "0x0006");
Get_L4 (Platform_Length, "Platform length");
Skip_UTF8(Platform_Length, "Platform");
Skip_L4( "0x00000000");
Skip_L4( "0x00085A05");
Skip_L4( "Unknown");
Skip_L4( "0x00002067");
Skip_L4( "0x002A0000");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Element_End();
Element_Begin1("Info list");
Get_L4 (Info_Count, "Info count");
if (4*Info_Count>Element_Size)
{
Element_End();
Reject();
return;
}
for (int32u Pos=0; Pos<Info_Count; Pos++)
{
Element_Begin1("Info");
Get_L4 (Info_Length, "Info length");
if (Info_Length)
{
Info_UTF8(Info_Length, Info, "Name"); Element_Info1(Info);
}
Element_End();
}
Element_End();
Element_Begin1("Unknown");
Skip_L4( "0x00000000");
Element_Begin1("Names list 1");
Get_L4 (Names_Count, "Names count minus 1");
if (4*Names_Count>Element_Size)
{
Element_End();
Reject();
return;
}
for (int16u Pos=0; Pos<1+Names_Count; Pos++)
{
Element_Begin1("Name");
Get_L4 (Name_Length, "Name length");
if (Name_Length)
{
Info_UTF8(Name_Length, Name, "Name"); Element_Name(Name);
}
Element_End();
}
Element_End();
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Element_Begin1("Names list 2");
Get_L4 (Names_Count, "Names count");
if (4*Names_Count>Element_Size)
{
Element_End();
Reject();
return;
}
for (int16u Pos=0; Pos<Names_Count; Pos++)
{
Element_Begin1("Name");
Get_L4 (Name_Length, "Name length");
if (Name_Length)
{
Info_UTF8(Name_Length, Name, "Name"); Element_Name(Name);
}
Element_End();
}
Element_End();
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x00000000");
Skip_L4( "Unknown");
Skip_L4( "0x00000101");
Skip_L4( "0x00055A00");
Skip_L4( "Unknown");
Skip_L4( "0x00012519");
Skip_L4( "0x00000000");
Skip_L4( "0x00000000");
Skip_L4( "0x00000001");
Skip_L2( "0x0003");
Element_End();
Get_L2 (Audio_Count, "Audio count");
if (111*Audio_Count>Element_Size)
{
Reject();
return;
}
Element_Begin1("Audio tracks list 1");
for (int16u Pos=0; Pos<Audio_Count; Pos++)
{
Element_Begin1("Name");
Skip_L4( "0x00000000");
Get_L4 (Unknown_Length, "Name length");
Info_UTF8(Unknown_Length, Name, "Name");
Skip_L2( "0x0000");
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown (same 1/2/3)");
Skip_L4( "Unknown (same 1/2/3)");
Info_L1(Number, "Ordered number"); Element_Info1(Number);
Element_Info1(Name);
Element_End();
Names.push_back(Name);
}
Element_End();
Skip_L2( "0x0000");
Element_Begin1("Audio tracks list 2");
for (int16u Pos=0; Pos<Audio_Count; Pos++)
{
Element_Begin1("Name");
int32u Size;
Skip_L3( "0x00025A");
Get_L4 (Size, "Size");
Skip_L4( "0x0000251A");
Get_L4 (Unknown_Length, "Name length");
Info_UTF8(Unknown_Length, Name, "Name");
Skip_L2( "0x0000");
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown (same 1/2/3)");
Skip_L4( "Unknown (same 1/2/3)");
Info_L1(Number, "Ordered number"); Element_Info1(Number);
Skip_L4( "0x00000000");
Element_Info1(Name);
if (Unknown_Length+31!=Size)
{
Reject();
return;
}
Element_End();
}
Element_End();
Get_L2 (Audio_Count, "Audio count");
if (4*Audio_Count>Element_Size)
{
Reject();
return;
}
Skip_L2( "0x00");
Element_Begin1("Audio tracks list 3");
for (int16u Pos=0; Pos<Audio_Count; Pos++)
{
Element_Begin1("Name");
int32u Size;
Skip_L3( "0x00025A");
Get_L4 (Size, "Size");
Skip_L4( "0x0000251A");
Get_L4 (Unknown_Length, "Name length");
Info_UTF8(Unknown_Length, Name, "Name");
Skip_L2( "0x0000");
Skip_L4( "0x00000000");
Skip_L4( "0x0000002A");
Skip_L4( "Unknown (same 1/2/3)");
Skip_L4( "Unknown (same 1/2/3)");
Info_L1(Number, "Ordered number"); Element_Info1(Number);
Skip_L4( "0x00000000");
Element_Info1(Name);
if (Unknown_Length+31!=Size)
{
Reject();
return;
}
Element_End();
}
Element_End();
Skip_L2( "0x0000");
Skip_L2( "0x0018");
Skip_L4( "0x00000001");
Skip_L2( "0x0018");
Skip_L4( "0x00000001");
Skip_L2( "0x0001");
Skip_L3( "0x00095A");
Get_L4 (Unknown_Length, "Opaque length");
Skip_XX(Unknown_Length, "Opaque");
Skip_L3( "0x00045A");
Skip_L4( "0x00000016");
Skip_L4( "0x06002026");
Skip_L4( "0x00000000");
Skip_L2( "0x0000");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x00000000");
Skip_L3( "0x00025A");
Skip_L4( "0x00000015");
Skip_L4( "0x075A2032");
Skip_L4( "0x00000C00");
Skip_L4( "0x01204200");
Skip_L4( "0x01000000");
Skip_L4( "Unknown");
Skip_L4( "0x00025A00");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x015A0000");
Skip_L4( "Unknown");
Skip_L4( "Unknown");
Skip_L4( "0x01000000");
Get_L4 (FileName_Count, "File name count");
if (13*FileName_Count>Element_Size)
{
Reject();
return;
}
Get_L4 (Directory_Length, "Directory length");
Get_UTF8(Directory_Length, Directory, "Directory");
Skip_L4( "0x00000000");
Element_Begin1("File names");
size_t Pos_Offset=0;
for (int32u Pos=0; Pos<FileName_Count; Pos++)
{
Ztring Name;
int32u Name_Length, Purpose;
Element_Begin1("File names");
Skip_L1( "0x0002");
Skip_L4( "Ordered number except WAV files and -1");
Get_L4 (Name_Length, "Name length");
Get_UTF8(Name_Length, Name, "Name"); Element_Name(Name);
Get_C4 (Purpose, "Purpose (e.g. EVAW for .wav files)");
Element_End();
switch (Purpose)
{
case 0x45564157:
if (Pos-Pos_Offset<Names.size()
&& (Name.find(Names[Pos-Pos_Offset])==0
|| Name.find(Names[Pos-Pos_Offset]+__T(".wav"))+5==Name.size()))
{
File__ReferenceFilesHelper::reference ReferenceFile;
ReferenceFile.StreamKind=Stream_Audio;
ReferenceFile.FileNames.push_back(Directory+PathSeparator+Name);
ReferenceFiles->References.push_back(ReferenceFile);
}
else if (ReferenceFiles->References.empty())
Pos_Offset++;
default: ;
}
}
Element_End();
Skip_XX(Element_Size-Element_Offset, "Unknown");
FILLING_BEGIN();
Accept("Ptx"); //Could be Ptf (former formatn but not supported, so we don't care currently
Fill("Ptx");
Fill(Stream_General, 0, General_Format, "Pro Tools Session");
Fill(Stream_General, 0, General_Format_Version, "Version 10");
Fill(Stream_General, 0, General_Encoded_Library_Name, LibraryName);
Fill(Stream_General, 0, General_Encoded_Library_Version, LibraryVersion);
FILLING_END();
}
//---------------------------------------------------------------------------
// Write
void ZtringListList::Write(const Ztring &ToWrite)
{
clear();
if (ToWrite.empty())
return;
size_type PosC=0;
bool Fini=false;
Ztring C1;
ZtringList ZL1;
ZL1.Separator_Set(0, Separator[1]);
ZL1.Quote_Set(Quote);
ZL1.Max_Set(0, Max[1]);
//Detecting carriage return format
Ztring WriteSeparator;
if (Separator[0]==EOL)
{
size_t CarriageReturn_Pos=ToWrite.find_first_of(__T("\r\n"));
if (CarriageReturn_Pos!=string::npos)
{
if (ToWrite[CarriageReturn_Pos]==__T('\r'))
{
if (CarriageReturn_Pos+1<ToWrite.size() && ToWrite[CarriageReturn_Pos+1]==__T('\n'))
WriteSeparator=__T("\r\n");
else
WriteSeparator=__T("\r");
}
else
WriteSeparator=__T("\n");
}
else
WriteSeparator=Separator[0];
}
else
WriteSeparator=Separator[0];
do
{
//Searching end of line, but it must not be in quotes
bool InQuotes=false;
Ztring CharsToFind=WriteSeparator+Quote;
size_t Pos_End=PosC;
while (Pos_End<ToWrite.size())
{
Pos_End=ToWrite.find(WriteSeparator, Pos_End);
if (Pos_End!=string::npos)
{
if (Pos_End+Quote.size()<ToWrite.size() && ToWrite[Pos_End]==Quote[0] && ToWrite[Pos_End+1]!=Quote[0])
{
InQuotes=!InQuotes; //This is not double quotes, so this is a normal quote
/*if (!InQuotes)
{
C1=ToWrite.substr(PosC, Pos_End-PosC);
break;
}*/
}
if (!InQuotes && Pos_End+WriteSeparator.size()<=ToWrite.size() && ToWrite[Pos_End]==WriteSeparator[0])
{
C1=ToWrite.substr(PosC, Pos_End-PosC);
break;
}
if (InQuotes && Pos_End+Quote.size()*2<ToWrite.size() && ToWrite[Pos_End]==Quote[0] && ToWrite[Pos_End+1]==Quote[0])
Pos_End+=2;
else
Pos_End++;
}
}
if (Pos_End>=ToWrite.size())
C1=ToWrite.substr(PosC, string::npos);
ZL1.Write(C1);
push_back(ZL1);
PosC+=C1.size()+WriteSeparator.size();
if (PosC>=ToWrite.size())
Fini=true;
}
while (!Fini);
}
void __stdcall Event_CallBackFunction(unsigned char* Data_Content, size_t Data_Size, void* UserHandle_Void)
{
/*Retrieving UserHandle*/
struct Events_UserHandle_struct* UserHandle=(struct Events_UserHandle_struct*)UserHandle_Void;
struct MediaInfo_Event_Generic* Event_Generic=(struct MediaInfo_Event_Generic*) Data_Content;
unsigned char ParserID;
unsigned short EventID;
unsigned char EventVersion;
/*integrity tests*/
if (Data_Size<4)
return; //There is a problem
if (UserHandle->PerEvent[Event_Generic->EventCode].F==NULL)
{
Ztring Number; Number.From_Number(Event_Generic->EventCode, 16);
while (Number.size()<8)
Number.insert(0, 1, __T('0'));
Ztring Name=Ztring(UserHandle->DataBaseDirectory+__T("\\Events\\New\\")+Ztring::ToZtring(UserHandle->Scenario)+__T("\\")+Number+__T("\\")+UserHandle->Name.Name_Get()+__T(".txt"));
if (!Dir::Exists(UserHandle->DataBaseDirectory+__T("\\Events\\New")))
Dir::Create(UserHandle->DataBaseDirectory+__T("\\Events\\New"));
if (!Dir::Exists(UserHandle->DataBaseDirectory+__T("\\Events\\New\\")+Ztring::ToZtring(UserHandle->Scenario)))
Dir::Create(UserHandle->DataBaseDirectory+__T("\\Events\\New\\")+Ztring::ToZtring(UserHandle->Scenario));
if (!Dir::Exists(UserHandle->DataBaseDirectory+__T("\\Events\\New\\")+Ztring::ToZtring(UserHandle->Scenario)+__T("\\")+Number))
Dir::Create(UserHandle->DataBaseDirectory+__T("\\Events\\New\\")+Ztring::ToZtring(UserHandle->Scenario)+__T("\\")+Number);
if (!Dir::Exists(FileName(Name).Path_Get()))
Dir::Create(FileName(Name).Path_Get());
UserHandle->PerEvent[Event_Generic->EventCode].F=fopen(Name.To_Local().c_str(), "w");
}
/*Retrieving EventID*/
ParserID =(unsigned char) ((Event_Generic->EventCode&0xFF000000)>>24);
EventID =(unsigned short)((Event_Generic->EventCode&0x00FFFF00)>>8 );
EventVersion=(unsigned char) ( Event_Generic->EventCode&0x000000FF );
//*Global to all parsers
switch (EventID)
{
CASE (Global, Demux, 4)
CASE (Video, SliceInfo, 0)
default : ;
}
switch (ParserID)
{
case MediaInfo_Parser_None :
switch (EventID)
{
case MediaInfo_Event_General_Start : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_Start_0)) General_Start_0((struct MediaInfo_Event_General_Start_0*)Data_Content, UserHandle); break;
case MediaInfo_Event_General_End : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_End_0)) General_End_0((struct MediaInfo_Event_General_End_0*)Data_Content, UserHandle); break;
case MediaInfo_Event_General_Parser_Selected : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_Parser_Selected_0)) General_Parser_Selected_0((struct MediaInfo_Event_General_Parser_Selected_0*)Data_Content, UserHandle); break;
case MediaInfo_Event_General_Move_Request : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_Move_Request_0)) General_Move_Request_0((struct MediaInfo_Event_General_Move_Request_0*)Data_Content, UserHandle); break;
case MediaInfo_Event_General_Move_Done : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_Move_Done_0)) General_Move_Done_0((struct MediaInfo_Event_General_Move_Done_0*)Data_Content, UserHandle); break;
case MediaInfo_Event_General_SubFile_Start : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_SubFile_Start_0)) General_SubFile_Start_0((struct MediaInfo_Event_General_SubFile_Start_0*)Data_Content, UserHandle); break;
case MediaInfo_Event_General_SubFile_End : if (EventVersion==0 && Data_Size==sizeof(struct MediaInfo_Event_General_SubFile_End_0)) General_SubFile_End_0((struct MediaInfo_Event_General_SubFile_End_0*)Data_Content, UserHandle); break;
default : ;
}
break;
default : ; //ParserID is unknown
}
}
Ztring OldFiles_Test ()
{
//Checking version in Info_Version
ToShow+=__T("Version checked : ");
F.Open(__T("../Source/MediaInfo/MediaInfo_Config.cpp"));
I=F.Read(C, 1000000);
if (!I)
{
ToShow+=__T("Error opening ../Source/MediaInfo/MediaInfo_Config.cpp");
return ToShow;
}
C[I]=0;
Z.From_Local(C);
Version=Z.SubString(__T("MediaInfoLib - v"), __T("\")"));
if (Version.size()!=7)
{
ToShow+=__T("Error reading ../Source/MediaInfo/MediaInfo.cpp : \"MediaInfoLib - vX.X.X.X - \" not found");
return ToShow;
}
Version_Short=Version; Version_Short.resize(3);
ToShow+=Version+__T("\r\n");
//Checking version in MediaInfo.h
if (Test_Version("../Source/MediaInfo/MediaInfo.h", "@version ", "\n")) return ToShow;
if (Test_Version("../Source/MediaInfo/MediaInfoList.h", "@version ", "\n")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " FILEVERSION ", "\n")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " PRODUCTVERSION ", "\n")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " VALUE \"FileVersion\", \"", "\"")) return ToShow;
if (Test_Version("../Project/MSVC/Dll/MediaInfo.rc", " VALUE \"ProductVersion\", \"", "\"")) return ToShow;
if (Test_Version("../History.txt", "Version ", " ")) return ToShow;
if (Test_Date(__T("MSVC/Library/MediaInfo.lib"))) return ToShow;
if (Test_Date(__T("MSVC/Dll/MediaInfo.dll"))) return ToShow;
return ToShow;
}