302 lines
8.8 KiB
C++
302 lines
8.8 KiB
C++
/****************************************************************************
|
||
** libmatroska : parse Matroska files, see http://www.matroska.org/
|
||
**
|
||
** <file/class description>
|
||
**
|
||
** Copyright (C) 2002-2004 Steve Lhomme. All rights reserved.
|
||
**
|
||
** This file is part of libmatroska.
|
||
**
|
||
** This library is free software; you can redistribute it and/or
|
||
** modify it under the terms of the GNU Lesser General Public
|
||
** License as published by the Free Software Foundation; either
|
||
** version 2.1 of the License, or (at your option) any later version.
|
||
**
|
||
** This library is distributed in the hope that it will be useful,
|
||
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
** Lesser General Public License for more details.
|
||
**
|
||
** You should have received a copy of the GNU Lesser General Public
|
||
** License along with this library; if not, write to the Free Software
|
||
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||
**
|
||
** See http://www.gnu.org/licenses/lgpl-2.1.html for LGPL licensing information.**
|
||
** Contact license@matroska.org if any conditions of this licensing are
|
||
** not clear to you.
|
||
**
|
||
**********************************************************************/
|
||
|
||
/*!
|
||
\file
|
||
\version \$Id$
|
||
\author Steve Lhomme <robux4 @ users.sf.net>
|
||
Test the EBML write possibilities
|
||
\see http://www.cl.cam.ac.uk/~mgk25/unicode.html
|
||
\see http://www-106.ibm.com/developerworks/unicode/library/u-encode.html
|
||
*/
|
||
|
||
#include <stdio.h>
|
||
|
||
#include "ebml/StdIOCallback.h"
|
||
|
||
#include "ebml/EbmlUInteger.h"
|
||
#include "ebml/EbmlSInteger.h"
|
||
#include "ebml/EbmlBinary.h"
|
||
#include "ebml/EbmlString.h"
|
||
#include "ebml/EbmlUnicodeString.h"
|
||
#include "ebml/EbmlMaster.h"
|
||
#include "ebml/EbmlFloat.h"
|
||
#include "ebml/EbmlStream.h"
|
||
#include "ebml/StdIOCallback.h"
|
||
|
||
using namespace LIBEBML_NAMESPACE;
|
||
|
||
const char RW_FILENAME[] = "test.kax";
|
||
|
||
enum SemanticType {
|
||
EBML_U_INTEGER,
|
||
EBML_S_INTEGER,
|
||
EBML_BINARY,
|
||
EBML_STRING,
|
||
EBML_STRING_UNICODE,
|
||
EBML_FLOAT,
|
||
EBML_MASTER,
|
||
};
|
||
|
||
typedef binary EBMLID[4];
|
||
struct Semantic {
|
||
EBMLID Id;
|
||
int IdLength;
|
||
SemanticType Type;
|
||
};
|
||
|
||
struct Semantic SemanticList[] =
|
||
{
|
||
{{0x42, 0x45}, 2, EBML_U_INTEGER},
|
||
{{0x1A, 0x45, 0x33, 0x80}, 4, EBML_S_INTEGER},
|
||
{{0x87}, 1, EBML_BINARY},
|
||
{{0x22, 0x33, 0x44}, 3, EBML_STRING},
|
||
{{0x44, 0x33}, 2, EBML_STRING_UNICODE},
|
||
{{0x50, 0x50}, 2, EBML_FLOAT},
|
||
{{0x36, 0x47, 0x58}, 3, EBML_MASTER},
|
||
};
|
||
|
||
/*!
|
||
\test Some test on the Cluster use
|
||
\todo render the Cluster to a file
|
||
*/
|
||
int main(void)
|
||
{
|
||
StdIOCallback Ebml_file(RW_FILENAME, ::MODE_CREATE);
|
||
|
||
///// Writing test
|
||
|
||
///////////////////////////////
|
||
// Unsigned integer
|
||
///////////////////////////////
|
||
|
||
EbmlUInteger testUInt(4); // supposed to hold a 4*8 bits value
|
||
|
||
testUInt.SetID(SemanticList[0].Id, SemanticList[0].IdLength);
|
||
testUInt = 52;
|
||
testUInt.SetSizeLength(3); // size should be coded on at least 3 octets
|
||
testUInt.Render(Ebml_file);
|
||
|
||
///////////////////////////////
|
||
// Signed integer
|
||
///////////////////////////////
|
||
|
||
EbmlSInteger testSInt(4); // supposed to hold a 4*8 bits value
|
||
|
||
testSInt.SetID(SemanticList[1].Id, SemanticList[1].IdLength);
|
||
testSInt = -20;
|
||
testSInt.Render(Ebml_file);
|
||
|
||
///////////////////////////////
|
||
// Binary data
|
||
///////////////////////////////
|
||
const int BINARY_SIZE=3000;
|
||
|
||
binary *bin = new binary[BINARY_SIZE];
|
||
memset(bin, 0x61, BINARY_SIZE);
|
||
EbmlBinary testBin;
|
||
|
||
testBin.SetID(SemanticList[2].Id, SemanticList[2].IdLength);
|
||
testBin.SetBuffer(bin, BINARY_SIZE);
|
||
testBin.Render(Ebml_file);
|
||
|
||
///////////////////////////////
|
||
// String data
|
||
///////////////////////////////
|
||
std::string aString = "Hello World !";
|
||
EbmlString testStr(200);
|
||
|
||
testStr.SetID(SemanticList[3].Id, SemanticList[3].IdLength);
|
||
testStr = aString;
|
||
testStr.Render(Ebml_file);
|
||
|
||
///////////////////////////////
|
||
// Master element
|
||
///////////////////////////////
|
||
EbmlMaster testMaster;
|
||
|
||
testMaster.SetID(SemanticList[6].Id, SemanticList[6].IdLength);
|
||
testMaster.PushElement(testStr);
|
||
testMaster.PushElement(testUInt);
|
||
testMaster.Render(Ebml_file);
|
||
|
||
///////////////////////////////
|
||
// Unicode String data
|
||
///////////////////////////////
|
||
UTFstring bString = L"St<EFBFBD>ve Lhomm<6D>";
|
||
EbmlUnicodeString testUStr(200);
|
||
|
||
testUStr.SetID(SemanticList[4].Id, SemanticList[4].IdLength);
|
||
testUStr = bString;
|
||
testUStr.Render(Ebml_file);
|
||
|
||
///////////////////////////////
|
||
// Float data
|
||
///////////////////////////////
|
||
EbmlFloat testFloat(EbmlFloat::FLOAT_32);
|
||
|
||
testFloat.SetID(SemanticList[5].Id, SemanticList[5].IdLength);
|
||
testFloat.SetPrecision(EbmlFloat::FLOAT_32);
|
||
testFloat = 1.01234567890123456;
|
||
testFloat.Render(Ebml_file);
|
||
|
||
testFloat.SetPrecision(EbmlFloat::FLOAT_64);
|
||
testFloat = -1.01234567890123456L;
|
||
testFloat.Render(Ebml_file);
|
||
|
||
Ebml_file.close();
|
||
|
||
///// Reading test
|
||
StdIOCallback Ebml_Wfile(RW_FILENAME, ::MODE_READ);
|
||
|
||
// example 1 skip all the elements found
|
||
EbmlStream aStream(Ebml_Wfile);
|
||
EbmlElement * ElementLevel0;
|
||
|
||
// read the data until a possible element is found (valid ID + size combination)
|
||
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
|
||
printf("Read EBML elements & skip data\n");
|
||
while (ElementLevel0 != NULL)
|
||
{
|
||
printf("ID : ");
|
||
for (int i=0; i<ElementLevel0->GetIDLength(); i++)
|
||
{
|
||
printf("[%02X]", ElementLevel0->GetID()[i]);
|
||
}
|
||
printf("\n");
|
||
|
||
ElementLevel0->SkipData(Ebml_Wfile);
|
||
if (ElementLevel0 != NULL)
|
||
delete ElementLevel0;
|
||
|
||
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
|
||
}
|
||
|
||
// example 2 evaluation of all elements found
|
||
EbmlStream bStream(Ebml_Wfile);
|
||
EbmlElement * EvaledElementLevel0;
|
||
// EbmlElement * EvaledElementLevel1;
|
||
|
||
// reset the stream to the beggining
|
||
Ebml_Wfile.setFilePointer(0);
|
||
|
||
// list of all IDs and their semantic type
|
||
// std::list<struct Semantic> SemanticList;
|
||
// SemanticList.push_back();
|
||
|
||
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
|
||
printf("Read EBML elements & evaluate data\n");
|
||
while (ElementLevel0 != NULL)
|
||
{
|
||
int i;
|
||
printf("ID : ");
|
||
for (i=0; i<ElementLevel0->GetIDLength(); i++)
|
||
{
|
||
printf("[%02X]", ElementLevel0->GetID()[i]);
|
||
}
|
||
|
||
// check if the element is known
|
||
for (i=0; i<countof(SemanticList); i++) {
|
||
if (ElementLevel0->GetIDLength() != SemanticList[i].IdLength)
|
||
continue;
|
||
if (memcmp(SemanticList[i].Id, ElementLevel0->GetID(), SemanticList[i].IdLength) == 0)
|
||
break;
|
||
}
|
||
/// \todo check if it is known in the context
|
||
// handle the data inside the element
|
||
if (i < countof(SemanticList)) {
|
||
switch (SemanticList[i].Type)
|
||
{
|
||
case EBML_U_INTEGER:
|
||
EvaledElementLevel0 = new EbmlUInteger(*ElementLevel0);
|
||
break;
|
||
case EBML_S_INTEGER:
|
||
EvaledElementLevel0 = new EbmlSInteger(*ElementLevel0);
|
||
break;
|
||
case EBML_BINARY:
|
||
EvaledElementLevel0 = new EbmlBinary(*ElementLevel0);
|
||
break;
|
||
case EBML_STRING:
|
||
EvaledElementLevel0 = new EbmlString(*ElementLevel0);
|
||
break;
|
||
case EBML_STRING_UNICODE:
|
||
EvaledElementLevel0 = new EbmlUnicodeString(*ElementLevel0);
|
||
break;
|
||
case EBML_FLOAT:
|
||
EvaledElementLevel0 = new EbmlFloat(*ElementLevel0);
|
||
break;
|
||
case EBML_MASTER:
|
||
EvaledElementLevel0 = new EbmlMaster(*ElementLevel0);
|
||
break;
|
||
}
|
||
|
||
EvaledElementLevel0->ReadData(Ebml_Wfile);
|
||
|
||
switch (SemanticList[i].Type)
|
||
{
|
||
case EBML_U_INTEGER:
|
||
printf(" : %d", uint32(*(EbmlUInteger*)EvaledElementLevel0));
|
||
break;
|
||
case EBML_S_INTEGER:
|
||
printf(" : %d", int32(*(EbmlSInteger*)EvaledElementLevel0));
|
||
break;
|
||
case EBML_BINARY:
|
||
printf(" : binary data, size = %ld", (*(EbmlBinary*)EvaledElementLevel0).GetSize());
|
||
printf(" [%02X]", binary(*(EbmlBinary*)EvaledElementLevel0));
|
||
break;
|
||
case EBML_STRING:
|
||
printf(" : %s", std::string(*(EbmlString*)EvaledElementLevel0).data());
|
||
break;
|
||
case EBML_STRING_UNICODE:
|
||
printf(" : (wide chars) %ls", UTFstring(*(EbmlUnicodeString*)EvaledElementLevel0).data());
|
||
break;
|
||
case EBML_FLOAT:
|
||
printf(" : %f / %.15lf", float(*(EbmlFloat*)EvaledElementLevel0), double(*(EbmlFloat*)EvaledElementLevel0));
|
||
break;
|
||
case EBML_MASTER:
|
||
printf(" : unsupported format 'Master'");
|
||
break;
|
||
}
|
||
delete EvaledElementLevel0;
|
||
} else {
|
||
ElementLevel0->SkipData(Ebml_Wfile);
|
||
}
|
||
if (ElementLevel0 != NULL)
|
||
delete ElementLevel0;
|
||
|
||
printf("\n");
|
||
|
||
ElementLevel0 = aStream.FindNextID(0xFFFFFFFFL, false);
|
||
}
|
||
|
||
Ebml_Wfile.close();
|
||
|
||
return 0;
|
||
}
|