AudioEngine::AudioEngine()
: m_pTempBuffer(),
m_pMixBuffer(0),
m_pLimiter(0),
m_bEnabled(true),
m_Volume(1),
m_bInitialized(false)
{
AVG_ASSERT(s_pInstance == 0);
if (SDL_InitSubSystem(SDL_INIT_AUDIO) == -1) {
AVG_LOG_ERROR("Can't init SDL audio subsystem.");
exit(-1);
}
s_pInstance = this;
}
xmlXPathObjectPtr TrackerConfig::findConfigNodes(const string& sXPathExpr) const
{
string sFullPath = string("/trackerconfig"+sXPathExpr);
xmlXPathContextPtr xpCtx;
xmlXPathObjectPtr xpElement;
xpCtx = xmlXPathNewContext(m_Doc);
if(!xpCtx) {
AVG_LOG_ERROR("Unable to create new XPath context");
return NULL;
}
xpElement = xmlXPathEvalExpression(BAD_CAST sFullPath.c_str(), xpCtx);
if(!xpElement) {
AVG_LOG_ERROR("Unable to evaluate XPath expression '"
<< sFullPath << "'");
xmlXPathFreeContext(xpCtx);
return NULL;
}
xmlXPathFreeContext(xpCtx);
return xpElement;
}
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 = loadBitmap(*it);
FilterGrayscale().applyInPlace(pBmp);
setImgSize(pBmp->getSize());
m_pBmpQ->push(pBmp);
} catch (Exception& ex) {
AVG_LOG_ERROR(ex.getStr());
throw;
}
}
}
void TrackerConfig::loadConfigFile(const string& sFilename)
{
// TODO: There is duplicated code here and in Player::loadFile which belongs
// in a lower-level xml handling class.
registerDTDEntityLoader("trackerconfig.dtd", g_pTrackerConfigDTD);
xmlDtdPtr dtd;
string sDTDFName = "trackerconfig.dtd";
dtd = xmlParseDTD(NULL, (const xmlChar*) sDTDFName.c_str());
if (!dtd) {
AVG_LOG_WARNING("DTD not found at " << sDTDFName
<< ". Not validating trackerconfig files.");
}
// xmlParseFile crashes for some reason under Lion.
string sFileContents;
readWholeFile(sFilename, sFileContents);
m_Doc = xmlParseMemory(sFileContents.c_str(), sFileContents.length());
if (!m_Doc) {
AVG_LOG_ERROR("Could not open tracker config file " << sFilename <<
". Using defaults which will probably not work.");
return;
}
xmlValidCtxtPtr cvp = xmlNewValidCtxt();
cvp->error = xmlParserValidityError;
cvp->warning = xmlParserValidityWarning;
int isValid = xmlValidateDtd(cvp, m_Doc, dtd);
xmlFreeValidCtxt(cvp);
if (!isValid) {
throw (Exception(AVG_ERR_XML_PARSE, sFilename + " does not validate."));
}
m_pRoot = xmlDocGetRootElement(m_Doc);
xmlFreeDtd(dtd);
m_sFilename = sFilename;
AVG_TRACE(Logger::category::CONFIG, Logger::severity::INFO,
"Reading Tracker config file from " << sFilename);
}
int AudioDecoderThread::getBytesPerSample(int sampleFormat)
{
switch (sampleFormat) {
case AV_SAMPLE_FMT_U8:
return 1;
case AV_SAMPLE_FMT_S16:
return 2;
case AV_SAMPLE_FMT_S32:
return 4;
case AV_SAMPLE_FMT_FLT:
return 4;
case AV_SAMPLE_FMT_DBL:
return 8;
case AV_SAMPLE_FMT_S16P:
return 2;
case AV_SAMPLE_FMT_FLTP:
return 4;
default:
AVG_LOG_ERROR("Unknown SampleFormat: " << sampleFormat << "\n");
AVG_ASSERT(false);
return 0;
}
}
OGLShader::OGLShader(const string& sName, const string& sVertProgram,
const string& sFragProgram, const string& sVertPrefix, const string& sFragPrefix)
: m_sName(sName),
m_sVertProgram(sVertProgram),
m_sFragProgram(sFragProgram)
{
m_hProgram = glproc::CreateProgram();
glproc::BindAttribLocation(m_hProgram, VertexArray::TEX_INDEX, "a_TexCoord");
glproc::BindAttribLocation(m_hProgram, VertexArray::COLOR_INDEX, "a_Color");
glproc::BindAttribLocation(m_hProgram, VertexArray::POS_INDEX, "a_Pos");
m_hVertexShader = compileShader(GL_VERTEX_SHADER, sVertProgram, sVertPrefix);
glproc::AttachShader(m_hProgram, m_hVertexShader);
m_hFragmentShader = compileShader(GL_FRAGMENT_SHADER, sFragProgram, sFragPrefix);
glproc::AttachShader(m_hProgram, m_hFragmentShader);
glproc::LinkProgram(m_hProgram);
GLContext::checkError("OGLShader::OGLShader: glLinkProgram()");
GLint bLinked;
glproc::GetProgramiv(m_hProgram, GL_LINK_STATUS, &bLinked);
if (!bLinked) {
AVG_LOG_ERROR("Linking shader program '"+sName+"' failed. Aborting.");
dumpInfoLog(m_hVertexShader, Logger::severity::ERROR);
dumpInfoLog(m_hFragmentShader, Logger::severity::ERROR);
dumpInfoLog(m_hProgram, Logger::severity::ERROR, true);
exit(-1);
} else {
AVG_TRACE(Logger::category::SHADER, Logger::severity::INFO,
"Linking shader program '"+sName+"'.");
dumpInfoLog(m_hVertexShader, Logger::severity::INFO);
dumpInfoLog(m_hFragmentShader, Logger::severity::INFO);
dumpInfoLog(m_hProgram, Logger::severity::INFO, true);
}
m_pShaderRegistry = &*ShaderRegistry::get();
m_TransformParam = *getParam<glm::mat4>("transform");
}
SDLWindow::SDLWindow(const DisplayParams& dp, GLConfig glConfig)
: Window(dp.getWindowParams(0), dp.isFullscreen()),
m_pLastMouseEvent(new MouseEvent(Event::CURSOR_MOTION, false, false, false,
IntPoint(-1, -1), MouseEvent::NO_BUTTON, glm::vec2(-1, -1), 0))
{
initTranslationTable();
// This "fixes" the default behaviour of SDL under x11, avoiding it
// to report relative mouse coordinates when going fullscreen and
// the mouse cursor is hidden (grabbed). So far libavg and apps based
// on it don't use relative coordinates.
setEnv("SDL_MOUSE_RELATIVE", "0");
const WindowParams& wp = dp.getWindowParams(0);
stringstream ss;
IntPoint pos = getPos();
if (pos.x != -1) {
ss << pos.x << "," << pos.y;
setEnv("SDL_VIDEO_WINDOW_POS", ss.str().c_str());
}
unsigned int flags = 0;
if (dp.isFullscreen()) {
flags |= SDL_FULLSCREEN;
}
if (!wp.m_bHasWindowFrame) {
flags |= SDL_NOFRAME;
}
IntPoint size = wp.m_Size;
SDL_Surface * pSDLSurface = 0;
#ifndef linux
if (glConfig.m_bUseDebugContext) {
glConfig.m_bUseDebugContext = false;
}
switch (dp.getBPP()) {
case 24:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 24);
break;
case 16:
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 16);
break;
default:
AVG_LOG_ERROR("Unsupported bpp " << dp.getBPP() <<
"in Window::init()");
exit(-1);
}
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL , 0);
flags |= SDL_OPENGL;
while (glConfig.m_MultiSampleSamples && !pSDLSurface) {
if (glConfig.m_MultiSampleSamples > 1) {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,
glConfig.m_MultiSampleSamples);
} else {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
}
pSDLSurface = SDL_SetVideoMode(size.x, size.y, dp.getBPP(), flags);
if (!pSDLSurface) {
glConfig.m_MultiSampleSamples = GLContext::nextMultiSampleValue(
glConfig.m_MultiSampleSamples);
}
}
#else
// Linux version: Context created manually, not by SDL
pSDLSurface = SDL_SetVideoMode(size.x, size.y, dp.getBPP(), flags);
#endif
if (!pSDLSurface) {
throw Exception(AVG_ERR_UNSUPPORTED, string("Setting SDL video mode failed: ")
+ SDL_GetError() + ". (size=" + toString(size) + ", bpp=" +
toString(dp.getBPP()) + ").");
}
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
int rc = SDL_GetWMInfo(&info);
AVG_ASSERT(rc != -1);
GLContext* pGLContext = GLContextManager::get()->createContext(glConfig, size, &info);
setGLContext(pGLContext);
#if defined(HAVE_XI2_1) || defined(HAVE_XI2_2)
SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
m_pXIMTInputDevice = 0;
#endif
SDL_WM_SetCaption("libavg", 0);
pGLContext->logConfig();
}
