void CMUCamera::setFeature(CameraFeature Feature, int Value, bool bIgnoreOldValue)
{
if (bIgnoreOldValue || m_Features[Feature] != Value) {
m_Features[Feature] = Value;
if (Feature == CAM_FEATURE_STROBE_DURATION) {
if (m_pCamera->HasStrobe()) {
C1394CameraControlStrobe* pControl = m_pCamera->GetStrobeControl(0);
int err = pControl->SetValue(Value);
checkCMUWarning(err == CAM_SUCCESS, "Error setting camera strobe.");
} else {
AVG_TRACE(Logger::WARNING, "Camera does not support strobe.");
}
} else {
CAMERA_FEATURE cmuFeature = getFeatureID(Feature);
if (m_pCamera->HasFeature(cmuFeature)) {
bool bAuto = (Value == -1);
C1394CameraControl* pControl = m_pCamera->GetCameraControl(cmuFeature);
int err1 = pControl->SetAutoMode(bAuto);
int err2 = CAM_SUCCESS;
if (!bAuto) {
err2 = pControl->SetValue(Value);
}
checkCMUWarning(err1 == CAM_SUCCESS && err2 == CAM_SUCCESS,
string("Error setting camera feature: ") +
cameraFeatureToString(Feature));
} else {
AVG_TRACE(Logger::WARNING, string("Camera does not support feature: ") +
cameraFeatureToString(Feature));
}
}
}
}
bool TrackerThread::init()
{
try {
m_pImagingContext = GLContext::create(
GLConfig(false, false, true, 1, GLConfig::AUTO, false));
createBandpassFilter();
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Using fragment shaders for imaging operations.");
} catch (Exception& e) {
AVG_LOG_WARNING(e.getStr());
AVG_TRACE(Logger::category::CONFIG, Logger::severity::WARNING,
"Using CPU for imaging operations (slow and inaccurate).");
m_pImagingContext = 0;
m_pBandpassFilter = FilterPtr(new FilterFastBandpass());
}
try {
m_StartTime = TimeSource::get()->getCurrentMillisecs();
m_HistoryDelay = m_pConfig->getIntParam("/tracker/historydelay/@value");
} catch (Exception& e) {
AVG_LOG_WARNING(e.getStr());
}
// Done in TrackerInputDevice::ctor to work around Leopard/libdc1394 threading issue.
// m_pCamera->open();
return true;
}
ColorNode::ColorNode(const ArgList& Args)
: m_sFillColorName("FFFFFF")
{
AVG_TRACE(Logger::category::PLUGIN, Logger::severity::INFO,
"ColorNode c'tor gets Argument fillcolor= " <<
Args.getArgVal<string>("fillcolor"));
Args.setMembers(this);
AVG_TRACE(Logger::category::PLUGIN, Logger::severity::INFO,
"ColorNode constructed with " << m_sFillColorName);
}
void TrackerThread::deinit()
{
m_pCamera = CameraPtr();
AVG_TRACE(Logger::category::PROFILE, Logger::severity::INFO,
"Total camera frames: " << m_NumFrames);
AVG_TRACE(Logger::category::PROFILE, Logger::severity::INFO,
"Camera frames discarded: " << m_NumCamFramesDiscarded);
if (m_pBandpassFilter) {
m_pBandpassFilter.reset();
}
if (m_pImagingContext) {
delete m_pImagingContext;
}
}
void AreaNode::maybeRender()
{
AVG_ASSERT(getState() == NS_CANRENDER);
if (isVisible()) {
if (getID() != "") {
AVG_TRACE(Logger::BLTS, "Rendering " << getTypeStr() <<
" with ID " << getID());
} else {
AVG_TRACE(Logger::BLTS, "Rendering " << getTypeStr());
}
m_Transform = getParentTransform()*calcTransform();
render();
}
}
void Image::setFilename(const std::string& sFilename, TextureCompression comp)
{
assertValid();
AVG_TRACE(Logger::category::MEMORY, Logger::severity::INFO, "Loading " << sFilename);
BitmapPtr pBmp = loadBitmap(sFilename);
if (comp == TEXTURECOMPRESSION_B5G6R5 && pBmp->hasAlpha()) {
throw Exception(AVG_ERR_UNSUPPORTED,
"B5G6R5-compressed textures with an alpha channel are not supported.");
}
changeSource(FILE);
m_pBmp = pBmp;
m_sFilename = sFilename;
switch (comp) {
case TEXTURECOMPRESSION_B5G6R5:
m_pBmp = BitmapPtr(new Bitmap(pBmp->getSize(), B5G6R5, sFilename));
if (!BitmapLoader::get()->isBlueFirst()) {
FilterFlipRGB().applyInPlace(pBmp);
}
m_pBmp->copyPixels(*pBmp);
break;
case TEXTURECOMPRESSION_NONE:
break;
default:
assert(false);
}
if (m_State == GPU) {
m_pSurface->destroy();
setupSurface();
}
assertValid();
}
OGLShader::OGLShader(const string& sName, const string& sProgram, const string& sDefines)
: m_sName(sName),
m_sProgram(sProgram)
{
m_hFragmentShader = glproc::CreateShaderObject(GL_FRAGMENT_SHADER);
const char * pProgramStrs[2];
pProgramStrs[0] = sDefines.c_str();
pProgramStrs[1] = m_sProgram.c_str();
glproc::ShaderSource(m_hFragmentShader, 2, pProgramStrs, 0);
glproc::CompileShader(m_hFragmentShader);
GLContext::getCurrent()->checkError("OGLShader::OGLShader: glCompileShader()");
dumpInfoLog(m_hFragmentShader);
m_hProgram = glproc::CreateProgramObject();
glproc::AttachObject(m_hProgram, m_hFragmentShader);
glproc::LinkProgram(m_hProgram);
GLContext::getCurrent()->checkError("OGLShader::OGLShader: glLinkProgram()");
GLint bLinked;
glproc::GetObjectParameteriv(m_hProgram, GL_OBJECT_LINK_STATUS_ARB, &bLinked);
dumpInfoLog(m_hProgram);
if (!bLinked) {
AVG_TRACE(Logger::ERROR, "Linking shader program '"+sName+"' failed. Aborting.");
exit(-1);
}
}
void DisplayEngine::checkJitter()
{
if (m_LastFrameTime == 0) {
m_EffFramerate = 0;
} else {
long long CurIntervalTime = TimeSource::get()->getCurrentMicrosecs()
-m_LastFrameTime;
m_EffFramerate = 1000000.0f/CurIntervalTime;
}
long long frameTime = TimeSource::get()->getCurrentMicrosecs();
int maxDelay;
if (m_VBRate == 0) {
maxDelay = 2;
} else {
maxDelay = 6;
}
if ((frameTime - m_TargetTime)/1000 > maxDelay || m_bFrameLate) {
AVG_TRACE (Logger::PROFILE_LATEFRAMES,
"DisplayEngine: frame too late by "
<< (frameTime - m_TargetTime)/1000 << " ms.");
m_bFrameLate = true;
m_FramesTooLate++;
}
m_LastFrameTime = frameTime;
m_TimeSpentWaiting += m_LastFrameTime-m_FrameWaitStartTime;
// cerr << m_LastFrameTime << ", m_FrameWaitStartTime=" << m_FrameWaitStartTime << endl;
// cerr << m_TimeSpentWaiting << endl;
}
AVPacket * FFMpegDemuxer::getPacket(int streamIndex)
{
// Make sure enableStream was called on streamIndex.
AVG_ASSERT(m_PacketLists.size() > 0);
AVG_ASSERT(streamIndex > -1 && streamIndex < 10);
if (m_PacketLists.find(streamIndex) == m_PacketLists.end()) {
cerr << this << ": getPacket: Stream " << streamIndex << " not found." << endl;
dump();
AVG_ASSERT(false);
}
PacketList& curPacketList = m_PacketLists.find(streamIndex)->second;
AVPacket* pPacket;
if (!curPacketList.empty()) {
// The stream has packets queued already.
pPacket = curPacketList.front();
curPacketList.pop_front();
} else {
// No packets queued for this stream -> read and queue packets until we get one
// that is meant for this stream.
do {
pPacket = new AVPacket;
memset(pPacket, 0, sizeof(AVPacket));
int err = av_read_frame(m_pFormatContext, pPacket);
if (err < 0) {
// EOF or error
if (err != int(AVERROR_EOF)) {
char sz[256];
av_strerror(err, sz, 256);
AVG_TRACE(Logger::category::PLAYER, Logger::severity::ERROR,
"Error decoding video: " << sz);
}
av_free_packet(pPacket);
delete pPacket;
pPacket = 0;
return 0;
}
if (pPacket->stream_index != streamIndex) {
if (m_PacketLists.find(pPacket->stream_index) != m_PacketLists.end()) {
// Relevant stream, but not ours
av_dup_packet(pPacket);
PacketList& otherPacketList =
m_PacketLists.find(pPacket->stream_index)->second;
otherPacketList.push_back(pPacket);
} else {
// Disabled stream
av_free_packet(pPacket);
delete pPacket;
pPacket = 0;
}
} else {
// Our stream
av_dup_packet(pPacket);
}
} while (!pPacket || pPacket->stream_index != streamIndex);
}
return pPacket;
}
void KeyEvent::trace()
{
Event::trace();
AVG_TRACE(Logger::EVENTS2, "Scancode: " << m_ScanCode
<< ", Keycode: " << m_KeyCode << ", KeyString: "
<< m_KeyString << ", Modifiers: " << m_Modifiers);
}
void RasterNode::checkReload()
{
string sLastMaskFilename = m_sMaskFilename;
string sMaskFilename = m_sMaskHref;
initFilename(sMaskFilename);
if (sLastMaskFilename != sMaskFilename) {
m_sMaskFilename = sMaskFilename;
try {
if (m_sMaskFilename != "") {
AVG_TRACE(Logger::category::MEMORY, Logger::severity::INFO,
"Loading " << m_sMaskFilename);
m_pMaskBmp = loadBitmap(m_sMaskFilename, I8);
setMaskCoords();
}
} catch (Exception & ex) {
if (ex.getCode() == AVG_ERR_VIDEO_GENERAL) {
throw;
}
m_sMaskFilename = "";
logFileNotFoundWarning(ex.getStr());
}
if (m_sMaskFilename == "") {
m_pMaskBmp = BitmapPtr();
getSurface()->setMask(MCTexturePtr());
}
if (getState() == Node::NS_CANRENDER && m_pMaskBmp) {
downloadMask();
}
} else {
setMaskCoords();
}
}
void ColorNode::setFillColor(const string& sFillColor)
{
AVG_TRACE(Logger::category::PLUGIN, Logger::severity::INFO,
"setFillColor called with " << sFillColor);
m_sFillColorName = sFillColor;
m_Color = colorStringToColor(m_sFillColorName);
}
void OGLShader::dumpInfoLog(GLuint hObj, long level, bool bIsProgram)
{
int infoLogLength;
GLchar * pInfoLog;
if (!hObj) {
return;
}
if (bIsProgram) {
glproc::GetProgramiv(hObj, GL_INFO_LOG_LENGTH, &infoLogLength);
} else {
glproc::GetShaderiv(hObj, GL_INFO_LOG_LENGTH, &infoLogLength);
}
GLContext::checkError("OGLShader::dumpInfoLog: glGetShaderiv()");
if (infoLogLength > 1) {
pInfoLog = (GLchar*)malloc(infoLogLength);
int charsWritten;
if (bIsProgram) {
glproc::GetProgramInfoLog(hObj, infoLogLength, &charsWritten, pInfoLog);
} else {
glproc::GetShaderInfoLog(hObj, infoLogLength, &charsWritten, pInfoLog);
}
string sLog = removeATIInfoLogSpam(pInfoLog);
GLContext::checkError("OGLShader::dumpInfoLog: glGetShaderInfoLog()");
if (sLog.size() > 3) {
AVG_TRACE(Logger::category::SHADER, level, sLog);
}
free(pInfoLog);
}
}
void TangibleEvent::trace()
{
CursorEvent::trace();
AVG_TRACE(Logger::category::EVENTS, Logger::severity::DEBUG, "pos: " << getPos()
<< ", ID: " << getCursorID()
<< ", Marker ID: " << m_MarkerID);
}
void AppleTrackpadInputDevice::start()
{
MultitouchInputDevice::start();
m_Device = MTDeviceCreateDefault();
MTRegisterContactFrameCallback(m_Device, callback);
MTDeviceStart(m_Device, 0);
AVG_TRACE(Logger::CONFIG, "Apple Trackpad Multitouch event source created.");
}
void TouchEvent::trace()
{
CursorEvent::trace();
AVG_TRACE(Logger::EVENTS2, "pos: " << getPos()
<< ", ID: " << getCursorID()
<< ", Area: " << m_Area
<< ", Eccentricity: " << m_Eccentricity);
}
void TouchEvent::trace()
{
CursorEvent::trace();
AVG_TRACE(Logger::category::EVENTS, Logger::severity::DEBUG, "pos: " << getPos()
<< ", ID: " << getCursorID()
<< ", Area: " << m_Area
<< ", Eccentricity: " << m_Eccentricity);
}
void FWCamera::startCapture()
{
#ifdef AVG_ENABLE_1394_2
int err = dc1394_video_set_transmission(m_pCamera, DC1394_ON);
AVG_ASSERT(err == DC1394_SUCCESS);
dc1394switch_t status = DC1394_OFF;
int i = 0;
while (status == DC1394_OFF && i++ < 5) {
usleep(50000);
err = dc1394_video_get_transmission(m_pCamera, &status);
AVG_ASSERT(err == DC1394_SUCCESS);
}
if (i == 5) {
AVG_ASSERT(false);
}
// Default to turning off any camera sharpness manipulation.
setFeature(CAM_FEATURE_SHARPNESS, 0);
// Turn off possible auto exposure.
dc1394_feature_set_mode(m_pCamera, DC1394_FEATURE_EXPOSURE,
DC1394_FEATURE_MODE_MANUAL);
dc1394_feature_set_power(m_pCamera, DC1394_FEATURE_EXPOSURE, DC1394_OFF);
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO, "Firewire camera opened.");
for (FeatureMap::iterator it=m_Features.begin(); it != m_Features.end(); it++) {
setFeature(it->first, it->second, true);
}
setWhitebalance(m_WhitebalanceU, m_WhitebalanceV, true);
if (getCamPF() == BAYER8) {
if (strcmp(m_pCamera->model, "DFx 31BF03") == 0) {
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Applying bayer pattern fixup for IS DFx31BF03 camera");
setCamPF(BAYER8_GRBG);
} else if (strcmp(m_pCamera->vendor, "Point Grey Research") == 0) {
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Applying bayer pattern fixup for PointGrey cameras");
enablePtGreyBayer();
}
}
#endif
}
NodePtr Canvas::getElementByID(const std::string& id)
{
if (m_IDMap.find(id) != m_IDMap.end()) {
return m_IDMap.find(id)->second;
} else {
AVG_TRACE(Logger::WARNING, "getElementByID(\"" << id << "\") failed.");
return NodePtr();
}
}
FWCamera::~FWCamera()
{
#ifdef AVG_ENABLE_1394_2
dc1394_video_set_transmission(m_pCamera, DC1394_OFF);
dc1394_capture_stop(m_pCamera);
dc1394_camera_free(m_pCamera);
dc1394_free(m_pDC1394);
#endif
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO, "Firewire camera closed.");
}
void DisplayEngine::setVBlankRate(int rate)
{
m_VBRate = rate;
if (m_bInitialized) {
bool bOK = GLContext::getCurrent()->initVBlank(rate);
m_Framerate = getRefreshRate()/m_VBRate;
if (!bOK || rate == 0) {
AVG_TRACE(Logger::WARNING, "Using framerate of " << m_Framerate <<
" instead of VBRate of " << m_VBRate);
m_VBRate = 0;
}
}
}
void VideoWriterThread::writeFrame(AVFrame* pFrame)
{
ScopeTimer timer(ProfilingZoneWriteFrame);
m_FramesWritten++;
AVCodecContext* pCodecContext = m_pVideoStream->codec;
AVPacket packet = { 0 };
int ret;
bool bGotOutput;
#if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(54, 0, 0)
av_init_packet(&packet);
int got_output = 0;
ret = avcodec_encode_video2(pCodecContext, &packet, pFrame, &got_output);
AVG_ASSERT(ret >= 0);
if ((pCodecContext->coded_frame->pts) != (long long)AV_NOPTS_VALUE) {
packet.pts = av_rescale_q(pCodecContext->coded_frame->pts,
pCodecContext->time_base, m_pVideoStream->time_base);
}
bGotOutput = (got_output != 0);
#else
int out_size = avcodec_encode_video(pCodecContext, m_pVideoBuffer,
VIDEO_BUFFER_SIZE, pFrame);
if (out_size > 0) {
av_init_packet(&packet);
if ((pCodecContext->coded_frame->pts) != (long long)AV_NOPTS_VALUE) {
packet.pts = av_rescale_q(pCodecContext->coded_frame->pts,
pCodecContext->time_base, m_pVideoStream->time_base);
}
if (pCodecContext->coded_frame->key_frame) {
packet.flags |= AV_PKT_FLAG_KEY;
}
packet.stream_index = m_pVideoStream->index;
packet.data = m_pVideoBuffer;
packet.size = out_size;
}
bGotOutput = (out_size > 0);
#endif
if (bGotOutput) {
/* write the compressed frame in the media file */
ret = av_interleaved_write_frame(m_pOutputFormatContext, &packet);
av_free_packet(&packet);
if (ret != 0) {
AVG_TRACE(Logger::category::VIDEO, Logger::severity::ERROR,
getAVErrorString(ret));
}
AVG_ASSERT(ret == 0);
}
}
void CMUCamera::internalGetFeature(CameraFeature Feature, unsigned short* val1,
unsigned short* val2) const
{
*val1 = -1;
*val2 = -1;
CAMERA_FEATURE cmuFeature = getFeatureID(Feature);
if (m_pCamera->HasFeature(cmuFeature)) {
C1394CameraControl* pControl = m_pCamera->GetCameraControl(cmuFeature);
pControl->Status();
pControl->GetValue(val1, val2);
} else {
AVG_TRACE(Logger::WARNING, string("Error reading camera feature: ") +
cameraFeatureToString(Feature));
}
}
void CMUCamera::setFeatureOneShot(CameraFeature Feature)
{
CAMERA_FEATURE cmuFeature = getFeatureID(Feature);
if (cmuFeature != FEATURE_INVALID_FEATURE && m_pCamera->HasFeature(cmuFeature)) {
C1394CameraControl* pControl = m_pCamera->GetCameraControl(cmuFeature);
int err1 = pControl->SetOnOff(false);
int err2 = pControl->SetAutoMode(false);
int err3 = pControl->SetOnePush(true);
checkCMUWarning(err1 == CAM_SUCCESS && err2 == CAM_SUCCESS
&& err3 == CAM_SUCCESS,
string("Error setting feature: ") + cameraFeatureToString(Feature));
} else {
AVG_TRACE(Logger::WARNING, string("Camera does not support feature: ") +
cameraFeatureToString(Feature));
}
}
FakeCamera::FakeCamera(std::vector<std::string>& pictures)
: Camera(I8, I8, IntPoint(640,480), 60),
m_pBmpQ(new std::queue<BitmapPtr>()),
m_bIsOpen(false)
{
for (vector<string>::iterator it = pictures.begin(); it != pictures.end(); ++it) {
try {
BitmapPtr pBmp (new Bitmap(*it));
FilterGrayscale().applyInPlace(pBmp);
setImgSize(pBmp->getSize());
m_pBmpQ->push(pBmp);
} catch (Exception& ex) {
AVG_TRACE(Logger::ERROR, ex.getStr());
throw;
}
}
}
int CMUCamera::getCamIndex(long long guid)
{
if (guid == 0) {
return 0;
} else {
for (int i=0; i<m_pCamera->GetNumberCameras(); ++i) {
m_pCamera->SelectCamera(i);
long long camGuid;
m_pCamera->GetCameraUniqueID((PLARGE_INTEGER)&camGuid);
if (camGuid == guid) {
return i;
}
}
AVG_TRACE(Logger::WARNING, string("Camera with guid ") + toString(guid)
+ " not present. Using first camera.");
return 0;
}
}
void OGLShader::dumpInfoLog(GLhandleARB hObj)
{
int InfoLogLength;
GLcharARB * pInfoLog;
glproc::GetObjectParameteriv(hObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &InfoLogLength);
GLContext::getCurrent()->checkError(
"OGLShader::dumpInfoLog: glGetObjectParameteriv()");
if (InfoLogLength > 1) {
pInfoLog = (GLcharARB*)malloc(InfoLogLength);
int CharsWritten;
glproc::GetInfoLog(hObj, InfoLogLength, &CharsWritten, pInfoLog);
string sLog = removeATIInfoLogSpam(pInfoLog);
GLContext::getCurrent()->checkError("OGLShader::dumpInfoLog: glGetInfoLog()");
AVG_TRACE(Logger::WARNING, sLog);
free(pInfoLog);
}
}
void AudioEngine::init(const AudioParams& ap, float volume)
{
m_Volume = volume;
if (!m_bInitialized) {
m_bInitialized = true;
m_AP = ap;
Dynamics<float, 2>* pLimiter = new Dynamics<float, 2>(float(m_AP.m_SampleRate));
pLimiter->setThreshold(0.f); // in dB
pLimiter->setAttackTime(0.f); // in seconds
pLimiter->setReleaseTime(0.05f); // in seconds
pLimiter->setRmsTime(0.f); // in seconds
pLimiter->setRatio(std::numeric_limits<float>::infinity());
pLimiter->setMakeupGain(0.f); // in dB
m_pLimiter = pLimiter;
SDL_AudioSpec desired;
desired.freq = m_AP.m_SampleRate;
desired.format = AUDIO_S16SYS;
desired.channels = m_AP.m_Channels;
desired.silence = 0;
desired.samples = m_AP.m_OutputBufferSamples;
desired.callback = audioCallback;
desired.userdata = this;
int err = SDL_OpenAudio(&desired, 0);
if (err < 0) {
AVG_TRACE(Logger::category::CONFIG, Logger::severity::WARNING,
"Can't open audio: " << SDL_GetError());
m_bStopGobbler = false;
m_bFakeAudio = true;
m_pGobblerThread = new boost::thread(&AudioEngine::consumeBuffers, this);
} else {
m_bFakeAudio = false;
}
} else {
if (m_bFakeAudio) {
m_bStopGobbler = false;
m_pGobblerThread = new boost::thread(&AudioEngine::consumeBuffers, this);
} else {
SDL_PauseAudio(0);
}
}
}
void XInputMTInputDevice::findMTDevice()
{
int ndevices;
XIDeviceInfo* pDevices;
XIDeviceInfo* pDevice;
pDevices = XIQueryDevice(s_pDisplay, XIAllDevices, &ndevices);
XITouchClassInfo* pTouchClass = 0;
for (int i = 0; i < ndevices && !pTouchClass; ++i) {
pDevice = &pDevices[i];
// cerr << "Device " << pDevice->name << "(id: " << pDevice->deviceid << ")."
// << endl;
if (pDevice->use == XISlavePointer || pDevice->use == XIFloatingSlave) {
for (int j = 0; j < pDevice->num_classes; ++j) {
XIAnyClassInfo * pClass = pDevice->classes[j];
if (pClass->type == XITouchClass) {
XITouchClassInfo* pTempTouchClass = (XITouchClassInfo *)pClass;
if (pTempTouchClass->mode == XIDirectTouch) {
pTouchClass = pTempTouchClass;
m_sDeviceName = pDevice->name;
m_DeviceID = pDevice->deviceid;
if (pDevice->use == XISlavePointer) {
m_OldMasterDeviceID = pDevice->attachment;
} else {
m_OldMasterDeviceID = -1;
}
break;
}
}
}
}
}
if (pTouchClass) {
AVG_TRACE(Logger::category::CONFIG,Logger::severity::INFO,
"Using multitouch input device " << m_sDeviceName << ", max touches: " <<
pTouchClass->num_touches);
} else {
throw Exception(AVG_ERR_MT_INIT,
"XInput multitouch event source: No multitouch device found.");
}
XIFreeDeviceInfo(pDevices);
}
ImageCache::ImageCache()
: m_CPUCacheUsed(0),
m_GPUCacheUsed(0)
{
glm::vec2 sizeOpt = ConfigMgr::get()->getSizeOption("scr", "imgcachesize");
if (sizeOpt[0] == -1) {
m_CPUCacheCapacity = (long long)(getPhysMemorySize())/4;
} else {
m_CPUCacheCapacity = (long long)(sizeOpt[0])*1024*1024;
}
if (sizeOpt[1] == -1) {
m_GPUCacheCapacity = 16*1024*1024;
} else {
m_GPUCacheCapacity = (long long)(sizeOpt[1])*1024*1024;
}
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Image cache size: CPU=" << m_CPUCacheCapacity/(1024*1024) <<
"MB, GPU=" << m_GPUCacheCapacity/(1024*1024) << "MB" << endl);
}
