void FilterTargets(std::list<WorldObject*>& targets)
{
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster()));
if (targets.size() > 4)
targets.resize(4);
while (targets.size() > 2)
targets.pop_front();
}
//! Loading for std::list
template <class Archive, class T, class A> inline
void load( Archive & ar, std::list<T, A> & list )
{
size_type size;
ar( make_size_tag( size ) );
list.resize( static_cast<size_t>( size ) );
for( auto & i : list )
ar( i );
}
//! Loading for std::list
template <class Archive, class T, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::list<T, A> & list )
{
size_type size;
ar( make_size_tag( size ) );
list.resize( static_cast<size_t>( size ) );
for( auto & i : list )
ar( i );
}
void FilterTargets(std::list<WorldObject*>& targets)
{
// get 2 targets except 2 nearest
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster()));
// .resize() runs pop_back();
if (targets.size() > 5)
targets.resize(5);
while (targets.size() > 2)
targets.pop_front();
}
void FilterTargets(std::list<Unit*>& targetList)
{
// get 2 targets except 2 nearest
targetList.sort(Trillium::ObjectDistanceOrderPred(GetCaster()));
// .resize() runs pop_back();
if (targetList.size() > 4)
targetList.resize(4);
while (targetList.size() > 2)
targetList.pop_front();
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(RaidCheck(GetCaster()));
uint32 const maxTargets = GetCaster()->HasAura(SPELL_PRIEST_GLYPH_OF_CIRCLE_OF_HEALING) ? 6 : 5; // Glyph of Circle of Healing
if (targets.size() > maxTargets)
{
targets.sort(Trinity::HealthPctOrderPred());
targets.resize(maxTargets);
}
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(RaidCheck(GetCaster()));
uint32 const maxTargets = 3;
if (targets.size() > maxTargets)
{
targets.sort(Trinity::HealthPctOrderPred());
targets.resize(maxTargets);
}
}
int TwoSum::find_range(int lower, int upper) {
int count = 0;
numbers_to_check.resize(upper-lower);
for (int i=lower; i<= upper; i++ ) {
numbers_to_check.push_back(i);
};
for( auto it = numbers.begin(); it != numbers.end(); ++it ) {
if( find_sum(it->first) ) {
++count;
};
};
return count;
};
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster()));
// Selects 5 nearest dummies, including the caster
// .resize() runs pop_back();
if (targets.size() > 5)
targets.resize(5);
// Selects 2 farthest ones to cast a spell
while (targets.size() > 2)
targets.pop_front();
}
void FilterTargets(std::list<WorldObject*>& targets)
{
targets.remove_if(RaidCheck(GetCaster()));
uint32 const maxTargets = uint32(GetSpellInfo()->Effects[EFFECT_2].CalcValue(GetCaster()));
if (targets.size() > maxTargets)
{
targets.sort(Trinity::HealthPctOrderPred());
targets.resize(maxTargets);
}
_targets = targets;
}
void FilterTargets(std::list<WorldObject*>& targets)
{
if (InstanceMap* instance = GetCaster()->GetMap()->ToInstanceMap())
{
if (InstanceScript* const script = instance->GetInstanceScript())
{
if (GameObject* go = ObjectAccessor::GetGameObject(*GetCaster(), script->GetData64(DATA_ANHUUR_DOOR)))
{
targets.remove_if(Trinity::HeightDifferenceCheck(go, 5.0f, false));
targets.remove(GetCaster());
targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster()));
targets.resize(2);
}
}
}
}
/**
* @param[in] p position.
* @param[in] num a number of node which you want
* @param[out] node result.
* @param[in] radius a radius of initial sphere.
*/
void find(const T p, const size_t num, std::list<T>& node, double radius = 0.1) {
if (_numElement < num) {
std::cerr<<"Error. you give larger number"<<std::endl;
return ;
}
const double base = pow(static_cast<double>(num), 0.3333f);
node.clear();
while ( node.size() < num ) {
this->find(p, radius, node, false);
if (node.size() == 0) radius *= 2;
else radius *= static_cast<double>(base / pow(node.size(), 0.3333));
}
node.sort(less_vec_length(p));
node.resize(num);
return;
}
static bool get_subject(std::string& s, std::list<std::string>& patterns, std::string& error) {
patterns.resize(0);
std::string::size_type f;
std::string str;
f = find(s.c_str(), s.length(), subjectname.c_str(), subjectname.length());
if(f == std::string::npos) {
error += "Missing subjects token in namespaces policy\n";
return false;
}
str = s.substr(f + subjectname.length());
std::string subject;
get_word(str,subject);
if(subject.empty()) {
error += "Missing subjects in namespaces policy\n";
return false;
}
patterns.push_back(subject);
return true;
}
//=================================================================================================
void DCmdFindID::exec(const DPreprocessor::DS_Command* pContext)
{
DStaticAssert(D_PREPROCESSOR_NBPARAMS >= 2);
DAssertMsg(pContext->nbParameters == 2, "Invalid parameter in script file.");
const std::list<DString>& fileList = DCmdFindFile::getFileList();
const char* pBeginMarkup = pContext->aParameters[0];
const char* pEndMarkup = pContext->aParameters[1];
if(!*pEndMarkup)
pEndMarkup = "\r\n";
u32 beginMarkupLength = DStrLen(pBeginMarkup);
u32 endMarkupLength = DStrLen(pEndMarkup);
// Parcours des fichiers
for(std::list<DString>::const_iterator it = fileList.begin(); it != fileList.end(); it++)
{
// Lecture du fichier
char* pFileBuffer = static_cast<char*>(DLoadFile(it->getCStr()));
// Recherche de la balise de début
const char* pBegin = DStrStr(pFileBuffer, pBeginMarkup);
while(pBegin)
{
pBegin += beginMarkupLength;
// Recherche de la balise de fin
const char* pEnd = DStrStr(pBegin, pEndMarkup);
if(pEnd)
{
g_ResultList.resize(g_ResultList.size() + 1);
DS_Result* pResult = &g_ResultList.back();
DStrNCpy(pResult->ID.getCStr(), D_STRING_LENGTH, pBegin, pEnd - pBegin);
pResult->filePath = it->getCStr();
pResult->position = static_cast<u32>(pBegin - pFileBuffer);
}
pBegin = DStrStr(pEnd + endMarkupLength, pBeginMarkup);
}
// Destruction du buffer de fichier
DUnloadFile(pFileBuffer);
}
}
int FFmpegImportFileHandle::Import(TrackFactory *trackFactory,
TrackHolders &outTracks,
Tags *tags)
{
outTracks.clear();
CreateProgress();
// Remove stream contexts which are not marked for importing and adjust mScs and mNumStreams accordingly
const auto scs = mScs->get();
for (int i = 0; i < mNumStreams;)
{
if (!scs[i]->m_use)
{
for (int j = i; j < mNumStreams - 1; j++)
{
scs[j] = std::move(scs[j+1]);
}
mNumStreams--;
}
else i++;
}
mChannels.resize(mNumStreams);
int s = -1;
for (auto &stream : mChannels)
{
++s;
auto sc = scs[s].get();
switch (sc->m_stream->codec->sample_fmt)
{
case AV_SAMPLE_FMT_U8:
case AV_SAMPLE_FMT_S16:
case AV_SAMPLE_FMT_U8P:
case AV_SAMPLE_FMT_S16P:
sc->m_osamplesize = sizeof(int16_t);
sc->m_osamplefmt = int16Sample;
break;
default:
sc->m_osamplesize = sizeof(float);
sc->m_osamplefmt = floatSample;
break;
}
// There is a possibility that number of channels will change over time, but we do not have WaveTracks for NEW channels. Remember the number of channels and stick to it.
sc->m_initialchannels = sc->m_stream->codec->channels;
stream.resize(sc->m_stream->codec->channels);
int c = -1;
for (auto &channel : stream)
{
++c;
channel = trackFactory->NewWaveTrack(sc->m_osamplefmt, sc->m_stream->codec->sample_rate);
if (sc->m_stream->codec->channels == 2)
{
switch (c)
{
case 0:
channel->SetChannel(Track::LeftChannel);
channel->SetLinked(true);
break;
case 1:
channel->SetChannel(Track::RightChannel);
break;
}
}
else
{
channel->SetChannel(Track::MonoChannel);
}
}
}
// Handles the start_time by creating silence. This may or may not be correct.
// There is a possibility that we should ignore first N milliseconds of audio instead. I do not know.
/// TODO: Nag FFmpeg devs about start_time until they finally say WHAT is this and HOW to handle it.
s = -1;
for (auto &stream : mChannels)
{
++s;
int64_t stream_delay = 0;
auto sc = scs[s].get();
if (sc->m_stream->start_time != int64_t(AV_NOPTS_VALUE) && sc->m_stream->start_time > 0)
{
stream_delay = sc->m_stream->start_time;
wxLogDebug(wxT("Stream %d start_time = %lld, that would be %f milliseconds."), s, (long long) sc->m_stream->start_time, double(sc->m_stream->start_time)/AV_TIME_BASE*1000);
}
if (stream_delay != 0)
{
int c = -1;
for (auto &channel : stream)
{
++c;
WaveTrack *t = channel.get();
t->InsertSilence(0,double(stream_delay)/AV_TIME_BASE);
}
}
}
// This is the heart of the importing process
// The result of Import() to be returend. It will be something other than zero if user canceled or some error appears.
int res = eProgressSuccess;
#ifdef EXPERIMENTAL_OD_FFMPEG
mUsingOD = false;
gPrefs->Read(wxT("/Library/FFmpegOnDemand"), &mUsingOD);
//at this point we know the file is good and that we have to load the number of channels in mScs[s]->m_stream->codec->channels;
//so for OD loading we create the tracks and releasee the modal lock after starting the ODTask.
if (mUsingOD) {
std::vector<ODDecodeFFmpegTask*> tasks;
//append blockfiles to each stream and add an individual ODDecodeTask for each one.
s = -1;
for (const auto &stream : mChannels) {
++s;
ODDecodeFFmpegTask* odTask =
new ODDecodeFFmpegTask(mScs, ODDecodeFFmpegTask::FromList(mChannels), mFormatContext, s);
odTask->CreateFileDecoder(mFilename);
//each stream has different duration. We need to know it if seeking is to be allowed.
sampleCount sampleDuration = 0;
auto sc = scs[s].get();
if (sc->m_stream->duration > 0)
sampleDuration = ((sampleCount)sc->m_stream->duration * sc->m_stream->time_base.num), sc->m_stream->codec->sample_rate / sc->m_stream->time_base.den;
else
sampleDuration = ((sampleCount)mFormatContext->duration *sc->m_stream->codec->sample_rate) / AV_TIME_BASE;
// printf(" OD duration samples %qi, sr %d, secs %d\n",sampleDuration, (int)sc->m_stream->codec->sample_rate, (int)sampleDuration/sc->m_stream->codec->sample_rate);
//for each wavetrack within the stream add coded blockfiles
for (int c = 0; c < sc->m_stream->codec->channels; c++) {
WaveTrack *t = stream[c].get();
odTask->AddWaveTrack(t);
sampleCount maxBlockSize = t->GetMaxBlockSize();
//use the maximum blockfile size to divide the sections (about 11secs per blockfile at 44.1khz)
for (sampleCount i = 0; i < sampleDuration; i += maxBlockSize) {
sampleCount blockLen = maxBlockSize;
if (i + blockLen > sampleDuration)
blockLen = sampleDuration - i;
t->AppendCoded(mFilename, i, blockLen, c, ODTask::eODFFMPEG);
// This only works well for single streams since we assume
// each stream is of the same duration and channels
res = mProgress->Update(i+sampleDuration*c+ sampleDuration*sc->m_stream->codec->channels*s,
sampleDuration*sc->m_stream->codec->channels*mNumStreams);
if (res != eProgressSuccess)
break;
}
}
tasks.push_back(odTask);
}
//Now we add the tasks and let them run, or DELETE them if the user cancelled
for(int i=0; i < (int)tasks.size(); i++) {
if(res==eProgressSuccess)
ODManager::Instance()->AddNewTask(tasks[i]);
else
{
delete tasks[i];
}
}
} else {
#endif
// Read next frame.
for (streamContext *sc; (sc = ReadNextFrame()) != NULL && (res == eProgressSuccess);)
{
// ReadNextFrame returns 1 if stream is not to be imported
if (sc != (streamContext*)1)
{
// Decode frame until it is not possible to decode any further
while (sc->m_pktRemainingSiz > 0 && (res == eProgressSuccess || res == eProgressStopped))
{
if (DecodeFrame(sc,false) < 0)
break;
// If something useable was decoded - write it to mChannels
if (sc->m_frameValid)
res = WriteData(sc);
}
// Cleanup after frame decoding
if (sc->m_pktValid)
{
av_free_packet(&sc->m_pkt);
sc->m_pktValid = 0;
}
}
}
// Flush the decoders.
if ((mNumStreams != 0) && (res == eProgressSuccess || res == eProgressStopped))
{
for (int i = 0; i < mNumStreams; i++)
{
auto sc = scs[i].get();
if (DecodeFrame(sc, true) == 0)
{
WriteData(sc);
if (sc->m_pktValid)
{
av_free_packet(&sc->m_pkt);
sc->m_pktValid = 0;
}
}
}
}
#ifdef EXPERIMENTAL_OD_FFMPEG
} // else -- !mUsingOD == true
#endif //EXPERIMENTAL_OD_FFMPEG
// Something bad happened - destroy everything!
if (res == eProgressCancelled || res == eProgressFailed)
return res;
//else if (res == 2), we just stop the decoding as if the file has ended
// Copy audio from mChannels to newly created tracks (destroying mChannels elements in process)
for (auto &stream : mChannels)
{
for(auto &channel : stream)
{
channel->Flush();
outTracks.push_back(std::move(channel));
}
}
// Save metadata
WriteMetadata(tags);
return res;
}
/// Called by gold to see whether this file is one that our plugin can handle.
/// We'll try to open it and register all the symbols with add_symbol if
/// possible.
static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
int *claimed) {
LLVMContext Context;
MemoryBufferRef BufferRef;
std::unique_ptr<MemoryBuffer> Buffer;
if (get_view) {
const void *view;
if (get_view(file->handle, &view) != LDPS_OK) {
message(LDPL_ERROR, "Failed to get a view of %s", file->name);
return LDPS_ERR;
}
BufferRef =
MemoryBufferRef(StringRef((const char *)view, file->filesize), "");
} else {
int64_t offset = 0;
// Gold has found what might be IR part-way inside of a file, such as
// an .a archive.
if (file->offset) {
offset = file->offset;
}
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
MemoryBuffer::getOpenFileSlice(file->fd, file->name, file->filesize,
offset);
if (std::error_code EC = BufferOrErr.getError()) {
message(LDPL_ERROR, EC.message().c_str());
return LDPS_ERR;
}
Buffer = std::move(BufferOrErr.get());
BufferRef = Buffer->getMemBufferRef();
}
Context.setDiagnosticHandler(diagnosticHandler);
ErrorOr<std::unique_ptr<object::IRObjectFile>> ObjOrErr =
object::IRObjectFile::create(BufferRef, Context);
std::error_code EC = ObjOrErr.getError();
if (EC == object::object_error::invalid_file_type ||
EC == object::object_error::bitcode_section_not_found)
return LDPS_OK;
*claimed = 1;
if (EC) {
message(LDPL_ERROR, "LLVM gold plugin has failed to create LTO module: %s",
EC.message().c_str());
return LDPS_ERR;
}
std::unique_ptr<object::IRObjectFile> Obj = std::move(*ObjOrErr);
Modules.resize(Modules.size() + 1);
claimed_file &cf = Modules.back();
cf.handle = file->handle;
// If we are doing ThinLTO compilation, don't need to process the symbols.
// Later we simply build a combined index file after all files are claimed.
if (options::thinlto) return LDPS_OK;
for (auto &Sym : Obj->symbols()) {
uint32_t Symflags = Sym.getFlags();
if (shouldSkip(Symflags))
continue;
cf.syms.push_back(ld_plugin_symbol());
ld_plugin_symbol &sym = cf.syms.back();
sym.version = nullptr;
SmallString<64> Name;
{
raw_svector_ostream OS(Name);
Sym.printName(OS);
}
sym.name = strdup(Name.c_str());
const GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
sym.visibility = LDPV_DEFAULT;
if (GV) {
switch (GV->getVisibility()) {
case GlobalValue::DefaultVisibility:
sym.visibility = LDPV_DEFAULT;
break;
case GlobalValue::HiddenVisibility:
sym.visibility = LDPV_HIDDEN;
break;
case GlobalValue::ProtectedVisibility:
sym.visibility = LDPV_PROTECTED;
break;
}
}
if (Symflags & object::BasicSymbolRef::SF_Undefined) {
sym.def = LDPK_UNDEF;
if (GV && GV->hasExternalWeakLinkage())
sym.def = LDPK_WEAKUNDEF;
} else {
sym.def = LDPK_DEF;
if (GV) {
assert(!GV->hasExternalWeakLinkage() &&
!GV->hasAvailableExternallyLinkage() && "Not a declaration!");
if (GV->hasCommonLinkage())
sym.def = LDPK_COMMON;
else if (GV->isWeakForLinker())
sym.def = LDPK_WEAKDEF;
}
}
sym.size = 0;
sym.comdat_key = nullptr;
if (GV) {
const GlobalObject *Base = getBaseObject(*GV);
if (!Base)
message(LDPL_FATAL, "Unable to determine comdat of alias!");
const Comdat *C = Base->getComdat();
if (C)
sym.comdat_key = strdup(C->getName().str().c_str());
else if (Base->hasWeakLinkage() || Base->hasLinkOnceLinkage())
sym.comdat_key = strdup(sym.name);
}
sym.resolution = LDPR_UNKNOWN;
}
if (!cf.syms.empty()) {
if (add_symbols(cf.handle, cf.syms.size(), cf.syms.data()) != LDPS_OK) {
message(LDPL_ERROR, "Unable to add symbols!");
return LDPS_ERR;
}
}
return LDPS_OK;
}
void NxScreenManager::GetActiveWindowsList( std::list< NxScreen *> & ScreenList )
{
ScreenList.resize(MonitorListActive.size());
std::copy(MonitorListActive.begin(),MonitorListActive.end(),ScreenList.begin());
}
/// claim_file_hook - called by gold to see whether this file is one that
/// our plugin can handle. We'll try to open it and register all the symbols
/// with add_symbol if possible.
static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
int *claimed) {
LTOModule *M;
const void *view;
std::unique_ptr<MemoryBuffer> buffer;
if (get_view) {
if (get_view(file->handle, &view) != LDPS_OK) {
(*message)(LDPL_ERROR, "Failed to get a view of %s", file->name);
return LDPS_ERR;
}
} else {
int64_t offset = 0;
// Gold has found what might be IR part-way inside of a file, such as
// an .a archive.
if (file->offset) {
offset = file->offset;
}
if (std::error_code ec = MemoryBuffer::getOpenFileSlice(
file->fd, file->name, buffer, file->filesize, offset)) {
(*message)(LDPL_ERROR, ec.message().c_str());
return LDPS_ERR;
}
view = buffer->getBufferStart();
}
if (!LTOModule::isBitcodeFile(view, file->filesize))
return LDPS_OK;
std::string Error;
M = LTOModule::makeLTOModule(view, file->filesize, TargetOpts, Error);
if (!M) {
(*message)(LDPL_ERROR,
"LLVM gold plugin has failed to create LTO module: %s",
Error.c_str());
return LDPS_OK;
}
*claimed = 1;
Modules.resize(Modules.size() + 1);
claimed_file &cf = Modules.back();
if (!options::triple.empty())
M->setTargetTriple(options::triple.c_str());
cf.handle = file->handle;
unsigned sym_count = M->getSymbolCount();
cf.syms.reserve(sym_count);
for (unsigned i = 0; i != sym_count; ++i) {
lto_symbol_attributes attrs = M->getSymbolAttributes(i);
if ((attrs & LTO_SYMBOL_SCOPE_MASK) == LTO_SYMBOL_SCOPE_INTERNAL)
continue;
cf.syms.push_back(ld_plugin_symbol());
ld_plugin_symbol &sym = cf.syms.back();
sym.name = strdup(M->getSymbolName(i));
sym.version = NULL;
int scope = attrs & LTO_SYMBOL_SCOPE_MASK;
bool CanBeHidden = scope == LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN;
if (!CanBeHidden)
CannotBeHidden.insert(sym.name);
switch (scope) {
case LTO_SYMBOL_SCOPE_HIDDEN:
sym.visibility = LDPV_HIDDEN;
break;
case LTO_SYMBOL_SCOPE_PROTECTED:
sym.visibility = LDPV_PROTECTED;
break;
case 0: // extern
case LTO_SYMBOL_SCOPE_DEFAULT:
case LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN:
sym.visibility = LDPV_DEFAULT;
break;
default:
(*message)(LDPL_ERROR, "Unknown scope attribute: %d", scope);
return LDPS_ERR;
}
int definition = attrs & LTO_SYMBOL_DEFINITION_MASK;
sym.comdat_key = NULL;
switch (definition) {
case LTO_SYMBOL_DEFINITION_REGULAR:
sym.def = LDPK_DEF;
break;
case LTO_SYMBOL_DEFINITION_UNDEFINED:
sym.def = LDPK_UNDEF;
break;
case LTO_SYMBOL_DEFINITION_TENTATIVE:
sym.def = LDPK_COMMON;
break;
case LTO_SYMBOL_DEFINITION_WEAK:
sym.comdat_key = sym.name;
sym.def = LDPK_WEAKDEF;
break;
case LTO_SYMBOL_DEFINITION_WEAKUNDEF:
sym.def = LDPK_WEAKUNDEF;
break;
default:
(*message)(LDPL_ERROR, "Unknown definition attribute: %d", definition);
return LDPS_ERR;
}
sym.size = 0;
sym.resolution = LDPR_UNKNOWN;
}
cf.syms.reserve(cf.syms.size());
if (!cf.syms.empty()) {
if ((*add_symbols)(cf.handle, cf.syms.size(), &cf.syms[0]) != LDPS_OK) {
(*message)(LDPL_ERROR, "Unable to add symbols!");
return LDPS_ERR;
}
}
if (CodeGen) {
std::string Error;
if (!CodeGen->addModule(M, Error)) {
(*message)(LDPL_ERROR, "Error linking module: %s", Error.c_str());
return LDPS_ERR;
}
}
delete M;
return LDPS_OK;
}
void Conditions::conditionnames(std::list < std::string >& lst) const
{
lst.resize(m_list.size());
std::transform(m_list.begin(), m_list.end(), lst.begin(),
utils::select1st < ConditionList::value_type >());
}
/// Called by gold to see whether this file is one that our plugin can handle.
/// We'll try to open it and register all the symbols with add_symbol if
/// possible.
static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file,
int *claimed) {
MemoryBufferRef BufferRef;
std::unique_ptr<MemoryBuffer> Buffer;
if (get_view) {
const void *view;
if (get_view(file->handle, &view) != LDPS_OK) {
message(LDPL_ERROR, "Failed to get a view of %s", file->name);
return LDPS_ERR;
}
BufferRef =
MemoryBufferRef(StringRef((const char *)view, file->filesize), "");
} else {
int64_t offset = 0;
// Gold has found what might be IR part-way inside of a file, such as
// an .a archive.
if (file->offset) {
offset = file->offset;
}
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
MemoryBuffer::getOpenFileSlice(file->fd, file->name, file->filesize,
offset);
if (std::error_code EC = BufferOrErr.getError()) {
message(LDPL_ERROR, EC.message().c_str());
return LDPS_ERR;
}
Buffer = std::move(BufferOrErr.get());
BufferRef = Buffer->getMemBufferRef();
}
*claimed = 1;
Expected<std::unique_ptr<InputFile>> ObjOrErr = InputFile::create(BufferRef);
if (!ObjOrErr) {
handleAllErrors(ObjOrErr.takeError(), [&](const ErrorInfoBase &EI) {
std::error_code EC = EI.convertToErrorCode();
if (EC == object::object_error::invalid_file_type ||
EC == object::object_error::bitcode_section_not_found)
*claimed = 0;
else
message(LDPL_ERROR,
"LLVM gold plugin has failed to create LTO module: %s",
EI.message().c_str());
});
return *claimed ? LDPS_ERR : LDPS_OK;
}
std::unique_ptr<InputFile> Obj = std::move(*ObjOrErr);
Modules.resize(Modules.size() + 1);
claimed_file &cf = Modules.back();
cf.handle = file->handle;
// Keep track of the first handle for each file descriptor, since there are
// multiple in the case of an archive. This is used later in the case of
// ThinLTO parallel backends to ensure that each file is only opened and
// released once.
auto LeaderHandle =
FDToLeaderHandle.insert(std::make_pair(file->fd, file->handle)).first;
cf.leader_handle = LeaderHandle->second;
// Save the filesize since for parallel ThinLTO backends we can only
// invoke get_input_file once per archive (only for the leader handle).
cf.filesize = file->filesize;
// In the case of an archive library, all but the first member must have a
// non-zero offset, which we can append to the file name to obtain a
// unique name.
cf.name = file->name;
if (file->offset)
cf.name += ".llvm." + std::to_string(file->offset) + "." +
sys::path::filename(Obj->getSourceFileName()).str();
for (auto &Sym : Obj->symbols()) {
uint32_t Symflags = Sym.getFlags();
cf.syms.push_back(ld_plugin_symbol());
ld_plugin_symbol &sym = cf.syms.back();
sym.version = nullptr;
StringRef Name = Sym.getName();
sym.name = strdup(Name.str().c_str());
ResolutionInfo &Res = ResInfo[Name];
Res.CanOmitFromDynSym &= Sym.canBeOmittedFromSymbolTable();
sym.visibility = LDPV_DEFAULT;
GlobalValue::VisibilityTypes Vis = Sym.getVisibility();
if (Vis != GlobalValue::DefaultVisibility)
Res.DefaultVisibility = false;
switch (Vis) {
case GlobalValue::DefaultVisibility:
break;
case GlobalValue::HiddenVisibility:
sym.visibility = LDPV_HIDDEN;
break;
case GlobalValue::ProtectedVisibility:
sym.visibility = LDPV_PROTECTED;
break;
}
if (Symflags & object::BasicSymbolRef::SF_Undefined) {
sym.def = LDPK_UNDEF;
if (Symflags & object::BasicSymbolRef::SF_Weak)
sym.def = LDPK_WEAKUNDEF;
} else if (Symflags & object::BasicSymbolRef::SF_Common)
sym.def = LDPK_COMMON;
else if (Symflags & object::BasicSymbolRef::SF_Weak)
sym.def = LDPK_WEAKDEF;
else
sym.def = LDPK_DEF;
sym.size = 0;
sym.comdat_key = nullptr;
int CI = check(Sym.getComdatIndex());
if (CI != -1) {
StringRef C = Obj->getComdatTable()[CI];
sym.comdat_key = strdup(C.str().c_str());
}
sym.resolution = LDPR_UNKNOWN;
}
if (!cf.syms.empty()) {
if (add_symbols(cf.handle, cf.syms.size(), cf.syms.data()) != LDPS_OK) {
message(LDPL_ERROR, "Unable to add symbols!");
return LDPS_ERR;
}
}
return LDPS_OK;
}
void FillTargets(std::list<WorldObject*>& targets)
{
if (!targets.empty())
targets.resize(1);
}
void resize(std::size_t s) { m_children.resize(s); }
int OggImportFileHandle::Import(TrackFactory *trackFactory, TrackHolders &outTracks,
Tags *tags)
{
outTracks.clear();
wxASSERT(mFile->IsOpened());
CreateProgress();
//Number of streams used may be less than mVorbisFile->links,
//but this way bitstream matches array index.
mChannels.resize(mVorbisFile->links);
int i = -1;
for (auto &link: mChannels)
{
++i;
//Stream is not used
if (mStreamUsage[i] == 0)
{
//This is just a padding to keep bitstream number and
//array indices matched.
continue;
}
vorbis_info *vi = ov_info(mVorbisFile, i);
link.resize(vi->channels);
int c = - 1;
for (auto &channel : link) {
++c;
channel = trackFactory->NewWaveTrack(mFormat, vi->rate);
if (vi->channels == 2) {
switch (c) {
case 0:
channel->SetChannel(Track::LeftChannel);
channel->SetLinked(true);
break;
case 1:
channel->SetChannel(Track::RightChannel);
break;
}
}
else {
channel->SetChannel(Track::MonoChannel);
}
}
}
/* The number of bytes to get from the codec in each run */
#define CODEC_TRANSFER_SIZE 4096
/* The number of samples to read between calls to the callback.
* Balance between responsiveness of the GUI and throughput of import. */
#define SAMPLES_PER_CALLBACK 100000
short *mainBuffer = new short[CODEC_TRANSFER_SIZE];
/* determine endianness (clever trick courtesy of Nicholas Devillard,
* (http://www.eso.org/~ndevilla/endian/) */
int testvar = 1, endian;
if(*(char *)&testvar)
endian = 0; // little endian
else
endian = 1; // big endian
/* number of samples currently in each channel's buffer */
int updateResult = eProgressSuccess;
long bytesRead = 0;
long samplesRead = 0;
int bitstream = 0;
int samplesSinceLastCallback = 0;
// You would think that the stream would already be seeked to 0, and
// indeed it is if the file is legit. But I had several ogg files on
// my hard drive that have malformed headers, and this added call
// causes them to be read correctly. Otherwise they have lots of
// zeros inserted at the beginning
ov_pcm_seek(mVorbisFile, 0);
do {
/* get data from the decoder */
bytesRead = ov_read(mVorbisFile, (char *) mainBuffer,
CODEC_TRANSFER_SIZE,
endian,
2, // word length (2 for 16 bit samples)
1, // signed
&bitstream);
if (bytesRead == OV_HOLE) {
wxFileName ff(mFilename);
wxLogError(wxT("Ogg Vorbis importer: file %s is malformed, ov_read() reported a hole"),
ff.GetFullName().c_str());
/* http://lists.xiph.org/pipermail/vorbis-dev/2001-February/003223.html
* is the justification for doing this - best effort for malformed file,
* hence the message.
*/
continue;
} else if (bytesRead < 0) {
/* Malformed Ogg Vorbis file. */
/* TODO: Return some sort of meaningful error. */
wxLogError(wxT("Ogg Vorbis importer: ov_read() returned error %i"),
bytesRead);
break;
}
samplesRead = bytesRead / mVorbisFile->vi[bitstream].channels / sizeof(short);
/* give the data to the wavetracks */
auto iter = mChannels.begin();
std::advance(iter, bitstream);
if (mStreamUsage[bitstream] != 0)
{
auto iter2 = iter->begin();
for (int c = 0; c < mVorbisFile->vi[bitstream].channels; ++iter2, ++c)
iter2->get()->Append((char *)(mainBuffer + c),
int16Sample,
samplesRead,
mVorbisFile->vi[bitstream].channels);
}
samplesSinceLastCallback += samplesRead;
if (samplesSinceLastCallback > SAMPLES_PER_CALLBACK) {
updateResult = mProgress->Update(ov_time_tell(mVorbisFile),
ov_time_total(mVorbisFile, bitstream));
samplesSinceLastCallback -= SAMPLES_PER_CALLBACK;
}
} while (updateResult == eProgressSuccess && bytesRead != 0);
delete[]mainBuffer;
int res = updateResult;
if (bytesRead < 0)
res = eProgressFailed;
if (res == eProgressFailed || res == eProgressCancelled) {
return res;
}
for (auto &link : mChannels)
{
for (auto &channel : link) {
channel->Flush();
outTracks.push_back(std::move(channel));
}
}
//\todo { Extract comments from each stream? }
if (mVorbisFile->vc[0].comments > 0) {
tags->Clear();
for (int c = 0; c < mVorbisFile->vc[0].comments; c++) {
wxString comment = UTF8CTOWX(mVorbisFile->vc[0].user_comments[c]);
wxString name = comment.BeforeFirst(wxT('='));
wxString value = comment.AfterFirst(wxT('='));
if (name.Upper() == wxT("DATE") && !tags->HasTag(TAG_YEAR)) {
long val;
if (value.Length() == 4 && value.ToLong(&val)) {
name = TAG_YEAR;
}
}
tags->SetTag(name, value);
}
}
return res;
}