void WaveRenderArea::paintEvent(QPaintEvent *)
{
Q_D(WaveRenderArea);
QPainter p(this);
QMutexLocker(d->sampleBufferMutex);
p.drawPixmap(0, 0, d->pixmap);
}
void QT_WIN_CALLBACK QAudioInputPrivate::waveInProc( HWAVEIN hWaveIn, UINT uMsg,
DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
{
Q_UNUSED(dwParam1)
Q_UNUSED(dwParam2)
Q_UNUSED(hWaveIn)
QAudioInputPrivate* qAudio;
qAudio = (QAudioInputPrivate*)(dwInstance);
if(!qAudio)
return;
QMutexLocker(&qAudio->mutex);
switch(uMsg) {
case WIM_OPEN:
break;
case WIM_DATA:
if(qAudio->waveFreeBlockCount > 0)
qAudio->waveFreeBlockCount--;
qAudio->feedback();
break;
case WIM_CLOSE:
qAudio->finished = true;
break;
default:
return;
}
}
void Buddha::resizeBuffers( ) {
qDebug() << "Buddha::resizeBuffers()";
mutex.lock();
#if QTOPENCL
raw = (unsigned int*) realloc( raw, size * 4 * sizeof( unsigned int ) );
#else
raw = (unsigned int*) realloc( raw, size * 3 * sizeof( unsigned int ) );
#endif
RGBImage = (unsigned int*) realloc( RGBImage, size * sizeof( unsigned int ) );
mutex.unlock();
#if QTOPENCL
convert.setRoundedGlobalWorkSize( QSize( w, h ) );
//convert.setGlobalWorkSize( QSize( w, h ) );
convert.setLocalWorkSize( convert.bestLocalWorkSizeImage2D() );
dstImageBuffer = context.createImage2DDevice( QImage::Format_RGB32, QSize( w, h ), QCLMemoryObject::WriteOnly );
#endif
for ( int i = 0; i < threads; ++i ) {
QMutexLocker( &generators[i]->mutex );
// could be done also indirectly but it not so costly
generators[i]->raw = (unsigned int*) realloc( generators[i]->raw, 3 * size * sizeof( unsigned int ) );
}
}
void AvatarJobManager::jobFinished()
{
QMutexLocker(&mutex());
IsJobRunning = false;
scheduleJob();
}
void GenomeAlignerFindTask::run() {
// TODO: this is a fastfix of reopened https://ugene.net/tracker/browse/UGENE-1190
// Problem:
// If reference sequence contains Ns only, ShortReadAligners will return without waiting for all short reads.
// GenomeAlignerTask will create another ReadShortReadsSubTask on GenomeAlignerFindTask->WriteAlignedReadsSubTask subtask finish
// Wait while ReadShortReadsSubTask finished reading.
while (true) {
if (isCanceled()) {
break;
}
QMutexLocker(&(alignContext->readingStatusMutex));
bool isReadingStarted = alignContext->isReadingStarted;
bool isReadingFinished = alignContext->isReadingFinished;
if (isReadingStarted && isReadingFinished) {
break;
}
alignContext->readShortReadsWait.wait(&(alignContext->readingStatusMutex));
}
QReadLocker locker(&alignContext->indexLock);
alignContext->needIndex = false;
alignContext->loadIndexTaskWait.wakeOne();
}
void CALLBACK QAudioOutputPrivate::waveOutProc( HWAVEOUT hWaveOut, UINT uMsg,
DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
{
Q_UNUSED(dwParam1)
Q_UNUSED(dwParam2)
Q_UNUSED(hWaveOut)
QAudioOutputPrivate* qAudio;
qAudio = (QAudioOutputPrivate*)(dwInstance);
if(!qAudio)
return;
QMutexLocker(&qAudio->mutex);
switch(uMsg) {
case WOM_OPEN:
qAudio->feedback();
break;
case WOM_CLOSE:
return;
case WOM_DONE:
if(qAudio->finished || qAudio->buffer_size == 0 || qAudio->period_size == 0) {
return;
}
qAudio->waveFreeBlockCount++;
if(qAudio->waveFreeBlockCount >= qAudio->buffer_size/qAudio->period_size)
qAudio->waveFreeBlockCount = qAudio->buffer_size/qAudio->period_size;
qAudio->feedback();
break;
default:
return;
}
}
void WaveRenderArea::resizeEvent(QResizeEvent *e)
{
Q_D(WaveRenderArea);
QMutexLocker(d->sampleBufferMutex);
d->pixmap = QPixmap(e->size());
drawPixmap();
}
void
GenericWatcher::scheduleBlockingTask(int taskID,
const boost::shared_ptr<GenericWatcherCallerArgs>& args)
{
{
QMutexLocker quitLocker(&_imp->mustQuitMutex);
if (_imp->mustQuit) {
return;
}
}
{
QMutexLocker(&_imp->tasksMutex);
GenericWatcherPrivate::Task t;
t.id = taskID;
t.args = args;
_imp->tasks.push_back(t);
}
if ( !isRunning() ) {
start();
} else {
///Wake up the thread with a start request
QMutexLocker locker(&_imp->startRequestsMutex);
if (_imp->startRequests <= 0) {
++_imp->startRequests;
}
_imp->startRequestsCond.wakeOne();
}
}
void XSLoadHostThread::run()
{
QMutexLocker(data->xen_lock);
emit progressChanged(0, trUtf8("Connecting to %1").arg(data->name));
data->session = xen_session_login_with_password(call_func, reinterpret_cast<void*>(data), data->username.toUtf8().data(), data->password.toUtf8().data(), xen_api_latest_version);
if(data->session == nullptr)
return error(trUtf8("Failed to connect to %1").arg(data->name), nullptr);
data->connected = true;
data->connect_button->setText(trUtf8("Disconnect"));
emit progressChanged(10, trUtf8("Fetching Host"));
xen_host host_handle = nullptr;
if(!xen_session_get_this_host(data->session, &host_handle, data->session))
return error(trUtf8("Failed to fetch host!"), data->session);
emit progressChanged(15, trUtf8("Fetching Data"));
if(!xen_host_get_record(data->session, &data->data, host_handle))
return error(trUtf8("Failed to fetch data!"), data->session);
emit progressChanged(20, trUtf8("Fetching VMs"));
xen_vm_xen_vm_record_map *vms;
if(!xen_vm_get_all_records(data->session, &vms))
return error(trUtf8("Failed to fetch VMs!"), data->session);
data->vm_list_widget->clear();
data->vm_count = vms->size;
data->vms = new xsvm_data*[vms->size];
for(size_t i = 0; i < data->vm_count; i++)
{
xen_vm_record *vm = vms->contents[i].val;
xsvm_data *vm_data = new xsvm_data;
vm_data->data = vm;
vm_data->host = data;
vm_data->tunnel = nullptr;
vm_data->window = nullptr;
data->vms[i] = vm_data;
if(vm->is_a_snapshot || vm->is_a_template)
continue;
doInGUIThread([this,vm_data] { QListWidgetItem *item = new QListWidgetItem(QString::fromUtf8(vm_data->data->name_label), data->vm_list_widget);
item->setData(Qt::UserRole, QVariant::fromValue(reinterpret_cast<void*>(vm_data))); });
}
doInGUIThread([this] { data->vm_list_widget->setDisabled(false); });
emit progressChanged(100, trUtf8("Connected to %1").arg(data->name));
}
void GroupManager::store()
{
QMutexLocker(&mutex());
emit saveGroupData();
SimpleManager<Group>::store();
}
void QLog_(const QString &module, LogLevel level, const QString &message)
{
QLoggerManager *manager = QLoggerManager::getInstance();
QMutexLocker(&manager->mutex);
QLoggerWriter *logWriter = manager->getLogWriter(module);
if (logWriter and logWriter->getLevel() <= level)
logWriter->write(module,message);
}
DataSource::~DataSource()
{
if (m_provider != nullptr) {
// Synchronously disconnect from texture (find a better way to handle this)
QMutexLocker(&m_provider->m_datatexture->m_source_access);
m_provider->m_datatexture->m_source = nullptr;
m_provider->deleteLater();
}
}
void AvatarJobManager::scheduleJob()
{
QMutexLocker(&mutex());
if (!IsJobRunning && hasJob())
// run it in next even cycle
// this is for reccursion prevention, so we save on stack memory
QTimer::singleShot(0, this, SLOT(runJob()));
}
/*!
Sends a message to this message handler. \a type is the kind of
message being sent. \a description is the message content. The \a
identifier is a URI that identifies the message and is the key to
interpreting the other arguments.
Typically, this class is used for reporting errors, as is the case
for QXmlQuery, which uses a QAbstractMessageHandler to report
compile and runtime XQuery errors. Hence, using a QUrl as the
message \a identifier is was inspired by the explanation of \l{error
handling in the XQuery language}. Because the \a identifier is
composed of a namespace URI and a local part, identifiers with the
same local part are unique. The caller is responsible for ensuring
that \a identifier is either a valid QUrl or a default constructed
QUrl.
\a sourceLocation identifies a location in a resource (i.e., file or
document) where the need for reporting a message was detected.
This function unconditionally calls handleMessage(), passing all
its parameters unmodified.
\sa {http://www.w3.org/TR/xquery/#errors}
*/
void QAbstractMessageHandler::message(QtMsgType type,
const QString &description,
const QUrl &identifier,
const QSourceLocation &sourceLocation)
{
Q_D(QAbstractMessageHandler);
QMutexLocker(&d->mutex);
handleMessage(type, description, identifier, sourceLocation);
}
void AvatarJobManager::addJob(const Contact &contact)
{
QMutexLocker(&mutex());
if (!contact)
return;
Jobs.insert(contact);
scheduleJob();
}
/*! \internal */
bool QMetaObject::hasMetaObject( const char *class_name )
{
if ( !qt_metaobjects )
return FALSE;
#ifdef QT_THREAD_SUPPORT
QMutexLocker( qt_global_mutexpool ?
qt_global_mutexpool->get( &qt_metaobjects ) : 0 );
#endif // QT_THREAD_SUPPORT
return !!qt_metaobjects->find( class_name );
}
bool PendingMessagesManager::hasPendingMessages()
{
QMutexLocker(&mutex());
foreach (const Message &message, items())
if (message.isPending())
return true;
return false;
}
bool PendingMessagesManager::hasPendingMessagesForChat(const Chat &chat)
{
QMutexLocker(&mutex());
foreach (const Message &message, items())
if (message.isPending() && message.messageChat() == chat)
return true;
return false;
}
void WaveRenderArea::setData(const SampleBufferType &data, qint64 processedUSecs)
{
Q_D(WaveRenderArea);
QMutexLocker(d->sampleBufferMutex);
d->sampleBuffer = data;
d->frameTimestampNs = 1000 * processedUSecs;
findPeaks();
d->lastFrameTimestampNs = d->frameTimestampNs;
drawPixmap();
}
Message PendingMessagesManager::firstPendingMessage()
{
QMutexLocker(&mutex());
foreach (const Message &message, items())
if (message.isPending())
return message;
return Message::null;
}
bool PendingMessagesManager::hasPendingMessagesForBuddy(const Buddy &buddy)
{
QMutexLocker(&mutex());
foreach (const Message &message, items())
if (message.isPending() && buddy.contacts().contains(message.messageSender()))
return true;
return false;
}
Chat PendingMessagesManager::chatForContact(const Contact &contact)
{
QMutexLocker(&mutex());
foreach (const Message &message, items())
if (message.isPending() && message.messageSender() == contact)
return message.messageChat();
return Chat::null;
}
Chat PendingMessagesManager::chatForBuddy(const Buddy &buddy)
{
QMutexLocker(&mutex());
foreach (const Message &message, items())
if (message.isPending() && buddy.contacts().contains(message.messageSender()))
return message.messageChat();
return Chat::null;
}
QList<Message> PendingMessagesManager::pendingMessages()
{
QMutexLocker(&mutex());
QList<Message> result;
foreach (const Message &message, items())
if (message.isPending())
result.append(message);
return result;
}
QList<Message> PendingMessagesManager::pendingMessagesForChat(const Chat &chat)
{
QMutexLocker(&mutex());
QList<Message> result;
foreach (const Message &message, items())
if (message.isPending() && message.messageChat() == chat)
result.append(message);
return result;
}
Contact AvatarJobManager::nextJob()
{
QMutexLocker(&mutex());
if (!hasJob())
return Contact::null;
Contact job = *Jobs.constBegin();
Jobs.remove(job);
return job;
}
QList<Message> PendingMessagesManager::pendingMessagesForBuddy(const Buddy &buddy)
{
QMutexLocker(&mutex());
QList<Message> result;
QSet<Contact> contacts = buddy.contacts().toSet();
foreach (const Message &message, items())
if (message.isPending() && !message.messageChat().contacts().intersect(contacts).isEmpty())
result.append(message);
return result;
}
void Buddha::clearBuffers ( ) {
qDebug() << "Buddha::clearBuffers()";
mutex.lock();
memset( RGBImage, 0, size * sizeof( int ) );
memset( raw, 0, 3 * size * sizeof( int ) );
mutex.unlock();
for ( int i = 0; i < threads; ++i ) {
QMutexLocker( &generators[i]->mutex );
// could be done also indirectly but it not so costly
if ( generators[i]->raw ) memset( generators[i]->raw, 0, 3 * size * sizeof( int ) );
}
}
void SymbianDeviceManager::delayedClosePort()
{
// Find any coda ports that are still open but have a reference count of zero, and delete them
QMutexLocker(&d->m_devicesLock);
foreach (const SymbianDevice& device, d->m_devices) {
Coda::CodaDevice* codaDevice = device.m_data->codaDevice.data();
if (codaDevice && device.m_data->deviceAcquired == 0 && codaDevice->device()->isOpen()) {
if (debug)
qDebug("Closing device %s", qPrintable(device.m_data->portName));
device.m_data->codaDevice->device()->close();
}
}
}
int JackAudioSystem::process_callback(jack_nframes_t nframes, void *arg) {
JackAudioSystem * const jas = static_cast<JackAudioSystem*>(arg);
if (jas && jas->bJackIsGood) {
AudioInputPtr ai = g.ai;
AudioOutputPtr ao = g.ao;
JackAudioInput * const jai = dynamic_cast<JackAudioInput *>(ai.get());
JackAudioOutput * const jao = dynamic_cast<JackAudioOutput *>(ao.get());
if (jai && jai->isRunning() && jai->iMicChannels > 0 && !jai->isFinished()) {
QMutexLocker(&jai->qmMutex);
void *input = jack_port_get_buffer(jas->in_port, nframes);
if (input != NULL) {
jai->addMic(input, nframes);
}
}
if (jao && jao->isRunning() && jao->iChannels > 0 && !jao->isFinished()) {
QMutexLocker(&jao->qmMutex);
jack_default_audio_sample_t *port_buffers[JACK_MAX_OUTPUT_PORTS];
for (unsigned int i = 0; i < jao->iChannels; ++i) {
port_buffers[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(jas->out_ports[i], nframes);
if (port_buffers[i] == NULL) {
return 1;
}
}
jack_default_audio_sample_t * const buffer = jas->output_buffer;
memset(buffer, 0, sizeof(jack_default_audio_sample_t) * nframes * jao->iChannels);
jao->mix(buffer, nframes);
if (jao->iChannels == 1) {
memcpy(port_buffers[0], buffer, sizeof(jack_default_audio_sample_t) * nframes);
} else {
// de-interleave channels
for (unsigned int i = 0; i < nframes * jao->iChannels; ++i) {
port_buffers[i % jao->iChannels][i / jao->iChannels] = buffer[i];
}
}
}
}
return 0;
}
