int op(int op_id, int arg)
{
int r;
// lock operation mutex
pthread_mutex_lock(&m_op_lock);
mlt_log_debug( getConsumer(), "%s: op_id=%d\n", __FUNCTION__, op_id );
// notify op id
pthread_mutex_lock(&m_op_arg_mutex);
m_op_id = op_id;
m_op_arg = arg;
pthread_cond_signal(&m_op_arg_cond);
pthread_mutex_unlock(&m_op_arg_mutex);
// wait op done
pthread_mutex_lock(&m_op_arg_mutex);
while(OP_NONE != m_op_id)
pthread_cond_wait(&m_op_arg_cond, &m_op_arg_mutex);
pthread_mutex_unlock(&m_op_arg_mutex);
// save result
r = m_op_res;
mlt_log_debug( getConsumer(), "%s: r=%d\n", __FUNCTION__, r );
// unlock operation mutex
pthread_mutex_unlock(&m_op_lock);
return r;
}
IDeckLinkDisplayMode* getDisplayMode()
{
mlt_profile profile = mlt_service_profile( MLT_CONSUMER_SERVICE( getConsumer() ) );
IDeckLinkDisplayModeIterator* iter = NULL;
IDeckLinkDisplayMode* mode = NULL;
IDeckLinkDisplayMode* result = 0;
if ( m_deckLinkOutput->GetDisplayModeIterator( &iter ) == S_OK )
{
while ( !result && iter->Next( &mode ) == S_OK )
{
m_width = mode->GetWidth();
m_height = mode->GetHeight();
mode->GetFrameRate( &m_duration, &m_timescale );
m_fps = (double) m_timescale / m_duration;
int p = mode->GetFieldDominance() == bmdProgressiveFrame;
mlt_log_verbose( getConsumer(), "BMD mode %dx%d %.3f fps prog %d\n", m_width, m_height, m_fps, p );
if ( m_width == profile->width && p == profile->progressive
&& (int) m_fps == (int) mlt_profile_fps( profile )
&& ( m_height == profile->height || ( m_height == 486 && profile->height == 480 ) ) )
result = mode;
else
SAFE_RELEASE( mode );
}
SAFE_RELEASE( iter );
}
return result;
}
virtual ~DeckLinkConsumer()
{
mlt_log_debug( getConsumer(), "%s: entering\n", __FUNCTION__ );
SAFE_RELEASE( m_displayMode );
SAFE_RELEASE( m_deckLinkKeyer );
SAFE_RELEASE( m_deckLinkOutput );
SAFE_RELEASE( m_deckLink );
mlt_deque_close( m_aqueue );
mlt_deque_close( m_frames );
op(OP_EXIT, 0);
mlt_log_debug( getConsumer(), "%s: waiting for op thread\n", __FUNCTION__ );
pthread_join(m_op_thread, NULL);
mlt_log_debug( getConsumer(), "%s: finished op thread\n", __FUNCTION__ );
pthread_mutex_destroy(&m_op_lock);
pthread_mutex_destroy(&m_op_arg_mutex);
pthread_cond_destroy(&m_op_arg_cond);
mlt_log_debug( getConsumer(), "%s: exiting\n", __FUNCTION__ );
}
Json::Value WSConnection::invokeCommand (Json::Value& jvRequest)
{
if (getConsumer().disconnect ())
{
disconnect ();
return rpcError (rpcSLOW_DOWN);
}
// Requests without "command" are invalid.
//
if (!jvRequest.isMember (jss::command))
{
Json::Value jvResult (Json::objectValue);
jvResult[jss::type] = jss::response;
jvResult[jss::status] = jss::error;
jvResult[jss::error] = jss::missingCommand;
jvResult[jss::request] = jvRequest;
if (jvRequest.isMember (jss::id))
{
jvResult[jss::id] = jvRequest[jss::id];
}
getConsumer().charge (Resource::feeInvalidRPC);
return jvResult;
}
Resource::Charge loadType = Resource::feeReferenceRPC;
RPCHandler mRPCHandler (m_netOPs, std::dynamic_pointer_cast<InfoSub> (this->shared_from_this ()));
Json::Value jvResult (Json::objectValue);
Config::Role const role = m_isPublic
? Config::GUEST // Don't check on the public interface.
: getConfig ().getAdminRole (
jvRequest, m_remoteAddress);
if (Config::FORBID == role)
{
jvResult[jss::result] = rpcError (rpcFORBIDDEN);
}
else
{
jvResult[jss::result] = mRPCHandler.doCommand (jvRequest, role, loadType);
}
getConsumer().charge (loadType);
if (getConsumer().warn ())
{
jvResult[jss::warning] = jss::load;
}
// Currently we will simply unwrap errors returned by the RPC
// API, in the future maybe we can make the responses
// consistent.
//
// Regularize result. This is duplicate code.
if (jvResult[jss::result].isMember (jss::error))
{
jvResult = jvResult[jss::result];
jvResult[jss::status] = jss::error;
jvResult[jss::request] = jvRequest;
}
else
{
jvResult[jss::status] = jss::success;
}
if (jvRequest.isMember (jss::id))
{
jvResult[jss::id] = jvRequest[jss::id];
}
jvResult[jss::type] = jss::response;
return jvResult;
}
