bool LLLFSThread::Request::processRequest()
{
bool complete = false;
if (mOperation == FILE_READ)
{
llassert(mOffset >= 0);
LLAPRFile infile ;
infile.open(mFileName, LL_APR_RB, LLAPRFile::local);
if (!infile.getFileHandle())
{
llwarns << "LLLFS: Unable to read file: " << mFileName << llendl;
mBytesRead = 0; // fail
return true;
}
S32 off;
if (mOffset < 0)
off = infile.seek(APR_END, 0);
else
off = infile.seek(APR_SET, mOffset);
llassert_always(off >= 0);
mBytesRead = infile.read(mBuffer, mBytes );
complete = true;
infile.close() ;
// llinfos << "LLLFSThread::READ:" << mFileName << " Bytes: " << mBytesRead << llendl;
}
else if (mOperation == FILE_WRITE)
{
apr_int32_t flags = APR_CREATE|APR_WRITE|APR_BINARY;
if (mOffset < 0)
flags |= APR_APPEND;
LLAPRFile outfile ;
outfile.open(mFileName, flags, LLAPRFile::local);
if (!outfile.getFileHandle())
{
llwarns << "LLLFS: Unable to write file: " << mFileName << llendl;
mBytesRead = 0; // fail
return true;
}
if (mOffset >= 0)
{
S32 seek = outfile.seek(APR_SET, mOffset);
if (seek < 0)
{
llwarns << "LLLFS: Unable to write file (seek failed): " << mFileName << llendl;
mBytesRead = 0; // fail
return true;
}
}
mBytesRead = outfile.write(mBuffer, mBytes );
complete = true;
// llinfos << "LLLFSThread::WRITE:" << mFileName << " Bytes: " << mBytesRead << "/" << mBytes << " Offset:" << mOffset << llendl;
}
else
{
llwarns << "LLLFSThread::unknown operation: " << (S32)mOperation << llendl;
}
return complete;
}
void LLObjectBackup::uploadNextAsset()
{
if (mTexturesList.empty())
{
llinfos << "Texture list is empty, moving to rez stage." << llendl;
mCurrentAsset = LLUUID::null;
importFirstObject();
return;
}
updateImportNumbers();
std::list<LLUUID>::iterator iter;
iter = mTexturesList.begin();
LLUUID id = *iter;
mTexturesList.pop_front();
llinfos << "Got texture ID " << id << ": trying to upload" << llendl;
mCurrentAsset = id;
std::string struid;
id.toString(struid);
std::string filename = mFolder + "//" + struid;
LLAssetID uuid;
LLTransactionID tid;
// generate a new transaction ID for this asset
tid.generate();
uuid = tid.makeAssetID(gAgent.getSecureSessionID());
S32 file_size;
LLAPRFile outfile;
outfile.open(filename, LL_APR_RB, LLAPRFile::global, &file_size);
if (outfile.getFileHandle())
{
const S32 buf_size = 65536;
U8 copy_buf[buf_size];
LLVFile file(gVFS, uuid, LLAssetType::AT_TEXTURE, LLVFile::WRITE);
file.setMaxSize(file_size);
while ((file_size = outfile.read(copy_buf, buf_size)))
{
file.write(copy_buf, file_size);
}
outfile.close();
}
else
{
llwarns << "Unable to access output file " << filename << llendl;
uploadNextAsset();
return;
}
myupload_new_resource(tid, LLAssetType::AT_TEXTURE, struid, struid, 0,
LLAssetType::AT_TEXTURE, LLInventoryType::defaultForAssetType(LLAssetType::AT_TEXTURE),
0x0, "Uploaded texture", NULL, NULL);
}
void completedRaw(
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
completedHeader();
if (!isGoodStatus())
{
if (getStatus() == HTTP_NOT_MODIFIED)
{
LL_INFOS("fsdata") << "Got [304] not modified for " << mURL << LL_ENDL;
}
else
{
LL_WARNS("fsdata") << "Error fetching " << mURL << " Status: [" << getStatus() << "]" << LL_ENDL;
}
return;
}
S32 data_size = buffer->countAfter(channels.in(), NULL);
if (data_size <= 0)
{
LL_WARNS("fsdata") << "Received zero data for " << mURL << LL_ENDL;
return;
}
U8* data = new U8[data_size];
buffer->readAfter(channels.in(), NULL, data, data_size);
// basic check for valid data received
LLXMLNodePtr xml_root;
if ( (!LLXMLNode::parseBuffer(data, data_size, xml_root, NULL)) || (xml_root.isNull()) || (!xml_root->hasName("script_library")) )
{
LL_WARNS("fsdata") << "Could not read the script library data from "<< mURL << LL_ENDL;
delete[] data;
data = NULL;
return;
}
LLAPRFile outfile ;
outfile.open(mFilename, LL_APR_WB);
if (!outfile.getFileHandle())
{
LL_WARNS("fsdata") << "Unable to open file for writing: " << mFilename << LL_ENDL;
}
else
{
LL_INFOS("fsdata") << "Saving " << mFilename << LL_ENDL;
outfile.write(data, data_size);
outfile.close() ;
}
delete[] data;
data = NULL;
}
void LLPreviewAnim::exportasdotAnim( void *userdata )
{
LLPreviewAnim* self = (LLPreviewAnim*) userdata;
const LLInventoryItem *item = self->getItem();
//LLVOAvatar* avatar = gAgent.getAvatarObject();
//LLMotion* motion = avatar->findMotion(item->getAssetUUID());
//LLKeyframeMotion* motionp = (LLKeyframeMotion*)motion;
//if (motionp)
{
//U32 size = motionp->getFileSize();
//U8* buffer = new U8[size];
//LLDataPackerBinaryBuffer dp(buffer, size);
//if(motionp->serialize(dp))
{
std::string filename = item->getName() + ".animatn";
LLFilePicker& picker = LLFilePicker::instance();
if(!picker.getSaveFile( LLFilePicker::FFSAVE_ALL, filename.c_str() ) )
{
// User canceled save.
return;
}
std::string name = picker.getFirstFile();
std::string save_filename(name);
LLAPRFile infile ;
infile.open(save_filename.c_str(), LL_APR_WB, LLAPRFile::local);
apr_file_t *fp = infile.getFileHandle();
if(fp)infile.write(self->mAnimBuffer, self->mAnimBufferSize);
infile.close();
}
//delete[] buffer;
}
//whole file imported from onyx thomas shikami gets credit for the exporter
}
// static
LLAssetType::EType LLAssetConverter::convert(std::string src_filename, std::string filename)
{
std::string exten = gDirUtilp->getExtension(src_filename);
LLAssetType::EType asset_type = LLAssetType::AT_NONE;
if (exten.empty())
return LLAssetType::AT_NONE;
else if(exten == "bmp")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_BMP ))
{
return LLAssetType::AT_NONE;
}
}
else if( exten == "tga")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_TGA ))
{
return LLAssetType::AT_NONE;
}
}
else if( exten == "jpg" || exten == "jpeg")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_JPEG ))
{
return LLAssetType::AT_NONE;
}
}
else if( exten == "png")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_PNG ))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "wav")
{
asset_type = LLAssetType::AT_SOUND;
if(encode_vorbis_file(src_filename, filename) != LLVORBISENC_NOERR)
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "ogg")
{
asset_type = LLAssetType::AT_SOUND;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
//else if(exten == "tmp") FIXME
else if (exten == "bvh")
{
asset_type = LLAssetType::AT_ANIMATION;
S32 file_size;
LLAPRFile fp;
fp.open(src_filename, LL_APR_RB, LLAPRFile::global, &file_size);
if(!fp.getFileHandle()) return LLAssetType::AT_NONE;
char* file_buffer = new char[file_size + 1];
if(fp.read(file_buffer, file_size) == 0) //not sure if this is right, gotta check this one
{
fp.close();
delete[] file_buffer;
return LLAssetType::AT_NONE;
}
LLBVHLoader* loaderp = new LLBVHLoader(file_buffer);
if(!loaderp->isInitialized())
{
fp.close();
delete[] file_buffer;
return LLAssetType::AT_NONE;
}
S32 buffer_size = loaderp->getOutputSize();
U8* buffer = new U8[buffer_size];
LLDataPackerBinaryBuffer dp(buffer, buffer_size);
loaderp->serialize(dp);
LLAPRFile apr_file(filename, LL_APR_WB, LLAPRFile::global);
apr_file.write(buffer, buffer_size);
delete[] file_buffer;
delete[] buffer;
fp.close();
apr_file.close();
}
else if (exten == "animatn")
{
asset_type = LLAssetType::AT_ANIMATION;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "jp2" || exten == "j2k" || exten == "j2c")
{
asset_type = LLAssetType::AT_TEXTURE;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "gesture")
{
asset_type = LLAssetType::AT_GESTURE;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "notecard")
{
asset_type = LLAssetType::AT_NOTECARD;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "lsl")
{
asset_type = LLAssetType::AT_LSL_TEXT;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "eyes" || exten == "gloves" || exten == "hair" || exten == "jacket" || exten == "pants" || exten == "shape" || exten == "shirt" || exten == "shoes" || exten == "skin" || exten == "skirt" || exten == "socks" || exten == "underpants" || exten == "undershirt" || exten == "bodypart" || exten == "clothing")
{
asset_type = LLAssetType::AT_CLOTHING;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else
{
llwarns << "Unhandled extension" << llendl;
return LLAssetType::AT_NONE;
}
return asset_type;
}
S32 check_for_invalid_wav_formats(const std::string& in_fname, std::string& error_msg)
{
U16 num_channels = 0;
U32 sample_rate = 0;
U32 bits_per_sample = 0;
U32 physical_file_size = 0;
U32 chunk_length = 0;
U32 raw_data_length = 0;
U32 bytes_per_sec = 0;
BOOL uncompressed_pcm = FALSE;
unsigned char wav_header[44]; /*Flawfinder: ignore*/
error_msg.clear();
// ********************************
LLAPRFile infile ;
infile.open(in_fname,LL_APR_RB);
// ********************************
if (!infile.getFileHandle())
{
error_msg = "CannotUploadSoundFile";
return(LLVORBISENC_SOURCE_OPEN_ERR);
}
infile.read(wav_header, 44);
physical_file_size = infile.seek(APR_END,0);
if (strncmp((char *)&(wav_header[0]),"RIFF",4))
{
error_msg = "SoundFileNotRIFF";
return(LLVORBISENC_WAV_FORMAT_ERR);
}
if (strncmp((char *)&(wav_header[8]),"WAVE",4))
{
error_msg = "SoundFileNotRIFF";
return(LLVORBISENC_WAV_FORMAT_ERR);
}
// parse the chunks
U32 file_pos = 12; // start at the first chunk (usually fmt but not always)
while ((file_pos + 8)< physical_file_size)
{
infile.seek(APR_SET,file_pos);
infile.read(wav_header, 44);
chunk_length = ((U32) wav_header[7] << 24)
+ ((U32) wav_header[6] << 16)
+ ((U32) wav_header[5] << 8)
+ wav_header[4];
if (chunk_length > physical_file_size - file_pos - 4)
{
infile.close();
error_msg = "SoundFileInvalidChunkSize";
return(LLVORBISENC_CHUNK_SIZE_ERR);
}
// llinfos << "chunk found: '" << wav_header[0] << wav_header[1] << wav_header[2] << wav_header[3] << "'" << llendl;
if (!(strncmp((char *)&(wav_header[0]),"fmt ",4)))
{
if ((wav_header[8] == 0x01) && (wav_header[9] == 0x00))
{
uncompressed_pcm = TRUE;
}
num_channels = ((U16) wav_header[11] << 8) + wav_header[10];
sample_rate = ((U32) wav_header[15] << 24)
+ ((U32) wav_header[14] << 16)
+ ((U32) wav_header[13] << 8)
+ wav_header[12];
bits_per_sample = ((U16) wav_header[23] << 8) + wav_header[22];
bytes_per_sec = ((U32) wav_header[19] << 24)
+ ((U32) wav_header[18] << 16)
+ ((U32) wav_header[17] << 8)
+ wav_header[16];
}
else if (!(strncmp((char *)&(wav_header[0]),"data",4)))
{
raw_data_length = chunk_length;
}
file_pos += (chunk_length + 8);
chunk_length = 0;
}
// ****************
infile.close();
// ****************
if (!uncompressed_pcm)
{
error_msg = "SoundFileNotPCM";
return(LLVORBISENC_PCM_FORMAT_ERR);
}
if ((num_channels < 1) || (num_channels > LLVORBIS_CLIP_MAX_CHANNELS))
{
error_msg = "SoundFileInvalidChannelCount";
return(LLVORBISENC_MULTICHANNEL_ERR);
}
if (sample_rate != LLVORBIS_CLIP_SAMPLE_RATE)
{
error_msg = "SoundFileInvalidSampleRate";
return(LLVORBISENC_UNSUPPORTED_SAMPLE_RATE);
}
if ((bits_per_sample != 16) && (bits_per_sample != 8))
{
error_msg = "SoundFileInvalidWordSize";
return(LLVORBISENC_UNSUPPORTED_WORD_SIZE);
}
if (!raw_data_length)
{
error_msg = "SoundFileInvalidHeader";
return(LLVORBISENC_CLIP_TOO_LONG);
}
F32 clip_length = (F32)raw_data_length/(F32)bytes_per_sec;
if (clip_length > LLVORBIS_CLIP_MAX_TIME)
{
error_msg = "SoundFileInvalidTooLong";
return(LLVORBISENC_CLIP_TOO_LONG);
}
return(LLVORBISENC_NOERR);
}
//------------------------------------------------------------------------
// LLBVHLoader::loadTranslationTable()
//------------------------------------------------------------------------
ELoadStatus LLBVHLoader::loadTranslationTable(const char *fileName)
{
mLineNumber = 0;
mTranslations.clear();
mConstraints.clear();
//--------------------------------------------------------------------
// open file
//--------------------------------------------------------------------
std::string path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,fileName);
LLAPRFile infile ;
infile.open(path, LL_APR_R);
apr_file_t *fp = infile.getFileHandle();
if (!fp)
return E_ST_NO_XLT_FILE;
llinfos << "NOTE: Loading translation table: " << fileName << llendl;
//--------------------------------------------------------------------
// register file to be closed on function exit
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// load header
//--------------------------------------------------------------------
if ( ! getLine(fp) )
return E_ST_EOF;
if ( strncmp(mLine, "Translations 1.0", 16) )
return E_ST_NO_XLT_HEADER;
//--------------------------------------------------------------------
// load data one line at a time
//--------------------------------------------------------------------
BOOL loadingGlobals = FALSE;
Translation *trans = NULL;
while ( getLine(fp) )
{
//----------------------------------------------------------------
// check the 1st token on the line to determine if it's empty or a comment
//----------------------------------------------------------------
char token[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %127s", token) != 1 ) /* Flawfinder: ignore */
continue;
if (token[0] == '#')
continue;
//----------------------------------------------------------------
// check if a [jointName] or [GLOBALS] was specified.
//----------------------------------------------------------------
if (token[0] == '[')
{
char name[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " [%127[^]]", name) != 1 )
return E_ST_NO_XLT_NAME;
if (strcmp(name, "GLOBALS")==0)
{
loadingGlobals = TRUE;
continue;
}
else
{
loadingGlobals = FALSE;
Translation &newTrans = mTranslations[ name ];
trans = &newTrans;
continue;
}
}
//----------------------------------------------------------------
// check for optional emote
//----------------------------------------------------------------
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "emote")==0)
{
char emote_str[1024]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %1023s", emote_str) != 1 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_EMOTE;
mEmoteName.assign( emote_str );
// llinfos << "NOTE: Emote: " << mEmoteName.c_str() << llendl;
continue;
}
//----------------------------------------------------------------
// check for global priority setting
//----------------------------------------------------------------
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "priority")==0)
{
S32 priority;
if ( sscanf(mLine, " %*s = %d", &priority) != 1 )
return E_ST_NO_XLT_PRIORITY;
mPriority = priority;
// llinfos << "NOTE: Priority: " << mPriority << llendl;
continue;
}
//----------------------------------------------------------------
// check for global loop setting
//----------------------------------------------------------------
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "loop")==0)
{
char trueFalse[128]; /* Flawfinder: ignore */
trueFalse[0] = '\0';
F32 loop_in = 0.f;
F32 loop_out = 1.f;
if ( sscanf(mLine, " %*s = %f %f", &loop_in, &loop_out) == 2 )
{
mLoop = TRUE;
}
else if ( sscanf(mLine, " %*s = %127s", trueFalse) == 1 ) /* Flawfinder: ignore */
{
mLoop = (LLStringUtil::compareInsensitive(trueFalse, "true")==0);
}
else
{
return E_ST_NO_XLT_LOOP;
}
mLoopInPoint = loop_in * mDuration;
mLoopOutPoint = loop_out * mDuration;
continue;
}
//----------------------------------------------------------------
// check for global easeIn setting
//----------------------------------------------------------------
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "easein")==0)
{
F32 duration;
char type[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %f %127s", &duration, type) != 2 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_EASEIN;
mEaseIn = duration;
continue;
}
//----------------------------------------------------------------
// check for global easeOut setting
//----------------------------------------------------------------
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "easeout")==0)
{
F32 duration;
char type[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %f %127s", &duration, type) != 2 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_EASEOUT;
mEaseOut = duration;
continue;
}
//----------------------------------------------------------------
// check for global handMorph setting
//----------------------------------------------------------------
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "hand")==0)
{
S32 handMorph;
if (sscanf(mLine, " %*s = %d", &handMorph) != 1)
return E_ST_NO_XLT_HAND;
mHand = handMorph;
continue;
}
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "constraint")==0)
{
Constraint constraint;
// try reading optional target direction
if(sscanf( /* Flawfinder: ignore */
mLine,
" %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f %f %f %f",
&constraint.mChainLength,
&constraint.mEaseInStart,
&constraint.mEaseInStop,
&constraint.mEaseOutStart,
&constraint.mEaseOutStop,
constraint.mSourceJointName,
&constraint.mSourceOffset.mV[VX],
&constraint.mSourceOffset.mV[VY],
&constraint.mSourceOffset.mV[VZ],
constraint.mTargetJointName,
&constraint.mTargetOffset.mV[VX],
&constraint.mTargetOffset.mV[VY],
&constraint.mTargetOffset.mV[VZ],
&constraint.mTargetDir.mV[VX],
&constraint.mTargetDir.mV[VY],
&constraint.mTargetDir.mV[VZ]) != 16)
{
if(sscanf( /* Flawfinder: ignore */
mLine,
" %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f",
&constraint.mChainLength,
&constraint.mEaseInStart,
&constraint.mEaseInStop,
&constraint.mEaseOutStart,
&constraint.mEaseOutStop,
constraint.mSourceJointName,
&constraint.mSourceOffset.mV[VX],
&constraint.mSourceOffset.mV[VY],
&constraint.mSourceOffset.mV[VZ],
constraint.mTargetJointName,
&constraint.mTargetOffset.mV[VX],
&constraint.mTargetOffset.mV[VY],
&constraint.mTargetOffset.mV[VZ]) != 13)
{
return E_ST_NO_CONSTRAINT;
}
}
else
{
// normalize direction
if (!constraint.mTargetDir.isExactlyZero())
{
constraint.mTargetDir.normVec();
}
}
constraint.mConstraintType = CONSTRAINT_TYPE_POINT;
mConstraints.push_back(constraint);
continue;
}
if (loadingGlobals && LLStringUtil::compareInsensitive(token, "planar_constraint")==0)
{
Constraint constraint;
// try reading optional target direction
if(sscanf( /* Flawfinder: ignore */
mLine,
" %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f %f %f %f",
&constraint.mChainLength,
&constraint.mEaseInStart,
&constraint.mEaseInStop,
&constraint.mEaseOutStart,
&constraint.mEaseOutStop,
constraint.mSourceJointName,
&constraint.mSourceOffset.mV[VX],
&constraint.mSourceOffset.mV[VY],
&constraint.mSourceOffset.mV[VZ],
constraint.mTargetJointName,
&constraint.mTargetOffset.mV[VX],
&constraint.mTargetOffset.mV[VY],
&constraint.mTargetOffset.mV[VZ],
&constraint.mTargetDir.mV[VX],
&constraint.mTargetDir.mV[VY],
&constraint.mTargetDir.mV[VZ]) != 16)
{
if(sscanf( /* Flawfinder: ignore */
mLine,
" %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f",
&constraint.mChainLength,
&constraint.mEaseInStart,
&constraint.mEaseInStop,
&constraint.mEaseOutStart,
&constraint.mEaseOutStop,
constraint.mSourceJointName,
&constraint.mSourceOffset.mV[VX],
&constraint.mSourceOffset.mV[VY],
&constraint.mSourceOffset.mV[VZ],
constraint.mTargetJointName,
&constraint.mTargetOffset.mV[VX],
&constraint.mTargetOffset.mV[VY],
&constraint.mTargetOffset.mV[VZ]) != 13)
{
return E_ST_NO_CONSTRAINT;
}
}
else
{
// normalize direction
if (!constraint.mTargetDir.isExactlyZero())
{
constraint.mTargetDir.normVec();
}
}
constraint.mConstraintType = CONSTRAINT_TYPE_PLANE;
mConstraints.push_back(constraint);
continue;
}
//----------------------------------------------------------------
// at this point there must be a valid trans pointer
//----------------------------------------------------------------
if ( ! trans )
return E_ST_NO_XLT_NAME;
//----------------------------------------------------------------
// check for ignore flag
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "ignore")==0 )
{
char trueFalse[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %127s", trueFalse) != 1 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_IGNORE;
trans->mIgnore = (LLStringUtil::compareInsensitive(trueFalse, "true")==0);
continue;
}
//----------------------------------------------------------------
// check for relativepos flag
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "relativepos")==0 )
{
F32 x, y, z;
char relpos[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %f %f %f", &x, &y, &z) == 3 )
{
trans->mRelativePosition.setVec( x, y, z );
}
else if ( sscanf(mLine, " %*s = %127s", relpos) == 1 ) /* Flawfinder: ignore */
{
if ( LLStringUtil::compareInsensitive(relpos, "firstkey")==0 )
{
trans->mRelativePositionKey = TRUE;
}
else
{
return E_ST_NO_XLT_RELATIVE;
}
}
else
{
return E_ST_NO_XLT_RELATIVE;
}
continue;
}
//----------------------------------------------------------------
// check for relativerot flag
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "relativerot")==0 )
{
//F32 x, y, z;
char relpos[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %127s", relpos) == 1 ) /* Flawfinder: ignore */
{
if ( LLStringUtil::compareInsensitive(relpos, "firstkey")==0 )
{
trans->mRelativeRotationKey = TRUE;
}
else
{
return E_ST_NO_XLT_RELATIVE;
}
}
else
{
return E_ST_NO_XLT_RELATIVE;
}
continue;
}
//----------------------------------------------------------------
// check for outname value
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "outname")==0 )
{
char outName[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %127s", outName) != 1 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_OUTNAME;
trans->mOutName = outName;
continue;
}
//----------------------------------------------------------------
// check for frame matrix value
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "frame")==0 )
{
LLMatrix3 fm;
if ( sscanf(mLine, " %*s = %f %f %f, %f %f %f, %f %f %f",
&fm.mMatrix[0][0], &fm.mMatrix[0][1], &fm.mMatrix[0][2],
&fm.mMatrix[1][0], &fm.mMatrix[1][1], &fm.mMatrix[1][2],
&fm.mMatrix[2][0], &fm.mMatrix[2][1], &fm.mMatrix[2][2] ) != 9 )
return E_ST_NO_XLT_MATRIX;
trans->mFrameMatrix = fm;
continue;
}
//----------------------------------------------------------------
// check for offset matrix value
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "offset")==0 )
{
LLMatrix3 om;
if ( sscanf(mLine, " %*s = %f %f %f, %f %f %f, %f %f %f",
&om.mMatrix[0][0], &om.mMatrix[0][1], &om.mMatrix[0][2],
&om.mMatrix[1][0], &om.mMatrix[1][1], &om.mMatrix[1][2],
&om.mMatrix[2][0], &om.mMatrix[2][1], &om.mMatrix[2][2] ) != 9 )
return E_ST_NO_XLT_MATRIX;
trans->mOffsetMatrix = om;
continue;
}
//----------------------------------------------------------------
// check for mergeparent value
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "mergeparent")==0 )
{
char mergeParentName[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %127s", mergeParentName) != 1 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_MERGEPARENT;
trans->mMergeParentName = mergeParentName;
continue;
}
//----------------------------------------------------------------
// check for mergechild value
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "mergechild")==0 )
{
char mergeChildName[128]; /* Flawfinder: ignore */
if ( sscanf(mLine, " %*s = %127s", mergeChildName) != 1 ) /* Flawfinder: ignore */
return E_ST_NO_XLT_MERGECHILD;
trans->mMergeChildName = mergeChildName;
continue;
}
//----------------------------------------------------------------
// check for per-joint priority
//----------------------------------------------------------------
if ( LLStringUtil::compareInsensitive(token, "priority")==0 )
{
S32 priority;
if ( sscanf(mLine, " %*s = %d", &priority) != 1 )
return E_ST_NO_XLT_PRIORITY;
trans->mPriorityModifier = priority;
continue;
}
}
infile.close() ;
return E_ST_OK;
}
//-----------------------------------------------------------------------------
// loadMotions()
//-----------------------------------------------------------------------------
BOOL LLKeyframeMotionParam::loadMotions()
{
//-------------------------------------------------------------------------
// Load named file by concatenating the character prefix with the motion name.
// Load data into a buffer to be parsed.
//-------------------------------------------------------------------------
std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix())
+ "_" + getName() + ".llp";
//-------------------------------------------------------------------------
// open the file
//-------------------------------------------------------------------------
S32 fileSize = 0;
LLAPRFile infile ;
infile.open(path, LL_APR_R, NULL, &fileSize);
apr_file_t* fp = infile.getFileHandle() ;
if (!fp || fileSize == 0)
{
llinfos << "ERROR: can't open: " << path << llendl;
return FALSE;
}
// allocate a text buffer
char *text = new char[ fileSize+1 ];
if ( !text )
{
llinfos << "ERROR: can't allocated keyframe text buffer." << llendl;
return FALSE;
}
//-------------------------------------------------------------------------
// load data from file into buffer
//-------------------------------------------------------------------------
bool error = false;
char *p = text;
while ( 1 )
{
if (apr_file_eof(fp) == APR_EOF)
{
break;
}
if (apr_file_gets(p, 1024, fp) != APR_SUCCESS)
{
error = true;
break;
}
while ( *(++p) )
;
}
//-------------------------------------------------------------------------
// close the file
//-------------------------------------------------------------------------
infile.close();
//-------------------------------------------------------------------------
// check for error
//-------------------------------------------------------------------------
llassert( p <= (text+fileSize) );
if ( error )
{
llinfos << "ERROR: error while reading from " << path << llendl;
delete [] text;
return FALSE;
}
llinfos << "Loading parametric keyframe data for: " << getName() << llendl;
//-------------------------------------------------------------------------
// parse the text and build keyframe data structures
//-------------------------------------------------------------------------
p = text;
S32 num;
char strA[80]; /* Flawfinder: ignore */
char strB[80]; /* Flawfinder: ignore */
F32 floatA = 0.0f;
//-------------------------------------------------------------------------
// get priority
//-------------------------------------------------------------------------
BOOL isFirstMotion = TRUE;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
while(1)
{
if (num == 0 || num == EOF) break;
if ((num != 3))
{
llinfos << "WARNING: can't read parametric motion" << llendl;
delete [] text;
return FALSE;
}
addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA);
if (isFirstMotion)
{
isFirstMotion = FALSE;
setDefaultKeyframeMotion(strA);
}
p = strstr(p, "\n");
if (!p)
{
break;
}
p++;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
}
delete [] text;
return TRUE;
}
//-----------------------------------------------------------------------------
// loadBVH()
//-----------------------------------------------------------------------------
BOOL LLFloaterAnimPreview::loadBVH()
{
LLKeyframeMotion* motionp = NULL;
LLBVHLoader* loaderp = NULL;
mPlayButton->setVisible(true);
mPauseButton->setVisible(false);
getChildView("bad_animation_text")->setVisible(FALSE);
std::string exten = gDirUtilp->getExtension(mFilename);
if (exten == "bvh")
{
// loading a bvh file
// now load bvh file
S32 file_size;
LLAPRFile infile ;
infile.open(mFilenameAndPath, LL_APR_RB, NULL, &file_size);
if (!infile.getFileHandle())
{
llwarns << "Can't open BVH file:" << mFilename << llendl;
}
else
{
char* file_buffer;
file_buffer = new char[file_size + 1];
if (file_size == infile.read(file_buffer, file_size))
{
file_buffer[file_size] = '\0';
llinfos << "Loading BVH file " << mFilename << llendl;
ELoadStatus load_status = E_ST_OK;
S32 line_number = 0;
loaderp = new LLBVHLoader(file_buffer, load_status, line_number);
std::string status = getString(STATUS[load_status]);
if(load_status == E_ST_NO_XLT_FILE)
{
llwarns << "NOTE: No translation table found." << llendl;
}
else
{
llwarns << "ERROR: [line: " << line_number << "] " << status << llendl;
}
}
infile.close() ;
delete[] file_buffer;
}
}
if (loaderp && loaderp->isInitialized() && loaderp->getDuration() <= MAX_ANIM_DURATION)
{
// generate unique id for this motion
mTransactionID.generate();
mMotionID = mTransactionID.makeAssetID(gAgent.getSecureSessionID());
mAnimPreview = new LLPreviewAnimation(256, 256);
// motion will be returned, but it will be in a load-pending state, as this is a new motion
// this motion will not request an asset transfer until next update, so we have a chance to
// load the keyframe data locally
motionp = (LLKeyframeMotion*)mAnimPreview->getPreviewAvatar()->createMotion(mMotionID);
// create data buffer for keyframe initialization
S32 buffer_size = loaderp->getOutputSize();
U8* buffer = new U8[buffer_size];
LLDataPackerBinaryBuffer dp(buffer, buffer_size);
// pass animation data through memory buffer
loaderp->serialize(dp);
dp.reset();
BOOL success = motionp && motionp->deserialize(dp);
delete []buffer;
if (success)
{
setAnimCallbacks() ;
const LLBBoxLocal &pelvis_bbox = motionp->getPelvisBBox();
LLVector3 temp = pelvis_bbox.getCenter();
// only consider XY?
//temp.mV[VZ] = 0.f;
F32 pelvis_offset = temp.magVec();
temp = pelvis_bbox.getExtent();
//temp.mV[VZ] = 0.f;
F32 pelvis_max_displacement = pelvis_offset + (temp.magVec() * 0.5f) + 1.f;
F32 camera_zoom = LLViewerCamera::getInstance()->getDefaultFOV() / (2.f * atan(pelvis_max_displacement / PREVIEW_CAMERA_DISTANCE));
mAnimPreview->setZoom(camera_zoom);
motionp->setName(getChild<LLUICtrl>("name_form")->getValue().asString());
mAnimPreview->getPreviewAvatar()->startMotion(mMotionID);
getChild<LLSlider>("playback_slider")->setMinValue(0.0);
getChild<LLSlider>("playback_slider")->setMaxValue(1.0);
getChild<LLUICtrl>("loop_check")->setValue(LLSD(motionp->getLoop()));
getChild<LLUICtrl>("loop_in_point")->setValue(LLSD(motionp->getLoopIn() / motionp->getDuration() * 100.f));
getChild<LLUICtrl>("loop_out_point")->setValue(LLSD(motionp->getLoopOut() / motionp->getDuration() * 100.f));
getChild<LLUICtrl>("priority")->setValue(LLSD((F32)motionp->getPriority()));
getChild<LLUICtrl>("hand_pose_combo")->setValue(LLHandMotion::getHandPoseName(motionp->getHandPose()));
getChild<LLUICtrl>("ease_in_time")->setValue(LLSD(motionp->getEaseInDuration()));
getChild<LLUICtrl>("ease_out_time")->setValue(LLSD(motionp->getEaseOutDuration()));
setEnabled(TRUE);
std::string seconds_string;
seconds_string = llformat(" - %.2f seconds", motionp->getDuration());
setTitle(mFilename + std::string(seconds_string));
}
else
{
mAnimPreview = NULL;
mMotionID.setNull();
getChild<LLUICtrl>("bad_animation_text")->setValue(getString("failed_to_initialize"));
}
}
else
{
if ( loaderp )
{
if (loaderp->getDuration() > MAX_ANIM_DURATION)
{
LLUIString out_str = getString("anim_too_long");
out_str.setArg("[LENGTH]", llformat("%.1f", loaderp->getDuration()));
out_str.setArg("[MAX_LENGTH]", llformat("%.1f", MAX_ANIM_DURATION));
getChild<LLUICtrl>("bad_animation_text")->setValue(out_str.getString());
}
else
{
LLUIString out_str = getString("failed_file_read");
out_str.setArg("[STATUS]", getString(STATUS[loaderp->getStatus()]));
getChild<LLUICtrl>("bad_animation_text")->setValue(out_str.getString());
}
}
//setEnabled(FALSE);
mMotionID.setNull();
mAnimPreview = NULL;
}
refresh();
delete loaderp;
return TRUE;
}
LLAssetType::EType LLAssetConverter::convert(std::string src_filename, std::string filename)
{
std::string exten = gDirUtilp->getExtension(src_filename);
LLAssetType::EType asset_type = LLAssetType::AT_NONE;
if (exten.empty())
return LLAssetType::AT_NONE;
else if(exten == "bmp")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerTextureList::createUploadFile(src_filename,
filename,
IMG_CODEC_BMP ))
{
return LLAssetType::AT_NONE;
}
}
else if( exten == "tga")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerTextureList::createUploadFile(src_filename,
filename,
IMG_CODEC_TGA ))
{
return LLAssetType::AT_NONE;
}
}
else if( exten == "jpg" || exten == "jpeg")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerTextureList::createUploadFile(src_filename,
filename,
IMG_CODEC_JPEG ))
{
return LLAssetType::AT_NONE;
}
}
else if( exten == "png")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerTextureList::createUploadFile(src_filename,
filename,
IMG_CODEC_PNG ))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "wav")
{
asset_type = LLAssetType::AT_SOUND;
if(encode_vorbis_file(src_filename, filename) != LLVORBISENC_NOERR)
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "ogg")
{
asset_type = LLAssetType::AT_SOUND;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
//else if(exten == "tmp") FIXME
else if (exten == "bvh")
{
asset_type = LLAssetType::AT_ANIMATION;
S32 file_size;
LLAPRFile fp;
fp.open(src_filename, LL_APR_RB, LLAPRFile::global, &file_size);
if(!fp.getFileHandle()) return LLAssetType::AT_NONE;
char* file_buffer = new char[file_size + 1];
ELoadStatus load_status = E_ST_OK;
S32 line_number = 0;
LLBVHLoader* loaderp = new LLBVHLoader(file_buffer, load_status, line_number);
if(load_status == E_ST_NO_XLT_FILE)
{
llwarns << "NOTE: No translation table found." << llendl;
}
else
{
llwarns << "ERROR: [line: " << line_number << "] " << STATUS[load_status].c_str() << llendl;
}
S32 buffer_size = loaderp->getOutputSize();
U8* buffer = new U8[buffer_size];
LLDataPackerBinaryBuffer dp(buffer, buffer_size);
loaderp->serialize(dp);
LLAPRFile apr_file(filename, LL_APR_WB, LLAPRFile::global);
apr_file.write(buffer, buffer_size);
delete[] file_buffer;
delete[] buffer;
fp.close();
apr_file.close();
}
else if (exten == "animatn")
{
asset_type = LLAssetType::AT_ANIMATION;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "jp2" || exten == "j2k" || exten == "j2c")
{
asset_type = LLAssetType::AT_TEXTURE;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "gesture")
{
asset_type = LLAssetType::AT_GESTURE;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "notecard")
{
asset_type = LLAssetType::AT_NOTECARD;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "lsl")
{
asset_type = LLAssetType::AT_LSL_TEXT;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else if(exten == "eyes" || exten == "gloves" || exten == "hair" || exten == "jacket" || exten == "pants" || exten == "shape" || exten == "shirt" || exten == "shoes" || exten == "skin" || exten == "skirt" || exten == "socks" || exten == "underpants" || exten == "undershirt" || exten == "bodypart" || exten == "clothing" || exten == "physics")
{
asset_type = LLAssetType::AT_CLOTHING;
if(!copyFile(src_filename, filename))
{
return LLAssetType::AT_NONE;
}
}
else
{
llwarns << "Unhandled extension" << llendl;
return LLAssetType::AT_NONE;
}
return asset_type;
}
//-----------------------------------------------------------------------------
// loadMotions()
//-----------------------------------------------------------------------------
BOOL LLKeyframeMotionParam::loadMotions()
{
//-------------------------------------------------------------------------
// Load named file by concatenating the character prefix with the motion name.
// Load data into a buffer to be parsed.
//-------------------------------------------------------------------------
//std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix())
// + "_" + getName() + ".llp";
//RN: deprecated unused reference to "motion" directory
std::string path;
//-------------------------------------------------------------------------
// open the file
//-------------------------------------------------------------------------
S32 fileSize = 0;
LLAPRFile infile ;
infile.open(path, LL_APR_R, NULL, &fileSize);
// <FS:ND> Remove LLVolatileAPRPool/apr_file_t and use FILE* instead
// apr_file_t* fp = infile.getFileHandle() ;
LLAPRFile::tFiletype* fp = infile.getFileHandle() ;
// </FS:ND>
if (!fp || fileSize == 0)
{
LL_INFOS() << "ERROR: can't open: " << path << LL_ENDL;
return FALSE;
}
// allocate a text buffer
std::vector<char> text(fileSize+1);
//-------------------------------------------------------------------------
// load data from file into buffer
//-------------------------------------------------------------------------
bool error = false;
char *p = &text[0];
while ( 1 )
{
if (apr_file_eof(fp) == APR_EOF)
{
break;
}
if (apr_file_gets(p, 1024, fp) != APR_SUCCESS)
{
error = true;
break;
}
while ( *(++p) )
;
}
//-------------------------------------------------------------------------
// close the file
//-------------------------------------------------------------------------
infile.close();
//-------------------------------------------------------------------------
// check for error
//-------------------------------------------------------------------------
llassert( p <= (&text[0] + fileSize) );
if ( error )
{
LL_INFOS() << "ERROR: error while reading from " << path << LL_ENDL;
return FALSE;
}
LL_INFOS() << "Loading parametric keyframe data for: " << getName() << LL_ENDL;
//-------------------------------------------------------------------------
// parse the text and build keyframe data structures
//-------------------------------------------------------------------------
p = &text[0];
S32 num;
char strA[80]; /* Flawfinder: ignore */
char strB[80]; /* Flawfinder: ignore */
F32 floatA = 0.0f;
//-------------------------------------------------------------------------
// get priority
//-------------------------------------------------------------------------
BOOL isFirstMotion = TRUE;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
while(1)
{
if (num == 0 || num == EOF) break;
if ((num != 3))
{
LL_INFOS() << "WARNING: can't read parametric motion" << LL_ENDL;
return FALSE;
}
addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA);
if (isFirstMotion)
{
isFirstMotion = FALSE;
setDefaultKeyframeMotion(strA);
}
p = strstr(p, "\n");
if (!p)
{
break;
}
p++;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
}
return TRUE;
}
//-----------------------------------------------------------------------------
// postBuild()
//-----------------------------------------------------------------------------
BOOL LLFloaterAnimPreview::postBuild()
{
LLRect r;
LLKeyframeMotion* motionp = NULL;
LLBVHLoader* loaderp = NULL;
if (!LLFloaterNameDesc::postBuild())
{
return FALSE;
}
childSetCommitCallback("name_form", onCommitName, this);
childSetLabelArg("ok_btn", "[AMOUNT]", llformat("%d",sUploadAmount));
childSetAction("ok_btn", onBtnOK, this);
setDefaultBtn();
mPreviewRect.set(PREVIEW_HPAD,
PREVIEW_TEXTURE_HEIGHT,
getRect().getWidth() - PREVIEW_HPAD,
PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
mPreviewImageRect.set(0.f, 1.f, 1.f, 0.f);
S32 y = mPreviewRect.mTop + BTN_HEIGHT;
S32 btn_left = PREVIEW_HPAD;
r.set( btn_left, y, btn_left + 32, y - BTN_HEIGHT );
mPlayButton = getChild<LLButton>( "play_btn");
if (!mPlayButton)
{
mPlayButton = new LLButton(std::string("play_btn"), LLRect(0,0,0,0));
}
mPlayButton->setClickedCallback(onBtnPlay);
mPlayButton->setCallbackUserData(this);
mPlayButton->setImages(std::string("button_anim_play.tga"),
std::string("button_anim_play_selected.tga"));
mPlayButton->setDisabledImages(LLStringUtil::null,LLStringUtil::null);
mPlayButton->setScaleImage(TRUE);
mStopButton = getChild<LLButton>( "stop_btn");
if (!mStopButton)
{
mStopButton = new LLButton(std::string("stop_btn"), LLRect(0,0,0,0));
}
mStopButton->setClickedCallback(onBtnStop);
mStopButton->setCallbackUserData(this);
mStopButton->setImages(std::string("button_anim_stop.tga"),
std::string("button_anim_stop_selected.tga"));
mStopButton->setDisabledImages(LLStringUtil::null,LLStringUtil::null);
mStopButton->setScaleImage(TRUE);
r.set(r.mRight + PREVIEW_HPAD, y, getRect().getWidth() - PREVIEW_HPAD, y - BTN_HEIGHT);
//childSetCommitCallback("playback_slider", onSliderMove, this);
childHide("bad_animation_text");
//childSetCommitCallback("preview_base_anim", onCommitBaseAnim, this);
//childSetValue("preview_base_anim", "Standing");
//childSetCommitCallback("priority", onCommitPriority, this);
//childSetCommitCallback("loop_check", onCommitLoop, this);
//childSetCommitCallback("loop_in_point", onCommitLoopIn, this);
//childSetValidate("loop_in_point", validateLoopIn);
//childSetCommitCallback("loop_out_point", onCommitLoopOut, this);
//childSetValidate("loop_out_point", validateLoopOut);
//childSetCommitCallback("hand_pose_combo", onCommitHandPose, this);
//childSetCommitCallback("emote_combo", onCommitEmote, this);
//childSetValue("emote_combo", "[None]");
//childSetCommitCallback("ease_in_time", onCommitEaseIn, this);
//childSetValidate("ease_in_time", validateEaseIn);
//childSetCommitCallback("ease_out_time", onCommitEaseOut, this);
//childSetValidate("ease_out_time", validateEaseOut);
std::string exten = gDirUtilp->getExtension(mFilename);
if (exten == "bvh")
{
// loading a bvh file
// now load bvh file
S32 file_size;
LLAPRFile infile ;
infile.open(mFilenameAndPath, LL_APR_RB, LLAPRFile::global, &file_size);
if (!infile.getFileHandle())
{
llwarns << "Can't open BVH file:" << mFilename << llendl;
}
else
{
char* file_buffer;
file_buffer = new char[file_size + 1];
if (file_size == infile.read(file_buffer, file_size))
{
file_buffer[file_size] = '\0';
llinfos << "Loading BVH file " << mFilename << llendl;
loaderp = new LLBVHLoader(file_buffer);
}
infile.close() ;
delete[] file_buffer;
}
}
if (loaderp && loaderp->isInitialized() && loaderp->getDuration() <= MAX_ANIM_DURATION)
{
// generate unique id for this motion
mTransactionID.generate();
mMotionID = mTransactionID.makeAssetID(gAgent.getSecureSessionID());
mAnimPreview = new LLPreviewAnimation(256, 256);
// motion will be returned, but it will be in a load-pending state, as this is a new motion
// this motion will not request an asset transfer until next update, so we have a chance to
// load the keyframe data locally
motionp = (LLKeyframeMotion*)mAnimPreview->getDummyAvatar()->createMotion(mMotionID);
// create data buffer for keyframe initialization
S32 buffer_size = loaderp->getOutputSize();
U8* buffer = new U8[buffer_size];
LLDataPackerBinaryBuffer dp(buffer, buffer_size);
// pass animation data through memory buffer
loaderp->serialize(dp);
dp.reset();
BOOL success = motionp && motionp->deserialize(dp);
delete []buffer;
if (success)
{
setAnimCallbacks() ;
const LLBBoxLocal &pelvis_bbox = motionp->getPelvisBBox();
LLVector3 temp = pelvis_bbox.getCenter();
// only consider XY?
//temp.mV[VZ] = 0.f;
F32 pelvis_offset = temp.magVec();
temp = pelvis_bbox.getExtent();
//temp.mV[VZ] = 0.f;
F32 pelvis_max_displacement = pelvis_offset + (temp.magVec() * 0.5f) + 1.f;
F32 camera_zoom = LLViewerCamera::getInstance()->getDefaultFOV() / (2.f * atan(pelvis_max_displacement / PREVIEW_CAMERA_DISTANCE));
mAnimPreview->setZoom(camera_zoom);
motionp->setName(childGetValue("name_form").asString());
mAnimPreview->getDummyAvatar()->startMotion(mMotionID);
childSetMinValue("playback_slider", 0.0);
childSetMaxValue("playback_slider", 1.0);
childSetValue("loop_check", LLSD(motionp->getLoop()));
childSetValue("loop_in_point", LLSD(motionp->getLoopIn() / motionp->getDuration() * 100.f));
childSetValue("loop_out_point", LLSD(motionp->getLoopOut() / motionp->getDuration() * 100.f));
childSetValue("priority", LLSD((F32)motionp->getPriority()));
childSetValue("hand_pose_combo", LLHandMotion::getHandPoseName(motionp->getHandPose()));
childSetValue("ease_in_time", LLSD(motionp->getEaseInDuration()));
childSetValue("ease_out_time", LLSD(motionp->getEaseOutDuration()));
setEnabled(TRUE);
std::string seconds_string;
seconds_string = llformat(" - %.2f seconds", motionp->getDuration());
setTitle(mFilename + std::string(seconds_string));
}
else
{
delete mAnimPreview;
mAnimPreview = NULL;
mMotionID.setNull();
childSetValue("bad_animation_text", getString("failed_to_initialize"));
}
}
else
{
if ( loaderp )
{
if (loaderp->getDuration() > MAX_ANIM_DURATION)
{
LLUIString out_str = getString("anim_too_long");
out_str.setArg("[LENGTH]", llformat("%.1f", loaderp->getDuration()));
out_str.setArg("[MAX_LENGTH]", llformat("%.1f", MAX_ANIM_DURATION));
childSetValue("bad_animation_text", out_str.getString());
}
else
{
LLUIString out_str = getString("failed_file_read");
out_str.setArg("[STATUS]", loaderp->getStatus()); // *TODO:Translate
childSetValue("bad_animation_text", out_str.getString());
}
}
//setEnabled(FALSE);
mMotionID.setNull();
mAnimPreview = NULL;
}
refresh();
delete loaderp;
return TRUE;
}
void primbackup::upload_next_asset()
{
if(textures.empty())
{
llinfos<<" Texture list is empty, moving to rez statge"<< llendl;
current_asset=LLUUID::null;
import_object1a();
return;
}
this->updateimportnumbers();
std::list<LLUUID>::iterator iter;
iter=textures.begin();
LLUUID id=(*iter);
textures.pop_front();
llinfos<<"Got texture ID "<<id<< "trying to upload"<<llendl;
current_asset=id;
std::string struid;
id.toString(struid);
std::string filename=folder+"//"+struid;
LLAssetID uuid;
LLTransactionID tid;
// gen a new transaction ID for this asset
tid.generate();
uuid = tid.makeAssetID(gAgent.getSecureSessionID());
S32 file_size;
apr_file_t* fp;
LLAPRFile aFile;
aFile.open(filename, LL_APR_RB, LLAPRFile::global, &file_size);
fp = aFile.getFileHandle();
if (fp)
{
const S32 buf_size = 65536;
U8 copy_buf[buf_size];
LLVFile file(gVFS, uuid, LLAssetType::AT_TEXTURE, LLVFile::WRITE);
file.setMaxSize(file_size);
while ((file_size =aFile.read(copy_buf, buf_size)))
{
file.write(copy_buf, file_size);
}
aFile.close();
}
else
{
llwarns<<"Unable to access output file "<<filename<<llendl;
upload_next_asset();
return;
}
myupload_new_resource(
tid, LLAssetType::AT_TEXTURE, struid,
struid, 0,
LLAssetType::AT_TEXTURE,
LLInventoryType::defaultForAssetType(LLAssetType::AT_TEXTURE),
0x0,
"Uploaded texture",
NULL,
NULL);
}
void upload_new_resource(const std::string& src_filename, std::string name,
std::string desc, S32 compression_info,
LLAssetType::EType destination_folder_type,
LLInventoryType::EType inv_type,
U32 next_owner_perms,
U32 group_perms,
U32 everyone_perms,
const std::string& display_name,
LLAssetStorage::LLStoreAssetCallback callback,
S32 expected_upload_cost,
void *userdata)
{
// Generate the temporary UUID.
std::string filename = gDirUtilp->getTempFilename();
LLTransactionID tid;
LLAssetID uuid;
LLSD args;
std::string exten = gDirUtilp->getExtension(src_filename);
LLAssetType::EType asset_type = LLAssetType::AT_NONE;
std::string error_message;
BOOL error = FALSE;
if (exten.empty())
{
std::string short_name = gDirUtilp->getBaseFileName(filename);
// No extension
error_message = llformat(
"No file extension for the file: '%s'\nPlease make sure the file has a correct file extension",
short_name.c_str());
args["FILE"] = short_name;
upload_error(error_message, "NofileExtension", filename, args);
return;
}
else if( exten == "bmp")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_BMP ))
{
error_message = llformat( "Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImage::getLastError().c_str());
args["FILE"] = src_filename;
args["ERROR"] = LLImage::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if( exten == "tga")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_TGA ))
{
error_message = llformat("Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImage::getLastError().c_str());
args["FILE"] = src_filename;
args["ERROR"] = LLImage::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if( exten == "jpg" || exten == "jpeg")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_JPEG ))
{
error_message = llformat("Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImage::getLastError().c_str());
args["FILE"] = src_filename;
args["ERROR"] = LLImage::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if( exten == "png")
{
asset_type = LLAssetType::AT_TEXTURE;
if (!LLViewerImageList::createUploadFile(src_filename,
filename,
IMG_CODEC_PNG ))
{
error_message = llformat("Problem with file %s:\n\n%s\n",
src_filename.c_str(), LLImage::getLastError().c_str());
args["FILE"] = src_filename;
args["ERROR"] = LLImage::getLastError();
upload_error(error_message, "ProblemWithFile", filename, args);
return;
}
}
else if(exten == "wav")
{
asset_type = LLAssetType::AT_SOUND; // tag it as audio
S32 encode_result = 0;
llinfos << "Attempting to encode wav as an ogg file" << llendl;
encode_result = encode_vorbis_file(src_filename, filename);
if (LLVORBISENC_NOERR != encode_result)
{
switch(encode_result)
{
case LLVORBISENC_DEST_OPEN_ERR:
error_message = llformat( "Couldn't open temporary compressed sound file for writing: %s\n", filename.c_str());
args["FILE"] = filename;
upload_error(error_message, "CannotOpenTemporarySoundFile", filename, args);
break;
default:
error_message = llformat("Unknown vorbis encode failure on: %s\n", src_filename.c_str());
args["FILE"] = src_filename;
upload_error(error_message, "UnknownVorbisEncodeFailure", filename, args);
break;
}
return;
}
}
else if(exten == "ogg")
{
asset_type = LLAssetType::AT_SOUND; // tag it as audio
filename = src_filename;
}
else if(exten == "tmp")
{
// This is a generic .lin resource file
asset_type = LLAssetType::AT_OBJECT;
LLFILE* in = LLFile::fopen(src_filename, "rb"); /* Flawfinder: ignore */
if (in)
{
// read in the file header
char buf[16384]; /* Flawfinder: ignore */
S32 read; /* Flawfinder: ignore */
S32 version;
if (fscanf(in, "LindenResource\nversion %d\n", &version))
{
if (2 == version)
{
// *NOTE: This buffer size is hard coded into scanf() below.
char label[MAX_STRING]; /* Flawfinder: ignore */
char value[MAX_STRING]; /* Flawfinder: ignore */
S32 tokens_read;
while (fgets(buf, 1024, in))
{
label[0] = '\0';
value[0] = '\0';
tokens_read = sscanf( /* Flawfinder: ignore */
buf,
"%254s %254s\n",
label, value);
llinfos << "got: " << label << " = " << value
<< llendl;
if (EOF == tokens_read)
{
fclose(in);
error_message = llformat("corrupt resource file: %s", src_filename.c_str());
args["FILE"] = src_filename;
upload_error(error_message, "CorruptResourceFile", filename, args);
return;
}
if (2 == tokens_read)
{
if (! strcmp("type", label))
{
asset_type = (LLAssetType::EType)(atoi(value));
}
}
else
{
if (! strcmp("_DATA_", label))
{
// below is the data section
break;
}
}
// other values are currently discarded
}
}
else
{
fclose(in);
error_message = llformat("unknown linden resource file version in file: %s", src_filename.c_str());
args["FILE"] = src_filename;
upload_error(error_message, "UnknownResourceFileVersion", filename, args);
return;
}
}
else
{
// this is an original binary formatted .lin file
// start over at the beginning of the file
fseek(in, 0, SEEK_SET);
const S32 MAX_ASSET_DESCRIPTION_LENGTH = 256;
const S32 MAX_ASSET_NAME_LENGTH = 64;
S32 header_size = 34 + MAX_ASSET_DESCRIPTION_LENGTH + MAX_ASSET_NAME_LENGTH;
S16 type_num;
// read in and throw out most of the header except for the type
if (fread(buf, header_size, 1, in) != 1)
{
llwarns << "Short read" << llendl;
}
memcpy(&type_num, buf + 16, sizeof(S16)); /* Flawfinder: ignore */
asset_type = (LLAssetType::EType)type_num;
}
// copy the file's data segment into another file for uploading
LLFILE* out = LLFile::fopen(filename, "wb"); /* Flawfinder: ignore */
if (out)
{
while((read = fread(buf, 1, 16384, in))) /* Flawfinder: ignore */
{
if (fwrite(buf, 1, read, out) != read)
{
llwarns << "Short write" << llendl;
}
}
fclose(out);
}
else
{
fclose(in);
error_message = llformat( "Unable to create output file: %s", filename.c_str());
args["FILE"] = filename;
upload_error(error_message, "UnableToCreateOutputFile", filename, args);
return;
}
fclose(in);
}
else
{
llinfos << "Couldn't open .lin file " << src_filename << llendl;
}
}
else if(exten == "ogg")
{
asset_type = LLAssetType::AT_SOUND; // tag it as audio
filename = src_filename;
}
else if (exten == "bvh")
{
// <edit> THE F**K WE DON'T
//error_message = llformat("We do not currently support bulk upload of animation files\n");
//upload_error(error_message, "DoNotSupportBulkAnimationUpload", filename, args);
//return;
asset_type = LLAssetType::AT_ANIMATION;
S32 file_size;
LLAPRFile fp;
if(!fp.open(src_filename, LL_APR_RB, LLAPRFile::local, &file_size))
{
args["ERROR_MESSAGE"] = llformat("Couldn't read file %s\n", src_filename.c_str());
LLNotifications::instance().add("ErrorMessage", args);
return;
}
char* file_buffer = new char[file_size + 1];
if(!fp.read(file_buffer, file_size))
{
fp.close();
delete[] file_buffer;
args["ERROR_MESSAGE"] = llformat("Couldn't read file %s\n", src_filename.c_str());
LLNotifications::instance().add("ErrorMessage", args);
return;
}
ELoadStatus load_status = E_ST_OK;
S32 line_number = 0;
LLBVHLoader* loaderp = new LLBVHLoader(file_buffer, load_status, line_number);
/// LLBVHLoader* loaderp = new LLBVHLoader(file_buffer);
if(!loaderp->isInitialized())
{
fp.close();
delete[] file_buffer;
args["ERROR_MESSAGE"] = llformat("Couldn't convert file %s to internal animation format\n", src_filename.c_str());
LLNotifications::instance().add("ErrorMessage", args);
return;
}
S32 buffer_size = loaderp->getOutputSize();
U8* buffer = new U8[buffer_size];
LLDataPackerBinaryBuffer dp(buffer, buffer_size);
loaderp->serialize(dp);
LLAPRFile apr_file;
apr_file.open(filename, LL_APR_WB, LLAPRFile::local);
apr_file.write(buffer, buffer_size);
delete[] file_buffer;
delete[] buffer;
fp.close();
apr_file.close();
// </edit>
}
// <edit>
else if (exten == "animatn" || exten == "anim" || exten == "neil")
{
asset_type = LLAssetType::AT_ANIMATION;
filename = src_filename;
}
else if(exten == "j2k" || exten == "jp2" || exten == "texture" || exten == "j2c")
{
asset_type = LLAssetType::AT_TEXTURE;
filename = src_filename;
}
else if(exten == "gesture")
{
asset_type = LLAssetType::AT_GESTURE;
filename = src_filename;
}
else if(exten == "notecard")
{
asset_type = LLAssetType::AT_NOTECARD;
filename = src_filename;
}
else if(exten == "lsl" || exten == "txt" || exten == "lso" | exten == "rtf")
{
asset_type = LLAssetType::AT_LSL_TEXT;
filename = src_filename;
}
else if(exten == "eyes" || exten == "gloves" || exten == "hair" || exten == "jacket" || exten == "pants" || exten == "shape" || exten == "shirt" || exten == "shoes" || exten == "skin" || exten == "skirt" || exten == "socks" || exten == "underpants" || exten == "tattoo" || exten == "alpha" || exten == "undershirt" || exten == "bodypart" || exten == "clothing")
{
asset_type = LLAssetType::AT_CLOTHING;
filename = src_filename;
}
// </edit>
else
{
// Unknown extension
// *TODO: Translate?
// <edit>
//error_message = llformat("Unknown file extension .%s\nExpected .wav, .tga, .bmp, .jpg, .jpeg, or .bvh", exten.c_str());
error_message = llformat("Unknown file extension .%s\nExpected .wav, .tga, .bmp, .jpg, .jpeg, .bvh, .animatn, .ogg, .gesture, .notecard, .lsl, .eyes, .gloves, .hair, .jacket, .pants, .shape, .shirt, .shoes, .skin, .skirt, .socks, .underpants, .undershirt, .bodypart, .clothing, .jp2, .j2k, or .j2c", exten.c_str());
// </edit>
error = TRUE;;
}
// gen a new transaction ID for this asset
tid.generate();
if (!error)
{
uuid = tid.makeAssetID(gAgent.getSecureSessionID());
// copy this file into the vfs for upload
S32 file_size;
LLAPRFile infile ;
infile.open(filename, LL_APR_RB, LLAPRFile::local, &file_size);
if (infile.getFileHandle())
{
LLVFile file(gVFS, uuid, asset_type, LLVFile::WRITE);
file.setMaxSize(file_size);
const S32 buf_size = 65536;
U8 copy_buf[buf_size];
while ((file_size = infile.read(copy_buf, buf_size)))
{
file.write(copy_buf, file_size);
}
}
else
{
error_message = llformat( "Unable to access output file: %s", filename.c_str());
error = TRUE;
}
}
if (!error)
{
std::string t_disp_name = display_name;
if (t_disp_name.empty())
{
t_disp_name = src_filename;
}
// <edit> hack to create scripts and gestures
if(exten == "lsl" || exten == "gesture" || exten == "notecard" || exten == "txt" || exten == "rtf" || exten == "lso")
{
LLInventoryType::EType inv_type = LLInventoryType::IT_GESTURE;
if(exten == "lsl") inv_type = LLInventoryType::IT_LSL;
else if(exten == "gesture") inv_type = LLInventoryType::IT_GESTURE;
else if(exten == "notecard") inv_type = LLInventoryType::IT_NOTECARD;
create_inventory_item( gAgent.getID(),
gAgent.getSessionID(),
gInventory.findCategoryUUIDForType(asset_type),
LLTransactionID::tnull,
name,
uuid.asString(), // fake asset id, but in vfs
asset_type,
inv_type,
NOT_WEARABLE,
PERM_ITEM_UNRESTRICTED,
new NewResourceItemCallback);
}
else
// </edit>
upload_new_resource(tid, asset_type, name, desc, compression_info, // tid
destination_folder_type, inv_type, next_owner_perms, group_perms, everyone_perms,
display_name, callback, expected_upload_cost, userdata);
}
else
{
llwarns << error_message << llendl;
LLSD args;
args["ERROR_MESSAGE"] = error_message;
LLNotifications::instance().add("ErrorMessage", args);
if(LLFile::remove(filename) == -1)
{
lldebugs << "unable to remove temp file" << llendl;
}
LLFilePicker::instance().reset();
}
}
