void capture(const char *save_file_name, RawData &data, bool playback) {
DAEPAnalysis ep;
AutoCapture c(&ep);
Tip("Press any key to capture:");
getch();
puts("");
Tip("Preparing...");
sleep(1);
char fn_buffer [128]="";
Tip("Start talking");
if(c.capture(&data)) {
data.saveWav(stringFile(save_file_name,".wav",fn_buffer));
//if(playback)c.play(&data);
ep.smooth();
ep.cut();
if(playback) c.play(&data);
data.saveWav(stringFile(save_file_name,"_cut.wav",fn_buffer));
}
else{
ErrorLog("Capture error");
}
}
SP_RESULT load_calc(const char *load_file_name,
const char *file_name,
EPAnalysis& ep,
bool playback) {
RawData data;
Capture c;
char fn_buffer [128]="";
data.loadWav(stringFile(load_file_name,".wav",fn_buffer));
ep.Initial(&data);
ep.reCalcAllData();
ep.saveMatlab(stringFile(file_name,".dat",fn_buffer));
if(playback)c.play(&data);
ep.smooth();
ep.saveMatlab(stringFile(file_name,"_smooth.dat",fn_buffer));
ep.cut();
ep.saveMatlab(stringFile(file_name,"_cut.dat",fn_buffer));
//ep.smooth();
//ep.cut();
//ep.saveMatlab(stringFile(file_name,"_cut_2.m",fn_buffer));
if(playback)c.play(&data);
return SP_SUCCESS;
}
SP_RESULT load_wav_file(const char *file_name, RawData &data) {
DAEPAnalysis da_ep;
Capture c;
char fn_buffer[128] = "";
data.loadWav(stringFile(file_name, ".wav", fn_buffer));
da_ep.Initial(&data);
da_ep.reCalcAllData();
// da_ep.smooth();
// da_ep.cut();
return SP_SUCCESS;
}
wxString StringReader::getString( ) const {
wxString string;
// Table header.
string << L"Entry;String" << L"\r\n";
gw2f::StringsFile stringFile( m_data.GetPointer( ), m_data.GetSize( ) );
#ifdef _DEBUG
auto language = stringFile.language( );
switch ( language ) {
case gw2f::language::English:
wxLogDebug( wxT( "English String." ) );
break;
case gw2f::language::French:
wxLogDebug( wxT( "French String." ) );
break;
case gw2f::language::German:
wxLogDebug( wxT( "German String." ) );
break;
case gw2f::language::Korean:
wxLogDebug( wxT( "Korean String." ) );
break;
case gw2f::language::Spanish:
wxLogDebug( wxT( "Spanish String." ) );
break;
default:
wxLogDebug( wxT( "Unknown Language: %d" ), language );
}
#endif
for ( size_t i = 0; i < stringFile.entryCount( ); i++ ) {
auto& entry = stringFile.entry( i );
wxString str;
if ( entry.isEncrypted( ) ) {
str = L"Encrypted string";
} else {
str = entry.get( );
if ( str.IsEmpty( ) ) {
str = L"Empty string";
}
}
string << i << L";\"" << str << L"\"\r\n";
}
return string;
}
int main( int argc, char** argv ) {
if ( argc <= 1 ) {
std::cout << "Usage: " << argv[0] << " <strs file>" << std::endl;
return 0;
}
// Characters below 128 are the same as for ANSI
auto isAbove127 = []( gw2f::char16 c ) { return ( c >= 0x80 ); };
gw2f::StringsFile stringFile( argv[1] );
for ( size_t i = 0; i < stringFile.entryCount( ); i++ ) {
auto& entry = stringFile.entry( i );
// Under windows, this poses the same problem as the Eula sample. When
// it encounters a character that the console cannot output, any
// subsequent characters sent to the stream are discarded. To prevent
// this, I am replacing all potentially invalid characters with a
// question mark.
std::basic_string<gw2f::char16> str;
if ( entry.isEncrypted( ) ) {
str = GW2F_U16( "Encrypted string" );
} else {
str = entry.get( );
if ( str.empty( ) ) {
str = GW2F_U16( "Empty string" );
}
std::replace_if( std::begin( str ), std::end( str ), isAbove127, '?' );
}
#if defined(_MSC_VER)
std::wcout << i << L";\"" << str << L"\"" << std::endl;
#elif defined(__GNUC__) || defined(__GNUG__)
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> temp;
std::string mbs = temp.to_bytes( str );
std::cout << i << ";\"" << mbs.c_str( ) << "\"" << std::endl;
#endif
}
return 0;
}
DatIndexCategory* ScanDatTask::categorize( ANetFileType p_fileType, const byte* p_data, size_t p_size ) {
DatIndexCategory* category = nullptr;
switch ( p_fileType ) {
case ANFT_ATEX:
case ANFT_ATTX:
case ANFT_ATEC:
case ANFT_ATEP:
case ANFT_ATEU:
case ANFT_ATET:
case ANFT_DDS:
case ANFT_JPEG:
case ANFT_WEBP:
MakeCategory( wxT( "Textures" ) );
switch ( p_fileType ) {
case ANFT_ATEX:
MakeSubCategory( wxT( "Generic Textures" ) );
break;
case ANFT_ATTX:
MakeSubCategory( wxT( "Terrain Textures" ) );
break;
case ANFT_ATEC:
MakeSubCategory( wxT( "ATEC" ) );
break;
case ANFT_ATEP:
MakeSubCategory( wxT( "Map Textures" ) );
break;
case ANFT_ATEU:
MakeSubCategory( wxT( "UI Textures" ) );
break;
case ANFT_ATET:
MakeSubCategory( wxT( "ATET" ) );
break;
case ANFT_DDS:
MakeSubCategory( wxT( "DDS" ) );
break;
case ANFT_JPEG:
MakeSubCategory( wxT( "JPEG" ) );
break;
case ANFT_WEBP:
MakeSubCategory( wxT( "WebP" ) );
break;
}
if ( ( p_fileType == ANFT_ATEX || p_fileType == ANFT_ATTX || p_fileType == ANFT_ATEC ||
p_fileType == ANFT_ATEP || p_fileType == ANFT_ATEU || p_fileType == ANFT_ATET ) ) {
uint16 width = *reinterpret_cast<const uint16*>( p_data + 8 );
uint16 height = *reinterpret_cast<const uint16*>( p_data + 10 );
MakeSubCategory( wxString::Format( wxT( "%ux%u" ), width, height ) );
} else if ( p_fileType == ANFT_DDS && p_size >= 20 ) {
uint32 width = *reinterpret_cast<const uint32*>( p_data + 16 );
uint32 height = *reinterpret_cast<const uint32*>( p_data + 12 );
MakeSubCategory( wxString::Format( wxT( "%ux%u" ), width, height ) );
}
break;
case ANFT_Sound:
case ANFT_MP3:
case ANFT_Ogg:
case ANFT_PackedMP3:
case ANFT_PackedOgg:
case ANFT_asndMP3:
case ANFT_asndOgg:
MakeCategory( wxT( "Sounds" ) );
switch ( p_fileType ) {
case ANFT_MP3:
MakeSubCategory( wxT( "MP3" ) );
break;
case ANFT_Ogg:
MakeSubCategory( wxT( "Ogg" ) );
break;
case ANFT_asndMP3:
MakeSubCategory( wxT( "asndMP3" ) );
break;
case ANFT_asndOgg:
MakeSubCategory( wxT( "asndOgg" ) );
break;
case ANFT_PackedMP3:
MakeSubCategory( wxT( "PackedMP3" ) );
break;
case ANFT_PackedOgg:
MakeSubCategory( wxT( "PackedOgg" ) );
break;
}
break;
case ANFT_Binary:
case ANFT_EXE:
case ANFT_DLL:
MakeCategory( wxT( "Binaries" ) );
break;
// when catagorize string files the process will slower,
// due to strs file format that have to read near end of file to know what language is
case ANFT_StringFile:
{
uint32 entryNumber = this->currentProgress( );
auto buffer = allocate<byte>( m_datFile.fileSize( entryNumber ) );
auto size = m_datFile.readFile( entryNumber, buffer );
gw2f::StringsFile stringFile( buffer, size );
MakeCategory( wxT( "Strings" ) );
switch ( stringFile.language( ) ) {
case gw2f::language::English:
MakeSubCategory( wxT( "English" ) );
break;
case gw2f::language::French:
MakeSubCategory( wxT( "French" ) );
break;
case gw2f::language::German:
MakeSubCategory( wxT( "German" ) );
break;
case gw2f::language::Korean:
MakeSubCategory( wxT( "Korean" ) );
break;
case gw2f::language::Spanish:
MakeSubCategory( wxT( "Spanish" ) );
break;
}
freePointer( buffer );
break;
}
case ANFT_Manifest:
MakeCategory( wxT( "Manifests" ) );
break;
case ANFT_PortalManifest:
MakeCategory( wxT( "Portal Manifests" ) );
break;
case ANFT_TextPackManifest:
MakeCategory( wxT( "TextPack Manifests" ) );
break;
case ANFT_TextPackVariant:
MakeCategory( wxT( "TextPack Variant" ) );
break;
case ANFT_TextPackVoices:
MakeCategory( wxT( "TextPack Voices" ) );
break;
case ANFT_Bank:
MakeCategory( wxT( "Soundbank" ) );
break;
case ANFT_BankIndex:
MakeCategory( wxT( "Soundbank Index" ) );
break;
case ANFT_AudioScript:
MakeCategory( wxT( "Audio Scripts" ) );
break;
case ANFT_Model:
MakeCategory( wxT( "Models" ) );
break;
case ANFT_DependencyTable:
MakeCategory( wxT( "Dependency Tables" ) );
break;
case ANFT_EULA:
MakeCategory( wxT( "EULA" ) );
break;
case ANFT_Cinematic:
MakeCategory( wxT( "Cinematics" ) );
break;
case ANFT_HavokCollision:
MakeCategory( wxT( "Havok Collision" ) );
break;
case ANFT_MapContent:
MakeCategory( wxT( "Map Content" ) );
break;
case ANFT_MapParam:
MakeCategory( wxT( "Map Parameter" ) );
break;
case ANFT_MapShadow:
MakeCategory( wxT( "Map Shadow" ) );
break;
case ANFT_PagedImageTable:
MakeCategory( wxT( "Paged Image Table" ) );
break;
case ANFT_Material:
MakeCategory( wxT( "Materials" ) );
break;
case ANFT_Composite:
MakeCategory( wxT( "Composite Data" ) );
break;
case ANFT_AnimSequences:
MakeCategory( wxT( "Animation Sequences" ) );
break;
case ANFT_EmoteAnimation:
MakeCategory( wxT( "Emote Animations" ) );
break;
case ANFT_FontFile:
MakeCategory( wxT( "Font" ) );
break;
case ANFT_Bink2Video:
MakeCategory( wxT( "Bink Videos" ) );
break;
case ANFT_ShaderCache:
MakeCategory( wxT( "Shader Cache" ) );
break;
case ANFT_Config:
MakeCategory( wxT( "Configuration" ) );
break;
case ANFT_PF:
case ANFT_ARAP:
MakeCategory( wxT( "Misc" ) );
if ( p_fileType == ANFT_PF && p_size >= 12 ) {
MakeSubCategory( wxString( reinterpret_cast<const char*>( p_data + 8 ), 4 ) );
}
break;
default: // unknown stuff
MakeCategory( wxT( "Unknown" ) );
// to do: printable character detection in files for detect text files.
//MakeSubCategory( wxString::Format( wxT( "%x" ), *reinterpret_cast<const uint32*>( p_data ) ) );
break;
}
return category;
}
bool fileReader::readFile(char* filename, CMMPointer<level> map) {
// read files into streams
ifstream mapInput(filename);
if (mapInput.fail()){
std::string stringFile(filename); //string filename for passing to the logger
Logger::Instance()->err("failed to open " + stringFile + " attempting to add .db extension");
mapInput.clear();
char fileExt[] = ".db";
strcat(filename, fileExt);
Logger::Instance()->write("Attempting to open level file with appended name: " + stringFile + ".db");
mapInput.open(filename, ifstream::in);
// throws error if reading failed
if (mapInput.fail())
{
Logger::Instance()->err("Error: File not Found: " + stringFile);
return false;
}
}
string line;
int lineNumber = 1;
getline(mapInput, line);
while (line.length() > 0) {
vector<string> tokens = strSplit(line);
// first token to the dataType
string type = tokens[0];
//A string stream of the line number for the logger
std::stringstream sLineNumber;
sLineNumber << lineNumber;
if (tokens.size() < 5) {
Logger::Instance()->err("Error: Invalid data in data file, line " + sLineNumber.str() );
return false;
} else if (tokens[0].compare(DataTypeTile) == 0) {
int id = atoi(tokens[1].c_str());
int numVertices = atoi(tokens[2].c_str());
// if total number of tokens dont add up, throw an error
//type, id, numVertices + 3 verts and 1 neighbor per vertex
if (tokens.size() != 3 + 4 * numVertices) {
Logger::Instance()->err("Error: Invalid data in data file, line " + sLineNumber.str() );
return false;
}
vector<Vec3f> verticesTemp;
vector<int> neighborsTemp;
int index = 3;
int neighborIndex = tokens.size() - numVertices;
for (int i = 0; i < numVertices; i++) {
// load the vertices
Vec3f vert =
Vec3f (atof(tokens[index].c_str()),
atof(tokens[index + 1].c_str()),
atof(tokens[index + 2].c_str()));
// add the vertices and the neighbor indices
verticesTemp.push_back(vert);
neighborsTemp.push_back( atoi(tokens[neighborIndex].c_str()) );
index += 3;
neighborIndex ++;
}
CMMPointer<tile>* tempTile =
new CMMPointer<tile>(new tile(id, verticesTemp, neighborsTemp, TILE_COLOR));
map->addTile(id, tempTile);
delete tempTile;
} else if (tokens[0].compare(DataTypeCup) == 0) {
int id = atoi(tokens[1].c_str());
Vec3f position(atof(tokens[2].c_str()),
atof(tokens[3].c_str()),
atof(tokens[4].c_str()));
CMMPointer<cup>* tempCup = new CMMPointer<cup>(new cup(id, position));
map->addCup(id, tempCup);
tempCup = 0;
delete tempCup;
} else if (tokens[0].compare(DataTypeTee) == 0) {
int id = atoi(tokens[1].c_str());
Vec3f position = Vec3f(atof(tokens[2].c_str()),
atof(tokens[3].c_str()),
atof(tokens[4].c_str()));
CMMPointer<tee>* tempTee = new CMMPointer<tee>(new tee(id, position));
map->addTee(id, tempTee);
//add a ball in the location of the tee
CMMPointer<ball>* tempBall = new CMMPointer<ball>(new ball(id, position, BALL_COLOR, BALL_RADIUS));
map->addBall(id, tempBall);
tempTee = 0;
tempBall = 0;
delete tempTee;
delete tempBall;
} else {
Logger::Instance()->err("Error: Unknown Type in data file, line " + sLineNumber.str() );
return false;
}
lineNumber++;
getline(mapInput, line);
}
mapInput.close();
if (!map->checkLevel()) {
return false;
}
return true;
}
bool fileReader::readCourseFile(char* filename, CMMPointer<Course> course) {
// read files into streams
ifstream mapInput(filename);
if (mapInput.fail()){
std::string stringFile(filename); //string filename for passing to the logger
Logger::Instance()->err("failed to open " + stringFile + " attempting to add .db extension");
mapInput.clear();
char fileExt[] = ".db";
strcat(filename, fileExt);
Logger::Instance()->write("Attempting to open level file with appended name: " + stringFile + ".db");
mapInput.open(filename, ifstream::in);
// throws error if reading failed
if (mapInput.fail())
{
Logger::Instance()->err("Error: File not Found: " + stringFile);
return false;
}
}
string line;
int lineNumber = 1;
int numLevelsToParse = 0;
int beginCount = 0;
int endCount = 0;
bool beganTile = false;
CMMPointer<level> newLevel;
while (getline(mapInput, line)) {
vector<string> tokens = strSplit(line);
// first token to the dataType
string type = tokens[0];
//A string stream of the line number for the logger
std::stringstream sLineNumber;
sLineNumber << lineNumber;
// loads course name and number of levels
if (tokens[0].compare("course") == 0) {
vector<string> names = strSplit(line, "\"");
if (tokens.size() < 3) {
Logger::Instance()->err("Error: Invalid course tokens, line " + sLineNumber.str() );
return false;
} else if (names.size() < 2) {
Logger::Instance()->err("Error: Invalid course name, line " + sLineNumber.str() );
return false;
} else {
numLevelsToParse = atoi(tokens.back().c_str());
course->setNumLevels(numLevelsToParse);
course->setCourseName(names[1]);
}
// does check for begin holes and end holes
} else if (tokens[0].compare("begin_hole") == 0) {
if (beganTile) {
Logger::Instance()->err("Error: trying to begin_hole when another begin_hole has started, line " + sLineNumber.str());
return false;
} else {
beginCount++;
newLevel = new level();
beganTile = true;
}
} else if (tokens[0].compare("end_hole") == 0) {
if (!beganTile) {
Logger::Instance()->err("Error: trying to end_hole before a valid begin_hole, line " + sLineNumber.str());
return false;
} else {
endCount++;
beganTile = false;
if (!newLevel->checkLevel()) {
return false;
} else {
course->addLevel(beginCount, newLevel);
}
}
// parsing of level name
} else if (tokens[0].compare("name") == 0) {
vector<string> names = strSplit(line, "\"");
if (names.size() < 2) {
Logger::Instance()->err("Error: Invalid level name, line " + sLineNumber.str() );
return false;
} else {
newLevel->setLevelName(names[1]);
}
} else if (tokens[0].compare("par") == 0) {
if (tokens.size() < 2) {
Logger::Instance()->err("Error: Invalid par entry, line " + sLineNumber.str() );
return false;
} else {
newLevel->setPar(atoi(tokens[1].c_str()));
}
// parsing of actual tile, tee, cups
} else {
if (tokens.size() < 5) {
Logger::Instance()->err("Error: Invalid data in data file, line " + sLineNumber.str() );
return false;
} else if (tokens[0].compare(DataTypeTile) == 0) {
int id = atoi(tokens[1].c_str());
int numVertices = atoi(tokens[2].c_str());
// if total number of tokens dont add up, throw an error
//type, id, numVertices + 3 verts and 1 neighbor per vertex
if (tokens.size() != 3 + 4 * numVertices) {
Logger::Instance()->err("Error: Invalid data in data file, line " + sLineNumber.str() );
return false;
}
vector<Vec3f> verticesTemp;
vector<int> neighborsTemp;
int index = 3;
int neighborIndex = tokens.size() - numVertices;
for (int i = 0; i < numVertices; i++) {
// load the vertices
Vec3f vert =
Vec3f (atof(tokens[index].c_str()),
atof(tokens[index + 1].c_str()),
atof(tokens[index + 2].c_str()));
// add the vertices and the neighbor indices
verticesTemp.push_back(vert);
neighborsTemp.push_back( atoi(tokens[neighborIndex].c_str()) );
index += 3;
neighborIndex ++;
}
CMMPointer<tile>* tempTile =
new CMMPointer<tile>(new tile(id, verticesTemp, neighborsTemp, TILE_COLOR));
newLevel->addTile(id, tempTile);
delete tempTile;
} else if (tokens[0].compare(DataTypeCup) == 0) {
int id = atoi(tokens[1].c_str());
Vec3f position(atof(tokens[2].c_str()),
atof(tokens[3].c_str()),
atof(tokens[4].c_str()));
CMMPointer<cup>* tempCup = new CMMPointer<cup>(new cup(id, position));
newLevel->addCup(id, tempCup);
tempCup = 0;
delete tempCup;
} else if (tokens[0].compare(DataTypeTee) == 0) {
int id = atoi(tokens[1].c_str());
Vec3f position = Vec3f(atof(tokens[2].c_str()),
atof(tokens[3].c_str()),
atof(tokens[4].c_str()));
CMMPointer<tee>* tempTee = new CMMPointer<tee>(new tee(id, position));
newLevel->addTee(id, tempTee);
//add a ball in the location of the tee
CMMPointer<ball>* tempBall = new CMMPointer<ball>(new ball(0, position, BALL_COLOR, BALL_RADIUS));
newLevel->addBall(0, tempBall);
tempTee = 0;
tempBall = 0;
delete tempTee;
delete tempBall;
} else {
Logger::Instance()->err("Error: Unknown Type in data file, line " + sLineNumber.str() );
return false;
}
}
lineNumber++;
}
mapInput.close();
course->setNumLevels(numLevelsToParse);
if (beginCount != endCount || course->getNumLevels() != endCount)
{
std::stringstream errorLog;
errorLog << "Error: Invalid number of levels parse. Expected: " << numLevelsToParse << " being_hole count: " << beginCount << " end_hole count: " << endCount;
Logger::Instance()->err(errorLog.str());
return false;
}
return true;
}
