void CVDPAU::BindPixmap()
{
CSharedLock lock(m_DecoderSection);
{ CSharedLock dLock(m_DisplaySection);
if (m_DisplayState != VDPAU_OPEN)
return;
}
if (m_glPixmap)
{
if(presentSurface != VDP_INVALID_HANDLE)
{
VdpPresentationQueueStatus status;
VdpTime time;
VdpStatus vdp_st;
vdp_st = vdp_presentation_queue_query_surface_status(
vdp_flip_queue, presentSurface, &status, &time);
CheckStatus(vdp_st, __LINE__);
while(status != VDP_PRESENTATION_QUEUE_STATUS_VISIBLE && vdp_st == VDP_STATUS_OK)
{
Sleep(1);
vdp_st = vdp_presentation_queue_query_surface_status(
vdp_flip_queue, presentSurface, &status, &time);
CheckStatus(vdp_st, __LINE__);
}
}
glXBindTexImageEXT(m_Display, m_glPixmap, GLX_FRONT_LEFT_EXT, NULL);
}
else CLog::Log(LOGERROR,"(VDPAU) BindPixmap called without valid pixmap");
}
bool CVDPAU::GetPicture(AVCodecContext* avctx, AVFrame* frame, DVDVideoPicture* picture)
{
CSharedLock lock(m_DecoderSection);
{ CSharedLock dLock(m_DisplaySection);
if (m_DisplayState != VDPAU_OPEN)
return false;
}
*picture = m_DVDVideoPics.front();
// if this is the first field of an interlaced frame, we'll need
// this same picture for the second field later
if (m_mixerstep != 1)
m_DVDVideoPics.pop();
picture->format = DVDVideoPicture::FMT_VDPAU;
picture->iFlags &= DVP_FLAG_DROPPED;
picture->iWidth = OutWidth;
picture->iHeight = OutHeight;
picture->vdpau = this;
if(m_mixerstep)
{
picture->iRepeatPicture = -0.5;
if(m_mixerstep > 1)
{
picture->dts = DVD_NOPTS_VALUE;
picture->pts = DVD_NOPTS_VALUE;
}
}
return true;
}
void SynchCorrection::Reset(bool soft)
{
Log("SynchCorrection::Reset %u", soft);
m_dBiasCorrection = 0.0001;
m_iBiasDir = 0;
//m_dlastAdjustment = 1.0;
if (!soft)
{
CAutoLock lock(&m_csSampleQueueLock);
m_rtStart = 0;
m_dEVRAudioDelay = 0.0;
m_dlastAdjustment = 1.0;
m_iQualityDir = 0;
m_bQualityCorrectionOn = false;
m_rtAHwStartSet = false;
m_rtAHwStart = 0;
{
CAutoLock dLock(&m_csDeltaLock);
m_dDeltaError = 0.0;
}
SetBias(1.0);
SetAdjustment(1.0);
Flush();
}
}
void CVDPAU::FFDrawSlice(struct AVCodecContext *s,
const AVFrame *src, int offset[4],
int y, int type, int height)
{
CDVDVideoCodecFFmpeg* ctx = (CDVDVideoCodecFFmpeg*)s->opaque;
CVDPAU* vdp = (CVDPAU*)ctx->GetHardware();
// while we are waiting to recover we can't do anything
CSharedLock lock(vdp->m_DecoderSection);
{ CSharedLock dLock(vdp->m_DisplaySection);
if(vdp->m_DisplayState != VDPAU_OPEN)
return;
}
if(src->linesize[0] || src->linesize[1] || src->linesize[2]
|| offset[0] || offset[1] || offset[2])
{
CLog::Log(LOGERROR, "CVDPAU::FFDrawSlice - invalid linesizes or offsets provided");
return;
}
VdpStatus vdp_st;
vdpau_render_state * render;
render = (vdpau_render_state*)src->data[0];
if(!render)
{
CLog::Log(LOGERROR, "CVDPAU::FFDrawSlice - invalid context handle provided");
return;
}
// ffmpeg vc-1 decoder does not flush, make sure the data buffer is still valid
if (!vdp->IsSurfaceValid(render))
{
CLog::Log(LOGWARNING, "CVDPAU::FFDrawSlice - ignoring invalid buffer");
return;
}
uint32_t max_refs = 0;
if(s->pix_fmt == PIX_FMT_VDPAU_H264)
max_refs = render->info.h264.num_ref_frames;
if(vdp->decoder == VDP_INVALID_HANDLE
|| vdp->vdpauConfigured == false
|| vdp->max_references < max_refs)
{
if(!vdp->ConfigVDPAU(s, max_refs))
return;
}
vdp_st = vdp->vdp_decoder_render(vdp->decoder,
render->surface,
(VdpPictureInfo const *)&(render->info),
render->bitstream_buffers_used,
render->bitstream_buffers);
vdp->CheckStatus(vdp_st, __LINE__);
}
void DeviceMuxer::clear()
{
if (_device)
_device->readAll();
QMutexLocker rLock(_readLock);
_buffer.clear();
rLock.unlock();
QMutexLocker dLock(_dataLock);
_data.clear();
}
void CVDPAU::ReleasePixmap()
{
CSharedLock lock(m_DecoderSection);
{ CSharedLock dLock(m_DisplaySection);
if (m_DisplayState != VDPAU_OPEN)
return;
}
if (m_glPixmap)
{
glXReleaseTexImageEXT(m_Display, m_glPixmap, GLX_FRONT_LEFT_EXT);
}
else CLog::Log(LOGERROR,"(VDPAU) ReleasePixmap called without valid pixmap");
}
void InStream::routeUpdateHook() {
AutoMutex dLock(mDev.mLock);
AutoMutex sLock(mLock);
int newDevices = -1;
mParameters.get(AUDIO_PARAMETER_STREAM_ROUTING, newDevices);
if (mDevices != newDevices && newDevices != -1) {
ALOGD("Devices changed from 0x%08x to 0x%08x", mDevices, newDevices);
mDevices = (audio_devices_t) newDevices;
mDbgStr.clear();
deviceUpdatePrepare();
deviceUpdateFinish();
}
else
ALOGE("Bogus device update 0x%08x", newDevices);
}
void DeviceMuxer::handleReadyRead()
{
if (!_device)
return;
channel_t chan;
quint16 dataSize;
int hdrSize = sizeof(chan) + sizeof(dataSize);
QMutexLocker rLock(_readLock);
_buffer.append(_device->readAll());
rLock.unlock();
while (_buffer.size() >= hdrSize) {
rLock.relock();
// read the channel no. and size from the device
// Extract the channel no.
memcpy(&chan, _buffer.constData(), sizeof(chan));
// Extract the size
memcpy(&dataSize, _buffer.constData() + sizeof(chan), sizeof(dataSize));
// Now try to read out the data
while (_buffer.size() < hdrSize + dataSize) {
QCoreApplication::processEvents();
_buffer.append(_device->readAll());
}
QMutexLocker dLock(_dataLock);
_data[chan].append(_buffer.constData() + hdrSize, dataSize);
dLock.unlock();
_buffer.remove(0, hdrSize + dataSize);
// Release the read lock
rLock.unlock();
// Emit a signal after all locks are released
_readyReadEmitted[chan] = true;
emit readyRead(chan);
rLock.relock();
_buffer.append(_device->readAll());
rLock.unlock();
}
}
void CVDPAU::Present()
{
//CLog::Log(LOGNOTICE,"%s",__FUNCTION__);
VdpStatus vdp_st;
CSharedLock lock(m_DecoderSection);
{ CSharedLock dLock(m_DisplaySection);
if (m_DisplayState != VDPAU_OPEN)
return;
}
presentSurface = outputSurface;
vdp_st = vdp_presentation_queue_display(vdp_flip_queue,
presentSurface,
0,
0,
0);
CheckStatus(vdp_st, __LINE__);
}
int CVDPAU::FFGetBuffer(AVCodecContext *avctx, AVFrame *pic)
{
//CLog::Log(LOGNOTICE,"%s",__FUNCTION__);
CDVDVideoCodecFFmpeg* ctx = (CDVDVideoCodecFFmpeg*)avctx->opaque;
CVDPAU* vdp = (CVDPAU*)ctx->GetHardware();
struct pictureAge* pA = &vdp->picAge;
// while we are waiting to recover we can't do anything
CSharedLock lock(vdp->m_DecoderSection);
{ CSharedLock dLock(vdp->m_DisplaySection);
if(vdp->m_DisplayState != VDPAU_OPEN)
{
CLog::Log(LOGWARNING, "CVDPAU::FFGetBuffer - returning due to awaiting recovery");
return -1;
}
}
vdpau_render_state * render = NULL;
// find unused surface
for(unsigned int i = 0; i < vdp->m_videoSurfaces.size(); i++)
{
if(!(vdp->m_videoSurfaces[i]->state & (FF_VDPAU_STATE_USED_FOR_REFERENCE | FF_VDPAU_STATE_USED_FOR_RENDER)))
{
render = vdp->m_videoSurfaces[i];
render->state = 0;
break;
}
}
VdpStatus vdp_st = VDP_STATUS_ERROR;
if (render == NULL)
{
// create a new surface
VdpDecoderProfile profile;
ReadFormatOf(avctx->pix_fmt, profile, vdp->vdp_chroma_type);
render = (vdpau_render_state*)calloc(sizeof(vdpau_render_state), 1);
if (render == NULL)
{
CLog::Log(LOGWARNING, "CVDPAU::FFGetBuffer - calloc failed");
return -1;
}
vdp_st = vdp->vdp_video_surface_create(vdp->vdp_device,
vdp->vdp_chroma_type,
avctx->coded_width,
avctx->coded_height,
&render->surface);
vdp->CheckStatus(vdp_st, __LINE__);
if (vdp_st != VDP_STATUS_OK)
{
free(render);
CLog::Log(LOGERROR, "CVDPAU::FFGetBuffer - No Video surface available could be created");
return -1;
}
vdp->m_videoSurfaces.push_back(render);
}
if (render == NULL)
return -1;
pic->data[1] = pic->data[2] = NULL;
pic->data[0]= (uint8_t*)render;
pic->linesize[0] = pic->linesize[1] = pic->linesize[2] = 0;
if(pic->reference)
{
pic->age = pA->ip_age[0];
pA->ip_age[0]= pA->ip_age[1]+1;
pA->ip_age[1]= 1;
pA->b_age++;
}
else
{
pic->age = pA->b_age;
pA->ip_age[0]++;
pA->ip_age[1]++;
pA->b_age = 1;
}
pic->type= FF_BUFFER_TYPE_USER;
render->state |= FF_VDPAU_STATE_USED_FOR_REFERENCE;
pic->reordered_opaque= avctx->reordered_opaque;
return 0;
}
int DroidStimpackModuleDataComponent::handleObjectMenuSelect(CreatureObject* player, byte selectedID, PetControlDevice* controller) {
ManagedReference<DroidObject*> droid = getDroidObject();
DroidComponent* droidComponent = cast<DroidComponent*>(getParent());
if( droid == NULL || droidComponent == NULL) {
player->sendSystemMessage("@pet/droid_modules:stimpack_error");
return 0;
}
if( selectedID == LOAD_STIMPACK ) {
Locker dLock(droid);
Locker crossLoker(player,droid);
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory == NULL) {
player->sendSystemMessage("@pet/droid_modules:no_stimpacks");
return 0;
}
int foundStims = 0;
for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
SceneObject* item = inventory->getContainerObject(i);
if (!item->isTangibleObject())
continue;
TangibleObject* tano = cast<TangibleObject*>( item);
// check it they have atleast 1 stim pack
if (tano->isPharmaceuticalObject()) {
PharmaceuticalObject* pharma = cast<PharmaceuticalObject*>( tano);
if (pharma->isStimPack()) {
StimPack* stim = cast<StimPack*>(pharma);
if (stim->isClassA()) {
foundStims += 1;
}
}
}
}
if (foundStims == 0) {
player->sendSystemMessage("@pet/droid_modules:no_stimpacks");
return 0;
} else {
sendLoadUI(player);
return 0;
}
}
if( selectedID == REQUEST_STIMPACK ) {
// we need to check cooldown on droid
if( droid->isDead() || droid->isIncapacitated() || player->isDead()) {
return 0;
}
// Droid must have power
if( !droid->hasPower() ) {
droid->showFlyText("npc_reaction/flytext","low_power", 204, 0, 0); // "*Low Power*"
return 0;
}
if(droid->getPendingTask("droid_request_stimpack") != NULL) {
player->sendSystemMessage("@pet/droid_modules:stimpack_not_ready");
return 0;
}
// Submit repair task
Reference<Task*> task = new DroidStimpackTask( droid,player,controller->getCustomObjectName().toString() );
droid->addPendingTask("droid_request_stimpack", task, 1); // rte determines when it will fire it
}
return 0;
}
