void gnGenomeSpec::RemoveFeature( const uint32 i ){
uint32 count = 0;
uint32 len = 0;
uint32 specI=0;
for(; specI < GetSpecListLength(); specI++){
len = GetSpec(specI)->GetFeatureListLength();
if(count <= i && i < count + len){
GetSpec(specI)->RemoveFeature( i - count);
}
count += len;
}
Throw_gnEx(FeatureIndexOutOfBounds());
}
void gnGenomeSpec::SetReverseComplement( const boolean value )
{
if(value == m_reverseComplement)
return;
//reverse the spec list entries
vector<gnFragmentSpec*> tmp_spec_list;
for(uint32 i=0; i < GetSpecListLength(); i++){
//transmit rev_comp down to each fragment spec
GetSpec(i)->SetReverseComplement(!GetSpec(i)->IsReverseComplement());
tmp_spec_list.insert(tmp_spec_list.begin(), GetSpec(i));
}
m_SpecList = tmp_spec_list;
m_reverseComplement = value;
}
gnBaseFeature* gnGenomeSpec::GetFeature(const uint32 i ) const
{
uint32 count = 0;
uint32 len = 0;
for(uint32 specI=0; specI < GetSpecListLength(); specI++){
len = GetSpec(specI)->GetFeatureListLength();
if(count <= i && i < count + len){
gnBaseFeature* feat = GetSpec(specI)->GetFeature(i - count);
feat->MovePositive(GetSpecStartBase(specI));
return feat;
}
count += len;
}
Throw_gnEx(FeatureIndexOutOfBounds());
}
static PGPError
sComposeProc(
PFLConstFileSpecRef parent,
const char * fileName,
PFLFileSpecRef * outRef )
{
PGPError err = kPGPError_NoErr;
FSSpec spec;
PGPSize nameLength;
CInfoPBRec cpb;
PGPValidateParam( parent->type == kPFLFileSpecMacType );
err = GetSpec( parent, &spec, &cpb );
if( IsntPGPError( err ) )
{
nameLength = strlen( fileName );
if ( nameLength > sizeof( spec.name ) - 1 )
{
err = kPGPError_BufferTooSmall;
}
else
{
pgpCopyMemory( fileName, spec.name + 1, nameLength );
spec.name[0] = nameLength;
spec.vRefNum = cpb.dirInfo.ioVRefNum;
spec.parID = cpb.dirInfo.ioDrDirID;
err = PFLNewFileSpecFromFSSpec( parent->memoryMgr, &spec,
outRef );
}
}
return( err );
}
nsresult nsNntpUrl::ParseNewsURL() {
// The path here is the group/msgid portion
nsAutoCString path;
nsresult rv = GetFilePath(path);
NS_ENSURE_SUCCESS(rv, rv);
// Drop the potential beginning from the path
if (path.Length() && path[0] == '/') path = Substring(path, 1);
// The presence of an `@' is a sign we have a msgid
if (path.Find("@") != -1 || path.Find("%40") != -1) {
MsgUnescapeString(path, 0, m_messageID);
// Set group, key for ?group=foo&key=123 uris
nsAutoCString spec;
rv = GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
int32_t groupPos = spec.Find(kNewsURIGroupQuery); // find ?group=
int32_t keyPos = spec.Find(kNewsURIKeyQuery); // find &key=
if (groupPos != kNotFound && keyPos != kNotFound) {
// get group name and message key
m_group = Substring(spec, groupPos + kNewsURIGroupQueryLen,
keyPos - groupPos - kNewsURIGroupQueryLen);
nsCString keyStr(Substring(spec, keyPos + kNewsURIKeyQueryLen));
m_key = keyStr.ToInteger(&rv, 10);
NS_ENSURE_SUCCESS(rv, NS_ERROR_MALFORMED_URI);
}
} else
MsgUnescapeString(path, 0, m_group);
return NS_OK;
}
// boolean equals (in nsIURI other)
// (based on nsSimpleURI::Equals)
NS_IMETHODIMP nsLDAPURL::Equals(nsIURI *other, bool *_retval)
{
*_retval = false;
if (other)
{
nsresult rv;
nsCOMPtr<nsILDAPURL> otherURL(do_QueryInterface(other, &rv));
if (NS_SUCCEEDED(rv))
{
nsAutoCString thisSpec, otherSpec;
uint32_t otherOptions;
rv = GetSpec(thisSpec);
NS_ENSURE_SUCCESS(rv, rv);
rv = otherURL->GetSpec(otherSpec);
NS_ENSURE_SUCCESS(rv, rv);
rv = otherURL->GetOptions(&otherOptions);
NS_ENSURE_SUCCESS(rv, rv);
if (thisSpec == otherSpec && mOptions == otherOptions)
*_retval = true;
}
}
return NS_OK;
}
uint32 gnGenomeSpec::GetFeatureListLength() const
{
uint32 len = 0;
for(uint32 i=0; i < GetSpecListLength(); i++)
len += GetSpec(i)->GetFeatureListLength();
return len;
}
uint32 gnGenomeSpec::AddFeature( gnBaseFeature* feat ){
uint32 count = 0;
uint32 len = 0;
uint32 featureI = 0;
uint32 specListLen = GetSpecListLength();
for(uint32 specI = 0; specI < specListLen; specI++){
len = GetSpec(specI)->GetLength();
gnLocation lt(count, count+len);
if(feat->IsContainedBy(lt)){
return featureI + GetSpec(specI)->AddFeature(feat);
}
count += len;
featureI += GetSpec(specI)->GetFeatureListLength();
}
//if we get this far then the feature has invalid coordinates
Throw_gnEx(SeqIndexOutOfBounds());
}
void gnGenomeSpec::GetBrokenFeatures(const gnLocation& lt, vector<gnBaseFeature*>& feature_vector) const{
uint32 ss_size = GetSpecListLength();
uint32 fl_size = 0;
gnSeqI start_base = 0;
for(uint32 i=0; i < ss_size; i++){
gnLocation sub_lt = lt;
gnSeqI sub_len = GetSpec(i)->GetLength();
sub_lt.MoveNegative(start_base);
sub_lt.CropEnd(sub_len);
GetSpec(i)->GetBrokenFeatures(sub_lt, feature_vector);
uint32 fvs = feature_vector.size();
for(uint32 j = 0; j < fvs; j++)
feature_vector[j]->MovePositive(start_base);
if(fvs > 0)
return;
start_base += sub_len;
fl_size += GetSpec(i)->GetFeatureListLength();
}
}
gnGenomeSpec* gnGenomeSpec::CloneRange( const gnSeqI startI, const gnSeqI len ) const{
if(len == 0)
return new gnGenomeSpec();
//find the valid range of specs to copy
uint32 firstSpec = GetSpecIndexByBase(startI);
gnSeqI total_copylen = len;
uint32 endSpec;
if(len != GNSEQI_END){
endSpec = GetSpecIndexByBase(startI + len - 1);
}else{
endSpec = GetSpecListLength() - 1;
total_copylen = GetLength() - startI;
}
//find their starting and ending bases
gnSeqI firstBase = startI - GetSpecStartBase(firstSpec);
gnSeqI firstSpecLen = GetSpec(firstSpec)->GetLength();
boolean spans_specs = true;
gnSeqI firstCopyLen = firstSpecLen - firstBase;
if(firstCopyLen >= total_copylen){
spans_specs = false;
firstCopyLen = total_copylen;
}
gnGenomeSpec* destSpec = new gnGenomeSpec();
gnFragmentSpec* newSpec = m_SpecList[firstSpec]->CloneRange(firstBase, firstCopyLen);
destSpec->AddSpec( newSpec );
gnSeqI cur_copylen = firstCopyLen;
//add all the completely covered specs in the middle
for(uint32 specI = firstSpec + 2; specI <= endSpec; specI++){
destSpec->AddSpec(GetSpec(specI-1)->Clone());
cur_copylen += GetSpec(specI-1)->GetLength();
}
//add the last spec if necessary
if(spans_specs){
newSpec = m_SpecList[endSpec]->CloneRange( 0, total_copylen - cur_copylen);
destSpec->AddSpec(newSpec);
}
return destSpec;
}
int main(int argc,char ** argv)
{
int i,k;
char name[100];
int ns;
SPEC_DATA spec;
double f=1000;
double sampleRate=44100.;
double fband=25;
double fmin=200;
double fmax=8000;
spec.f=f;
spec.fband=fband;
spec.sampleRate=sampleRate;
sprintf(name,"%s",argv[1]);
double * input=load_wave_file(name,&ns);
TimeFreq(input,ns,sampleRate,f,fband,&spec);
double amin=-0.70, amax=0.0, da=0.01;
double bmin=-0.70, bmax=0.0, db=0.001;
int frame;
int nb=10;
int imax[nb];
double vmax[nb];
double vtmax;
for(frame=0;frame<spec.frameCount;frame++)
{
int size;
double * v = GetSpec(&spec,frame,fmax,fmin,&size);
int fftLen=spec.winLength;
int imin=ceil(fmin/sampleRate*fftLen);
int ixmax=ceil(fmax/sampleRate*fftLen);
int nfreq=ixmax-imin;
find_max_divisors(v,nfreq,1,vmax,imax);
printf("%d %lg %lg ",frame,fmin+(fmax-fmin)*imax[0]/nfreq,vmax[0]);
vtmax=vmax[0];
find_max_divisors(v,nfreq,nb,vmax,imax);
for(i=0;i<nb;i++)
printf("%lg %lg ",fmin+(fmax-fmin)*imax[i]/nfreq,vmax[i]/vtmax);
printf("\n");
free(v);
}
free(spec.data);
free(spec.input);
}
PGPError
PFLGetFSSpecFromFileSpec(
PFLConstFileSpecRef ref,
FSSpec * spec)
{
PGPError err = kPGPError_NoErr;
PGPValidatePtr( spec );
pgpClearMemory( spec, sizeof( *spec ) );
PFLValidateFileSpec( ref );
err = GetSpec( ref, spec, NULL );
return err;
}
int Bitmaps::ReadOne()
{
int offset;
offset = 1;
this->_spec = GetSpec();
this->_combat = GetCombat();
this->_follow = GetFollow();
this->_forceFollow = GetForceFollow();
this->_casting = GetCasting();
//printf("Spec: %d\n",this->_spec);
//printf("Combat: %d\n",this->_combat);
//printf("Follow: %d\n",this->_follow);
//printf("ForceFollow: %d\n",this->_forceFollow);
//printf("Casting: %d\n",this->_casting);
return 1;
}
// from nsIMsgMessageUrl
NS_IMETHODIMP nsNntpUrl::GetUri(char **aURI) {
nsresult rv = NS_OK;
// if we have been given a uri to associate with this url, then use it
// otherwise try to reconstruct a URI on the fly....
if (mURI.IsEmpty()) {
nsAutoCString spec;
rv = GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
mURI = spec;
}
*aURI = ToNewCString(mURI);
if (!*aURI) return NS_ERROR_OUT_OF_MEMORY;
return rv;
}
NS_IMETHODIMP nsNntpUrl::SetSpec(const nsACString &aSpec)
{
// For [s]news: URIs, we need to munge the spec if it is no authority, because
// the URI parser guesses the wrong thing otherwise
nsCString parseSpec(aSpec);
int32_t colon = parseSpec.Find(":");
// Our smallest scheme is 4 characters long, so colon must be at least 4
if (colon < 4 || colon + 1 == (int32_t) parseSpec.Length())
return NS_ERROR_MALFORMED_URI;
if (Substring(parseSpec, colon - 4, 4).EqualsLiteral("news") &&
parseSpec[colon + 1] != '/')
{
// To make this parse properly, we add in three slashes, which convinces the
// parser that the authority component is empty.
parseSpec = Substring(aSpec, 0, colon + 1);
parseSpec.AppendLiteral("///");
parseSpec += Substring(aSpec, colon + 1);
}
nsresult rv = nsMsgMailNewsUrl::SetSpec(parseSpec);
NS_ENSURE_SUCCESS(rv,rv);
nsAutoCString scheme;
rv = GetScheme(scheme);
NS_ENSURE_SUCCESS(rv, rv);
if (scheme.EqualsLiteral("news") || scheme.EqualsLiteral("snews"))
rv = ParseNewsURL();
else if (scheme.EqualsLiteral("nntp") || scheme.EqualsLiteral("nntps"))
rv = ParseNntpURL();
else if (scheme.EqualsLiteral("news-message"))
{
nsAutoCString spec;
GetSpec(spec);
rv = nsParseNewsMessageURI(spec.get(), m_group, &m_key);
NS_ENSURE_SUCCESS(rv, NS_ERROR_MALFORMED_URI);
}
else
return NS_ERROR_MALFORMED_URI;
NS_ENSURE_SUCCESS(rv, rv);
rv = DetermineNewsAction();
NS_ENSURE_SUCCESS(rv,rv);
return rv;
}
NS_IMETHODIMP
nsMozIconURI::Equals(nsIURI *other, PRBool *result)
{
NS_ENSURE_ARG_POINTER(other);
NS_PRECONDITION(result, "null pointer");
nsCAutoString spec1;
nsCAutoString spec2;
other->GetSpec(spec2);
GetSpec(spec1);
if (!PL_strcasecmp(spec1.get(), spec2.get()))
*result = PR_TRUE;
else
*result = PR_FALSE;
return NS_OK;
}
NS_IMETHODIMP nsNntpUrl::GetMessageHeader(nsIMsgDBHdr ** aMsgHdr)
{
nsresult rv;
nsCOMPtr <nsINntpService> nntpService = do_GetService(NS_NNTPSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr <nsIMsgMessageService> msgService = do_QueryInterface(nntpService, &rv);
NS_ENSURE_SUCCESS(rv,rv);
nsAutoCString spec(mOriginalSpec);
if (spec.IsEmpty())
// Handle the case where necko directly runs an internal news:// URL,
// one that looks like news://host/message-id?group=mozilla.announce&key=15
// Other sorts of URLs -- e.g. news://host/message-id -- will not succeed.
GetSpec(spec);
return msgService->MessageURIToMsgHdr(spec.get(), aMsgHdr);
}
PGPError
pgpPlatformNewDirectoryIter(
PFLConstFileSpecRef parentDir,
PFLDirectoryIterRef * outIter )
{
PGPMemoryMgrRef memoryMgr = parentDir->memoryMgr;
PGPError err = kPGPError_NoErr;
FSSpec spec;
PFLDirectoryIterRef newIter = NULL;
CInfoPBRec cpb;
*outIter = NULL;
PGPValidateParam( parentDir->type == kPFLFileSpecMacType );
PGPValidateMemoryMgr( memoryMgr );
err = GetSpec( parentDir, &spec, &cpb );
if( IsntPGPError( err ) )
{
newIter = (PFLDirectoryIterRef)PGPNewData( memoryMgr,
sizeof( *newIter ), 0 );
if ( NULL!=(int)( newIter ) )
{
pgpAssert( cpbIsFolder( &cpb ) );
newIter->memoryMgr = memoryMgr;
newIter->vRefNum = spec.vRefNum;
newIter->parID = cpb.dirInfo.ioDrDirID;
newIter->dirIndex = 1;
}
else
{
err = kPGPError_OutOfMemory;
}
}
if ( IsntPGPError( err ) )
*outIter = newIter;
else if ( NULL!=(int)( newIter ) )
PGPFreeData( newIter );
return err;
}
NS_IMETHODIMP nsMsgMailNewsUrl::Clone(nsIURI **_retval)
{
nsresult rv;
nsCAutoString urlSpec;
nsCOMPtr<nsIIOService> ioService = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = GetSpec(urlSpec);
NS_ENSURE_SUCCESS(rv, rv);
rv = ioService->NewURI(urlSpec, nsnull, nsnull, _retval);
NS_ENSURE_SUCCESS(rv, rv);
// add the msg window to the cloned url
nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(m_msgWindowWeak));
if (msgWindow)
{
nsCOMPtr<nsIMsgMailNewsUrl> msgMailNewsUrl = do_QueryInterface(*_retval, &rv);
NS_ENSURE_SUCCESS(rv, rv);
msgMailNewsUrl->SetMsgWindow(msgWindow);
}
return rv;
}
NS_IMETHODIMP MsgMailNewsUrlBase::Clone(nsIURI **_retval)
{
nsresult rv;
nsAutoCString urlSpec;
nsCOMPtr<nsIIOService> ioService =
mozilla::services::GetIOService();
NS_ENSURE_TRUE(ioService, NS_ERROR_UNEXPECTED);
rv = GetSpec(urlSpec);
NS_ENSURE_SUCCESS(rv, rv);
rv = ioService->NewURI(urlSpec, nullptr, nullptr, _retval);
NS_ENSURE_SUCCESS(rv, rv);
// add the msg window to the cloned url
nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(m_msgWindowWeak));
if (msgWindow)
{
nsCOMPtr<nsIMsgMailNewsUrl> msgMailNewsUrl = do_QueryInterface(*_retval, &rv);
NS_ENSURE_SUCCESS(rv, rv);
msgMailNewsUrl->SetMsgWindow(msgWindow);
}
return rv;
}
PGPError
pgpPlatformGetFileInfo(
PFLConstFileSpecRef ref,
PFLFileInfo * outInfo )
{
PGPError err = kPGPError_NoErr;
FSSpec spec;
CInfoPBRec cpb;
PGPValidateParam( ref->type == kPFLFileSpecMacType );
err = GetSpec( ref, &spec, &cpb );
if( IsntPGPError( err ) )
{
time_t nowStdTime = time( NULL );
unsigned long nowMacTime;
if( cpbIsFolder( &cpb ) )
{
outInfo->flags = kPGPFileInfo_IsDirectory;
outInfo->dataLength = 0;
}
else
{
outInfo->flags = kPGPFileInfo_IsPlainFile;
outInfo->dataLength = cpbDataForkSize( &cpb );
}
GetDateTime( &nowMacTime );
outInfo->modificationTime = (time_t)(cpbModificationDate( &cpb )
+ ((unsigned long)nowStdTime - nowMacTime));
}
return err;
}
NS_IMETHODIMP
nsMozIconURI::GetAsciiSpec(nsACString &aSpecA)
{
return GetSpec(aSpecA);
}
void AasRenderer::Render(gfx::AnimatedModel *model,
const gfx::AnimatedModelParams& params,
gsl::span<Light3d> lights,
const MdfRenderOverrides *materialOverrides) {
// Find or create render caching data for the model
auto &renderData = mRenderDataCache[model->GetHandle()];
if (!renderData) {
renderData = std::make_unique<AasRenderData>();
}
auto materialIds(model->GetSubmeshes());
for (size_t i = 0; i < materialIds.size(); ++i) {
auto materialId = materialIds[i];
auto submesh(model->GetSubmesh(params, i));
// Remove special material marker in the upper byte and only
// use the actual shader registration id
materialId &= 0x00FFFFFF;
// Usually this should not happen, since it means there's
// an unbound replacement material
if (materialId == 0) {
continue;
}
// if material was not found
if (materialId == 0x00FFFFFF) {
continue;
}
auto material = mMdfFactory.GetById(materialId);
if (!material) {
logger->error("Legacy shader with id {} wasn't found.", materialId);
continue;
}
material->Bind(mDevice, lights, materialOverrides);
// Do we have to recalculate the normals?
if (material->GetSpec()->recalculateNormals) {
RecalcNormals(
submesh->GetVertexCount(),
submesh->GetPositions().data(),
submesh->GetNormals().data(),
submesh->GetPrimitiveCount(),
submesh->GetIndices().data()
);
}
auto &submeshData = GetSubmeshData(*renderData, i, *submesh);
submeshData.binding.Bind();
auto d3d = mDevice.GetDevice();
d3d->SetIndices(submeshData.idxBuffer->GetBuffer());
D3DLOG(d3d->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, submesh->GetVertexCount(), 0, submesh->GetPrimitiveCount()));
}
}
