VOID
FxWorkItem::FlushAndWait()
{
PFX_DRIVER_GLOBALS pFxDriverGlobals;
pFxDriverGlobals = GetDriverGlobals();
if (m_WorkItemThread == Mx::MxGetCurrentThread()) {
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
"Calling WdfWorkItemFlush from within the WDFWORKITEM "
"%p callback will lead to deadlock, PRKTHREAD %p",
GetHandle(), m_WorkItemThread);
FxVerifierDbgBreakPoint(pFxDriverGlobals);
return;
}
//
// Wait for any outstanding workitem to complete.
// The event is only set upon return from the callback
// into the driver *and* the driver did not re-queue
// the workitem. See similar comment in WorkItemHandler().
//
WaitForSignal();
return;
}
VOID
FxWorkItem::FlushAndRundown(
VOID
)
{
FxObject* pObject;
//
// Wait for any outstanding workitem to complete if the workitem is not
// deleted from within the workitem callback to avoid deadlock.
//
if (m_WorkItemThread != Mx::MxGetCurrentThread()) {
WaitForSignal();
}
//
// Release our reference count to the associated parent object if present
//
if (m_Object != NULL) {
pObject = m_Object;
m_Object = NULL;
pObject->RELEASE(this);
}
//
// Perform our final release to ourselves, destroying the FxWorkItem
//
RELEASE(this);
}
void SkydriveService::EnsureConnected() {
if (!access_token_.isEmpty()) {
return;
}
Connect();
WaitForSignal(this, SIGNAL(Connected()));
}
QUrl SkydriveService::GetStreamingUrlFromSongId(const QString& file_id) {
EnsureConnected();
QUrl url(QString(kSkydriveBase) + file_id);
QNetworkRequest request(url);
AddAuthorizationHeader(&request);
std::unique_ptr<QNetworkReply> reply(network_->get(request));
WaitForSignal(reply.get(), SIGNAL(finished()));
QJson::Parser parser;
QVariantMap response = parser.parse(reply.get()).toMap();
return response["source"].toUrl();
}
TInt CTestSemtrywait::TestSem390( )
{
int errsum=0, err = 0;
int retval = 0;
ThreadData lThreadData;
sem_t lSignalSemaphore;
sem_t lSuspendSemaphore;
sem_t lTestSemaphore;
pthread_mutex_t lTestMutex;
pthread_cond_t lTestCondVar;
pthread_condattr_t lCondAttr;
pthread_mutexattr_t lTestMutexAttr;
pthread_mutexattr_t defaultattr;
pthread_mutexattr_t errorcheckattr;
pthread_mutexattr_t recursiveattr;
pthread_mutexattr_init(&defaultattr);
pthread_mutexattr_init(&errorcheckattr);
pthread_mutexattr_init(&recursiveattr);
pthread_mutexattr_settype(&errorcheckattr,PTHREAD_MUTEX_ERRORCHECK);
pthread_mutexattr_settype(&recursiveattr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_t l_staticmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t l_errorcheckmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
pthread_mutex_t l_recursivemutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t l_staticcondvar = PTHREAD_COND_INITIALIZER;
CommonData lCommonData;
lCommonData.iStaticMutex = &l_staticmutex;
lCommonData.iErrorCheckMutex = &l_errorcheckmutex;
lCommonData.iRecursiveMutex = &l_recursivemutex;
lCommonData.iStaticCondVar = &l_staticcondvar;
retval = sem_init(&lSignalSemaphore,0,0);
if(retval != 0)
{
return retval;
}
retval = sem_init(&lSuspendSemaphore,0,0);
if(retval != 0)
{
return retval;
}
lThreadData.iSignalSemaphore = &lSignalSemaphore;
lThreadData.iSuspendSemaphore = &lSuspendSemaphore;
lThreadData.iTestSemaphore = &lTestSemaphore;
lThreadData.iTestMutex = &lTestMutex;
lThreadData.iTestMutexAttr = &lTestMutexAttr;
lThreadData.iTestCondVar = &lTestCondVar;
lThreadData.iDefaultAttr = &defaultattr;
lThreadData.iErrorcheckAttr = &errorcheckattr;
lThreadData.iRecursiveAttr = &recursiveattr;
lThreadData.iCondAttr = &lCondAttr;
for (int loop = 0; loop < EThreadMain; loop++)
{
g_spinFlag[loop] = true;
}
lThreadData.iSuspending = false;
lThreadData.iSpinCounter = 0;
lThreadData.iCurrentCommand = -1;
lThreadData.iSelf = EThreadMain;
lThreadData.iValue = 0;
lThreadData.iRetValue = 0;
lThreadData.ierrno = 0;
lThreadData.iExpectederrno = 0;
lThreadData.iTimes = 0;
lThreadData.iStopped = false;
lThreadData.iCommonData = &lCommonData;
retval = SemInit(&lThreadData);
fp=func1;
retval = ThreadCreate(&lThreadData, (void*) EThread1);
retval = WaitForSignal(&lThreadData);
retval = SemDestroy(&lThreadData);
retval = ThreadDestroy(&lThreadData, (void*) EThread1);
StopThread(&lThreadData);
err = pthread_cond_destroy(&l_staticcondvar);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_recursivemutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_errorcheckmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutex_destroy(&l_staticmutex);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&recursiveattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&errorcheckattr);
if(err != EINVAL)
{
errsum += err;
}
err = pthread_mutexattr_destroy(&defaultattr);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSignalSemaphore);
if(err != EINVAL)
{
errsum += err;
}
err = sem_destroy(&lSuspendSemaphore);
if(err != EINVAL)
{
errsum += err;
}
return retval+errsum;
}
PlaylistItemList SubsonicDynamicPlaylist::GenerateMore(int count) {
SubsonicService* service = InternetModel::Service<SubsonicService>();
const int task_id =
service->app_->task_manager()->StartTask(tr("Fetching Playlist Items"));
BOOST_SCOPE_EXIT((service)(task_id)) {
// stop task when we're done
service->app_->task_manager()->SetTaskFinished(task_id);
}
BOOST_SCOPE_EXIT_END
QUrl url = service->BuildRequestUrl("GetAlbumList");
QNetworkAccessManager network;
if (count > kMaxCount) count = kMaxCount;
url.addQueryItem("type", GetTypeString());
url.addQueryItem("size", QString::number(count));
url.addQueryItem("offset", QString::number(offset_));
PlaylistItemList items;
QNetworkReply* reply = Send(network, url, service->usesslv3_);
WaitForSignal(reply, SIGNAL(finished()));
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
qLog(Warning) << "HTTP error returned from Subsonic:"
<< reply->errorString() << ", url:" << url.toString();
return items; // empty
}
QXmlStreamReader reader(reply);
reader.readNextStartElement();
if (reader.name() != "subsonic-response") {
qLog(Warning) << "Not a subsonic-response, aboring playlist fetch";
return items;
}
if (reader.attributes().value("status") != "ok") {
reader.readNextStartElement();
int error = reader.attributes().value("code").toString().toInt();
qLog(Warning) << "An error occured fetching data. Code: " << error
<< " Message: "
<< reader.attributes().value("message").toString();
}
reader.readNextStartElement();
if (reader.name() != "albumList") {
qLog(Warning) << "albumList tag expected. Aboring playlist fetch";
return items;
}
while (reader.readNextStartElement()) {
if (reader.name() != "album") {
qLog(Warning) << "album tag expected. Aboring playlist fetch";
return items;
}
qLog(Debug) << "Getting album: "
<< reader.attributes().value("album").toString();
GetAlbum(service, items, reader.attributes().value("id").toString(),
network, service->usesslv3_);
reader.skipCurrentElement();
}
offset_ += count;
return items;
}
void SubsonicDynamicPlaylist::GetAlbum(SubsonicService* service,
PlaylistItemList& list, QString id,
QNetworkAccessManager& network,
const bool usesslv3) {
QUrl url = service->BuildRequestUrl("getAlbum");
url.addQueryItem("id", id);
if (service->IsAmpache()) {
url.addQueryItem("ampache", "1");
}
QNetworkReply* reply = Send(network, url, usesslv3);
WaitForSignal(reply, SIGNAL(finished()));
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
qLog(Warning) << "HTTP error returned from Subsonic:"
<< reply->errorString() << ", url:" << url.toString();
return;
}
QXmlStreamReader reader(reply);
reader.readNextStartElement();
if (reader.name() != "subsonic-response") {
qLog(Warning) << "Not a subsonic-response. Aborting playlist fetch.";
return;
}
if (reader.attributes().value("status") != "ok") {
qLog(Warning) << "Status not okay. Aborting playlist fetch.";
return;
}
// Read album information
reader.readNextStartElement();
if (reader.name() != "album") {
qLog(Warning) << "album tag expected. Aborting playlist fetch.";
return;
}
QString album_artist = reader.attributes().value("artist").toString();
// Read song information
while (reader.readNextStartElement()) {
if (reader.name() != "song") {
qLog(Warning) << "song tag expected. Aborting playlist fetch.";
return;
}
Song song;
QString id = reader.attributes().value("id").toString();
song.set_title(reader.attributes().value("title").toString());
song.set_album(reader.attributes().value("album").toString());
song.set_track(reader.attributes().value("track").toString().toInt());
song.set_disc(reader.attributes().value("discNumber").toString().toInt());
song.set_artist(reader.attributes().value("artist").toString());
song.set_albumartist(album_artist);
song.set_bitrate(reader.attributes().value("bitRate").toString().toInt());
song.set_year(reader.attributes().value("year").toString().toInt());
song.set_genre(reader.attributes().value("genre").toString());
qint64 length = reader.attributes().value("duration").toString().toInt();
length *= kNsecPerSec;
song.set_length_nanosec(length);
QUrl url = QUrl(QString("subsonic://%1").arg(id));
song.set_url(url);
song.set_filesize(reader.attributes().value("size").toString().toInt());
QFileInfo fi(reader.attributes().value("path").toString());
song.set_basefilename(fi.fileName());
// We need to set these to satisfy the database constraints
song.set_directory_id(0);
song.set_mtime(0);
song.set_ctime(0);
if (reader.attributes().hasAttribute("playCount")) {
song.set_playcount(
reader.attributes().value("playCount").toString().toInt());
}
list << std::shared_ptr<PlaylistItem>(
new InternetPlaylistItem(service, song));
reader.skipCurrentElement();
}
}
