CameraFrameTest() : CameraStreamFixture(STREAM_PARAMETERS) {
TEST_EXTENSION_FORKING_CONSTRUCTOR;
if (!HasFatalFailure()) {
CreateStream();
}
}
void sensor_server() {
struct SensorService service;
sensorservice_initialize(&service);
RegisterAs("SensorServer");
// Create the thing sending us sensor messages.
Create(HIGH, sensor_notifier);
tid_t stream = CreateStream("SensorServerStream");
int tid;
SensorServerMessage msg, rply;
for(;;) {
Receive(&tid, (char *) &msg, sizeof(msg));
switch(msg.type) {
case SENSOR_EVENT_REQUEST:
rply.type = SENSOR_EVENT_RESPONSE;
Reply(tid, (char *) &rply, sizeof(rply));
sensorservice_process_data(&service, msg.data);
publish(&service, stream);
break;
default:
ulog("Invalid SensorServer Request");
}
}
Exit();
}
long CStream::GetNextStream(short nKeyNum)
{
long nResult = -1;
if (!IsStreamRunning())
{
m_nFunc = DBA_GET_NEXT_STREAM;
nResult = CreateStream(nKeyNum);
}
return nResult;
}
//+----------------------------------------------------------------------------+
//|bool Initialize(AudioEngine* engine, const rString &path, SoundType type)
//\----------------------------------------------------------------------------+
bool SoundSDL::Initialize(AudioEngine* engine, const rString &path, SoundType type)
{
AudioEngineSDL* audioEngine = reinterpret_cast<AudioEngineSDL*>(engine);
const SDL_AudioSpec* sysSpec = audioEngine->GetSystemSpec();
m_AudioEngine = audioEngine;
m_Type = type;
m_Name = path;
m_ChunkSize = sysSpec->size;
m_AudioCVT = pNew(SDL_AudioCVT);
m_BufferData = tNew(AudioBuffer);
m_AudioFile = nullptr;
///Check which file format the requested audiofile are
///Only wav and ogg are supported
///Is wave file
if(path.find(".wav", 0) != std::string::npos)
{
m_AudioFile = pNew(WavFileReader);
}
///Is ogg file
else if(path.find(".ogg", 0) != std::string::npos)
{
m_AudioFile = pNew(OggFileReader);
}
///Not supported format
else
{
fprintf(stderr, "SoundSDL. Trying to load unsupported file format %s \n", path.c_str());
return false;
}
m_AudioFile->Initialize();
///Read as sample, read everything into buffer
if(type == SoundType::SAMPLE)
{
CreateSample(path, m_BufferData, sysSpec);
}
///Read as stream, prepare for buffer streaming
else if(type == SoundType::STREAM)
{
CreateStream(path, m_BufferData, sysSpec);
}
else
{
///This should not happend..
fprintf(stderr, "SoundSDL. Unexpected error loading %s while setting sound type \n", path.c_str());
return false;
}
return true;
}
// Simple segment reading.
TEST(TestBufferedInputStream, SimpleReadSegments) {
const size_t kBufSize = 10;
nsCString buf;
RefPtr<nsBufferedInputStream> bis = CreateStream(kBufSize, buf);
char buf2[kBufSize];
uint32_t count;
ASSERT_EQ(NS_OK, bis->ReadSegments(NS_CopySegmentToBuffer, buf2, sizeof(buf2), &count));
ASSERT_EQ(count, buf.Length());
ASSERT_TRUE(nsCString(buf.get(), kBufSize).Equals(nsCString(buf2, count)));
}
bool PAPlayer::QueueNextFile(const CFileItem &file, bool checkCrossFading)
{
if (IsPaused())
Pause();
if (file.m_strPath == m_currentFile->m_strPath &&
file.m_lStartOffset > 0 &&
file.m_lStartOffset == m_currentFile->m_lEndOffset)
{ // continuing on a .cue sheet item - return true to say we'll handle the transistion
*m_nextFile = file;
return true;
}
// check if we can handle this file at all
int decoder = 1 - m_currentDecoder;
int64_t seekOffset = (file.m_lStartOffset * 1000) / 75;
if (!m_decoder[decoder].Create(file, seekOffset, m_crossFading))
{
m_bQueueFailed = true;
return false;
}
// ok, we're good to go on queuing this one up
CLog::Log(LOGINFO, "PAPlayer: Queuing next file %s", file.m_strPath.c_str());
m_bQueueFailed = false;
if (checkCrossFading)
{
UpdateCrossFadingTime(file);
}
unsigned int channels, samplerate, bitspersample;
m_decoder[decoder].GetDataFormat(&channels, &samplerate, &bitspersample);
// check the number of channels isn't changing (else we can't do crossfading)
if (m_crossFading && m_decoder[m_currentDecoder].GetChannels() == channels)
{ // crossfading - need to create a new stream
if (!CreateStream(1 - m_currentStream, channels, samplerate, bitspersample))
{
m_decoder[decoder].Destroy();
CLog::Log(LOGERROR, "PAPlayer::Unable to create audio stream");
}
}
else
{ // no crossfading if nr of channels is not the same
m_crossFading = 0;
}
*m_nextFile = file;
return true;
}
//---------------------------------------------------------------------------
void File_DtvccTransport::Streams_Finish()
{
Clear(Stream_Text);
if (ServiceDescriptors)
{
if (ServiceDescriptors->ServiceDescriptors608.find(0)!=ServiceDescriptors->ServiceDescriptors608.end())
CreateStream(0);
if (ServiceDescriptors->ServiceDescriptors608.find(1)!=ServiceDescriptors->ServiceDescriptors608.end())
CreateStream(1);
if (!ServiceDescriptors->ServiceDescriptors708.empty())
CreateStream(2);
}
//Per stream
for (size_t Pos=0; Pos<Streams.size(); Pos++)
if (Streams[Pos] && Streams[Pos]->Parser && Streams[Pos]->Parser->Status[IsAccepted] /*&& Streams[Pos]->Parser->Status[IsUpdated]*/)
{
Finish(Streams[Pos]->Parser);
Streams_Update_PerStream(Pos);
}
}
void AudioFMOD::Add(Resources::SoundCue::Ptr soundCue)
{
Trace("'" + soundCue->getName() + "'");
soundCue->getSound().Type = ::Audio::Sound::Type::File;
auto& soundAddress = soundCue->getSound().Handle.Sound.File;
auto& soundFile = soundCue->getAssetPath();
//auto& soundAddress = soundCue->getSound().Address;
// You pick which to use depending on file size here.
// For now, we will be using stream.
CreateStream(soundFile, &soundAddress);
//CreateSound(soundFile, &soundAddress);
}
int DiskThread::Main() {
dmsg(3,("Disk thread running\n"));
while (true) {
pthread_testcancel(); // mandatory for OSX
IsIdle = true; // will be set to false if a stream got filled
// if there are ghost streams, delete them
for (int i = 0; i < GhostQueue->read_space(); i++) { //FIXME: unefficient
Stream::Handle hGhostStream;
GhostQueue->pop(&hGhostStream);
bool found = false;
for (int i = 0; i < this->Streams; i++) {
if (pStreams[i]->GetHandle() == hGhostStream) {
pStreams[i]->Kill();
found = true;
break;
}
}
if (!found) GhostQueue->push(&hGhostStream); // put ghost stream handle back to the queue
}
// if there are creation commands, create new streams
while (Stream::UnusedStreams > 0 && CreationQueue->read_space() > 0) {
create_command_t command;
CreationQueue->pop(&command);
CreateStream(command);
}
// if there are deletion commands, delete those streams
while (Stream::UnusedStreams < Stream::TotalStreams && DeletionQueue->read_space() > 0) {
delete_command_t command;
DeletionQueue->pop(&command);
DeleteStream(command);
}
RefillStreams(); // refill the most empty streams
// if nothing was done during this iteration (eg no streambuffer
// filled with data) then sleep for 50ms
if (IsIdle) usleep(30000);
int streamsInUsage = 0;
for (int i = Streams - 1; i >= 0; i--) {
if (pStreams[i]->GetState() != Stream::state_unused) streamsInUsage++;
}
ActiveStreamCount = streamsInUsage;
if (streamsInUsage > ActiveStreamCountMax) ActiveStreamCountMax = streamsInUsage;
}
return EXIT_FAILURE;
}
// AsyncWait - sync
TEST(TestBufferedInputStream, AsyncWait_sync) {
const size_t kBufSize = 10;
nsCString buf;
RefPtr<nsBufferedInputStream> bis = CreateStream(kBufSize, buf);
RefPtr<testing::InputStreamCallback> cb =
new testing::InputStreamCallback();
ASSERT_EQ(NS_OK, bis->AsyncWait(cb, 0, 0, nullptr));
// Immediatelly called
ASSERT_TRUE(cb->Called());
}
bool tdnMesh::Create( const CreateData &data )
{
if ( CreateVertex( data.numVertexes, data.vertexSize, data.vertexArray ) == false )
return false;
if ( data.numIndexes != 0 && data.indexArray != nullptr )
if ( CreateIndexes( data.numIndexes, data.indexArray ) == false )
return false;
if ( data.streamSize != 0 && data.streamArray != nullptr && data.numStream != 0 )
if ( CreateStream( data.numStream, data.streamSize, data.streamArray ) == false )
return false;
if ( CreateDeclaration( data.vertexSize, data.decl ) == false )
return false;
numFaces = data.numIndexes / 3;
return true;
}
// Simple reading.
TEST(TestBufferedInputStream, SimpleRead) {
const size_t kBufSize = 10;
nsCString buf;
RefPtr<nsBufferedInputStream> bis = CreateStream(kBufSize, buf);
uint64_t length;
ASSERT_EQ(NS_OK, bis->Available(&length));
ASSERT_EQ((uint64_t)kBufSize, length);
char buf2[kBufSize];
uint32_t count;
ASSERT_EQ(NS_OK, bis->Read(buf2, sizeof(buf2), &count));
ASSERT_EQ(count, buf.Length());
ASSERT_TRUE(nsCString(buf.get(), kBufSize).Equals(nsCString(buf2, count)));
}
static bool_t create_client(ext2fs_st *st,
Client_st *c,
IDCServerBinding_clp binding)
{
int i;
USD_QoS qos;
c->fs=st;
CL_INIT(c->cl, &fs_ms, c);
c->binding=binding;
/* Default QoS? Hmm. */
c->qos.p = MILLISECS(200);
c->qos.s = MILLISECS(10);
c->qos.l = MILLISECS(5);
c->qos.x = True;
qos.p = c->qos.p;
qos.s = c->qos.s;
qos.x = c->qos.x;
for (i=0; i<MAX_CLIENT_HANDLES; i++) {
c->handles[i].used=False;
}
/* Create a stream for the client. This involves calling the USD domain;
must be careful we don't deadlock. */
if(USDCtl$CreateStream(st->disk.usdctl,
(USD_ClientID)(word_t)c,
&(c->usd_stream),
&(c->usd))
!= USDCtl_Error_None)
{
return False;
}
if(USDCtl$AdjustQoS(st->disk.usdctl,
c->usd_stream,
&qos)
!= USDCtl_Error_None)
{
(void)USDCtl$DestroyStream(st->disk.usdctl,
c->usd_stream);
return False;
}
return True;
}
int XSocketMgr::ProcessNewSocket(XListenNode* pListen, time_t nTimeNow)
{
int nCount = 0;
int nRetCode = 0;
sockaddr_in remoteAddr;
while (!pListen->bUsrClose)
{
SOCKET nSocket = INVALID_SOCKET;
int nAddrLen = sizeof(sockaddr_in);
XStreamNode* pNode = NULL;
memset(&remoteAddr, 0, sizeof(sockaddr_in));
nSocket = accept(pListen->nSocket, (sockaddr*)&remoteAddr, &nAddrLen);
if (nSocket == INVALID_SOCKET)
break;
nCount++;
nRetCode = SetSocketNoneBlock(nSocket);
if (!nRetCode)
{
closesocket(nSocket);
continue;
}
pNode = CreateStream(
nSocket, inet_ntoa(remoteAddr.sin_addr), ntohs(remoteAddr.sin_port), nTimeNow, pListen->uMaxRecvPackSize
);
if (pNode == NULL)
{
closesocket(nSocket);
continue;
}
pNode->nSendRetryCount = pListen->nSendRetryCount;
pNode->nSendRetrySleep = pListen->nSendRetrySleep;
if (pListen->pCallback)
{
(*pListen->pCallback)(pListen, pListen->pvUsrData, pNode);
}
}
return nCount;
}
TInt CMccControllerStub::ControllerStreamCtrCalled( TMMCActionType aAction,
TUint32 aSessionID,
TUint32 aLinkID,
TUint32 aStreamID,
TUint32 aEndpointID,
TUint32 aPaused,
TUint32 aEnableRTCP )
{
TAction action;
action.iAction = aAction;
action.iSessionID = aSessionID;
action.iLinkID = aLinkID;
action.iStreamID = aStreamID;
action.iEndpointID = aEndpointID;
action.iLinkType = KMceNotAssigned;
action.iStreamType = KMceNotAssigned;
action.iPaused = aPaused;
action.iEnableRTCP = aEnableRTCP;
action.iKey = KMceNotAssigned;
action.iParamSet = KMceNotAssigned;
iActions[ iActionPtr++ ] = action;
iActionPtr = iActionPtr < KMce_MM_MaxArray-1 ? iActionPtr : 0;
if ( aAction == EMccCreateStream )
{
TLink link;
link.iSessionID = aSessionID;
link.iLinkID = aLinkID;
CreateStream( link );
}
else if ( aAction == EMccDeleteStream )
{
TLink link;
link.iSessionID = aSessionID;
link.iLinkID = aLinkID;
TLink& l = GetLink( link );
l.iStreams--;
}
return iLeaveError;
}
// AsyncWait - async
TEST(TestBufferedInputStream, AsyncWait_async) {
const size_t kBufSize = 10;
nsCString buf;
RefPtr<nsBufferedInputStream> bis = CreateStream(kBufSize, buf);
RefPtr<testing::InputStreamCallback> cb =
new testing::InputStreamCallback();
nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
ASSERT_EQ(NS_OK, bis->AsyncWait(cb, 0, 0, thread));
ASSERT_FALSE(cb->Called());
// Eventually it is called.
MOZ_ALWAYS_TRUE(mozilla::SpinEventLoopUntil([&]() { return cb->Called(); }));
ASSERT_TRUE(cb->Called());
}
// AsyncWait - sync - closureOnly
TEST(TestBufferedInputStream, AsyncWait_sync_closureOnly) {
const size_t kBufSize = 10;
nsCString buf;
RefPtr<nsBufferedInputStream> bis = CreateStream(kBufSize, buf);
RefPtr<testing::InputStreamCallback> cb =
new testing::InputStreamCallback();
ASSERT_EQ(NS_OK, bis->AsyncWait(cb, nsIAsyncInputStream::WAIT_CLOSURE_ONLY,
0, nullptr));
ASSERT_FALSE(cb->Called());
bis->CloseWithStatus(NS_ERROR_FAILURE);
// Immediatelly called
ASSERT_TRUE(cb->Called());
}
///////////////////////////////////////////////////////////////////////////////
// //
// File I/O //
// //
///////////////////////////////////////////////////////////////////////////////
aalError Sample::Load(const char * _name)
{
Stream * stream = CreateStream(_name);
if (!stream) return AAL_ERROR_FILEIO;
stream->GetFormat(format);
stream->GetLength(length);
DeleteStream(stream);
aalVoid * ptr = realloc(name, strlen(_name) + 1);
if (!ptr) return AAL_ERROR_MEMORY;
name = (char *)ptr;
strcpy(name, _name);
return AAL_OK;
}
nsresult
LockedFile::CreateParallelStream(nsISupports** aStream)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
nsIFileStorage* fileStorage = mFileHandle->mFileStorage;
if (fileStorage->IsStorageInvalidated()) {
return NS_ERROR_NOT_AVAILABLE;
}
nsCOMPtr<nsISupports> stream =
mFileHandle->CreateStream(mFileHandle->mFile, mMode == READ_ONLY);
NS_ENSURE_TRUE(stream, NS_ERROR_FAILURE);
mParallelStreams.AppendElement(stream);
stream.forget(aStream);
return NS_OK;
}
// AsyncWait - async
TEST(TestBufferedInputStream, AsyncWait_async_closureOnly) {
const size_t kBufSize = 10;
nsCString buf;
RefPtr<nsBufferedInputStream> bis = CreateStream(kBufSize, buf);
RefPtr<testing::InputStreamCallback> cb =
new testing::InputStreamCallback();
nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
ASSERT_EQ(NS_OK, bis->AsyncWait(cb, nsIAsyncInputStream::WAIT_CLOSURE_ONLY,
0, thread));
ASSERT_FALSE(cb->Called());
bis->CloseWithStatus(NS_ERROR_FAILURE);
ASSERT_FALSE(cb->Called());
// Eventually it is called.
MOZ_ALWAYS_TRUE(mozilla::SpinEventLoopUntil([&]() { return cb->Called(); }));
ASSERT_TRUE(cb->Called());
}
XnStatus XnDeviceBase::CreateStreamsFromFile(const XnChar* csINIFilePath, const XnChar* csSectionName)
{
XnStatus nRetVal = XN_STATUS_OK;
// go through numbers until no stream is found
XnUInt32 nStreamIndex = 0;
XnChar csKeyName[XN_INI_MAX_LEN];
for (;;)
{
sprintf(csKeyName, "Stream%u_Type", nStreamIndex);
XnChar csStreamType[XN_INI_MAX_LEN];
XnChar csStreamName[XN_INI_MAX_LEN];
nRetVal = xnOSReadStringFromINI(csINIFilePath, csSectionName, csKeyName, csStreamType, XN_INI_MAX_LEN);
if (nRetVal != XN_STATUS_OK) // no more streams
{
break;
}
// check if the stream has a name
sprintf(csKeyName, "Stream%u_Name", nStreamIndex);
nRetVal = xnOSReadStringFromINI(csINIFilePath, csSectionName, csKeyName, csStreamName, XN_INI_MAX_LEN);
if (nRetVal != XN_STATUS_OK)
{
// use its type as a name
strcpy(csStreamName, csStreamType);
}
nRetVal = CreateStream(csStreamType, csStreamName);
XN_IS_STATUS_OK(nRetVal);
nStreamIndex++;
}
return (XN_STATUS_OK);
}
TEST_P(CameraStreamTest, CreateStream) {
TEST_EXTENSION_FORKING_INIT;
/** Make sure the format requested is supported. PASS this test if it's not
* not supported.
*
* TODO: would be nice of not running this test in the first place
* somehow.
*/
{
camera_metadata_ro_entry availableFormats =
GetStaticEntry(ANDROID_SCALER_AVAILABLE_FORMATS);
bool hasFormat = false;
for (size_t i = 0; i < availableFormats.count; ++i) {
if (availableFormats.data.i32[i] == GetParam().mFormat) {
hasFormat = true;
break;
}
}
if (!hasFormat) {
const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();
std::cerr << "Skipping test "
<< test_info->test_case_name() << "."
<< test_info->name()
<< " because the format was not available: "
<< GetParam() << std::endl;
return;
}
}
ASSERT_NO_FATAL_FAILURE(CreateStream());
ASSERT_NO_FATAL_FAILURE(DeleteStream());
}
void Picture::SaveBitmapToFile(const std::wstring & path, IWICBitmap* bitmap)
{
auto wicFactory = PublicResource::GetGraphicsResource().WicImagingFactory.p;
CComPtr<IWICStream> stream;
CComPtr<IWICBitmapEncoder> encoder;
CComPtr<IWICBitmapFrameEncode> frameEncoder;
CComPtr<ID2D1Bitmap> newBitmap;
WICPixelFormatGUID format = GUID_WICPixelFormat32bppPBGRA;
wicFactory->CreateStream(&stream);
UINT width, height;
bitmap->GetSize(&width, &height);
stream->InitializeFromFilename(path.data(), GENERIC_WRITE);
HRESULT hr = wicFactory->CreateEncoder(Picture::PictureTypeParser(path),
nullptr,
&encoder);
hr = encoder->Initialize(stream, WICBitmapEncoderNoCache);
hr = encoder->CreateNewFrame(&frameEncoder, nullptr);
hr = frameEncoder->Initialize(nullptr);
hr = frameEncoder->SetSize(width, height);
hr = frameEncoder->SetPixelFormat(&format);
hr = frameEncoder->WriteSource(bitmap,nullptr);
hr = frameEncoder->Commit();
hr = encoder->Commit();
}
bool PAPlayer::OpenFile(const CFileItem& file, const CPlayerOptions &options)
{
if (m_currentlyCrossFading) CloseFileInternal(false); //user seems to be in a hurry
m_crossFading = g_guiSettings.GetInt("musicplayer.crossfade");
//WASAPI doesn't support multiple streams, no crossfading for cdda, cd-reading goes mad and no crossfading for last.fm doesn't like two connections
if (file.IsCDDA() || file.IsLastFM() || g_guiSettings.GetString("audiooutput.audiodevice").find("wasapi:") != CStdString::npos) m_crossFading = 0;
if (m_crossFading && IsPlaying())
{
//do a short crossfade on trackskip
//set to max 2 seconds for these prev/next transitions
if (m_crossFading > 2) m_crossFading = 2;
//queue for crossfading
bool result = QueueNextFile(file, false);
if (result)
{
//crossfading value may be update by QueueNextFile when nr of channels changed
if (!m_crossFading) // swap to next track
m_decoder[m_currentDecoder].SetStatus(STATUS_ENDED);
else //force to fade to next track immediately
m_forceFadeToNext = true;
}
return result;
}
// normal opening of file, nothing playing or crossfading not enabled
// however no need to return to gui audio device
CloseFileInternal(false);
// always open the file using the current decoder
m_currentDecoder = 0;
if (!m_decoder[m_currentDecoder].Create(file, (__int64)(options.starttime * 1000), m_crossFading))
return false;
m_iSpeed = 1;
m_bPaused = false;
m_bStopPlaying = false;
m_bytesSentOut = 0;
CLog::Log(LOGINFO, "PAPlayer: Playing %s", file.m_strPath.c_str());
m_timeOffset = (__int64)(options.starttime * 1000);
unsigned int channel, sampleRate, bitsPerSample;
m_decoder[m_currentDecoder].GetDataFormat(&channel, &sampleRate, &bitsPerSample);
if (!CreateStream(m_currentStream, channel, sampleRate, bitsPerSample))
{
m_decoder[m_currentDecoder].Destroy();
CLog::Log(LOGERROR, "PAPlayer::Unable to create audio stream");
}
*m_currentFile = file;
if (ThreadHandle() == NULL)
Create();
m_startEvent.Set();
m_bIsPlaying = true;
m_cachingNextFile = false;
m_currentlyCrossFading = false;
m_forceFadeToNext = false;
m_bQueueFailed = false;
m_decoder[m_currentDecoder].Start(); // start playback
return true;
}
/*
* Compose stage file events into a stage stream. Streams
* represent optimal i/o requests for media. A stream is
* added to work queue.
*/
void
Compose(void)
{
FileInfo_t **sortList;
StreamInfo_t *stream;
FileInfo_t *file;
char *currentVsn;
int i;
int copy;
int retry;
boolean_t added;
if (composeList.entries == 0) {
return;
}
sortList = makeSortList();
separateVsns(sortList);
currentVsn = NULL;
stream = NULL;
for (i = 0; i < composeList.entries; i++) {
file = GetFile(composeList.data[i]);
copy = file->copy;
/*
* If first VSN (currentVsn == NULL) or different VSN or
* disk cache already open, ie. multivolume, create a new
* stream. Add new stream to the work queue.
*/
if (currentVsn == NULL ||
(strcmp(file->ar[copy].section.vsn, currentVsn) != 0) ||
GET_FLAG(file->flags, FI_DCACHE)) {
retry = 3;
stream = NULL;
while (stream == NULL && retry-- > 0) {
stream = CreateStream(file);
if (stream == NULL) {
SetErrno = 0; /* set for trace */
Trace(TR_ERR, "Create stream failed");
sleep(5);
}
}
if (stream == NULL) {
FatalSyscallError(EXIT_FATAL, HERE,
"Compose create stream", currentVsn);
}
AddWork(stream);
if (GET_FLAG(file->flags, FI_DCACHE_CLOSE) == 0) {
currentVsn = file->ar[copy].section.vsn;
}
}
/*
* Add stage request to the stream.
*/
added = AddStream(stream, composeList.data[i],
ADD_STREAM_NOSORT);
if (added == B_FALSE) {
SetErrno = 0; /* set for trace */
Trace(TR_ERR,
"Compose add stream '%s.%d' 0x%x failed",
stream->vsn, stream->seqnum, (int)stream);
SET_FLAG(stream->flags, SR_full);
}
/* Stream is full, create a new one. */
if (GET_FLAG(stream->flags, SR_full)) {
currentVsn = NULL;
}
}
/*
* We should have added all requests to the work queue
* so free the composition list.
*/
composeList.entries = 0;
}
//---------------------------------------------------------------------------
void File_DtvccTransport::Read_Buffer_Continue()
{
//Parsing
Element_Begin1(Format==Format_DVD?"DVD Captions":"DTVCC Transport");
int8u cc_count;
bool process_cc_data_flag, additional_data_flag;
BS_Begin();
if (Format==Format_DVD)
{
//Modified DTVCC Transport from DVD
Skip_SB( "field 1 then field 2");
Get_S1 (7, cc_count, "cc_count");
process_cc_data_flag=true;
additional_data_flag=false;
}
else
{
//Normal DTVCC Transport
bool process_em_data_flag;
Get_SB (process_em_data_flag, "process_em_data_flag");
Get_SB (process_cc_data_flag, "process_cc_data_flag");
Get_SB (additional_data_flag, "additional_data_flag");
Get_S1 (5, cc_count, "cc_count");
Skip_S1(8, process_em_data_flag?"em_data":"reserved"); //Emergency message
}
BS_End();
if (process_cc_data_flag)
{
for (int8u Pos=0; Pos<cc_count; Pos++)
{
if (Element_Offset+3>Element_Size)
break; //Found one stream with bad cc_count, we discard cc_count without flagging the stream as untrusted for the moment
Element_Begin1("cc");
int8u cc_type;
bool cc_valid;
BS_Begin();
Mark_1();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
if (Format==Format_DVD)
{
//Modified DTVCC Transport from DVD
Mark_1();
Mark_1();
Get_S1 (1, cc_type, "cc_type"); Param_Info1(DtvccTransport_cc_type(cc_type));
cc_valid=true;
}
else
{
//Normal DTVCC Transport
Get_SB ( cc_valid, "cc_valid");
Get_S1 (2, cc_type, "cc_type"); Param_Info1(DtvccTransport_cc_type(cc_type));
}
BS_End();
#if MEDIAINFO_ADVANCED
if (cc_type>=2 && !Streams[2] && Config->File_Eia708_DisplayEmptyStream_Get())
CreateStream(2);
#endif //MEDIAINFO_ADVANCED
if (cc_valid)
{
Element_Begin1("cc_data");
//Calculating the parser position
int8u Parser_Pos=cc_type==3?2:cc_type; //cc_type 2 and 3 are for the same text
//Stream creation
if (Streams[Parser_Pos]==NULL)
CreateStream(Parser_Pos);
//Parsing
#if MEDIAINFO_DEMUX
Element_Code=Parser_Pos;
Demux(Buffer+(size_t)(Buffer_Offset+Element_Offset), 2, ContentType_MainStream);
#endif //MEDIAINFO_DEMUX
if (!Streams[Parser_Pos]->Parser->Status[IsFinished])
{
//Parsing
if (Streams[Parser_Pos]->Parser->PTS_DTS_Needed)
{
Streams[Parser_Pos]->Parser->FrameInfo.PCR=FrameInfo.PCR;
Streams[Parser_Pos]->Parser->FrameInfo.PTS=FrameInfo.PTS;
Streams[Parser_Pos]->Parser->FrameInfo.DTS=FrameInfo.DTS;
}
if (Parser_Pos==2)
{
#if defined(MEDIAINFO_EIA708_YES)
((File_Eia708*)Streams[2]->Parser)->cc_type=cc_type;
if (AspectRatio)
((File_Eia708*)Streams[2]->Parser)->AspectRatio=AspectRatio;
#endif
if (cc_type==3)
{
((File_Eia708*)Streams[2]->Parser)->cc_type=4; //Magic value saying that the buffer must be kept (this is only a point of synchro from the undelying layer)
Open_Buffer_Continue(Streams[Parser_Pos]->Parser, Buffer+(size_t)(Buffer_Offset+Element_Offset), 0);
((File_Eia708*)Streams[2]->Parser)->cc_type=3;
}
}
else
{
}
#if defined(MEDIAINFO_EIA608_YES) || defined(MEDIAINFO_EIA708_YES)
Streams[Parser_Pos]->Parser->ServiceDescriptors=ServiceDescriptors;
#endif
Open_Buffer_Continue(Streams[Parser_Pos]->Parser, Buffer+(size_t)(Buffer_Offset+Element_Offset), 2);
Element_Show();
Element_Offset+=2;
}
else
Skip_XX(2, "Data");
Element_End0();
}
else
Skip_XX(2, "Junk");
Element_End0();
}
FILLING_BEGIN();
if (!Status[IsAccepted])
Accept("DTVCC Transport");
FILLING_END();
}
else
Skip_XX(cc_count*2, "Junk");
if (Format==Format_A53_4_GA94_03)
{
//Normal DTVCC Transport
BS_Begin();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
Mark_1_NoTrustError();
BS_End();
if (additional_data_flag)
{
Skip_XX(Element_Size-Element_Offset, "additional_user_data");
}
while (Element_Offset<Element_Size)
{
Skip_B1( "Zero"); //TODO: test Zero
}
}
Element_End0();
}
//---------------------------------------------------------------------------
void File_Cdp::ccsvcinfo_section()
{
//Parsing
int8u svc_count;
Element_Begin1("ccsvcinfo_section");
Skip_B1( "ccsvcinfo_id");
BS_Begin();
Skip_SB( "reserved");
Skip_SB( "svc_info_start");
Skip_SB( "svc_info_change");
Skip_SB( "svc_info_complete");
Get_S1 (4, svc_count, "svc_count");
BS_End();
for (int8u Pos=0; Pos<svc_count; Pos++)
{
Element_Begin1("svc");
bool csn_size;
BS_Begin();
Skip_SB( "reserved");
Get_SB ( csn_size, "csn_size");
if (csn_size)
{
Skip_SB( "reserved");
Skip_S1(5, "caption_service_number");
}
else
Skip_S1(6, "caption_service_number");
BS_End();
//svc_data_byte - caption_service_descriptor
Element_Begin1("service");
string language;
int8u caption_service_number=0;
bool digital_cc, line21_field=false;
Get_String(3, language, "language");
BS_Begin();
Get_SB (digital_cc, "digital_cc");
Skip_SB( "reserved");
if (digital_cc) //line21
Get_S1 (6, caption_service_number, "caption_service_number");
else
{
Skip_S1(5, "reserved");
Get_SB ( line21_field, "line21_field");
//Coherency test
if (line21_field && svc_count==1)
line21_field=false; // Wrong info in the descriptor?
}
Skip_SB( "easy_reader");
Skip_SB( "wide_aspect_ratio");
Skip_S2(14, "reserved");
BS_End();
Element_End0();
Element_End0();
FILLING_BEGIN();
#if defined(MEDIAINFO_EIA608_YES) || defined(MEDIAINFO_EIA708_YES)
if (digital_cc)
{
#if defined(MEDIAINFO_EIA708_YES)
ServiceDescriptors->ServiceDescriptors708[caption_service_number].language=language;
#endif
}
else
{
#if defined(MEDIAINFO_EIA708_YES)
ServiceDescriptors->ServiceDescriptors608[line21_field?1:0].language=language;
#endif
}
#endif
//Stream creation
int8u Parser_Pos;
if (digital_cc) //line21
Parser_Pos = 2;
else
Parser_Pos= (line21_field ? 1 : 0); //cc_type 2 and 3 are for the same text
if (Streams[Parser_Pos]==NULL)
CreateStream(Parser_Pos);
FILLING_END();
}
Element_End0();
}
bool PAPlayer::ProcessPAP()
{
/*
* Here's what we should be doing in each player loop:
*
* 1. Run DoWork() on our audio device to actually output audio.
*
* 2. Pass our current buffer to the audio device to see if it wants anything,
* and if so, reduce our buffer size accordingly.
*
* 3. Check whether we have space in our buffer for more data, and if so,
* read some more in.
*
* 4. Check for end of file and return false if we reach it.
*
* 5. Perform any seeking and ffwd/rewding as necessary.
*
* 6. If we don't do anything in 2...5, we can take a breather and break out for sleeping.
*/
while (true)
{
if (m_bStop) return false;
// Check for .cue sheet item end
if (m_currentFile->m_lEndOffset && GetTime() >= GetTotalTime64())
{
CLog::Log(LOGINFO, "PAPlayer: Passed end of track in a .cue sheet item");
m_decoder[m_currentDecoder].SetStatus(STATUS_ENDED);
}
// check whether we need to send off our callbacks etc.
int status = m_decoder[m_currentDecoder].GetStatus();
if (status == STATUS_NO_FILE)
return false;
UpdateCacheLevel();
// check whether we should queue the next file up
if ((GetTotalTime64() > 0) && GetTotalTime64() - GetTime() < TIME_TO_CACHE_NEXT_FILE + m_crossFading * 1000L && !m_cachingNextFile)
{ // request the next file from our application
m_callback.OnQueueNextItem();
m_cachingNextFile = true;
}
if (m_crossFading && m_decoder[0].GetChannels() == m_decoder[1].GetChannels())
{
if (((GetTotalTime64() - GetTime() < m_crossFading * 1000L) || (m_forceFadeToNext)) && !m_currentlyCrossFading)
{ // request the next file from our application
if (m_decoder[1 - m_currentDecoder].GetStatus() == STATUS_QUEUED && m_pAudioDecoder[1 - m_currentStream])
{
m_currentlyCrossFading = true;
if (m_forceFadeToNext)
{
m_forceFadeToNext = false;
m_crossFadeLength = m_crossFading * 1000L;
}
else
{
m_crossFadeLength = GetTotalTime64() - GetTime();
}
m_currentDecoder = 1 - m_currentDecoder;
m_decoder[m_currentDecoder].Start();
m_currentStream = 1 - m_currentStream;
CLog::Log(LOGDEBUG, "Starting Crossfade - resuming stream %i", m_currentStream);
m_pAudioDecoder[m_currentStream]->Resume();
m_callback.OnPlayBackStarted();
m_timeOffset = m_nextFile->m_lStartOffset * 1000 / 75;
m_bytesSentOut = 0;
*m_currentFile = *m_nextFile;
m_nextFile->Reset();
m_cachingNextFile = false;
}
}
}
// Check for EOF and queue the next track if applicable
if (m_decoder[m_currentDecoder].GetStatus() == STATUS_ENDED)
{ // time to swap tracks
if (m_nextFile->m_strPath != m_currentFile->m_strPath ||
!m_nextFile->m_lStartOffset ||
m_nextFile->m_lStartOffset != m_currentFile->m_lEndOffset)
{ // don't have a .cue sheet item
int nextstatus = m_decoder[1 - m_currentDecoder].GetStatus();
if (nextstatus == STATUS_QUEUED || nextstatus == STATUS_QUEUING || nextstatus == STATUS_PLAYING)
{ // swap streams
CLog::Log(LOGDEBUG, "PAPlayer: Swapping tracks %i to %i", m_currentDecoder, 1-m_currentDecoder);
if (!m_crossFading || m_decoder[0].GetChannels() != m_decoder[1].GetChannels())
{ // playing gapless (we use only the 1 output stream in this case)
int prefixAmount = m_decoder[m_currentDecoder].GetDataSize();
CLog::Log(LOGDEBUG, "PAPlayer::Prefixing %i samples of old data to new track for gapless playback", prefixAmount);
m_decoder[1 - m_currentDecoder].PrefixData(m_decoder[m_currentDecoder].GetData(prefixAmount), prefixAmount);
// check if we need to change the resampler (due to format change)
unsigned int channels, samplerate, bitspersample;
m_decoder[m_currentDecoder].GetDataFormat(&channels, &samplerate, &bitspersample);
unsigned int channels2, samplerate2, bitspersample2;
m_decoder[1 - m_currentDecoder].GetDataFormat(&channels2, &samplerate2, &bitspersample2);
// change of channels - reinitialize our speaker configuration
if (channels != channels2 || (g_advancedSettings.m_musicResample == 0 && (samplerate != samplerate2 || bitspersample != bitspersample2)))
{
CLog::Log(LOGINFO, "PAPlayer: Stream properties have changed, restarting stream");
FreeStream(m_currentStream);
if (!CreateStream(m_currentStream, channels2, samplerate2, bitspersample2))
{
CLog::Log(LOGERROR, "PAPlayer: Error creating stream!");
return false;
}
m_pAudioDecoder[m_currentStream]->Resume();
}
else if (samplerate != samplerate2 || bitspersample != bitspersample2)
{
CLog::Log(LOGINFO, "PAPlayer: Restarting resampler due to a change in data format");
m_resampler[m_currentStream].DeInitialize();
if (!m_resampler[m_currentStream].InitConverter(samplerate2, bitspersample2, channels2, g_advancedSettings.m_musicResample, 16, PACKET_SIZE))
{
CLog::Log(LOGERROR, "PAPlayer: Error initializing resampler!");
return false;
}
}
CLog::Log(LOGINFO, "PAPlayer: Starting new track");
m_decoder[m_currentDecoder].Destroy();
m_decoder[1 - m_currentDecoder].Start();
m_callback.OnPlayBackStarted();
m_timeOffset = m_nextFile->m_lStartOffset * 1000 / 75;
m_bytesSentOut = 0;
*m_currentFile = *m_nextFile;
m_nextFile->Reset();
m_cachingNextFile = false;
m_currentDecoder = 1 - m_currentDecoder;
}
else
{ // cross fading - shouldn't ever get here - if we do, return false
if (!m_currentlyCrossFading)
{
CLog::Log(LOGERROR, "End of file Reached before crossfading kicked in!");
return false;
}
else
{
CLog::Log(LOGINFO, "End of file reached before crossfading finished!");
return false;
}
}
}
else
{
if (GetTotalTime64() <= 0 && !m_bQueueFailed)
{ //we did not know the duration so didn't queue the next song, try queueing it now
if (!m_cachingNextFile)
{// request the next file from our application
m_callback.OnQueueNextItem();
m_cachingNextFile = true;
}
}
else
{
// no track queued - return and get another one once we are finished
// with the current stream
WaitForStream();
return false;
}
}
}
else
{
// set the next track playing (.cue sheet)
m_decoder[m_currentDecoder].SetStatus(STATUS_PLAYING);
m_callback.OnPlayBackStarted();
m_timeOffset = m_nextFile->m_lStartOffset * 1000 / 75;
m_bytesSentOut = 0;
*m_currentFile = *m_nextFile;
m_nextFile->Reset();
m_cachingNextFile = false;
}
}
// handle seeking and ffwd/rewding.
HandleSeeking();
if (!HandleFFwdRewd())
{
// need to skip to the next track - let's see if we already have another one
m_decoder[m_currentDecoder].SetStatus(STATUS_ENDED);
continue; // loop around to start the next track
}
if (!m_bPaused)
{
// Let our decoding stream(s) do their thing
int retVal = m_decoder[m_currentDecoder].ReadSamples(PACKET_SIZE);
if (retVal == RET_ERROR)
{
m_decoder[m_currentDecoder].Destroy();
return false;
}
int retVal2 = m_decoder[1 - m_currentDecoder].ReadSamples(PACKET_SIZE);
if (retVal2 == RET_ERROR)
{
m_decoder[1 - m_currentDecoder].Destroy();
}
// if we're cross-fading, then we do this for both streams, otherwise
// we do it just for the one stream.
if (m_currentlyCrossFading)
{
if (GetTime() >= m_crossFadeLength) // finished
{
CLog::Log(LOGDEBUG, "Finished Crossfading");
m_currentlyCrossFading = false;
SetStreamVolume(m_currentStream, g_settings.m_nVolumeLevel);
FreeStream(1 - m_currentStream);
m_decoder[1 - m_currentDecoder].Destroy();
}
else
{
float fraction = (float)(m_crossFadeLength - GetTime()) / (float)m_crossFadeLength - 0.5f;
// make sure we can take valid logs.
if (fraction > 0.499f) fraction = 0.499f;
if (fraction < -0.499f) fraction = -0.499f;
float volumeCurrent = 2000.0f * log10(0.5f - fraction);
float volumeNext = 2000.0f * log10(0.5f + fraction);
SetStreamVolume(m_currentStream, g_settings.m_nVolumeLevel + (int)volumeCurrent);
SetStreamVolume(1 - m_currentStream, g_settings.m_nVolumeLevel + (int)volumeNext);
if (AddPacketsToStream(1 - m_currentStream, m_decoder[1 - m_currentDecoder]))
retVal2 = RET_SUCCESS;
}
}
// add packets as necessary
if (AddPacketsToStream(m_currentStream, m_decoder[m_currentDecoder]))
retVal = RET_SUCCESS;
if (retVal == RET_SLEEP && retVal2 == RET_SLEEP)
{
float maximumSleepTime = m_pAudioDecoder[m_currentStream]->GetCacheTime();
if (m_pAudioDecoder[1 - m_currentStream])
maximumSleepTime = std::min(maximumSleepTime, m_pAudioDecoder[1 - m_currentStream]->GetCacheTime());
int sleep = std::max((int)((maximumSleepTime / 2.0f) * 1000.0f), 1);
Sleep(std::min(sleep, 15));
}
}
else
Sleep(100);
}
return true;
}
int DiskThread::Main() {
dmsg(3,("Disk thread running\n"));
while (true) {
#if !defined(WIN32)
pthread_testcancel(); // mandatory for OSX
#endif
IsIdle = true; // will be set to false if a stream got filled
// if there are ghost streams, delete them
for (int i = 0; i < GhostQueue->read_space(); i++) { //FIXME: unefficient
delete_command_t ghostStream;
GhostQueue->pop(&ghostStream);
bool found = false;
for (int i = 0; i < this->Streams; i++) {
if (pStreams[i]->GetHandle() == ghostStream.hStream) {
pStreams[i]->Kill();
found = true;
// if original sender requested a notification, let him know now
if (ghostStream.bNotify)
DeletionNotificationQueue.push(&ghostStream.hStream);
break;
}
}
if (!found) GhostQueue->push(&ghostStream); // put ghost stream handle back to the queue
}
// if there are creation commands, create new streams
while (Stream::UnusedStreams > 0 && CreationQueue->read_space() > 0) {
create_command_t command;
CreationQueue->pop(&command);
CreateStream(command);
}
// if there are deletion commands, delete those streams
while (Stream::UnusedStreams < Stream::TotalStreams && DeletionQueue->read_space() > 0) {
delete_command_t command;
DeletionQueue->pop(&command);
DeleteStream(command);
}
// release DimensionRegions that belong to instruments
// that are no longer loaded
while (DeleteDimregQueue->read_space() > 0) {
::gig::DimensionRegion* dimreg;
DeleteDimregQueue->pop(&dimreg);
pInstruments->HandBackDimReg(dimreg);
}
RefillStreams(); // refill the most empty streams
// if nothing was done during this iteration (eg no streambuffer
// filled with data) then sleep for 30ms
if (IsIdle) usleep(30000);
int streamsInUsage = 0;
for (int i = Streams - 1; i >= 0; i--) {
if (pStreams[i]->GetState() != Stream::state_unused) streamsInUsage++;
}
ActiveStreamCount = streamsInUsage;
if (streamsInUsage > ActiveStreamCountMax) ActiveStreamCountMax = streamsInUsage;
}
return EXIT_FAILURE;
}
