// 2008/03/12 kazuhide nakata
void Newton::initialize_sparse_bMat(int m, IV *newToOldIV,
IVL *symbfacIVL)
{
// bMat_type = SPARSE;
// printf("SPARSE computation\n");
int* newToOld;
newToOld = IV_entries(newToOldIV);
NewArray(ordering,int,m);
NewArray(reverse_ordering,int,m);
for (int i=0; i<m; i++){
ordering[i] = newToOld[i];
}
for (int i=0; i<m; i++){
reverse_ordering[ordering[i]] = i;
}
// separate front or back node
int* counter;
int nClique = IVL_nlist(symbfacIVL);
int psize;
int* pivec;
bool* bnode;
int* nFront;
NewArray(counter,int ,m);
NewArray(bnode ,bool,m);
NewArray(nFront ,int ,nClique);
for (int k=0; k<m; k++){
bnode[k] = false;
counter[k] = -1;
}
// search number of front
for (int l=nClique-1; l >= 0; l--){
IVL_listAndSize(symbfacIVL,l,&psize,&pivec);
int i;
for (i=0; i<psize; i++){
int ii = reverse_ordering[pivec[i]];
if (bnode[ii] == false){
counter[ii] = psize - i;
bnode[ii] = true;
} else {
nFront[l] = i;
break;
}
}
if (i == psize){
nFront[l] = psize;
}
}
// error check
for (int k=0; k<m; k++){
if (counter[k] == -1){
rError("Newton::initialize_sparse_bMat: program bug");
}
}
// make index of diagonal
NewArray(diagonalIndex,int,m+1);
diagonalIndex[0] = 0;
for (int k=1; k<m+1; k++){
diagonalIndex[k] = diagonalIndex[k-1] + counter[k-1];
}
// initialize sparse_bMat
sparse_bMat.initialize(m,m,SparseMatrix::SPARSE,diagonalIndex[m]);
// initialize index of sparse_bmat
int nonzeros = 0;
for (int l=0; l<nClique; l++){
IVL_listAndSize(symbfacIVL,l,&psize,&pivec);
for (int i=0; i<nFront[l]; i++){
int ii = reverse_ordering[pivec[i]];
for (int j=i; j<psize; j++){
int jj = reverse_ordering[pivec[j]];
int index = diagonalIndex[ii] + j - i;
sparse_bMat.row_index[index] = ii;
sparse_bMat.column_index[index] = jj;
nonzeros++;
}
}
}
// error check
if (nonzeros!= sparse_bMat.NonZeroNumber){
rError("Newton::initialize_sparse_bMat probram bug");
}
sparse_bMat.NonZeroCount = nonzeros;
// sparse_bMat.display();
DeleteArray(counter);
DeleteArray(bnode);
DeleteArray(nFront);
}
void AutoMapSaver::checkSave()
{
// Check if we have a proper map
if (!GlobalMap().isValid() || !GlobalMainFrame().screenUpdatesEnabled())
{
return;
}
// greebo: Check if we have a valid main window to grab the pointer
wxFrame* mainWindow = GlobalMainFrame().getWxTopLevelWindow();
if (mainWindow == NULL || !mainWindow->IsActive())
{
rMessage() << "AutoSaver: Main window not present or not shown on screen, " <<
"will wait for another period." << std::endl;
return;
}
// Check, if changes have been made since the last autosave
if (_changes == GlobalSceneGraph().root()->getUndoChangeTracker().changes())
{
return;
}
// Check if the user is currently pressing a mouse button
// Don't start the save if the user is holding a mouse button
if (wxGetMouseState().ButtonIsDown(wxMOUSE_BTN_ANY))
{
return;
}
_changes = GlobalSceneGraph().root()->getUndoChangeTracker().changes();
// Stop the timer before saving
stopTimer();
if (_enabled)
{
// only snapshot if not working on an unnamed map
if (_snapshotsEnabled && !GlobalMap().isUnnamed())
{
try
{
saveSnapshot();
}
catch (boost::filesystem::filesystem_error& f)
{
rError() << "AutoSaver::saveSnapshot: " << f.what() << std::endl;
}
}
else
{
if (GlobalMap().isUnnamed())
{
// Get the maps path (within the mod path)
std::string autoSaveFilename = GlobalRegistry().get(RKEY_MAP_PATH);
// Try to create the map folder, in case there doesn't exist one
os::makeDirectory(autoSaveFilename);
// Append the "autosave.map" to the filename
autoSaveFilename += "autosave.";
autoSaveFilename += game::current::getValue<std::string>(GKEY_MAP_EXTENSION);
rMessage() << "Autosaving unnamed map to " << autoSaveFilename << std::endl;
// Invoke the save call
GlobalMap().saveDirect(autoSaveFilename);
}
else
{
// Construct the new filename (e.g. "test_autosave.map")
std::string filename = GlobalMap().getMapName();
std::string extension = os::getExtension(filename);
// Cut off the extension
filename = filename.substr(0, filename.rfind('.'));
filename += "_autosave";
filename += "." + extension;
rMessage() << "Autosaving map to " << filename << std::endl;
// Invoke the save call
GlobalMap().saveDirect(filename);
}
}
}
else
{
rMessage() << "Autosave skipped..." << std::endl;
}
// Re-start the timer after saving has finished
startTimer();
}
void user_error_fn(png_structp png_ptr, png_const_charp error_msg)
{
rError() << "libpng error: " << error_msg << std::endl;
longjmp(png_jmpbuf(png_ptr), 1);
}
int main(int argc, char **argv)
{
g_BufferedMemorySize = 100;
string compressorName;
string commandLineOptions;
std::vector<string> fuseOptions;
fuseOptions.push_back(argv[0]);
po::options_description desc("Usage: " PACKAGE "_offline [options] path\n"
"\nPath may be directory or file.\n"
"\nNo options mean decompression mode.\n\n"
"Allowed options");
desc.add_options()
("options,o", po::value<string>(&commandLineOptions),
"fc_c:arg - compression method (lzo/bzip2/zlib/lzma)\n"
" (default: gz)\n"
"fc_b:arg - size of blocks in kilobytes\n"
" (default: 100)\n"
"fc_d - run in debug mode\n"
"fc_ma:arg - files with passed mime types to be\n"
" always not compressed\n"
"fc_mr:arg - files with passed mime types to be\n"
" always compressed\n"
"\nOther options are passed directly to fuse library. See fuse documentation for full list of supported options.\n")
("dir_lower", po::value<string>(&g_dirLower), "path")
("help,h", "print this help")
("version,v", "print version")
("quiet,q", "quiet mode")
;
po::positional_options_description pdesc;
pdesc.add("dir_lower", 1);
po::variables_map vm;
try {
po::store(po::command_line_parser(argc, argv).options(desc).positional(pdesc).run(), vm);
} catch (...) {
print_help(desc);
exit(EXIT_FAILURE);
}
po::notify(vm);
if (vm.count("help"))
{
print_help(desc);
exit(EXIT_SUCCESS);
}
if (vm.count("version"))
{
print_license();
exit(EXIT_SUCCESS);
}
if (vm.count("quiet"))
{
g_QuietMode = true;
}
g_RLog = new rlog::RLog("FuseCompress_offline", g_QuietMode ? LOG_NOTICE : LOG_INFO, true);
if (vm.count("options"))
{
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(",");
tokenizer tokens(commandLineOptions, sep);
for (tokenizer::iterator tok_it = tokens.begin(); tok_it != tokens.end(); ++tok_it)
{
if ((*tok_it).find_first_of("fc_", 0, 3) == 0)
{
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(":");
tokenizer tokens(*tok_it, sep);
tokenizer::iterator key = tokens.begin();
tokenizer::iterator value = key; ++value;
if (*key == "fc_c")
{
if (value == tokens.end())
{
rError("Compression type not set!");
exit(EXIT_FAILURE);
}
compressorName = *value;
}
if (*key == "fc_b")
{
if (value == tokens.end())
{
rError("Block size not set!");
exit(EXIT_FAILURE);
}
g_BufferedMemorySize = boost::lexical_cast<unsigned int>(*value);
}
if (*key == "fc_d")
{
g_DebugMode = true;
g_RLog->setLevel(LOG_DEBUG);
}
if (*key == "fc_ma")
{
if (value == tokens.end())
{
rError("Mime type(s) not set!");
exit(EXIT_FAILURE);
}
g_CompressedMagic.Add(*value);
}
if (*key == "fc_mr")
{
if (value == tokens.end())
{
rError("Mime type(s) not set!");
exit(EXIT_FAILURE);
}
g_CompressedMagic.Remove(*value);
}
}
else
{
fuseOptions.push_back("-o");
fuseOptions.push_back(*tok_it);
}
}
}
if (!vm.count("dir_lower"))
{
print_help(desc);
exit(EXIT_FAILURE);
}
g_BufferedMemorySize *= 1024;
if (compressorName != "")
{
g_RawOutput = false;
if (g_CompressionType.parseType(compressorName) == false)
{
rError("Compressor %s not found!", compressorName.c_str());
exit(EXIT_FAILURE);
}
}
fs::path pathLower(g_dirLower
#if BOOST_VERSION <= 104600
, fs::native
#endif
);
if (!pathLower.is_complete())
{
char cwd[PATH_MAX];
// Transform relative path to absolute path.
if (getcwd(cwd, sizeof(cwd)) == NULL)
{
rError("Cannot determine current working directory!");
exit(EXIT_FAILURE);
}
pathLower = fs::path(cwd
#if BOOST_VERSION <= 104600
, fs::native
#endif
) / pathLower;
}
// Set signal handler to catch SIGINT (CTRL+C).
struct sigaction setup_kill;
memset(&setup_kill, 0, sizeof(setup_kill));
setup_kill.sa_handler = catch_kill;
sigaction(SIGINT, &setup_kill, NULL);
// Iterate over directory structure and execute compress
// for every files there.
if (nftw(const_cast<char *>(pathLower.string().c_str()), compress, 100, FTW_PHYS | FTW_CHDIR))
exit(EXIT_FAILURE);
exit(EXIT_SUCCESS);
}
void CommandEditor::createArgumentWidgets(int commandTypeID)
{
try
{
const conversation::ConversationCommandInfo& cmdInfo =
conversation::ConversationCommandLibrary::Instance().findCommandInfo(commandTypeID);
// Remove all possible previous items from the list
_argumentItems.clear();
// Clear the panel and add a new table
wxPanel* argPanel = findNamedObject<wxPanel>(this, "ConvCmdEditorArgPanel");
argPanel->DestroyChildren();
// Create the table
wxFlexGridSizer* table = new wxFlexGridSizer(static_cast<int>(cmdInfo.arguments.size()), 3, 6, 12);
table->AddGrowableCol(1);
argPanel->SetSizer(table);
if (cmdInfo.arguments.empty())
{
wxStaticText* noneText = new wxStaticText(argPanel, wxID_ANY, _("None"));
noneText->SetFont(noneText->GetFont().Italic());
argPanel->GetSizer()->Add(noneText, 0, wxLEFT, 6);
return;
}
// Setup the table with default spacings
typedef conversation::ConversationCommandInfo::ArgumentInfoList::const_iterator ArgumentIter;
int index = 1;
for (ArgumentIter i = cmdInfo.arguments.begin();
i != cmdInfo.arguments.end(); ++i, ++index)
{
const conversation::ArgumentInfo& argInfo = *i;
CommandArgumentItemPtr item;
switch (argInfo.type)
{
case conversation::ArgumentInfo::ARGTYPE_BOOL:
// Create a new bool argument item
item = CommandArgumentItemPtr(new BooleanArgument(argPanel, argInfo));
break;
case conversation::ArgumentInfo::ARGTYPE_INT:
case conversation::ArgumentInfo::ARGTYPE_FLOAT:
case conversation::ArgumentInfo::ARGTYPE_STRING:
// Create a new string argument item
item = CommandArgumentItemPtr(new StringArgument(argPanel, argInfo));
break;
case conversation::ArgumentInfo::ARGTYPE_VECTOR:
case conversation::ArgumentInfo::ARGTYPE_SOUNDSHADER:
// Create a new string argument item
item = CommandArgumentItemPtr(new StringArgument(argPanel, argInfo));
break;
case conversation::ArgumentInfo::ARGTYPE_ACTOR:
// Create a new actor argument item
item = CommandArgumentItemPtr(new ActorArgument(argPanel, argInfo, _conversation.actors));
break;
case conversation::ArgumentInfo::ARGTYPE_ENTITY:
// Create a new string argument item
item = CommandArgumentItemPtr(new StringArgument(argPanel, argInfo));
break;
default:
rError() << "Unknown command argument type: " << argInfo.type << std::endl;
break;
};
if (item != NULL)
{
_argumentItems.push_back(item);
// The label
table->Add(item->getLabelWidget(), 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 6);
// The edit widgets
table->Add(item->getEditWidget(), 1, wxEXPAND, wxALIGN_CENTER_VERTICAL);
// The help widgets
table->Add(item->getHelpWidget(), 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT | wxRIGHT, 6);
}
}
}
catch (std::runtime_error&)
{
rError() << "Cannot find conversation command info for index " << commandTypeID << std::endl;
}
wxPanel* mainPanel = findNamedObject<wxPanel>(this, "ConvCmdEditorMainPanel");
mainPanel->Fit();
mainPanel->Layout();
Fit();
}
bool rSdpaLib::dumpInit(const char* filename)
{
ofstream output;
output.open(filename);
if (output.fail()) {
rError("Cannot Open " << filename);
}
output << "{ ";
for (int k = 0; k<m ; ++k) {
output << -initPt.yVec.ele[k] << " ";
}
output << "}";
output << '\n';
for (int l=0; l<nBlock; ++l) {
int size;
int i = 0;
switch (initPt.zMat.ele[l].De_Di) {
case rDenseMatrix::DENSE:
size = initPt.zMat.ele[l].nRow;
for (i=0; i<size; ++i) {
for (int j=0; j<size; ++j) {
double value = initPt.zMat.ele[l].de_ele[i+size*j];
if (i<=j && value!=0.0) {
output << "1 " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< value << '\n';
}
}
}
break;
case rDenseMatrix::DIAGONAL:
for (int index = 0; index < initPt.zMat.ele[l].nRow; ++index) {
double value = initPt.zMat.ele[l].di_ele[index];
if (value!=0.0) {
output << "1 " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< value << '\n';
}
}
break;
} // end of switch
}// end of 'for (int l)'
for (int l=0; l<nBlock; ++l) {
int size;
int i = 0;
switch (initPt.xMat.ele[l].De_Di) {
case rDenseMatrix::DENSE:
size = initPt.xMat.ele[l].nRow;
for (i=0; i<size; ++i) {
for (int j=0; j<size; ++j) {
double value = initPt.xMat.ele[l].de_ele[i+size*j];
if (i<=j && value!=0.0) {
output << "2 " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< value << '\n';
}
}
}
break;
case rDenseMatrix::DIAGONAL:
for (int index = 0; index < initPt.xMat.ele[l].nRow; ++index) {
double value = initPt.xMat.ele[l].di_ele[index];
if (value!=0.0) {
output << "2 " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< value << '\n';
}
}
break;
} // end of switch
}// end of 'for (int l)'
output.close();
return true;
}
// Required entity visit function
void ConversationKeyExtractor::operator()(const std::string& key, const std::string& value)
{
// Quick discard of any non-conversation keys
if (key.substr(0, 4) != "conv") return;
// Extract the objective number
static const std::regex reConvNum("conv_(\\d+)_(.*)");
std::smatch results;
int iNum;
if (!std::regex_match(key, results, reConvNum)) {
// No match, abort
return;
}
// Get the conversation number
iNum = string::convert<int>(results[1].str());
// We now have the conversation number and the substring (everything after
// "conv_<n>_" which applies to this conversation.
std::string convSubString = results[2];
// Switch on the substring
if (convSubString == "name") {
_convMap[iNum].name = value;
}
else if (convSubString == "talk_distance") {
_convMap[iNum].talkDistance = string::convert<float>(value, 60);
}
else if (convSubString == "actors_must_be_within_talkdistance") {
_convMap[iNum].actorsMustBeWithinTalkdistance = (value == "1");
}
else if (convSubString == "actors_always_face_each_other_while_talking") {
_convMap[iNum].actorsAlwaysFaceEachOther = (value == "1");
}
else if (convSubString == "max_play_count") {
_convMap[iNum].maxPlayCount = string::convert<int>(value, -1);
}
else if (convSubString.substr(0, 6) == "actor_") {
// This is an actor definition, extract the number
int actorNum = string::convert<int>(convSubString.substr(6), -1);
if (actorNum == -1) {
return;
}
// Store the actor in the map
_convMap[iNum].actors.insert(Conversation::ActorMap::value_type(actorNum, value));
}
else if (convSubString.substr(0, 4) == "cmd_") {
// This is a conversation command, form a new regex
static const std::regex reCommand("cmd_(\\d+)_(.*)");
std::smatch cmdResults;
if (!std::regex_match(convSubString, cmdResults, reCommand)) {
return; // not matching
}
int cmdIndex = string::convert<int>(cmdResults[1].str());
std::string cmdSubStr = cmdResults[2];
ConversationCommandPtr command;
Conversation::CommandMap::iterator found = _convMap[iNum].commands.find(cmdIndex);
if (found != _convMap[iNum].commands.end()) {
// Command already exists
command = found->second;
}
else {
// Command with the given index does not exist yet, create it
command = ConversationCommandPtr(new ConversationCommand);
// Insert this into the map
_convMap[iNum].commands[cmdIndex] = command;
}
if (cmdSubStr == "type") {
try {
command->type = ConversationCommandLibrary::Instance().findCommandInfo(value).id;
}
catch (std::runtime_error& e) {
rError() << e.what() << std::endl;
return;
}
}
else if (cmdSubStr == "actor") {
command->actor = string::convert<int>(value);
}
else if (cmdSubStr == "wait_until_finished") {
command->waitUntilFinished = (value == "1");
}
else if (cmdSubStr.substr(0,4) == "arg_") {
int cmdArgIndex = string::convert<int>(cmdSubStr.substr(4));
command->arguments[cmdArgIndex] = value;
}
}
}
void rSparseMatrix::
initialize(int nRow, int nCol,
rSparseMatrix::rSpMat_Sp_De_Di Sp_De_Di,
int NonZeroNumber)
{
// rMessage("rSparseMatrix initialize");
rSparseMatrix();
if (nRow<=0 || nCol<=0) {
rError("rSparseMatrix:: Dimensions are nonpositive");
}
this->nRow = nRow;
this->nCol = nCol;
this->Sp_De_Di = Sp_De_Di;
int length;
row_index = NULL;
column_index = NULL;
sp_ele = NULL;
switch(Sp_De_Di) {
case SPARSE:
this->NonZeroNumber = NonZeroNumber;
this->NonZeroCount = 0;
this->NonZeroEffect = 0;
if (NonZeroNumber > 0) {
rNewCheck();
row_index = new int[NonZeroNumber];
rNewCheck();
column_index = new int[NonZeroNumber];
rNewCheck();
sp_ele = new double[NonZeroNumber];
if (row_index==NULL || column_index==NULL
|| sp_ele==NULL) {
rError("rSparseMatrix:: memory exhausted");
}
}
break;
case DENSE:
this->NonZeroNumber = nRow*nCol;
this->NonZeroCount = nRow*nCol;
this->NonZeroEffect = nRow*nCol;
rNewCheck();
de_ele = new double[NonZeroNumber];
if (de_ele==NULL) {
rError("rSparseMatrix:: memory exhausted");
}
length = nRow*nCol;
catlas_dset(length,DZERO,de_ele,IONE);
// all elements are 0.
break;
case DIAGONAL:
if (nRow!=nCol) {
rError("rSparseMatrix:: Diagonal must be Square matrix");
}
this->NonZeroNumber = nCol;
this->NonZeroCount = nCol;
this->NonZeroEffect = nCol;
if (di_ele==NULL) {
rNewCheck();
di_ele = new double[NonZeroNumber];
if (di_ele==NULL) {
rError("rSparseMatrix:: memory exhausted");
}
}
catlas_dset(nCol,DZERO,di_ele,IONE);
// all elements are 0.
break;
}
}
bool rSparseMatrix::copyFrom(rSparseMatrix& other)
{
if (Sp_De_Di != other.Sp_De_Di || nRow != other.nRow
|| nCol != other.nCol) {
this->~rSparseMatrix();
initialize(other.nRow,other.nCol,other.Sp_De_Di,
NonZeroNumber);
NonZeroCount = other.NonZeroCount;
NonZeroEffect = other.NonZeroEffect;
int length,index=0;
switch(Sp_De_Di) {
case SPARSE:
for (index = 0; index<NonZeroCount;++index) {
row_index[index] = other.row_index[index];
column_index[index] = other.column_index[index];
sp_ele[index] = other.sp_ele[index];
}
break;
case DENSE:
length = nRow*nCol;
dcopy(&length,other.de_ele,&IONE,de_ele,&IONE);
break;
case DIAGONAL:
dcopy(&nCol,other.di_ele,&IONE,di_ele,&IONE);
break;
}
} else { // Sp_De_Di == other.Sp_De_Di
// && nRow == other.nRow && nCol == other.nCol
NonZeroCount = other.NonZeroCount;
NonZeroEffect = other.NonZeroEffect;
int length,index=0;
switch(Sp_De_Di) {
case SPARSE:
if (NonZeroNumber!=other.NonZeroNumber) {
delete[] row_index;
delete[] column_index;
delete[] sp_ele;
row_index = column_index = NULL;
sp_ele = NULL;
rNewCheck();
row_index = new int[NonZeroNumber];
rNewCheck();
column_index = new int[NonZeroNumber];
rNewCheck();
sp_ele = new double[NonZeroNumber];
if (row_index==NULL || column_index==NULL
|| sp_ele==NULL) {
rError("rSparseMatrix:: memory exhausted");
}
}
for (index = 0; index<NonZeroCount;++index) {
row_index[index] = other.row_index[index];
column_index[index] = other.column_index[index];
sp_ele[index] = other.sp_ele[index];
}
break;
case DENSE:
length = nRow*nCol;
dcopy(&length,other.de_ele,&IONE,de_ele,&IONE);
break;
case DIAGONAL:
dcopy(&nCol,other.di_ele,&IONE,di_ele,&IONE);
break;
} // end of switch
} // end of else
return _SUCCESS;
}
// Set the model, this also resets the camera
void AnimationPreview::setModelNode(const scene::INodePtr& node)
{
// Ensure that this is an MD5 model node
model::ModelNodePtr model = Node_getModel(node);
if (!model)
{
rError() << "AnimationPreview::setModelNode: node is not a model." << std::endl;
_model.reset();
return;
}
// Set up the scene
if (!_entity)
{
setupSceneGraph();
}
try
{
dynamic_cast<const md5::IMD5Model&>(model->getIModel());
}
catch (std::bad_cast&)
{
rError() << "AnimationPreview::setModelNode: modelnode doesn't contain an MD5 model." << std::endl;
_model.reset();
return;
}
if (_model)
{
_entity->removeChildNode(_model);
}
_model = node;
// Set the animation to play
dynamic_cast<md5::IMD5Model&>(model->getIModel()).setAnim(_anim);
// AddChildNode also tells the model which renderentity it is attached to
_entity->addChildNode(_model);
if (_model != NULL)
{
// Reset preview time
stopPlayback();
// Reset the rotation to the default one
_rotation = Matrix4::getRotation(Vector3(0,-1,0), Vector3(0,-0.3f,1));
_rotation.multiplyBy(Matrix4::getRotation(Vector3(0,1,0), Vector3(1,-1,0)));
// Use AABB to adjust camera distance
const AABB& bounds = _model->localAABB();
if (bounds.isValid())
{
_camDist = -5.0f * static_cast<float>(bounds.getRadius());
}
else
{
// Bounds not valid, fall back to default
_camDist = -40.0f;
}
// Start playback when switching particles
startPlayback();
}
else
{
stopPlayback();
}
// Redraw
queueDraw();
}
std::ostream& ApplicationContextImpl::getErrorStream() const {
return rError();
}
bool pinpal(char* dataFile, char* initFile, char* outFile,
char* paraFile, bool isInitFile, bool isInitSparse,
bool isDataSparse, bool isParameter,
rParameter::parameterType parameterType,
FILE* Display)
{
rTimeStart(TOTAL_TIME_START1);
rTimeStart(FILE_READ_START1);
rComputeTime com;
FILE* fpData = NULL;
FILE* fpOut = NULL;
if ((fpOut=fopen(outFile,"w"))==NULL) {
rError("Cannot open out file " << outFile);
}
rParameter param;
param.setDefaultParameter(parameterType);
if (isParameter) {
FILE* fpParameter = NULL;
if ((fpParameter=fopen(paraFile,"r"))==NULL) {
fprintf(Display,"Cannot open parameter file %s \n",
paraFile);
exit(0);
} else {
param.readFile(fpParameter);
fclose(fpParameter);
}
}
// param.display(Display);
if ((fpData=fopen(dataFile,"r"))==NULL) {
rError("Cannot open data file " << dataFile);
}
char titleAndComment[LengthOfBuffer];
int m;
time_t ltime;
time( <ime );
fprintf(fpOut,"SDPA start at %s",ctime(<ime));
rIO::read(fpData,fpOut,m,titleAndComment);
fprintf(fpOut,"data is %s\n",dataFile);
if (paraFile) {
fprintf(fpOut,"parameter is %s\n",paraFile);
}
if (initFile) {
fprintf(fpOut,"initial is %s\n",initFile);
}
fprintf(fpOut,"out is %s\n",outFile);
int nBlock;
rIO::read(fpData,nBlock);
int* blockStruct = NULL;
blockStruct = new int[nBlock];
if (blockStruct==NULL) {
rError("Memory exhausted about blockStruct");
}
rIO::read(fpData,nBlock,blockStruct);
int nDim = 0;
for (int l=0; l<nBlock; ++l) {
nDim += abs(blockStruct[l]);
}
// rMessage("b has not been read yet , m = " << m);
rVector b(m);
rIO::read(fpData,b);
// rMessage("b has been read");
rBlockSparseMatrix C;
rBlockSparseMatrix* A = NULL;
A = new rBlockSparseMatrix[m];
if (A==NULL) {
rError("Memory exhausted about blockStruct");
}
long position = ftell(fpData);
// C,A must be accessed "twice".
// count numbers of elements of C and A
int* CNonZeroCount = NULL;
CNonZeroCount = new int[nBlock];
if (CNonZeroCount==NULL) {
rError("Memory exhausted about blockStruct");
}
int* ANonZeroCount = NULL;
ANonZeroCount = new int[nBlock*m];
if (ANonZeroCount==NULL) {
rError("Memory exhausted about blockStruct");
}
// initialize C and A
rIO::read(fpData,m,nBlock,blockStruct,
CNonZeroCount,ANonZeroCount,isDataSparse);
// rMessage(" C and A count over");
C.initialize(nBlock,blockStruct);
for (int l=0; l<nBlock; ++l) {
int size = blockStruct[l];
if (size > 0) {
C.ele[l].initialize(size,size,rSparseMatrix::SPARSE,
CNonZeroCount[l]);
} else {
C.ele[l].initialize(-size,-size,rSparseMatrix::DIAGONAL,
-size);
}
}
for (int k=0; k<m; ++k) {
A[k].initialize(nBlock,blockStruct);
for (int l=0; l<nBlock; ++l) {
int size = blockStruct[l];
if (size > 0) {
A[k].ele[l].initialize(size,size,rSparseMatrix::SPARSE,
ANonZeroCount[k*nBlock+l]);
} else {
A[k].ele[l].initialize(-size,-size,rSparseMatrix::DIAGONAL,
-size);
}
}
}
delete[] CNonZeroCount;
CNonZeroCount = NULL;
delete[] ANonZeroCount;
ANonZeroCount = NULL;
// rMessage(" C and A initialize over");
rIO::read(fpData, C, A, m, nBlock, blockStruct, position, isDataSparse);
// rMessage(" C and A have been read");
fclose(fpData);
#if 0
fprintf(Display,"C = \n");
C.display(Display);
for (int k=0; k<m; ++k) {
fprintf(Display,"A[%d] = \n",k);
A[k].display(Display);
}
#endif
#if 0
// write C and A in SDPA sparse data format to file
ofstream output;
output.open("dumped.rsdpa.dat-s");
if (output.fail()) {
rError("Cannot Open dumped.rsdpa.dat-s");
}
output << m << endl;
output << nBlock << endl;
for (l = 0; l<nBlock ; ++l) {
output << blockStruct[l] << " " ;
}
output << endl;
for (k=0; k<m; ++k) {
output << b.ele[k] << " ";
}
output << endl;
int index=0;
for (l=0; l<nBlock; ++l) {
switch (C.ele[l].Sp_De_Di) {
case rSparseMatrix::SPARSE:
for (index = 0; index < C.ele[l].NonZeroCount; ++index) {
int i = C.ele[l].row_index[index];
int j = C.ele[l].column_index[index];
double value = C.ele[l].sp_ele[index];
if (value!=0.0) {
output << "0 " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< -value << endl;
}
}
break;
case rSparseMatrix::DENSE:
break;
case rSparseMatrix::DIAGONAL:
for (int index = 0; index < C.ele[l].nRow; ++index) {
double value = C.ele[l].di_ele[index];
if (value!=0.0) {
output << "0 " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< -value << endl;
}
}
break;
} // end of switch
}// end of 'for (int l)'
for (k=0; k<m; ++k) {
for (int l=0; l<nBlock; ++l) {
switch (A[k].ele[l].Sp_De_Di) {
case rSparseMatrix::SPARSE:
for (index = 0; index < A[k].ele[l].NonZeroCount; ++index) {
int i = A[k].ele[l].row_index[index];
int j = A[k].ele[l].column_index[index];
double value = A[k].ele[l].sp_ele[index];
if (value!=0.0) {
output << k+1 << " " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< value << endl;
}
}
break;
case rSparseMatrix::DENSE:
break;
case rSparseMatrix::DIAGONAL:
for (int index = 0; index < A[k].ele[l].nRow; ++index) {
double value = A[k].ele[l].di_ele[index];
if (value!=0.0) {
output << k+1 << " " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< value << endl;
}
}
break;
} // end of switch
} // end of 'for (int l)'
} // end of 'for (int k)'
output.close();
#endif
#if 0
rTimeStart(FILE_CHECK_START1);
// check whether C,A are symmetric or not.
int lin,iin,jin;
if (C.sortSparseIndex(lin,iin,jin)==FAILURE) {
fprintf(Display,"C is not symmetric, block %d,"
"(%d,%d) ", lin+1,iin+1,jin+1);
exit(0);
}
for (int k=0; k<m; ++k) {
if (A[k].sortSparseIndex(lin,iin,jin)==FAILURE) {
fprintf(Display,"A[%d] is not symmetric, block %d,"
"(%d,%d) ", k+1,lin+1,iin+1,jin+1);
exit(0);
}
}
rTimeEnd(FILE_CHECK_END1);
com.FileCheck += rTimeCal(FILE_CHECK_START1,
FILE_CHECK_END1);
#endif
#if 1
rTimeStart(FILE_CHANGE_START1);
// if possible , change C and A to Dense
C.changeToDense();
for (int k=0; k<m; ++k) {
A[k].changeToDense();
}
rTimeEnd(FILE_CHANGE_END1);
com.FileChange += rTimeCal(FILE_CHANGE_START1,
FILE_CHANGE_END1);
#endif
// rMessage("C = ");
// C.display(Display);
// for (int k=0; k<m; ++k) {
// rMessage("A["<<k<<"] = ");
// A[k].display(Display);
// }
// the end of initialization of C and A
// set initial solutions.
rSolutions initPt;
rSolutions currentPt;
if (isInitFile) {
initPt.initializeZero(m,nBlock,blockStruct,com);
FILE* fpInit = NULL;
if ((fpInit=fopen(initFile,"r"))==NULL) {
rError("Cannot open init file " << initFile);
}
rIO::read(fpInit,initPt.xMat,initPt.yVec,initPt.zMat, nBlock,
blockStruct, isInitSparse);
fclose(fpInit);
initPt.initializeResetup(m,nBlock,blockStruct,com);
currentPt.copyFrom(initPt);
} else {
initPt.initialize(m,nBlock,blockStruct,param.lambdaStar,com);
currentPt.initialize(m,nBlock,blockStruct,param.lambdaStar,com);
}
// rMessage("initial pt = ");
// initPt.display(Display);
// rMessage("current pt = ");
// currentPt.display(Display);
rTimeEnd(FILE_READ_END1);
com.FileRead += rTimeCal(FILE_READ_START1,
FILE_READ_END1);
// -------------------------------------------------------------
// the end of file read
// -------------------------------------------------------------
rResiduals initRes(m, nBlock, blockStruct, b, C, A, currentPt);
rResiduals currentRes;
currentRes.copyFrom(initRes);
// rMessage("initial currentRes = ");
// currentRes.display(Display);
rNewton newton(m, nBlock, blockStruct);
newton.computeFormula(m,A,0.0,KAPPA);
rStepLength alpha(1.0,1.0,nBlock, blockStruct);
rDirectionParameter beta(param.betaStar);
rSwitch reduction(rSwitch::ON);
rAverageComplementarity mu(param.lambdaStar);
rLanczos lanczos(nBlock,blockStruct);
// rMessage("init mu");
// mu.display();
if (isInitFile) {
mu.initialize(nDim, initPt);
}
rRatioInitResCurrentRes theta(param, initRes);
rSolveInfo solveInfo(nDim, b, C, A, initPt, mu.initial,
param.omegaStar);
rPhase phase(initRes, solveInfo, param, nDim);
int pIteration = 0;
rIO::printHeader(fpOut, Display);
// -----------------------------------------------------
// Here is MAINLOOP
// -----------------------------------------------------
rTimeStart(MAIN_LOOP_START1);
// explicit maxIteration
// param.maxIteration = 2;
while (phase.updateCheck(currentRes, solveInfo, param)
&& pIteration < param.maxIteration) {
// rMessage(" turn hajimari " << pIteration );
// Mehrotra's Predictor
rTimeStart(MEHROTRA_PREDICTOR_START1);
// set variable of Mehrotra
reduction.MehrotraPredictor(phase);
beta.MehrotraPredictor(phase, reduction, param);
// rMessage("reduction = ");
// reduction.display();
// rMessage("phase = ");
// phase.display();
// rMessage("beta.predictor.value = " << beta.value);
// rMessage("xMat = ");
// currentPt.xMat.display();
// rMessage("zMat = ");
// currentPt.zMat.display();
// rMessage(" mu = " << mu.current);
bool isSuccessCholesky;
isSuccessCholesky = newton.Mehrotra(rNewton::PREDICTOR,
m, A, C, mu,
beta, reduction,
phase, currentPt,
currentRes, com);
if (isSuccessCholesky == false) {
break;
}
// rMessage("newton predictor = ");
// newton.display();
// rMessage("newton Dy predictor = ");
// newton.DyVec.display();
// newton.bMat.display();
rTimeEnd(MEHROTRA_PREDICTOR_END1);
com.Predictor += rTimeCal(MEHROTRA_PREDICTOR_START1,
MEHROTRA_PREDICTOR_END1);
rTimeStart(STEP_PRE_START1);
alpha.MehrotraPredictor(b,C,A, currentPt, phase, newton,
lanczos, com);
// rMessage("xMat = ");
// currentPt.xMat.display();
// rMessage("zMat = ");
// currentPt.zMat.display();
// rMessage("alpha predictor = ");
// alpha.display();
// phase.display();
// rMessage("newton predictor = ");
// newton.display();
// rMessage("currentPt = ");
// currentPt.display();
rTimeStart(STEP_PRE_END1);
com.StepPredictor += rTimeCal(STEP_PRE_START1,STEP_PRE_END1);
// rMessage("alphaStar = " << param.alphaStar);
// Mehrotra's Corrector
// rMessage(" Corrector ");
rTimeStart(CORRECTOR_START1);
beta.MehrotraCorrector(nDim,phase,alpha,currentPt,
newton,mu,param);
// rMessage("beta corrector = " << beta.value);
newton.Mehrotra(rNewton::CORRECTOR,m,A,C,mu,beta,reduction,
phase, currentPt, currentRes, com);
// rMessage("currentPt = ");
// currentPt.display();
// rMessage("newton corrector = ");
// newton.display();
// rMessage("newton Dy corrector = ");
// newton.DyVec.display();
rTimeEnd(CORRECTOR_END1);
com.Corrector += rTimeCal(CORRECTOR_START1,
CORRECTOR_END1);
rTimeStart(CORRECTOR_STEP_START1);
alpha.MehrotraCorrector(nDim, b, C, A, currentPt, phase,
reduction, newton, mu, theta,
lanczos, param, com);
// rMessage("alpha corrector = ");
// alpha.display();
rTimeEnd(CORRECTOR_STEP_END1);
com.StepCorrector += rTimeCal(CORRECTOR_STEP_START1,
CORRECTOR_STEP_END1);
// the end of Corrector
rIO::printOneIteration(pIteration, mu, theta, solveInfo,
alpha, beta, currentRes, fpOut, Display);
if (currentPt.update(alpha,newton,com)==false) {
// if step length is too short,
// we finish algorithm
rMessage("cannot move");
pIteration++;
break;
}
// rMessage("currentPt = ");
// currentPt.display();
// rMessage("newton = ");
// newton.display();
// rMessage("updated");
theta.update(reduction,alpha);
mu.update(nDim,currentPt);
currentRes.update(m,nBlock,blockStruct,b,C,A,
initRes, theta, currentPt, phase, mu,com);
theta.update_exact(initRes,currentRes);
solveInfo.update(nDim, b, C, initPt, currentPt,
currentRes, mu, theta, param);
pIteration++;
} // end of MAIN_LOOP
rTimeEnd(MAIN_LOOP_END1);
com.MainLoop = rTimeCal(MAIN_LOOP_START1,
MAIN_LOOP_END1);
currentPt.update_last(com);
currentRes.compute(m,nBlock,blockStruct,b,C,A,currentPt,mu);
rTimeEnd(TOTAL_TIME_END1);
com.TotalTime = rTimeCal(TOTAL_TIME_START1,
TOTAL_TIME_END1);
#if REVERSE_PRIMAL_DUAL
phase.reverse();
#endif
#if 1
rIO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
nDim, b, C, A, com, param, fpOut, Display);
#endif
// com.display(fpOut);
if (blockStruct) {
delete[] blockStruct;
blockStruct = NULL;
}
C.~rBlockSparseMatrix();
for (int k=0; k<m; ++k) {
A[k].~rBlockSparseMatrix();
}
delete[] A;
A = NULL;
fprintf(Display, " main loop time = %.6f\n",com.MainLoop);
fprintf(fpOut, " main loop time = %.6f\n",com.MainLoop);
fprintf(Display, " total time = %.6f\n",com.TotalTime);
fprintf(fpOut, " total time = %.6f\n",com.TotalTime);
#if 0
fprintf(Display, "file check time = %.6f\n",com.FileCheck);
fprintf(fpOut, " file check time = %.6f\n",com.FileCheck);
fprintf(Display, "file change time = %.6f\n",com.FileChange);
fprintf(fpOut, " file change time = %.6f\n",com.FileChange);
#endif
fprintf(Display, "file read time = %.6f\n",com.FileRead);
fprintf(fpOut, " file read time = %.6f\n",com.FileRead);
fclose(fpOut);
return true;
}
void brushMakePrefab(const cmd::ArgumentList& args)
{
if (args.size() != 1) {
return;
}
if (GlobalSelectionSystem().getSelectionInfo().brushCount != 1)
{
// Display a modal error dialog
gtkutil::MessageBox::ShowError(_("Exactly one brush must be selected for this operation."), GlobalMainFrame().getTopLevelWindow());
return;
}
// First argument contains the number of sides
int input = args[0].getInt();
if (input >= eBrushCuboid && input < eNumPrefabTypes) {
// Boundary checks passed
EBrushPrefab type = static_cast<EBrushPrefab>(input);
int minSides = 3;
int maxSides = Brush::PRISM_MAX_SIDES;
switch (type)
{
case eBrushCuboid:
// Cuboids don't need to query the number of sides
Scene_BrushConstructPrefab(GlobalSceneGraph(), type, 0, GlobalTextureBrowser().getSelectedShader());
return;
case eBrushPrism:
minSides = Brush::PRISM_MIN_SIDES;
maxSides = Brush::PRISM_MAX_SIDES;
break;
case eBrushCone:
minSides = Brush::CONE_MIN_SIDES;
maxSides = Brush::CONE_MAX_SIDES;
break;
case eBrushSphere:
minSides = Brush::SPHERE_MIN_SIDES;
maxSides = Brush::SPHERE_MAX_SIDES;
break;
default:
maxSides = 9999;
};
ui::QuerySidesDialog dialog(minSides, maxSides);
int sides = dialog.queryNumberOfSides();
if (sides != -1)
{
Scene_BrushConstructPrefab(GlobalSceneGraph(), type, sides, GlobalTextureBrowser().getSelectedShader());
}
}
else {
rError() << "BrushMakePrefab: invalid prefab type. Allowed types are: " << std::endl
<< eBrushCuboid << " = cuboid " << std::endl
<< eBrushPrism << " = prism " << std::endl
<< eBrushCone << " = cone " << std::endl
<< eBrushSphere << " = sphere " << std::endl;
}
}
void Newton::make_aggrigateIndex_LP(InputData& inputData)
{
int t, ii, jj;
LP_nBlock = inputData.LP_nBlock;
NewArray(LP_number,int,LP_nBlock);
// memory allocate for aggrigateIndex
NewArray(LP_constraint1,int*,LP_nBlock);
NewArray(LP_constraint2,int*,LP_nBlock);
NewArray(LP_blockIndex1,int*,LP_nBlock);
NewArray(LP_blockIndex2,int*,LP_nBlock);
NewArray(LP_location_sparse_bMat,int*,LP_nBlock);
for (int l=0; l<LP_nBlock; l++){
int size = (inputData.LP_nConstraint[l] + 1)
* inputData.LP_nConstraint[l] / 2;
LP_number[l] = size;
NewArray(LP_constraint1[l],int,size);
NewArray(LP_constraint2[l],int,size);
NewArray(LP_blockIndex1[l],int,size);
NewArray(LP_blockIndex2[l],int,size);
NewArray(LP_location_sparse_bMat[l],int,size);
}
for (int l = 0; l<LP_nBlock; l++){
int NonZeroCount = 0;
for (int k1=0; k1<inputData.LP_nConstraint[l]; k1++){
int i = inputData.LP_constraint[l][k1];
int ib = inputData.LP_blockIndex[l][k1];
for (int k2=0; k2<inputData.LP_nConstraint[l]; k2++){
int j = inputData.LP_constraint[l][k2];
int jb = inputData.LP_blockIndex[l][k2];
if (i < j){
continue;
}
// set index which A_i and A_j are not zero matrix
LP_constraint1[l][NonZeroCount] = i;
LP_constraint2[l][NonZeroCount] = j;
LP_blockIndex1[l][NonZeroCount] = ib;
LP_blockIndex2[l][NonZeroCount] = jb;
if (reverse_ordering[i] < reverse_ordering[j]){
ii = reverse_ordering[i];
jj = reverse_ordering[j];
} else {
jj = reverse_ordering[i];
ii = reverse_ordering[j];
}
// binary search for index of sparse_bMat
t = -1;
int begin = diagonalIndex[ii];
int end = diagonalIndex[ii+1]-1;
int target = (begin + end) / 2;
while (end - begin > 1){
if (sparse_bMat.column_index[target] < jj){
begin = target;
target = (begin + end) / 2;
} else if (sparse_bMat.column_index[target] > jj){
end = target;
target = (begin + end) / 2;
} else if (sparse_bMat.column_index[target] == jj){
t = target;
break;
}
}
if (t == -1){
if (sparse_bMat.column_index[begin] == jj){
t = begin;
} else if (sparse_bMat.column_index[end] == jj){
t = end;
} else {
rError("Newton::make_aggrigateIndex_SDP program bug");
}
}
LP_location_sparse_bMat[l][NonZeroCount] = t;
NonZeroCount++;
}
} // for k1
} //for k kth block
}
void rSdpaLib::inputElement(int k,int l, int i, int j, double value)
{
k--;
if (k<-1 || k>=m) {
#if REVERSE_PRIMAL_DUAL
rMessage("Over index of F:: " << k+1);
rError("Length of F :: " << m);
#else
rMessage("Over index of A or C:: " << k+1);
rError("Length of A :: " << m);
#endif
}
l--;
if (l<0 || l>=nBlock) {
#if REVERSE_PRIMAL_DUAL
rMessage("Over nBlock of F:: " << l+1);
rError("nBlock of F :: " << nBlock);
#else
rMessage("Over nBlock of A or C:: " << l+1);
rError("nBlock of A :: " << nBlock);
#endif
}
i--;
j--;
int size = blockStruct[l];
if (k==-1) {
rSparseMatrix& target = C.ele[l];
int count = target.NonZeroCount;
if (target.Sp_De_Di == rSparseMatrix::SPARSE
&& count >= target.NonZeroNumber) {
#if REVERSE_PRIMAL_DUAL
rError("C.ele[" << (l+1) << "]"
<< " is too much element which is assigned");
#else
rError("F[0].ele[" << (l+1) << "]"
<< " is too much element which is assigned");
#endif
}
if (size>0) {
target.row_index[count] = i;
target.column_index[count] = j;
#if REVERSE_PRIMAL_DUAL
target.sp_ele[count] = -value;
#else
target.sp_ele[count] = value;
#endif
target.NonZeroCount++;
if (i==j) {
target.NonZeroEffect++;
} else {
target.NonZeroEffect += 2;
}
} else {
#if REVERSE_PRIMAL_DUAL
target.di_ele[j] = -value;
#else
target.di_ele[j] = value;
#endif
}
} else { // k>=0
rSparseMatrix& target = A[k].ele[l];
int count = target.NonZeroCount;
if (target.Sp_De_Di == rSparseMatrix::SPARSE
&& count >= target.NonZeroNumber) {
#if REVERSE_PRIMAL_DUAL
rError("F["<<(k+1)<<"].ele[" << (l+1) << "]"
<< " is too much element which is assigned");
#else
rError("A["<<(k+1)<<"].ele[" << (l+1) << "]"
<< " is too much element which is assigned");
#endif
}
if (size>0) {
target.row_index[count] = i;
target.column_index[count] = j;
target.sp_ele[count] = value;
target.NonZeroCount++;
if (i==j) {
target.NonZeroEffect++;
} else {
target.NonZeroEffect += 2;
}
} else {
target.di_ele[j] = value;
}
}
}
bool rDenseMatrix::copyFrom(rSparseMatrix& other)
{
int length,index=0;
switch(other.Sp_De_Di) {
case rSparseMatrix::SPARSE:
De_Di = DENSE;
if (de_ele) {
delete[] de_ele;
}
de_ele = NULL;
nRow = other.nRow;
nCol = other.nCol;
rNewCheck();
de_ele = new double[nRow*nCol];
if (de_ele==NULL) {
rError("rDenseMatrix:: memory exhausted");
}
length = nRow*nCol;
catlas_dset(length,DZERO,de_ele,IONE);
for (index = 0; index<other.NonZeroCount; ++index) {
int i = other.row_index[index];
int j = other.column_index[index];
double value = other.sp_ele[index];
de_ele[i+nCol*j] = de_ele[j+nCol*i] = value;
}
break;
case rSparseMatrix::DENSE:
De_Di = DENSE;
if (de_ele && (other.nRow!=nRow || other.nCol!=nCol)) {
delete[] de_ele;
de_ele = NULL;
}
nRow = other.nRow;
nCol = other.nCol;
rNewCheck();
de_ele = new double[nRow*nCol];
if (de_ele==NULL) {
rError("rDenseMatrix:: memory exhausted");
}
length = nRow*nCol;
dcopy(&length,other.de_ele,&IONE,de_ele,&IONE);
break;
case rSparseMatrix::DIAGONAL:
De_Di = DIAGONAL;
if (di_ele && (other.nRow!=nRow || other.nCol!=nCol)) {
delete[] di_ele;
di_ele = NULL;
}
nRow = other.nRow;
nCol = other.nCol;
if (di_ele==NULL) {
rNewCheck();
di_ele = new double[nCol];
if (di_ele==NULL) {
rError("rDenseMatrix:: memory exhausted");
}
}
dcopy(&nCol,other.di_ele,&IONE,di_ele,&IONE);
break;
}
return _SUCCESS;
}
bool rSdpaLib::dumpData(const char* filename)
{
ofstream output;
output.open(filename);
if (output.fail()) {
rError("Cannot Open " << filename);
}
output << m << endl;
output << nBlock << endl;
for (int l = 0; l<nBlock ; ++l) {
output << blockStruct[l] << " " ;
}
output << '\n';
output << "{ ";
for (int k=0; k<m; ++k) {
output << b.ele[k] << " ";
}
output << "}";
output << '\n';
for (int l=0; l<nBlock; ++l) {
int index = 0;
switch (C.ele[l].Sp_De_Di) {
case rSparseMatrix::SPARSE:
for (index = 0; index < C.ele[l].NonZeroCount; ++index) {
int i = C.ele[l].row_index[index];
int j = C.ele[l].column_index[index];
double value = C.ele[l].sp_ele[index];
if (value!=0.0) {
output << "0 " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< -value << '\n';
}
}
break;
case rSparseMatrix::DENSE:
// a Matrix must not be DENSE,
// since it was read as SPARSE or DIAGONAL
break;
case rSparseMatrix::DIAGONAL:
for (index = 0; index < C.ele[l].nRow; ++index) {
double value = C.ele[l].di_ele[index];
if (value!=0.0) {
output << "0 " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< -value << '\n';
}
}
break;
} // end of switch
}// end of 'for (int l)'
for (int k=0; k<m; ++k) {
for (int l=0; l<nBlock; ++l) {
int index = 0;
switch (A[k].ele[l].Sp_De_Di) {
case rSparseMatrix::SPARSE:
for (index = 0; index < A[k].ele[l].NonZeroCount;
++index) {
int i = A[k].ele[l].row_index[index];
int j = A[k].ele[l].column_index[index];
double value = A[k].ele[l].sp_ele[index];
if (value!=0.0) {
output << k+1 << " " << l+1 << " "
<< i+1 << " " << j+1 << " "
<< value << '\n';
}
}
break;
case rSparseMatrix::DENSE:
// a Matrix must not be DENSE,
// since it was read as SPARSE or DIAGONAL
break;
case rSparseMatrix::DIAGONAL:
for (index = 0; index < A[k].ele[l].nRow; ++index) {
double value = A[k].ele[l].di_ele[index];
if (value!=0.0) {
output << k+1 << " " << l+1 << " "
<< index+1 << " " << index+1 << " "
<< value << '\n';
}
}
break;
} // end of switch
} // end of 'for (int l)'
} // end of 'for (int k)'
output.close();
return true;
}
off_t Compress::writeCompressed(LayerMap& lm, off_t offset, off_t coffset, const char *buf, size_t size, int fd, off_t rawFileSize)
{
assert(coffset >= FileHeader::MaxSize);
rDebug("offset: 0x%lx, coffset: 0x%lx, size: 0x%lx",
(long int) offset, (long int) coffset, (long int) size);
Block *bl = NULL;
try {
// Append a new Block to the file.
bl = new Block(g_CompressionType);
bl->offset = offset;
bl->coffset = coffset;
bl->length = size;
bl->olength = size;
// Truncate the file to m_RawFileSize.
//
// This efectively removes layer map from the file, so if
// anything wrong happens until store() is called we lost the
// file!
//
// We have to do that until I find a way how to get length of
// the compressed block that is written by io::write()...
//
// OK, I now know how to get length of the compressed block,
// but I don't know anymore how to use it to avoid the truncation.
assert(bl->coffset == rawFileSize);
::ftruncate(fd, bl->coffset);
// Compress and write block to the file.
io::nonclosable_file_descriptor file(fd);
file.seek(bl->coffset, ios_base::beg);
io::bytescounter length;
{
io::filtering_ostream out;
bl->type.push(out);
out.push(boost::ref(length));
out.push(file);
io::write(out, buf, bl->length);
// Destroying the object 'out' causes all filters to flush.
}
bl->clength = length.bytes();
coffset = bl->coffset + bl->clength;
}
catch (...)
{
rError("Failed to add a new Block to the file.");
delete bl;
return -1;
}
assert(bl != NULL);
lm.Put(bl);
rDebug("length: 0x%lx", (long int) coffset);
return coffset;
}
void rSdpaLib::solve()
{
if (CheckMatrix) {
rTimeStart(FILE_CHECK_START1);
int i=0,j=0,k=0,l=0;
// this method needs long time
checkData(k,l,i,j);
if (i>0 || j>0) {
rError("checkData stops");
cout << "constraint " << k <<":"
<< "block " << l <<":"
<< "row " << i <<":"
<< "column " << j << endl;
}
rTimeEnd(FILE_CHECK_END1);
com.FileCheck += rTimeCal(FILE_CHECK_START1,
FILE_CHECK_END1);
}
#if 1
rTimeStart(FILE_CHANGE_START1);
// if possible, change C and A to Dense type matrices.
C.changeToDense();
for (int k=0; k<m; ++k) {
A[k].changeToDense();
}
rTimeEnd(FILE_CHANGE_END1);
com.FileChange += rTimeCal(FILE_CHANGE_START1,
FILE_CHANGE_END1);
#endif
if (InitialPoint) {
initPt.initializeResetup(m,nBlock,blockStruct,com);
currentPt.copyFrom(initPt);
// rMessage("initialize? ");
} else {
currentPt.initialize(m,nBlock,blockStruct,pARAM.lambdaStar,com);
}
// rMessage("initPt = ");
// initPt.display();
// rMessage("currentPt = ");
// currentPt.display();
initRes.initialize(m, nBlock, blockStruct, b, C, A, currentPt);
currentRes.copyFrom(initRes);
// rMessage("initial currentRes = ");
// currentRes.display();
newton.initialize(m, nBlock, blockStruct);
newton.computeFormula(m,A,0.0,KAPPA);
alpha.initialize(1.0,1.0,nBlock, blockStruct);
beta.initialize(pARAM.betaStar);
reduction.initialize(rSwitch::ON);
mu.initialize(pARAM.lambdaStar);
lanczos.initialize(nBlock,blockStruct);
if (InitialPoint) {
mu.initialize(nDim,initPt);
}
theta.initialize(pARAM,initRes);
solveInfo.initialize(nDim, b, C, A, initPt, mu.initial,
pARAM.omegaStar);
phase.initialize(initRes, solveInfo, pARAM, nDim);
rIO::printHeader(OutputFile,DisplayInformation);
int pIteration = 0;
// -----------------------------------------------------
// Here is MAINLOOP
// -----------------------------------------------------
rTimeStart(MAIN_LOOP_START1);
// explisit maxIteration
// pARAM.maxIteration = 100;
while (phase.updateCheck(currentRes, solveInfo, pARAM)
&& pIteration < pARAM.maxIteration) {
// rMessage(" turn hajimari " << pIteration );
#if 0
if (alpha.primal<1.0e-5 && alpha.dual<1.0e-5) {
break;
}
#endif
// Mehrotra's Predictor
rTimeStart(MEHROTRA_PREDICTOR_START1);
// calculate variables of Mehrotra
reduction.MehrotraPredictor(phase);
beta.MehrotraPredictor(phase, reduction, pARAM);
// rMessage("reduction = ");
// reduction.display();
// rMessage("phase = ");
// phase.display();
// rMessage("beta.predictor.value = " << beta.value);
// rMessage("xMat = ");
// currentPt.xMat.display();
// rMessage("zMat = ");
// currentPt.zMat.display();
// rMessage(" mu = " << mu.current);
bool isSuccessCholesky;
isSuccessCholesky = newton.Mehrotra(rNewton::PREDICTOR,
m, A, C, mu,
beta, reduction,
phase, currentPt,
currentRes, com);
if (isSuccessCholesky == false) {
break;
}
// rMessage("newton predictor = ");
// newton.display();
// rMessage("newton Dy predictor = ");
// newton.DyVec.display();
// newton.bMat.display();
rTimeEnd(MEHROTRA_PREDICTOR_END1);
com.Predictor += rTimeCal(MEHROTRA_PREDICTOR_START1,
MEHROTRA_PREDICTOR_END1);
rTimeStart(STEP_PRE_START1);
alpha.MehrotraPredictor(b,C,A, currentPt, phase,
newton, lanczos, com);
// rMessage("xMat = ");
// currentPt.xMat.display();
// rMessage("zMat = ");
// currentPt.zMat.display();
// rMessage("alpha predictor = ");
// alpha.display();
// phase.display();
// rMessage("newton predictor = ");
// newton.display();
// rMessage("currentPt = ");
// currentPt.display();
rTimeStart(STEP_PRE_END1);
com.StepPredictor += rTimeCal(STEP_PRE_START1,STEP_PRE_END1);
// rMessage("alphaStar = " << pARAM.alphaStar);
// Mehrotra's Corrector
// rMessage(" Corrector ");
rTimeStart(CORRECTOR_START1);
beta.MehrotraCorrector(nDim,phase,alpha,currentPt,
newton,mu,pARAM);
// rMessage("beta corrector = " << beta.value);
newton.Mehrotra(rNewton::CORRECTOR,m,A,C,mu,beta,reduction,
phase, currentPt, currentRes, com);
// rMessage("currentPt = ");
// currentPt.display();
// rMessage("newton corrector = ");
// newton.display();
// rMessage("newton Dy corrector = ");
// newton.DyVec.display();
rTimeEnd(CORRECTOR_END1);
com.Corrector += rTimeCal(CORRECTOR_START1,
CORRECTOR_END1);
rTimeStart(CORRECTOR_STEP_START1);
alpha.MehrotraCorrector(nDim, b, C, A, currentPt, phase,
reduction, newton, mu, theta,
lanczos, pARAM, com);
// rMessage("alpha corrector = ");
// alpha.display();
rTimeEnd(CORRECTOR_STEP_END1);
com.StepCorrector += rTimeCal(CORRECTOR_STEP_START1,
CORRECTOR_STEP_END1);
// the end of Corrector
rIO::printOneIteration(pIteration, mu, theta, solveInfo,
alpha, beta, currentRes, OutputFile,
DisplayInformation);
if (currentPt.update(alpha,newton,com)==false) {
// if step length is too short,
// the algorithm ends.
// rMessage("cannot move");
pIteration++;
break;
}
// rMessage("currentPt = ");
// currentPt.display();
// rMessage("newton = ");
// newton.display();
// rMessage("updated");
theta.update(reduction,alpha);
mu.update(nDim,currentPt);
currentRes.update(m,nBlock,blockStruct,b,C,A,
initRes, theta, currentPt, phase, mu,com);
theta.update_exact(initRes,currentRes);
solveInfo.update(nDim, b, C, initPt, currentPt,
currentRes, mu, theta, pARAM);
pIteration++;
} // end of MAIN_LOOP
rTimeEnd(MAIN_LOOP_END1);
com.MainLoop = rTimeCal(MAIN_LOOP_START1,
MAIN_LOOP_END1);
currentPt.update_last(com);
currentRes.compute(m,nBlock,blockStruct,b,C,A,currentPt,mu);
rIO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
nDim,b,C,A,com,pARAM, OutputFile,
DisplayInformation,false);
#if REVERSE_PRIMAL_DUAL
// reverse the sign of y and phase
rAl::let(currentPt.yVec,'=',currentPt.yVec,'*',&DMONE);
phase.reverse();
#endif
iteration = pIteration;
// for compability SDPA
PrimalObj = getPrimalObj();
DualObj = getDualObj();
PrimalError = getPrimalError();
DualError = getDualError();
Iteration = getIteration();
switch (phase.value) {
case rSolveInfo::noINFO : Value = ::noINFO; break;
case rSolveInfo::pFEAS : Value = ::pFEAS; break;
case rSolveInfo::dFEAS : Value = ::dFEAS; break;
case rSolveInfo::pdFEAS : Value = ::pdFEAS; break;
case rSolveInfo::pdINF : Value = ::pdINF; break;
case rSolveInfo::pFEAS_dINF: Value = ::pFEAS_dINF; break;
case rSolveInfo::pINF_dFEAS: Value = ::pINF_dFEAS; break;
case rSolveInfo::pdOPT : Value = ::pdOPT; break;
case rSolveInfo::pUNBD : Value = ::pUNBD; break;
case rSolveInfo::dUNBD : Value = ::dUNBD; break;
}
}
/* m_fh.size, m_lm */
ssize_t Compress::readCompressed(char *buf, size_t size, off_t offset, int fd) const
{
Block block;
size_t osize;
off_t len;
if (offset + (off_t) size > m_fh.size)
{
if (m_fh.size > offset)
{
size = m_fh.size - offset;
} else
size = 0;
}
osize = size;
while (size > 0)
{
if (!m_lm.Get(offset, block, len))
{
// Block not found. There also is no block on a upper
// offset.
//
memset(buf, 0, size);
size = 0;
break;
}
if (len)
{
// Block covers the offset, we can read len bytes
// from it's de-compressed stream...
off_t r;
try {
r = readBlock(fd, block, size, len, offset, buf);
}
catch (...)
{
rError("%s: Block read failed: block.offset:%lx, block.coffset:%lx, block.length: %lx, block.clength: %lx",
__PRETTY_FUNCTION__, (long int) block.offset, (long int) block.coffset,
(long int) block.length, (long int) block.clength);
return -1;
}
buf += r;
offset += r;
size -= r;
}
else
{
off_t r;
// Block doesn't exists on the offset, but there is
// a Block on the bigger offset. Fill the gap with
// zeroes...
r = min(block.offset - offset, (off_t) (size));
memset(buf, 0, r);
buf += r;
offset += r;
size -= r;
}
}
return osize - size;
}
int compress(const char *i, const struct stat *i_st, int mode, struct FTW *n)
{
if (!((mode == FTW_F) && (S_ISREG(i_st->st_mode))))
return 0;
fs::path input(i
#if BOOST_VERSION <= 104600
, fs::native
#endif
);
fs::path input_directory(input.branch_path());
fs::path output(input_directory / "XXXXXX");
rInfo("Processing file (%s)", input.string().c_str());
// Remember times of the input file.
struct stat stbuf;
lstat(input.string().c_str(), &stbuf);
int o_fd = mkstemp(const_cast<char *>(output.string().c_str()));
if (o_fd < 0)
{
rError("Failed to create an temporary file in (%s) directory", input_directory.string().c_str());
return -1;
}
rInfo("Temporary file (%s)", output.string().c_str());
struct stat o_st;
if (fstat(o_fd, &o_st) == -1)
{
rError("Failed to read stat of temporary file (%s)", output.string().c_str());
close(o_fd);
return -1;
}
close(o_fd);
if (!copy(i, output.string().c_str(), i_st, &o_st))
{
unlink(output.string().c_str());
return -1;
}
if (rename(output.string().c_str(), i) == -1)
{
rError("Failed to rename temporary file (%s) to (%s) (%s)", output.string().c_str(), input.string().c_str(), strerror(errno));
return -1;
}
if (chmod(i, i_st->st_mode) == -1)
{
rError("Failed to change mode (%s) (%s)", input.string().c_str(), strerror(errno));
return -1;
}
// Write back original times.
struct timespec times[2];
times[0].tv_sec = stbuf.st_atime;
times[0].tv_nsec = stbuf.st_atim.tv_nsec;
times[1].tv_sec = stbuf.st_mtime;
times[1].tv_nsec = stbuf.st_mtim.tv_nsec;
utimensat(AT_FDCWD, i, times, AT_SYMLINK_NOFOLLOW);
return 0;
}
off_t Compress::cleverCopy(int readFd, off_t writeOffset, int writeFd, LayerMap& writeLm)
{
off_t offset = 0;
off_t size = m_fh.size;
Block block;
off_t len;
while (size > 0)
{
if (!m_lm.Get(offset, block, len))
{
// Block not found. There also is no block on a upper
// offset.
//
break;
}
if (len)
{
// Block covers the offset, we can read len bytes
// from it's de-compressed stream...
try {
boost::scoped_array<char> buf(new char[block.length]);
// Read old block (or part of it we need)...
off_t r = readBlock(readFd, block, size, len, offset, buf.get());
// Write new block...
writeOffset = writeCompressed(writeLm, offset, writeOffset, buf.get(), r, writeFd, writeOffset);
if (writeOffset == -1)
return -1;
assert (r == writeOffset);
offset += r;
size -= r;
}
catch (...)
{
rError("%s: Block read failed: block.offset:%lx, block.coffset:%lx, block.length: %lx, block.clength: %lx",
__PRETTY_FUNCTION__, (long int) block.offset, (long int) block.coffset,
(long int) block.length, (long int) block.clength);
return -1;
}
}
else
{
off_t r;
// Block doesn't exists on the offset, but there is
// a Block on the bigger offset.
r = min(block.offset - offset, (off_t) (size));
offset += r;
size -= r;
}
}
return writeOffset;
}
bool copy(const char *i, const char *o, const struct stat *i_st, const struct stat *o_st)
{
Compress input(i_st, i);
int i_fd = input.open(i, O_RDONLY);
if (i_fd == -1)
{
rError("File (%s) cannot be opened! (%s)", i, strerror(errno));
return false;
}
if (input.isCompressed() == false)
{
rInfo(" Not compressed");
if (g_RawOutput)
{
rInfo(" Skipped");
// Input file is not compressed an user wants
// to decomrpess file. Return now.
input.release(i);
return false;
}
}
else
{
rInfo(" Compressed");
if (g_RawOutput)
{
}
else
{
if (input.isCompressedOnlyWith(g_CompressionType))
{
rInfo(" All blocks compressed with the same compression method");
// Input file is compressed only with
// the same compression type as user wants.
// Return now.
input.release(i);
return false;
}
rInfo(" Some block(s) compressed with different compression method than others");
}
}
Compress output(o_st, o);
if (g_RawOutput)
{
output.setCompressed(false);
}
boost::scoped_array<char> buffer(new char[g_BufferedMemorySize]);
int o_fd = output.open(o, O_WRONLY);
if (o_fd == -1)
{
rError("File (%s) cannot be opened! (%s)", o, strerror(errno));
input.release(i);
return false;
}
// Get the apparent input file size.
struct stat st;
int r = input.getattr(i, &st);
if (r == -1)
{
rError("Cannot determine apparent size of input file (%s) (%s)", i, strerror(errno));
input.release(i);
return false;
}
rInfo(" Processing");
for (off_t off = 0; off < st.st_size; off += g_BufferedMemorySize)
{
if (g_BreakFlag)
{
rWarning("Interrupted when processing file (%s)", i);
rWarning("File is left untouched");
input.release(i);
output.release(o);
return false;
}
off_t r = input.read(buffer.get(), g_BufferedMemorySize, off);
if (r == -1)
{
rError("Read failed! (offset: %lld, size: %lld)", (unsigned long long) off ,(unsigned long long) g_BufferedMemorySize);
input.release(i);
output.release(o);
return false;
}
off_t rr = output.write(buffer.get(), r, off);
if (rr != r)
{
rError("Write failed! (offset: %lld, size: %lld)", (unsigned long long) off , (unsigned long long) r);
input.release(i);
output.release(o);
return false;
}
}
// Remember extended attributes.
FileRememberXattrs xattrs;
xattrs.read(i_fd);
xattrs.write(o_fd);
input.release(i);
output.release(o);
return true;
}
void Compress::DefragmentFast()
{
rDebug("%s", __PRETTY_FUNCTION__);
struct stat st;
struct timespec m_times[2];
::fstat(m_fd, &st);
m_times[0].tv_sec = st.st_atime;
m_times[0].tv_nsec = st.st_atim.tv_nsec;
m_times[1].tv_sec = st.st_mtime;
m_times[1].tv_nsec = st.st_mtim.tv_nsec;
// Prepare a temporary file.
char tmp_name[] = "./.fc.XXXXXX";
int tmp_fd = mkstemp(tmp_name);
if (tmp_fd < 0)
{
// EINVAL would be a programmer error.
//
assert(errno != EINVAL);
rError("%s: Temporary file creation failed with errno: %d", __PRETTY_FUNCTION__, errno);
return;
}
// Reserve space for a FileHeader.
off_t tmp_offset = FileHeader::MaxSize;
// Temporary file prepared, now do the deframentation.
LayerMap tmp_lm;
tmp_offset = cleverCopy(m_fd, tmp_offset, tmp_fd, tmp_lm);
// tmp_offset = copy(m_fd, tmp_offset, tmp_fd, tmp_lm);
if (tmp_offset == -1)
{
::unlink(tmp_name);
::close(tmp_fd);
return;
}
::fchmod(tmp_fd, st.st_mode);
::fchown(tmp_fd, st.st_uid, st.st_gid);
::futimens(tmp_fd, m_times);
::close(m_fd);
m_fd = tmp_fd;
// Store new file header and layer map to the new file.
// m_fd contains file descriptor of the new file and
// file header is the same except m_fh.index but
// the index will be updated in the store() function.
// Update m_RawFileSize to tell store() where save the
// index and set m_lm to layer map of the new file.
m_RawFileSize = tmp_offset;
// Set index to zero (no index). Index will be set to
// correct value in store according to m_RawFileSize and
// existence of modified layer map.
m_fh.index = 0;
m_lm = tmp_lm;
store();
// The inode number of the lower file will be changed
// by rename so we have to update the g_FileManager to reflect
// that change. Without this update the g_FileManager
// would create an another File object for the same file.
::fstat(tmp_fd, &st);
g_FileManager->Lock();
g_FileManager->UpdateUnlocked(dynamic_cast<CFile*>(this), st.st_ino);
if (::rename(tmp_name, m_name.c_str()) == -1)
{
g_FileManager->Unlock();
rError("Cannot rename '%s' to '%s'", tmp_name, m_name.c_str());
return;
}
g_FileManager->Unlock();
}
void AutoMapSaver::saveSnapshot()
{
// Original GtkRadiant comments:
// we need to do the following
// 1. make sure the snapshot directory exists (create it if it doesn't)
// 2. find out what the lastest save is based on number
// 3. inc that and save the map
unsigned int maxSnapshotFolderSize =
registry::getValue<int>(RKEY_AUTOSAVE_MAX_SNAPSHOT_FOLDER_SIZE);
// Sanity check in case there is something weird going on in the registry
if (maxSnapshotFolderSize == 0)
{
maxSnapshotFolderSize = 100;
}
// Construct the boost::path class out of the full map path (throws on fail)
Path fullPath = GlobalMap().getMapName();
// Append the the snapshot folder to the path
Path snapshotPath = fullPath;
snapshotPath.remove_filename();
snapshotPath /= GlobalRegistry().get(RKEY_AUTOSAVE_SNAPSHOTS_FOLDER);
// Retrieve the mapname
std::string mapName = os::filename_from_path(fullPath.filename());
// Check if the folder exists and create it if necessary
if (boost::filesystem::exists(snapshotPath) || os::makeDirectory(snapshotPath.string()))
{
// Reset the size counter of the snapshots folder
std::size_t folderSize = 0;
// This holds the target path of the snapshot
std::string filename;
for (int nCount = 0; nCount < INT_MAX; nCount++)
{
// Construct the base name without numbered extension
filename = (snapshotPath / mapName).string();
// Now append the number and the map extension to the map name
filename += ".";
filename += string::to_string(nCount);
filename += ".";
filename += game::current::getValue<std::string>(GKEY_MAP_EXTENSION);
if (os::fileOrDirExists(filename))
{
// Add to the folder size
folderSize += file_size(filename.c_str());
}
else
{
// We've found an unused filename, break the loop
break;
}
}
rMessage() << "Autosaving snapshot to " << filename << std::endl;
// Dump to map to the next available filename
GlobalMap().saveDirect(filename);
// Display a warning, if the folder size exceeds the limit
if (folderSize > maxSnapshotFolderSize*1024*1024)
{
rMessage() << "AutoSaver: The snapshot files in " << snapshotPath;
rMessage() << " total more than " << maxSnapshotFolderSize;
rMessage() << " MB. You might consider cleaning up." << std::endl;
}
}
else
{
rError() << "Snapshot save failed.. unable to create directory";
rError() << snapshotPath << std::endl;
}
}
bool pinpal(char* dataFile, char* initFile, char* outFile,
char* paraFile, bool isInitFile, bool isInitSparse,
bool isDataSparse, bool isParameter,
Parameter::parameterType parameterType,
FILE* Display)
{
TimeStart(TOTAL_TIME_START1);
TimeStart(FILE_READ_START1);
ComputeTime com;
FILE* fpData = NULL;
FILE* fpOut = NULL;
if ((fpOut=fopen(outFile,"w"))==NULL) {
rError("Cannot open out file " << outFile);
}
Parameter param;
param.setDefaultParameter(parameterType);
if (isParameter) {
FILE* fpParameter = NULL;
if ((fpParameter=fopen(paraFile,"r"))==NULL) {
fprintf(Display,"Cannot open parameter file %s \n",
paraFile);
exit(0);
} else {
param.readFile(fpParameter);
fclose(fpParameter);
}
}
// param.display(Display,param.infPrint);
if ((fpData=fopen(dataFile,"r"))==NULL) {
rError("Cannot open data file " << dataFile);
}
char titleAndComment[LengthOfBuffer];
int m;
time_t ltime;
time( <ime );
fprintf(fpOut,"SDPA start at %s",ctime(<ime));
IO::read(fpData,fpOut,m,titleAndComment);
fprintf(fpOut,"data is %s\n",dataFile);
if (paraFile) {
fprintf(fpOut,"parameter is %s\n",paraFile);
}
if (initFile) {
fprintf(fpOut,"initial is %s\n",initFile);
}
fprintf(fpOut,"out is %s\n",outFile);
#if 1 // 2007/11/28 nakata for multi LP block
int SDP_nBlock, SOCP_nBlock,LP_nBlock, nBlock;
IO::read(fpData,nBlock);
int* blockStruct = NULL;
IO::BlockType* blockType = NULL;
int* blockNumber = NULL;
int* SDP_blockStruct = NULL;
int* SOCP_blockStruct = NULL;
NewArray(blockStruct,int,nBlock);
NewArray(blockType, IO::BlockType, nBlock);
NewArray(blockNumber,int,nBlock);
IO::read(fpData,nBlock,blockStruct);
SDP_nBlock = 0;
SOCP_nBlock = 0;
LP_nBlock = 0;
for (int l=0; l<nBlock; l++){
if (blockStruct[l] >= 2) {
blockType[l] = IO::btSDP;
blockNumber[l] = SDP_nBlock;
SDP_nBlock++;
} else if (blockStruct[l] < 0) {
blockType[l] = IO::btLP;
blockStruct[l] = - blockStruct[l];
blockNumber[l] = LP_nBlock;
LP_nBlock += blockStruct[l];
} else if (blockStruct[l] == 1) {
blockType[l] = IO::btLP;
blockNumber[l] = LP_nBlock;
LP_nBlock += blockStruct[l];
} else {
rError("block struct");
}
}
NewArray(SDP_blockStruct, int,SDP_nBlock);
NewArray(SOCP_blockStruct,int,SOCP_nBlock);
SDP_nBlock = 0;
for (int l=0; l<nBlock; l++){
if (blockType[l] == IO::btSDP) {
SDP_blockStruct[SDP_nBlock] = blockStruct[l];
SDP_nBlock++;
}
}
InputData inputData;
// rMessage("read input data: start");
IO::read(fpData, m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock,
nBlock, blockStruct, blockType, blockNumber,
inputData,isDataSparse);
// rMessage("read input data: end");
inputData.initialize_index(SDP_nBlock,SOCP_nBlock,LP_nBlock,com);
#else
int SDP_nBlock, SOCP_nBlock,LP_nBlock;
IO::read(fpData,SDP_nBlock,SOCP_nBlock,LP_nBlock);
int* SDP_blockStruct;
int* SOCP_blockStruct;
NewArray(SDP_blockStruct ,int,SDP_nBlock);
NewArray(SOCP_blockStruct,int,SOCP_nBlock);
IO::read(fpData,SDP_nBlock,SDP_blockStruct,
SOCP_nBlock,SOCP_blockStruct, LP_nBlock);
for (int l=0; l<SDP_nBlock-1; l++){
if (SDP_blockStruct[l] < 0){
rError("LP block must be in the last block");
}
}
// muriyari nyuuryoku saseru
if (SDP_blockStruct[SDP_nBlock-1] < 0){
LP_nBlock = - SDP_blockStruct[SDP_nBlock-1];
SDP_nBlock--;
}
InputData inputData;
IO::read(fpData, m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock,
inputData,isDataSparse);
inputData.initialize_index(SDP_nBlock,SOCP_nBlock,LP_nBlock,com);
#endif
fclose(fpData);
// inputData.display();
#if 1
TimeStart(FILE_CHANGE_START1);
// if possible , change C and A to Dense
inputData.C.changeToDense();
for (int k=0; k<m; ++k) {
inputData.A[k].changeToDense();
}
TimeEnd(FILE_CHANGE_END1);
com.FileChange += TimeCal(FILE_CHANGE_START1,
FILE_CHANGE_END1);
#endif
// rMessage("C = ");
// inputData.C.display(Display);
// for (int k=0; k<m; ++k) {
// rMessage("A["<<k<<"] = ");
// inputData.A[k].display(Display);
// }
// the end of initialization of C and A
Newton newton(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock);
int nBlock2 = SDP_nBlock+SOCP_nBlock+LP_nBlock;
// 2008/03/12 kazuhide nakata
Chordal chordal;
// rMessage("ordering bMat: start");
chordal.ordering_bMat(m, nBlock2, inputData, fpOut);
// rMessage("ordering bMat: end");
newton.initialize_bMat(m, chordal,inputData, fpOut);
chordal.terminate();
// rMessage("newton.computeFormula_SDP: start");
newton.computeFormula_SDP(inputData,0.0,KAPPA);
// rMessage("newton.computeFormula_SDP: end");
// set initial solutions.
Solutions currentPt;
WorkVariables work;
DenseLinearSpace initPt_xMat;
DenseLinearSpace initPt_zMat;
currentPt.initialize(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock,
param.lambdaStar,com);
work.initialize(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct, LP_nBlock);
if (isInitFile) {
FILE* fpInit = NULL;
if ((fpInit=fopen(initFile,"r"))==NULL) {
rError("Cannot open init file " << initFile);
}
IO::read(fpInit,currentPt.xMat,currentPt.yVec,currentPt.zMat,
SDP_nBlock,SDP_blockStruct,
SOCP_nBlock,SOCP_blockStruct,
LP_nBlock, nBlock, blockStruct,
blockType, blockNumber,
isInitSparse);
#if 0
rMessage("intial X = ");
currentPt.xMat.display();
rMessage("intial Z = ");
currentPt.zMat.display();
#endif
fclose(fpInit);
currentPt.computeInverse(work,com);
initPt_xMat.initialize(SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct,
LP_nBlock);
initPt_zMat.initialize(SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct,
LP_nBlock);
initPt_xMat.copyFrom(currentPt.xMat);
initPt_zMat.copyFrom(currentPt.zMat);
}
// rMessage("initial xMat = "); initPt_xMat.display(Display);
// rMessage("initial yVec = "); currentPt.yVec.display(Display);
// rMessage("initial zMat = "); initPt_zMat.display(Display);
// rMessage("current pt = "); currentPt.display(Display);
TimeEnd(FILE_READ_END1);
com.FileRead += TimeCal(FILE_READ_START1,
FILE_READ_END1);
// -------------------------------------------------------------
// the end of file read
// -------------------------------------------------------------
Residuals initRes(m, SDP_nBlock, SDP_blockStruct,
SOCP_nBlock, SOCP_blockStruct,
LP_nBlock, inputData, currentPt);
Residuals currentRes;
currentRes.copyFrom(initRes);
// rMessage("initial currentRes = ");
// currentRes.display(Display);
StepLength alpha;
DirectionParameter beta(param.betaStar);
Switch reduction(Switch::ON);
AverageComplementarity mu(param.lambdaStar);
// rMessage("init mu"); mu.display();
if (isInitFile) {
mu.initialize(currentPt);
}
RatioInitResCurrentRes theta(param, initRes);
SolveInfo solveInfo(inputData, currentPt,
mu.initial, param.omegaStar);
Phase phase(initRes, solveInfo, param, currentPt.nDim);
int pIteration = 0;
IO::printHeader(fpOut, Display);
// -----------------------------------------------------
// Here is MAINLOOP
// -----------------------------------------------------
TimeStart(MAIN_LOOP_START1);
// explicit maxIteration for debug
// param.maxIteration = 2;
while (phase.updateCheck(currentRes, solveInfo, param)
&& pIteration < param.maxIteration) {
// rMessage(" turn hajimari " << pIteration );
// Mehrotra's Predictor
TimeStart(MEHROTRA_PREDICTOR_START1);
// set variable of Mehrotra
reduction.MehrotraPredictor(phase);
beta.MehrotraPredictor(phase, reduction, param);
// rMessage("reduction = "); reduction.display();
// rMessage("phase = "); phase.display();
// rMessage("beta.predictor.value = " << beta.value);
// rMessage(" mu = " << mu.current);
// rMessage("currentPt = "); currentPt.display();
bool isSuccessCholesky;
isSuccessCholesky = newton.Mehrotra(Newton::PREDICTOR,
inputData, currentPt,
currentRes,
mu, beta, reduction,
phase,work,com);
if (isSuccessCholesky == false) {
break;
}
// rMessage("newton predictor = "); newton.display();
TimeEnd(MEHROTRA_PREDICTOR_END1);
com.Predictor += TimeCal(MEHROTRA_PREDICTOR_START1,
MEHROTRA_PREDICTOR_END1);
TimeStart(STEP_PRE_START1);
alpha.MehrotraPredictor(inputData, currentPt, phase, newton,
work, com);
// rMessage("alpha predictor = "); alpha.display();
TimeStart(STEP_PRE_END1);
com.StepPredictor += TimeCal(STEP_PRE_START1,STEP_PRE_END1);
// rMessage("alphaStar = " << param.alphaStar);
// Mehrotra's Corrector
// rMessage(" Corrector ");
TimeStart(CORRECTOR_START1);
beta.MehrotraCorrector(phase,alpha,currentPt, newton,mu,param);
// rMessage("beta corrector = " << beta.value);
#if 1 // 2007/08/29 kazuhide nakata
// add stopping criteria: objValPrimal < ObjValDual
// if ((pIteration > 10) &&
if (phase.value == SolveInfo::pdFEAS
&& ( beta.value> 5.0
|| solveInfo.objValPrimal < solveInfo.objValDual)){
break;
}
#endif
newton.Mehrotra(Newton::CORRECTOR,
inputData, currentPt, currentRes,
mu, beta, reduction, phase,work,com);
// rMessage("currentPt = "); currentPt.display();
// rMessage("newton corrector = "); newton.display();
TimeEnd(CORRECTOR_END1);
com.Corrector += TimeCal(CORRECTOR_START1,
CORRECTOR_END1);
TimeStart(CORRECTOR_STEP_START1);
alpha.MehrotraCorrector(inputData, currentPt, phase,
reduction, newton, mu, theta,
work, param, com);
// rMessage("alpha corrector = "); alpha.display();
TimeEnd(CORRECTOR_STEP_END1);
com.StepCorrector += TimeCal(CORRECTOR_STEP_START1,
CORRECTOR_STEP_END1);
// the end of Corrector
IO::printOneIteration(pIteration, mu, theta, solveInfo,
alpha, beta, fpOut, Display);
if (currentPt.update(alpha,newton,work,com)==false) {
// if step length is too short,
// we finish algorithm
rMessage("cannot move: step length is too short");
// memo by kazuhide nakata
// StepLength::MehrotraCorrector
// thetaMax*mu.initial -> thetamax*thetaMax*mu.initial
break;
}
// rMessage("currentPt = "); currentPt.display();
// rMessage("updated");
theta.update(reduction,alpha);
mu.update(currentPt);
currentRes.update(m,inputData, currentPt, com);
theta.update_exact(initRes,currentRes);
if (isInitFile) {
solveInfo.update(inputData, initPt_xMat, initPt_zMat, currentPt,
currentRes, mu, theta, param);
} else {
solveInfo.update(param.lambdaStar,inputData, currentPt,
currentRes, mu, theta, param);
}
// 2007/09/18 kazuhide nakata
// print information of ObjVal, residual, gap, complementarity
// solveInfo.check(inputData, currentPt,
// currentRes, mu, theta, param);
pIteration++;
} // end of MAIN_LOOP
TimeEnd(MAIN_LOOP_END1);
com.MainLoop = TimeCal(MAIN_LOOP_START1,
MAIN_LOOP_END1);
currentRes.compute(m,inputData,currentPt);
TimeEnd(TOTAL_TIME_END1);
com.TotalTime = TimeCal(TOTAL_TIME_START1,
TOTAL_TIME_END1);
#if REVERSE_PRIMAL_DUAL
phase.reverse();
#endif
#if 1
IO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
nBlock, blockStruct, blockType, blockNumber,
inputData, work, com, param, fpOut, Display);
#else
IO::printLastInfo(pIteration, mu, theta, solveInfo, alpha, beta,
currentRes, phase, currentPt, com.TotalTime,
inputData, work, com, param, fpOut, Display);
#endif
// com.display(fpOut);
DeleteArray(SDP_blockStruct);
DeleteArray(blockStruct);
DeleteArray(blockType);
DeleteArray(blockNumber);
fprintf(Display, " main loop time = %.6f\n",com.MainLoop);
fprintf(fpOut, " main loop time = %.6f\n",com.MainLoop);
fprintf(Display, " total time = %.6f\n",com.TotalTime);
fprintf(fpOut, " total time = %.6f\n",com.TotalTime);
#if 0
fprintf(Display, "file check time = %.6f\n",com.FileCheck);
fprintf(fpOut, " file check time = %.6f\n",com.FileCheck);
fprintf(Display, "file change time = %.6f\n",com.FileChange);
fprintf(fpOut, " file change time = %.6f\n",com.FileChange);
#endif
fprintf(Display, "file read time = %.6f\n",com.FileRead);
fprintf(fpOut, " file read time = %.6f\n",com.FileRead);
fclose(fpOut);
#if 0
rMessage("memory release");
currentRes.terminate();
initRes.terminate();
currentPt.terminate();
initPt_xMat.terminate();
initPt_zMat.terminate();
newton.terminate();
work.terminate();
inputData.terminate();
com.~ComputeTime();
param.~Parameter();
alpha.~StepLength();
beta.~DirectionParameter();
reduction.~Switch();
mu.~AverageComplementarity();
theta.~RatioInitResCurrentRes();
solveInfo.~SolveInfo();
phase.~Phase();
#endif
return true;
}
void user_warning_fn(png_structp png_ptr, png_const_charp warning_msg)
{
rError() << "libpng warning: " << warning_msg << std::endl;
}
void rSdpaLib::initializeFromFile()
{
rTimeStart(FILE_READ_START1);
bool isDataSparse = false;
int len = strlen(InputFileName);
if (InputFileName[len-1] == 's'
&& InputFileName[len-2] == '-') {
isDataSparse = true;
}
// initialize b,C,A
char titleAndComment[1024];
rIO::read(InputFile,OutputFile,m,titleAndComment);
if (OutputFile) {
fprintf(OutputFile,"data is %s\n",InputFileName);
fprintf(OutputFile,"parameter is %s\n",ParameterFileName);
fprintf(OutputFile,"initial is %s\n",InitialFileName);
fprintf(OutputFile,"out is %s\n",OutputFileName);
}
mDIM = m;
rIO::read(InputFile,nBlock);
blockStruct = NULL;
blockStruct = new int[nBlock];
if (blockStruct==NULL) {
rError("Memory exhausted about blockStruct");
}
nBLOCK = nBlock;
bLOCKsTRUCT = blockStruct;
rIO::read(InputFile,nBlock,blockStruct);
nDim = 0;
for (int l=0; l<nBlock; ++l) {
nDim += abs(blockStruct[l]);
}
b.initialize(m);
rIO::read(InputFile,b);
A = new rBlockSparseMatrix[m];
if (A==NULL) {
rError("Memory exhausted about blockStruct");
}
long position = ftell(InputFile);
// C,A must be accessed "twice".
// count numbers of elements of C and A
int* CNonZeroCount = NULL;
CNonZeroCount = new int[nBlock];
if (CNonZeroCount==NULL) {
rError("Memory exhausted about blockStruct");
}
int* ANonZeroCount = NULL;
ANonZeroCount = new int[nBlock*m];
if (ANonZeroCount==NULL) {
rError("Memory exhausted about blockStruct");
}
// initialize C and A
rIO::read(InputFile,m,nBlock,blockStruct,
CNonZeroCount,ANonZeroCount,isDataSparse);
// rMessage(" C and A count over");
C.initialize(nBlock,blockStruct);
for (int l=0; l<nBlock; ++l) {
int size = blockStruct[l];
if (size > 0) {
C.ele[l].initialize(size,size,rSparseMatrix::SPARSE,
CNonZeroCount[l]);
} else {
C.ele[l].initialize(-size,-size,rSparseMatrix::DIAGONAL,
-size);
}
}
for (int k=0; k<m; ++k) {
A[k].initialize(nBlock,blockStruct);
for (int l=0; l<nBlock; ++l) {
int size = blockStruct[l];
if (size > 0) {
A[k].ele[l].initialize(size,size,rSparseMatrix::SPARSE,
ANonZeroCount[k*nBlock+l]);
} else {
A[k].ele[l].initialize(-size,-size,rSparseMatrix::DIAGONAL,
-size);
}
}
}
delete[] CNonZeroCount;
CNonZeroCount = NULL;
delete[] ANonZeroCount;
ANonZeroCount = NULL;
rIO::read(InputFile, C, A, m, nBlock, blockStruct,
position, isDataSparse);
if (InitialFile != NULL && InitialPoint == true) {
// isInitPoint = true;
bool isInitSparse = false;
int len = strlen(InitialFileName);
if (InitialFileName[len-1] == 's'
&& InitialFileName[len-2] == '-') {
isInitSparse = true;
}
initPt.initializeZero(m,nBlock,blockStruct,com);
rIO::read(InitialFile,initPt.xMat,initPt.yVec,initPt.zMat, nBlock,
blockStruct, isInitSparse);
initPt.initializeResetup(m,nBlock,blockStruct,com);
} else {
initPt.initialize(m,nBlock,blockStruct,pARAM.lambdaStar,com);
}
rTimeEnd(FILE_READ_END1);
com.FileRead += rTimeCal(FILE_READ_START1,
FILE_READ_END1);
}
static RGBAImagePtr LoadPNGBuff (unsigned char* fbuffer)
{
png_byte** row_pointers;
png_bytep p_fbuffer;
p_fbuffer = fbuffer;
// the reading glue
// http://www.libpng.org/pub/png/libpng-manual.html
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, user_error_fn, user_warning_fn);
if (!png_ptr)
{
rError() << "libpng error: png_create_read_struct\n";
return RGBAImagePtr();
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
rError() << "libpng error: png_create_info_struct (info_ptr)" << std::endl;
return RGBAImagePtr();
}
png_infop end_info = png_create_info_struct(png_ptr);
if (!end_info)
{
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
rError() << "libpng error: png_create_info_struct (end_info)" << std::endl;
return RGBAImagePtr();
}
// configure the read function
png_set_read_fn(png_ptr, (png_voidp)&p_fbuffer, (png_rw_ptr)&user_read_data);
if (setjmp(png_jmpbuf(png_ptr)))
{
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
return RGBAImagePtr();
}
png_read_info(png_ptr, info_ptr);
int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
int color_type = png_get_color_type(png_ptr, info_ptr);
// we want to treat all images the same way
// The following code transforms grayscale images of less than 8 to 8 bits,
// changes paletted images to RGB, and adds a full alpha channel if there is
// transparency information in a tRNS chunk.
if (color_type == PNG_COLOR_TYPE_PALETTE)
{
png_set_palette_to_rgb(png_ptr);
}
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
{
#if PNG_LIBPNG_VER < 10400
png_set_gray_1_2_4_to_8(png_ptr);
#else
png_set_expand_gray_1_2_4_to_8(png_ptr);
#endif
}
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
{
png_set_tRNS_to_alpha(png_ptr);
}
if (!(color_type & PNG_COLOR_MASK_ALPHA))
{
// Set the background color to draw transparent and alpha images over.
png_color_16 my_background, *image_background;
if (png_get_bKGD(png_ptr, info_ptr, &image_background))
{
png_set_background(png_ptr, image_background, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
}
else
{
png_set_background(png_ptr, &my_background, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
}
// Add alpha byte after each RGB triplet
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
}
// read the sucker in one chunk
png_read_update_info(png_ptr, info_ptr);
color_type = png_get_color_type(png_ptr, info_ptr);
bit_depth = png_get_bit_depth(png_ptr, info_ptr);
int width = png_get_image_width(png_ptr, info_ptr);
int height = png_get_image_height(png_ptr, info_ptr);
// allocate the pixel buffer, and the row pointers
RGBAImagePtr image(new RGBAImage(width, height));
row_pointers = (png_byte**) malloc((height) * sizeof(png_byte*));
for (int i = 0; i < height; i++)
{
row_pointers[i] = (png_byte*)(image->getMipMapPixels(0)) + i * 4 * (width);
}
// actual read
png_read_image(png_ptr, row_pointers);
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end(png_ptr, info_ptr);
/* free up the memory structure */
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
free(row_pointers);
return image;
}
void SoundPlayer::play(ArchiveFile& file) {
// If we're not initialised yet, do it now
if (!_initialised) {
initialise();
}
// Stop any previous playback operations, that might be still active
clearBuffer();
// Retrieve the extension
std::string ext = os::getExtension(file.getName());
if (boost::algorithm::to_lower_copy(ext) == "ogg") {
// Convert the file into a buffer, self-destructs at end of scope
ScopedArchiveBuffer buffer(file);
// This is an OGG Vorbis file, decode it
vorbis_info* vorbisInfo;
OggVorbis_File oggFile;
// Initialise the wrapper class
OggFileStream stream(buffer);
// Setup the callbacks and point them to the helper class
ov_callbacks callbacks;
callbacks.read_func = OggFileStream::oggReadFunc;
callbacks.seek_func = OggFileStream::oggSeekFunc;
callbacks.close_func = OggFileStream::oggCloseFunc;
callbacks.tell_func = OggFileStream::oggTellFunc;
// Open the OGG data stream using the custom callbacks
int res = ov_open_callbacks(static_cast<void*>(&stream), &oggFile,
NULL, 0, callbacks);
if (res == 0) {
// Open successful
// Get some information about the OGG file
vorbisInfo = ov_info(&oggFile, -1);
// Check the number of channels
ALenum format = (vorbisInfo->channels == 1) ? AL_FORMAT_MONO16
: AL_FORMAT_STEREO16;
// Get the sample Rate
ALsizei freq = (vorbisInfo->rate);
//std::cout << "Sample rate is " << freq << "\n";
long bytes;
char smallBuffer[4096];
DecodeBufferPtr largeBuffer(new DecodeBuffer());
do {
int bitStream;
// Read a chunk of decoded data from the vorbis file
bytes = ov_read(&oggFile, smallBuffer, sizeof(smallBuffer),
0, 2, 1, &bitStream);
if (bytes == OV_HOLE) {
rError() << "SoundPlayer: Error decoding OGG: OV_HOLE.\n";
}
else if (bytes == OV_EBADLINK) {
rError() << "SoundPlayer: Error decoding OGG: OV_EBADLINK.\n";
}
else {
// Stuff this into the variable-sized buffer
largeBuffer->insert(largeBuffer->end(), smallBuffer, smallBuffer + bytes);
}
} while (bytes > 0);
// Allocate a new buffer
alGenBuffers(1, &_buffer);
DecodeBuffer& bufferRef = *largeBuffer;
// Upload sound data to buffer
alBufferData(_buffer,
format,
&bufferRef[0],
static_cast<ALsizei>(bufferRef.size()),
freq);
// Clean up the OGG routines
ov_clear(&oggFile);
}
else {
rError() << "SoundPlayer: Error opening OGG file.\n";
}
}
else {
// Must be a wave file
try {
// Create an AL sound buffer directly from the buffer in memory
_buffer = WavFileLoader::LoadFromStream(file.getInputStream());
}
catch (std::runtime_error& e) {
rError() << "SoundPlayer: Error opening WAV file: " << e.what() << std::endl;
_buffer = 0;
}
}
if (_buffer != 0) {
alGenSources(1, &_source);
// Assign the buffer to the source and play it
alSourcei(_source, AL_BUFFER, _buffer);
// greebo: Wait 10 msec. to fix a problem with buffers not being played
// maybe the AL needs time to push the data?
usleep(10000);
alSourcePlay(_source);
// Enable the periodic buffer check, this destructs the buffer
// as soon as the playback has finished
_timer.enable();
}
}
