int MOVE::localInit(double *p, int n_args)
{
if (n_args < 6) {
die(name(), "Wrong number of args.");
return(DONT_SCHEDULE);
}
m_dist = p[4];
m_rvbamp = p[5];
m_inchan = n_args > 6 ? (int)p[6] : AVERAGE_CHANS;
// copy global params into instrument
if (get_path_params(&rholoc[0], &thetaloc[0], &cartflag, &mindiff) < 0) {
die(name(), "get_path_params failed.");
return(DONT_SCHEDULE);
}
// treat mindiff as update rate in seconds
if (mindiff > 0.0) {
m_updateSamps = (int) (SR * mindiff + 0.5);
if (m_updateSamps <= BUFLEN)
{
setBufferSize(m_updateSamps);
#ifdef debug
printf("buffer size reset to %d samples\n", getBufferSize());
#endif
}
// if update rate is larger than BUFLEN samples, set buffer size
// to be some integer fraction of the desired update count, then
// reset update count to be multiple of this.
else {
int divisor = 2;
int newBufferLen;
while ((newBufferLen = m_updateSamps / divisor) > BUFLEN)
divisor++;
setBufferSize(newBufferLen);
m_updateSamps = newBufferLen * divisor;
#ifdef debug
printf("buffer size reset to %d samples\n", getBufferSize());
#endif
}
#ifdef debug
printf("updating every %d samps\n", m_updateSamps);
#endif
}
// tables for positional lookup
tableset(SR, m_dur, ARRAYSIZE, tabr);
tableset(SR, m_dur, ARRAYSIZE, tabt);
return 0;
}
int DMOVE::localInit(double *p, int n_args)
{
if (n_args < 7)
return die(name(), "Wrong number of args.");
m_dist = p[6];
if (m_dist < 0.0) {
rtcmix_advise(name(), "Using cartesian coordinate system");
m_dist *= -1.0;
m_cartflag = 1;
}
m_inchan = n_args > 7 ? (int)p[7] : AVERAGE_CHANS;
// copy global params into instrument
int ignoreme;
if (get_params(&ignoreme, &mindiff) < 0)
return die(name(), "get_params failed.");
// treat mindiff as update rate in seconds
if (mindiff > 0.0) {
m_updateSamps = (int) (SR * mindiff + 0.5);
if (m_updateSamps <= RTBUFSAMPS)
{
setBufferSize(m_updateSamps);
#ifdef debug
printf("buffer size reset to %d samples\n", getBufferSize());
#endif
}
// if update rate is larger than RTBUFSAMPS samples, set buffer size
// to be some integer fraction of the desired update count, then
// reset update count to be multiple of this.
else {
int divisor = 2;
int newBufferLen;
while ((newBufferLen = m_updateSamps / divisor) > RTBUFSAMPS)
divisor++;
setBufferSize(newBufferLen);
m_updateSamps = newBufferLen * divisor;
#ifdef debug
printf("buffer size reset to %d samples\n", getBufferSize());
#endif
}
#ifdef debug
printf("updating every %d samps\n", m_updateSamps);
#endif
}
return 0;
}
gl::Error StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
{
unsigned int curBufferSize = getBufferSize();
unsigned int writePos = getWritePosition();
if (size > curBufferSize)
{
gl::Error error = setBufferSize(std::max(size, 2 * curBufferSize), indexType);
if (error.isError())
{
return error;
}
setWritePosition(0);
}
else if (writePos + size > curBufferSize || writePos + size < writePos)
{
gl::Error error = discard();
if (error.isError())
{
return error;
}
setWritePosition(0);
}
return gl::Error(GL_NO_ERROR);
}
RESULT eDVBSectionReader::start(const eDVBSectionFilterMask &mask)
{
RESULT res;
if (fd < 0)
return -ENODEV;
notifier->start();
dmx_sct_filter_params sct;
sct.pid = mask.pid;
sct.timeout = 0;
sct.flags = DMX_IMMEDIATE_START;
if (mask.flags & eDVBSectionFilterMask::rfCRC)
{
sct.flags |= DMX_CHECK_CRC;
checkcrc = 1;
} else
checkcrc = 0;
memcpy(sct.filter.filter, mask.data, DMX_FILTER_SIZE);
memcpy(sct.filter.mask, mask.mask, DMX_FILTER_SIZE);
memcpy(sct.filter.mode, mask.mode, DMX_FILTER_SIZE);
setBufferSize(8192*8);
res = ::ioctl(fd, DMX_SET_FILTER, &sct);
if (!res)
{
active = 1;
}
return res;
}
void QQnxWindow::setParent(const QPlatformWindow *window)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << this->window() << "platformWindow =" << window;
// Cast away the const, we need to modify the hierarchy.
QQnxWindow* const newParent = static_cast<QQnxWindow*>(const_cast<QPlatformWindow*>(window));
if (newParent == m_parentWindow)
return;
removeFromParent();
m_parentWindow = newParent;
// Add to new hierarchy position.
if (m_parentWindow) {
if (m_parentWindow->m_screen != m_screen)
setScreen(m_parentWindow->m_screen);
m_parentWindow->m_childWindows.push_back(this);
// we don't need any buffers, since
// Qt will draw to the parent TLW
// backing store.
setBufferSize(QSize(1, 1));
} else {
m_screen->addWindow(this);
// recreate buffers, in case the
// window has been reparented and
// becomes a TLW
adjustBufferSize();
}
m_screen->updateHierarchy();
}
RESULT eDVBTSRecorder::start()
{
std::map<int,int>::iterator i(m_pids.begin());
if (m_running)
return -1;
if (m_target_fd == -1)
return -2;
if (i == m_pids.end())
return -3;
char filename[128];
snprintf(filename, 128, "/dev/dvb/adapter%d/demux%d", m_demux->adapter, m_demux->demux);
m_source_fd = ::open(filename, O_RDONLY | O_CLOEXEC);
if (m_source_fd < 0)
{
eDebug("FAILED to open demux (%s) in ts recoder (%m)", filename);
return -3;
}
setBufferSize(1024*1024);
dmx_pes_filter_params flt;
memset(&flt, 0, sizeof(flt));
flt.pes_type = DMX_PES_OTHER;
flt.output = DMX_OUT_TSDEMUX_TAP;
flt.pid = i->first;
++i;
flt.input = DMX_IN_FRONTEND;
flt.flags = 0;
int res = ::ioctl(m_source_fd, DMX_SET_PES_FILTER, &flt);
if (res)
{
eDebug("DMX_SET_PES_FILTER: %m");
::close(m_source_fd);
m_source_fd = -1;
return -3;
}
::ioctl(m_source_fd, DMX_START);
if (!m_target_filename.empty())
m_thread->startSaveMetaInformation(m_target_filename);
m_thread->start(m_source_fd);
m_running = 1;
while (i != m_pids.end()) {
startPID(i->first);
++i;
}
return 0;
}
// ---------------------------------------------------------------------
FileReader::FileReader(FileInputStream *inputStream, encoding::TextEncoding
decoder, uint32_t sizeBuffer)
: m_nInputBufferPos(0), m_nInputBufferLength(0)
{
setBufferSize(sizeBuffer);
setDecoder(encoding::BaseDecoder::getDecoder(decoder));
setInputStream(inputStream);
}
void QQnxRasterWindow::adjustBufferSize()
{
// When having a raster window we don't need any buffers, since
// Qt will draw to the parent TLW backing store.
const QSize windowSize = window()->parent() ? QSize(1,1) : window()->size();
if (windowSize != bufferSize())
setBufferSize(windowSize);
}
DisplayWrapper::DisplayWrapper()
{
bufferSize = 0;
outputLocation = 0;
setBufferSize(0);
display = DriverStationLCD::GetInstance();
displayDirty = true;
}
void QQnxWindow::adjustBufferSize()
{
if (m_parentWindow)
return;
const QSize windowSize = window()->size();
if (windowSize != bufferSize())
setBufferSize(windowSize);
}
void RosoutPanel::onSetup(wxCommandEvent& evt)
{
RosoutSetupDialog dialog(this, topic_, max_messages_);
if (dialog.ShowModal() == wxOK)
{
setTopic(dialog.getTopic());
setBufferSize(dialog.getBufferSize());
}
}
bool Net::openPort(S32 port, bool doBind)
{
if(udpSocket != InvalidSocket)
::closesocket(udpSocket);
// we turn off VDP in non-release builds because VDP does not support broadcast packets
// which are required for LAN queries (PC->Xbox connectivity). The wire protocol still
// uses the VDP packet structure, though.
int protocol = 0;
bool useVDP = false;
#ifdef TORQUE_DISABLE_PC_CONNECTIVITY
// Xbox uses a VDP (voice/data protocol) socket for networking
protocol = IPPROTO_VDP;
useVDP = true;
#endif
udpSocket = socket(AF_INET, SOCK_DGRAM, protocol);
if(udpSocket != InvalidSocket)
{
Net::Error error = NoError;
if (doBind)
{
error = bind(udpSocket, port);
}
if(error == NoError)
// start jc
// this little sucker limits LAN utilization to 1% of
// our modern 1Gb large window hardware.
// hard coded values ruin lives!
// error = setBufferSize(udpSocket, 32768);
error = setBufferSize(udpSocket, 32768*8);
// end jc
if(error == NoError && !useVDP)
error = setBroadcast(udpSocket, true);
if(error == NoError)
error = setBlocking(udpSocket, false);
if(error == NoError)
Con::printf("UDP initialized on port %d", port);
else
{
::closesocket(udpSocket);
udpSocket = InvalidSocket;
Con::printf("Unable to initialize UDP - error %d", error);
}
}
netPort = port;
return udpSocket != InvalidSocket;
}
RESULT eDVBSectionReader::start(const eDVBSectionFilterMask &mask)
{
RESULT res;
if (fd < 0)
return -ENODEV;
notifier->start();
#if HAVE_DVB_API_VERSION < 3
dmxSctFilterParams sct;
#else
dmx_sct_filter_params sct;
#endif
sct.pid = mask.pid;
sct.timeout = 0;
#if HAVE_DVB_API_VERSION < 3
sct.flags = 0;
#else
sct.flags = DMX_IMMEDIATE_START;
#endif
#if !FUZZING
if (mask.flags & eDVBSectionFilterMask::rfCRC)
{
sct.flags |= DMX_CHECK_CRC;
checkcrc = 1;
} else
#endif
checkcrc = 0;
memcpy(sct.filter.filter, mask.data, DMX_FILTER_SIZE);
memcpy(sct.filter.mask, mask.mask, DMX_FILTER_SIZE);
#if HAVE_DVB_API_VERSION >= 3
memcpy(sct.filter.mode, mask.mode, DMX_FILTER_SIZE);
setBufferSize(8192*8);
#endif
res = ::ioctl(fd, DMX_SET_FILTER, &sct);
if (!res)
{
#if HAVE_DVB_API_VERSION < 3
res = ::ioctl(fd, DMX_SET_NEGFILTER_MASK, mask.mode);
if (!res)
{
res = ::ioctl(fd, DMX_START, 0);
if (!res)
active = 1;
}
#else
active = 1;
#endif
}
return res;
}
/*
* デストラクタ。
* @return なし
*/
ScreenControl::~ScreenControl()
{
setDefaultColor();
setWindow(mInitWindow.Left, mInitWindow.Top, mInitWindow.Right, mInitWindow.Bottom);
setBufferSize(mInitBufferSize.X, mInitBufferSize.Y);
// 初期ハンドルの再設定
SetConsoleActiveScreenBuffer(mInitHandle);
// スクリーンバッファを解放
CloseHandle(mHandle);
mHandle = NULL;
}
angle::Result StaticIndexBufferInterface::reserveBufferSpace(const gl::Context *context,
unsigned int size,
gl::DrawElementsType indexType)
{
unsigned int curSize = getBufferSize();
if (curSize == 0)
{
return setBufferSize(context, size, indexType);
}
ASSERT(curSize >= size && indexType == getIndexType());
return angle::Result::Continue;
}
ParticleSystem::ParticleSystem(Image * sprite, unsigned int buffer) : pStart(0), pLast(0), pEnd(0), active(true), emissionRate(0),
emitCounter(0), lifetime(-1), life(0), particleLifeMin(0), particleLifeMax(0),
direction(0), spread(0), relative(false), speedMin(0), speedMax(0), gravityMin(0),
gravityMax(0), radialAccelerationMin(0), radialAccelerationMax(0),
tangentialAccelerationMin(0), tangentialAccelerationMax(0),
sizeStart(1), sizeEnd(1), sizeVariation(0), rotationMin(0), rotationMax(0),
spinStart(0), spinEnd(0), spinVariation(0)
{
this->sprite = sprite;
sprite->retain();
colorStart = Color(255, 255, 255, 255);
colorEnd = Color(255, 255, 255, 255);
setBufferSize(buffer);
}
unsigned EthernetFrame::setBack(ACE_UINT8* buffer, const unsigned bufLen) {
ACE_TRACE("EthernetFrame::setBack");
throwIfUninitialized(); // setHeader() has to be called first
if ( getExpectedLength() != bufLen + minBytesToDetermineLength() ) {
ND_ERROR("Expected length %d != %d + buffer size %d (type is %04X)!\n",
getExpectedLength(), minBytesToDetermineLength(), bufLen, getEtherType());
throw std::runtime_error("Expected Ethernet header/payload length is different than buffer.");
}
setBufferSize(getExpectedLength());
copyUnit(ptrUnit() + minBytesToDetermineLength(), buffer, bufLen);
return getUnitLength();
}
ParticleSystem::ParticleSystem(const ParticleSystem &p)
: pMem(nullptr)
, pFree(nullptr)
, pHead(nullptr)
, pTail(nullptr)
, particleVerts(nullptr)
, texture(p.texture)
, active(p.active)
, insertMode(p.insertMode)
, maxParticles(p.maxParticles)
, activeParticles(0)
, emissionRate(p.emissionRate)
, emitCounter(0.0f)
, position(p.position)
, prevPosition(p.prevPosition)
, areaSpreadDistribution(p.areaSpreadDistribution)
, areaSpread(p.areaSpread)
, lifetime(p.lifetime)
, life(p.lifetime) // Initialize with the maximum life time.
, particleLifeMin(p.particleLifeMin)
, particleLifeMax(p.particleLifeMax)
, direction(p.direction)
, spread(p.spread)
, speedMin(p.speedMin)
, speedMax(p.speedMax)
, linearAccelerationMin(p.linearAccelerationMin)
, linearAccelerationMax(p.linearAccelerationMax)
, radialAccelerationMin(p.radialAccelerationMin)
, radialAccelerationMax(p.radialAccelerationMax)
, tangentialAccelerationMin(p.tangentialAccelerationMin)
, tangentialAccelerationMax(p.tangentialAccelerationMax)
, linearDampingMin(p.linearDampingMin)
, linearDampingMax(p.linearDampingMax)
, sizes(p.sizes)
, sizeVariation(p.sizeVariation)
, rotationMin(p.rotationMin)
, rotationMax(p.rotationMax)
, spinStart(p.spinStart)
, spinEnd(p.spinEnd)
, spinVariation(p.spinVariation)
, offsetX(p.offsetX)
, offsetY(p.offsetY)
, colors(p.colors)
, quads(p.quads)
, relativeRotation(p.relativeRotation)
{
setBufferSize(maxParticles);
}
eDVBPESReader::eDVBPESReader(eDVBDemux *demux, eMainloop *context, RESULT &res): m_demux(demux), m_active(0)
{
m_fd = m_demux->openDemux();
if (m_fd >= 0)
{
setBufferSize(64*1024);
::fcntl(m_fd, F_SETFL, O_NONBLOCK);
m_notifier = eSocketNotifier::create(context, m_fd, eSocketNotifier::Read, false);
CONNECT(m_notifier->activated, eDVBPESReader::data);
res = 0;
} else
{
perror("openDemux");
res = errno;
}
}
ParticleSystem::ParticleSystem(Texture *texture, uint32 size)
: pMem(nullptr)
, pFree(nullptr)
, pHead(nullptr)
, pTail(nullptr)
, particleVerts(nullptr)
, texture(texture)
, active(true)
, insertMode(INSERT_MODE_TOP)
, maxParticles(0)
, activeParticles(0)
, emissionRate(0)
, emitCounter(0)
, areaSpreadDistribution(DISTRIBUTION_NONE)
, lifetime(-1)
, life(0)
, particleLifeMin(0)
, particleLifeMax(0)
, direction(0)
, spread(0)
, speedMin(0)
, speedMax(0)
, linearAccelerationMin(0, 0)
, linearAccelerationMax(0, 0)
, radialAccelerationMin(0)
, radialAccelerationMax(0)
, tangentialAccelerationMin(0)
, tangentialAccelerationMax(0)
, linearDampingMin(0.0f)
, linearDampingMax(0.0f)
, sizeVariation(0)
, rotationMin(0)
, rotationMax(0)
, spinStart(0)
, spinEnd(0)
, spinVariation(0)
, offsetX(float(texture->getWidth())*0.5f)
, offsetY(float(texture->getHeight())*0.5f)
, relativeRotation(false)
{
if (size == 0 || size > MAX_PARTICLES)
throw love::Exception("Invalid ParticleSystem size.");
sizes.push_back(1.0f);
colors.push_back(Colorf(1.0f, 1.0f, 1.0f, 1.0f));
setBufferSize(size);
}
gl::Error StaticIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
{
unsigned int curSize = getBufferSize();
if (curSize == 0)
{
return setBufferSize(size, indexType);
}
else if (curSize >= size && indexType == getIndexType())
{
return gl::Error(GL_NO_ERROR);
}
else
{
UNREACHABLE();
return gl::Error(GL_INVALID_OPERATION, "Internal static index buffers can't be resized");
}
}
gl::Error StaticVertexBufferInterface::reserveSpace(unsigned int size)
{
unsigned int curSize = getBufferSize();
if (curSize == 0)
{
return setBufferSize(size);
}
else if (curSize >= size)
{
return gl::Error(GL_NO_ERROR);
}
else
{
UNREACHABLE();
return gl::Error(GL_INVALID_OPERATION, "Internal error, Static vertex buffers can't be resized.");
}
}
bool StaticVertexBufferInterface::reserveSpace(unsigned int size)
{
unsigned int curSize = getBufferSize();
if (curSize == 0)
{
setBufferSize(size);
return true;
}
else if (curSize >= size)
{
return true;
}
else
{
UNREACHABLE(); // Static vertex buffers can't be resized
return false;
}
}
bool StaticIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
{
unsigned int curSize = getBufferSize();
if (curSize == 0)
{
return setBufferSize(size, indexType);
}
else if (curSize >= size && indexType == getIndexType())
{
return true;
}
else
{
ERR("Static index buffers can't be resized");
UNREACHABLE();
return false;
}
}
void ofxAudioUnitFftNode::setFftBufferSize(unsigned int bufferSize)
{
_log2N = (unsigned int) ceilf(log2f(bufferSize));
_N = 1 << _log2N;
// if the new buffer size is bigger than what we've allocated for,
// free everything and allocate anew (otherwise re-use)
if(_log2N > _currentMaxLog2N) {
freeBuffers();
_fftData.realp = (float *)calloc(_N / 2, sizeof(float));
_fftData.imagp = (float *)calloc(_N / 2, sizeof(float));
_window = (float *)calloc(_N, sizeof(float));
_fftSetup = vDSP_create_fftsetup(_log2N, kFFTRadix2);
_currentMaxLog2N = _log2N;
}
generateWindow(_outputSettings.window, _window, _N);
setBufferSize(_N);
}
angle::Result StreamingIndexBufferInterface::reserveBufferSpace(const gl::Context *context,
unsigned int size,
gl::DrawElementsType indexType)
{
unsigned int curBufferSize = getBufferSize();
unsigned int writePos = getWritePosition();
if (size > curBufferSize)
{
ANGLE_TRY(setBufferSize(context, std::max(size, 2 * curBufferSize), indexType));
setWritePosition(0);
}
else if (writePos + size > curBufferSize || writePos + size < writePos)
{
ANGLE_TRY(discard(context));
setWritePosition(0);
}
return angle::Result::Continue;
}
MultiChannelBuffer & MultiChannelBuffer::operator=( const MultiChannelBuffer & other )
{
if ( mBufferSize != other.mBufferSize )
{
setBufferSize(other.mBufferSize);
}
if ( mChannelCount != other.mChannelCount )
{
setChannelCount(other.mChannelCount);
}
for(int i = 0; i < mChannelCount; i++)
{
memcpy(mChannels[i], other.mChannels[i], sizeof(float)*mBufferSize);
}
return *this;
}
//==============================================================================
AudioAnalysisManager::AudioAnalysisManager(int bufferSize_) : bufferSize(bufferSize_), audioBuffer(bufferSize), gist(bufferSize,DEFAULT_SAMPLING_FREQUENCY)
{
setBufferSize(bufferSize);
// this function adds all algorithms that the plug-in will have access to
addAudioAnalysisAlgorithms();
currentAnalysisToPlotType = FloatOutput;
setAnalyserIdString("1");
vectorPlot.resize(512);
plotHistory.resize(512);
for (int i = 0;i < 512;i++)
{
plotHistory[i] = 0;
vectorPlot[i] = 0;
}
}
bool StreamingVertexBufferInterface::reserveSpace(unsigned int size)
{
bool result = true;
unsigned int curBufferSize = getBufferSize();
if (size > curBufferSize)
{
result = setBufferSize(std::max(size, 3 * curBufferSize / 2));
setWritePosition(0);
}
else if (getWritePosition() + size > curBufferSize)
{
if (!discard())
{
return false;
}
setWritePosition(0);
}
return result;
}
bool StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
{
bool result = true;
unsigned int curBufferSize = getBufferSize();
unsigned int writePos = getWritePosition();
if (size > curBufferSize)
{
result = setBufferSize(std::max(size, 2 * curBufferSize), indexType);
setWritePosition(0);
}
else if (writePos + size > curBufferSize || writePos + size < writePos)
{
if (!discard())
{
return false;
}
setWritePosition(0);
}
return result;
}
