ESourceState::TYPE OpenAL::GetSourceState(ALuint source)
{
if(!IsInitialized())
return ESourceState::_COUNT;
if(!IsSource(source))
return ESourceState::_COUNT;
GetLastError();
ALint state = 0;
alGetSourcei(source, AL_SOURCE_STATE, &state);
if(GetLastError() != AL_NO_ERROR)
return ESourceState::_COUNT;
switch(state)
{
case AL_PLAYING: return ESourceState::Playing;
case AL_PAUSED: return ESourceState::Paused;
case AL_STOPPED: return ESourceState::Stopped;
default: return ESourceState::_COUNT;
}
}
GMC_DCL(tp_FilHdr, OrigFilHdr)
{
tp_LocElm LocElm, LastLocElm;
tps_FileName DestFileName;
LocElm = NIL;
if (!IsSource(DestFilHdr)) {
SystemError("Destination of copy must be a source file or directory.\n");
goto done; }/*if*/;
FilHdr_HostFN(DestFileName, DestFilHdr, FALSE);
if (!IsDirectory_FileName(DestFileName)) {
if (IsList(OrigFilHdr)) {
SystemError("List objects can only be copied to directories.\n");
goto done; }/*if*/;
LocElm = Make_CopyLocElm(OrigFilHdr, DestFilHdr, FilHdr);
goto done; }/*if*/;
LastLocElm = NIL;
Get_CopyList(&LocElm, &LastLocElm, OrigFilHdr, DestFilHdr, FilHdr);
Clr_UnionFlags(OrigFilHdr);
done:;
Set_LocElm(FilHdr, LocElm);
}/*Exec_CopyCmd*/
void sftp_TraceStatus(struct SFTP_Entry *sEntry, int filenum, int linenum)
{
#ifdef RPC2DEBUG
struct TraceEntry *te;
te = (struct TraceEntry *)CBUF_NextSlot(TraceBuf);
te->tcode = STATUS;
if (IsSource(sEntry))
{
te->ph.GotEmAll = htonl(sEntry->SendLastContig);
te->ph.BitMask0 = (unsigned) htonl(sEntry->SendTheseBits[0]);
te->ph.BitMask1 = (unsigned) htonl(sEntry->SendTheseBits[1]);
}
else
{
te->ph.GotEmAll = htonl(sEntry->RecvLastContig);
te->ph.BitMask0 = (unsigned) htonl(sEntry->RecvTheseBits[0]);
te->ph.BitMask1 = (unsigned) htonl(sEntry->RecvTheseBits[1]);
}
te->ph.Opcode = htonl(-1);
te->ph.LocalHandle = htonl(sEntry->LocalHandle);
te->ph.RemoteHandle = htonl(sEntry->PInfo.RemoteHandle);
te->ph.SeqNumber = htonl(filenum);
te->ph.Flags = 0;
te->ph.SEFlags = 0;
te->ph.BodyLength = htonl(linenum);
#endif
}
GMC_DCL(tp_FilHdr, FilHdr)
{
FORBIDDEN(IsTargetsPtr(FilHdr));
while (!IsSource(FilHdr)) {
if (IsVTgtText(FilHdr) || FilHdr_FilTyp(FilHdr) == VirTargetsFilTyp) {
return FilHdr_Father(FilHdr_Father(FilHdr)); }/*if*/;
if (IsVTgt(FilHdr)) {
return FilHdr_Father(FilHdr_Father(FilHdr_Father(FilHdr))); }/*if*/;
FilHdr = FilHdr_Father(FilHdr); }/*while*/;
return FilHdr;
}/*Get_BaseVTgtFilHdr*/
GMC_DCL(tp_FilHdr, FilHdr)
{
tp_FilHdr ElmFilHdr;
if (FilHdr == ERROR) {
return ERROR; }/*if*/;
if (!IsSymLink(FilHdr) || FilHdr_Status(FilHdr) == STAT_Circular) {
return FilHdr; }/*if*/;
ElmFilHdr = FilHdr_ElmFilHdr(FilHdr);
FORBIDDEN(IsSymLink(ElmFilHdr) || !IsSource(ElmFilHdr));
return ElmFilHdr;
}/*Deref_SymLink*/
GMC_DCL(tp_FileName, FileName)
{
tp_FilHdr FilHdr, SymLinkFH;
FilHdr = OdinExpr_FilHdr(FileName);
if (FilHdr == ERROR) {
return; }/*if*/;
if (IsSource(FilHdr)) {
SymLinkFH = Deref_SymLink(Copy_FilHdr(FilHdr));
Set_Status(SymLinkFH, STAT_Unknown);
Ret_FilHdr(SymLinkFH);
Update_SrcFilHdr(FilHdr, FALSE); }/*if*/;
Ret_FilHdr(FilHdr);
}/*Local_Test*/
bool OpenAL::PushBufferQueue(ALuint source, ALuint buffer)
{
if(!IsInitialized())
return false;
if(!IsSource(source) || !IsBuffer(buffer))
return false;
GetLastError();
alSourceQueueBuffers(source, 1, &buffer);
return GetLastError() == AL_NO_ERROR;
};
bool OpenAL::SourcePause(ALuint source)
{
if(!IsInitialized())
return false;
if(!IsSource(source))
return false;
if(GetSourceState(source) == ESourceState::Paused)
return true;
GetLastError();
alSourcePause(source);
return GetLastError() == AL_NO_ERROR && GetSourceState(source) == ESourceState::Paused;
};
int OpenAL::GetProcessedBuffersCount(ALuint source)
{
if(!IsInitialized())
return 0;
if(IsSource(source) != AL_TRUE)
return 0;
GetLastError();
ALint processed = 0;
alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
return GetLastError() == AL_NO_ERROR ? processed : 0;
};
bool OpenAL::SetSourceProperties(ALuint source, const sSourceProperties &props)
{
if(!IsInitialized())
return false;
if(IsSource(source) != AL_TRUE)
return false;
GetLastError();
alSourcef(source, AL_GAIN, props.m_Volume);
alSourcef(source, AL_PITCH, props.m_Pitch);
alSourcei(source, AL_LOOPING, props.m_Looping ? AL_TRUE : AL_FALSE);
return GetLastError() == AL_NO_ERROR;
};
bool XMMediaStream::Close()
{
if (IsSource()) {
if (!LockReadWrite()) {
return false;
}
if (hasStarted == true) {
_XMStopMediaTransmit(2);
} else {
isTerminated = true;
}
UnlockReadWrite();
// Wait until the video system terminated
while(isTerminated == false) {
PThread::Sleep(10);
}
}
return OpalMediaStream::Close();
}
void
ScriptLoadRequest::MaybeCancelOffThreadScript()
{
MOZ_ASSERT(NS_IsMainThread());
if (!mOffThreadToken) {
return;
}
JSContext* cx = danger::GetJSContext();
// Follow the same conditions as ScriptLoader::AttemptAsyncScriptCompile
if (IsModuleRequest()) {
JS::CancelOffThreadModule(cx, mOffThreadToken);
} else if (IsSource()) {
JS::CancelOffThreadScript(cx, mOffThreadToken);
} else {
MOZ_ASSERT(IsBytecode());
JS::CancelOffThreadScriptDecoder(cx, mOffThreadToken);
}
mOffThreadToken = nullptr;
}
void XMMediaStream::OnPatchStart()
{
if (IsSource()) {
PSafeLockReadWrite safeLock(*this);
if (!safeLock.IsLocked()) {
return;
}
// Ensure the code below runs just once.
// Also avoid possible race conditions
if (hasStarted == true || isTerminated == true) {
return;
}
RTP_DataFrame::PayloadTypes payloadType = mediaFormat.GetPayloadType();
unsigned frameTime = mediaFormat.GetFrameTime();
unsigned framesPerSecond = (unsigned)round((double)OpalMediaFormat::VideoClockRate / (double)frameTime);
framesPerSecond = std::min((unsigned)XM_MAX_FPS, framesPerSecond);
framesPerSecond = std::max(framesPerSecond, (unsigned)1);
unsigned bitrate = mediaFormat.GetBandwidth();
bitrate = std::min(bitrate, XMOpalManager::GetManager()->GetVideoBandwidthLimit(mediaFormat));
unsigned flags = 0;
XMCodecIdentifier codecIdentifier = _XMGetMediaFormatCodec(mediaFormat);
XMVideoSize videoSize = _XMGetMediaFormatSize(mediaFormat);
if (codecIdentifier == XMCodecIdentifier_UnknownCodec ||
videoSize == XMVideoSize_NoVideo || videoSize == XMVideoSize_Custom) {
// Shouldn't actually happen
return;
}
if (codecIdentifier == XMCodecIdentifier_H263) {
// If we're sending H.263, we need to know which
// format to send. The payload code is submitted in the
// flags parameter
flags = payloadType;
if (payloadType == RTP_DataFrame::H263) {
cout << "Sending RFC2190" << endl;
} else {
cout << "Sending RFC2429" << endl;
}
} else if (codecIdentifier == XMCodecIdentifier_H264) {
unsigned packetizationMode = _XMGetH264PacketizationMode(mediaFormat);
if (packetizationMode == XM_H264_PACKETIZATION_MODE_SINGLE_NAL) {
// We send only at a limited bitrate to avoid too many
// NAL units which are TOO big to fit
if (bitrate > 380000) {
bitrate = 380000;
}
}
flags = (packetizationMode << 8) + (_XMGetH264Profile(mediaFormat) << 4) + _XMGetH264Level(mediaFormat);
}
videoTransmitterStream = this;
hasStarted = true;
dataFrame.SetPayloadSize(0);
dataFrame.SetPayloadType(payloadType);
unsigned keyFrameInterval = GetKeyFrameInterval(codecIdentifier);
_XMStartMediaTransmit(2, codecIdentifier, videoSize, framesPerSecond, bitrate, keyFrameInterval, flags);
}
}
GMC_DCL(tp_Key, Key)
{
tp_FilHdr DirFilHdr, DirSymFilHdr, SymDirFilHdr;
tp_FilTyp FilTyp;
tp_FKind FKind;
if (FilHdr == ERROR || Key == ERROR) {
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
if (strcmp(Key, ".") == 0) {
return FilHdr; }/*if*/;
if (strcmp(Key, "") == 0
&& !(FilHdr == RootFilHdr || FilHdr == NetRootFilHdr)) {
return FilHdr; }/*if*/;
if (IsSource(FilHdr)) {
if (strcmp(Key, "..") == 0) {
if (FilHdr == RootFilHdr) {
return FilHdr; }/*if*/;
DirFilHdr = FilHdr_Father(Copy_FilHdr(FilHdr));
if (DirFilHdr == NetRootFilHdr) {
Ret_FilHdr(DirFilHdr);
return FilHdr; }/*if*/;
DirSymFilHdr = FilHdr_Father(Deref_SymLink(Copy_FilHdr(FilHdr)));
SymDirFilHdr = Deref_SymLink(Copy_FilHdr(DirFilHdr));
Ret_FilHdr(FilHdr);
if (DirSymFilHdr == SymDirFilHdr) {
Ret_FilHdr(DirSymFilHdr); Ret_FilHdr(SymDirFilHdr);
return DirFilHdr; }/*if*/;
Ret_FilHdr(DirFilHdr); Ret_FilHdr(SymDirFilHdr);
return FilHdr_AliasFilHdr(DirSymFilHdr); }/*if*/;
if (FilHdr == CacheDirFilHdr) {
if (strlen(Key) == 1) {
return FilHdr; }/*if*/;
Ret_FilHdr(FilHdr);
return CacheFileName_FilHdr(Key); }/*if*/;
return Get_KeyDrv(FilHdr, FK_SrcReg, Key); }/*if*/;
if (IsVirDir(FilHdr)) {
return Get_KeyDrv(FilHdr, FK_VirDirElm, Key); }/*if*/;
if (IsTargets(FilHdr)) {
return Get_KeyDrv(FilHdr, FK_ActTgtText, Key); }/*if*/;
if (IsPntr(FilHdr)) {
return Get_Drv(FilHdr, FK_PntrElm, Key_FilTyp(Key), RootFilPrm, Key);
}/*if*/;
if (IsDrvDirElm(FilHdr)) {
return Get_KeyDrv(FilHdr, FK_DrvDirElm, Key); }/*if*/;
if (!IsKeyList(FilHdr)) {
FilHdr_Error("Cannot select from <%s>.\n", FilHdr);
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
FilTyp = FilHdr_FilTyp(FilHdr);
/*select*/{
if (FilTyp == ActTargetsFilTyp) {
FKind = FK_ActTgt;
}else if (FilTyp == VirTargetsFilTyp) {
FKind = FK_VirTgt;
}else{
FKind = FK_DrvDirElm; };}/*select*/;
return Get_KeyDrv(FilHdr, FKind, Key);
}/*Do_Key*/
