bool CacheManagerI::load(const KeySeq& keys, const std::string& namespaceId, const std::string& businessId,
long expiredTime, bool useMaster, const Ice::Current& current) {
std::ostringstream os;
os<<"Key : ";
for(KeySeq::const_iterator it = keys.begin(); it != keys.end(); ++it) {
os<<*it<<" ";
}
os<<" namespaceId :"<<namespaceId;
os<<" businessId :"<<businessId;
os<<" expiredTime :"<<expiredTime;
os<<" useMaster :"<<useMaster;
MyUtil::InvokeClient ic = MyUtil::InvokeClient::create(current, os.str(), MyUtil::InvokeClient::INVOKE_LEVEL_INFO);
ProducerManagerClientPtr producer = getProducer();
if(producer == NULL) {
return false;
}
bool sucFlag = true;
KeySeq inputKeys(keys.begin(), keys.end());
KeySeq lockedKeys;
KeySeq failedLockedKeys;
DataMap res;
while(true) {
xce::tempmutext::Locks<std::string> locks(&tempMutexManager_, inputKeys, lockedKeys, failedLockedKeys);
if(!lockedKeys.empty()) {
DataMap singleRes = producer->produce(keys, businessId, useMaster, 1000);
if(!singleRes.empty()) {
res.insert(singleRes.begin(), singleRes.end());
}
CacheClientPtr cache = getCache();
if(cache != NULL) {
for(DataMap::const_iterator it = singleRes.begin(); it != singleRes.end(); ++it) {
sucFlag &= cache->set(it->first, it->second, namespaceId, businessId, expiredTime, 1000);
}
}
if(failedLockedKeys.empty()) {
break;
}
}
inputKeys.swap(failedLockedKeys);
lockedKeys.clear();
failedLockedKeys.clear();
}
return sucFlag;
}
bool CacheManagerI::loadListCache(const std::string& key, const std::string& namespace_id, const std::string& biz_id, bool use_master, const Ice::Current& current) {
std::ostringstream os;
os << "key :" << key;
os << " namespaceId :" << namespace_id;
os << " businessId :" << biz_id;
os << " use_master :" << use_master;
MyUtil::InvokeClient ic = MyUtil::InvokeClient::create(current, os.str(), MyUtil::InvokeClient::INVOKE_LEVEL_INFO);
ProducerManagerClientPtr producer = getProducer();
if(!producer) {
MCE_ERROR("CacheManagerI::loadListCache() getProducer() return NULL!!!");
return false;
}
KeySeq input_keys;
input_keys.push_back(key);
KeySeq locked_keys;
KeySeq failed_locked_keys;
bool result = false;
while(true) {
xce::tempmutext::Locks<std::string> locks(&tempMutexManager_, input_keys, locked_keys, failed_locked_keys);
if(!locked_keys.empty()) {
DataMap data;
try {
data = producer->produce(locked_keys, biz_id, use_master, 10000);
} catch (Ice::Exception& e) {
MCE_ERROR("CacheManagerI::loadListCache() rpc call produce() " << e.what());
}
DataMap::const_iterator iter = data.begin();
for (; iter != data.end(); ++iter) {
if (!iter->second.empty()) {
ListOrHashValue list_value;
list_value.ParseFromArray(iter->second.data(), iter->second.size());
if (list_value.values_size() > 0) {
StrList str_list;
BOOST_FOREACH(const std::string& v, list_value.values()) {
str_list.push_back(v);
}
RedisCacheClientPtr cache = GetRedisCache();
if (!cache) {
MCE_ERROR("CacheManagerI::loadListCache() GetRedisCache() return NULL !!!");
continue;
}
result = cache->SetList(key, str_list, namespace_id, biz_id);
}
}
}
virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived(
IDeckLinkVideoInputFrame* video,
IDeckLinkAudioInputPacket* audio )
{
if ( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "preview" ) &&
mlt_producer_get_speed( getProducer() ) == 0.0 && !mlt_deque_count( m_queue ))
{
pthread_cond_broadcast( &m_condition );
return S_OK;
}
// Create mlt_frame
mlt_frame frame = mlt_frame_init( MLT_PRODUCER_SERVICE( getProducer() ) );
// Copy video
if ( video )
{
if ( !( video->GetFlags() & bmdFrameHasNoInputSource ) )
{
int size = video->GetRowBytes() * ( video->GetHeight() + m_vancLines );
void* image = mlt_pool_alloc( size );
void* buffer = 0;
unsigned char* p = (unsigned char*) image;
int n = size / 2;
\
// Initialize VANC lines to nominal black
while ( --n )
{
*p ++ = 16;
*p ++ = 128;
}
// Capture VANC
if ( m_vancLines > 0 )
{
IDeckLinkVideoFrameAncillary* vanc = 0;
if ( video->GetAncillaryData( &vanc ) == S_OK && vanc )
{
for ( int i = 1; i < m_vancLines + 1; i++ )
{
if ( vanc->GetBufferForVerticalBlankingLine( i, &buffer ) == S_OK )
swab( (char*) buffer, (char*) image + ( i - 1 ) * video->GetRowBytes(), video->GetRowBytes() );
else
mlt_log_debug( getProducer(), "failed capture vanc line %d\n", i );
}
SAFE_RELEASE(vanc);
}
}
// Capture image
video->GetBytes( &buffer );
if ( image && buffer )
{
size = video->GetRowBytes() * video->GetHeight();
swab( (char*) buffer, (char*) image + m_vancLines * video->GetRowBytes(), size );
mlt_frame_set_image( frame, (uint8_t*) image, size, mlt_pool_release );
}
else if ( image )
{
mlt_log_verbose( getProducer(), "no video\n" );
mlt_pool_release( image );
}
}
else
{
mlt_log_verbose( getProducer(), "no signal\n" );
mlt_frame_close( frame );
frame = 0;
}
// Get timecode
IDeckLinkTimecode* timecode = 0;
if ( video->GetTimecode( bmdTimecodeVITC, &timecode ) == S_OK && timecode )
{
DLString timecodeString = 0;
if ( timecode->GetString( &timecodeString ) == S_OK )
{
char* s = getCString( timecodeString );
mlt_properties_set( MLT_FRAME_PROPERTIES( frame ), "meta.attr.vitc.markup", s );
mlt_log_debug( getProducer(), "timecode %s\n", s );
freeCString( s );
}
freeDLString( timecodeString );
SAFE_RELEASE( timecode );
}
}
else
{
mlt_log_verbose( getProducer(), "no video\n" );
mlt_frame_close( frame );
frame = 0;
}
// Copy audio
if ( frame && audio )
{
int channels = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "channels" );
int size = audio->GetSampleFrameCount() * channels * sizeof(int16_t);
mlt_audio_format format = mlt_audio_s16;
void* pcm = mlt_pool_alloc( size );
void* buffer = 0;
audio->GetBytes( &buffer );
if ( buffer )
{
memcpy( pcm, buffer, size );
mlt_frame_set_audio( frame, pcm, format, size, mlt_pool_release );
mlt_properties_set_int( MLT_FRAME_PROPERTIES(frame), "audio_samples", audio->GetSampleFrameCount() );
}
else
{
mlt_log_verbose( getProducer(), "no audio\n" );
mlt_pool_release( pcm );
}
}
else
{
mlt_log_verbose( getProducer(), "no audio\n" );
}
// Put frame in queue
if ( frame )
{
int queueMax = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "buffer" );
pthread_mutex_lock( &m_mutex );
if ( mlt_deque_count( m_queue ) < queueMax )
{
mlt_deque_push_back( m_queue, frame );
pthread_cond_broadcast( &m_condition );
}
else
{
mlt_frame_close( frame );
mlt_properties_set_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "dropped", ++m_dropped );
mlt_log_warning( getProducer(), "frame dropped %d\n", m_dropped );
}
pthread_mutex_unlock( &m_mutex );
}
return S_OK;
}
mlt_frame getFrame()
{
struct timeval now;
struct timespec tm;
double fps = mlt_producer_get_fps( getProducer() );
mlt_position position = mlt_producer_position( getProducer() );
mlt_frame frame = mlt_cache_get_frame( m_cache, position );
// Allow the buffer to fill to the requested initial buffer level.
if ( m_isBuffering )
{
int prefill = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "prefill" );
int buffer = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "buffer" );
m_isBuffering = false;
prefill = prefill > buffer ? buffer : prefill;
pthread_mutex_lock( &m_mutex );
while ( mlt_deque_count( m_queue ) < prefill )
{
// Wait up to buffer/fps seconds
gettimeofday( &now, NULL );
long usec = now.tv_sec * 1000000 + now.tv_usec;
usec += 1000000 * buffer / fps;
tm.tv_sec = usec / 1000000;
tm.tv_nsec = (usec % 1000000) * 1000;
if ( pthread_cond_timedwait( &m_condition, &m_mutex, &tm ) )
break;
}
pthread_mutex_unlock( &m_mutex );
}
if ( !frame )
{
// Wait if queue is empty
pthread_mutex_lock( &m_mutex );
while ( mlt_deque_count( m_queue ) < 1 )
{
// Wait up to twice frame duration
gettimeofday( &now, NULL );
long usec = now.tv_sec * 1000000 + now.tv_usec;
usec += 2000000 / fps;
tm.tv_sec = usec / 1000000;
tm.tv_nsec = (usec % 1000000) * 1000;
if ( pthread_cond_timedwait( &m_condition, &m_mutex, &tm ) )
// Stop waiting if error (timed out)
break;
}
frame = ( mlt_frame ) mlt_deque_pop_front( m_queue );
pthread_mutex_unlock( &m_mutex );
// add to cache
if ( frame )
{
mlt_frame_set_position( frame, position );
mlt_cache_put_frame( m_cache, frame );
}
}
// Set frame timestamp and properties
if ( frame )
{
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( getProducer() ) );
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_properties_set_int( properties, "progressive", profile->progressive );
mlt_properties_set_int( properties, "meta.media.progressive", profile->progressive );
mlt_properties_set_int( properties, "top_field_first", m_topFieldFirst );
mlt_properties_set_double( properties, "aspect_ratio", mlt_profile_sar( profile ) );
mlt_properties_set_int( properties, "meta.media.sample_aspect_num", profile->sample_aspect_num );
mlt_properties_set_int( properties, "meta.media.sample_aspect_den", profile->sample_aspect_den );
mlt_properties_set_int( properties, "meta.media.frame_rate_num", profile->frame_rate_num );
mlt_properties_set_int( properties, "meta.media.frame_rate_den", profile->frame_rate_den );
mlt_properties_set_int( properties, "width", profile->width );
mlt_properties_set_int( properties, "meta.media.width", profile->width );
mlt_properties_set_int( properties, "height", profile->height );
mlt_properties_set_int( properties, "meta.media.height", profile->height );
mlt_properties_set_int( properties, "format", mlt_image_yuv422 );
mlt_properties_set_int( properties, "colorspace", m_colorspace );
mlt_properties_set_int( properties, "meta.media.colorspace", m_colorspace );
mlt_properties_set_int( properties, "audio_frequency", 48000 );
mlt_properties_set_int( properties, "audio_channels",
mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "channels" ) );
}
else
mlt_log_warning( getProducer(), "buffer underrun\n" );
return frame;
}
bool start( mlt_profile profile = 0 )
{
if ( m_started )
return false;
try
{
// Initialize some members
m_vancLines = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "vanc" );
if ( m_vancLines == -1 )
m_vancLines = profile->height <= 512 ? 26 : 32;
if ( !profile )
profile = mlt_service_profile( MLT_PRODUCER_SERVICE( getProducer() ) );
// Get the display mode
BMDDisplayMode displayMode = getDisplayMode( profile, m_vancLines );
if ( displayMode == (BMDDisplayMode) bmdDisplayModeNotSupported )
{
mlt_log_info( getProducer(), "profile = %dx%d %f fps %s\n", profile->width, profile->height,
mlt_profile_fps( profile ), profile->progressive? "progressive" : "interlace" );
throw "Profile is not compatible with decklink.";
}
// Determine if supports input format detection
#ifdef WIN32
BOOL doesDetectFormat = FALSE;
#else
bool doesDetectFormat = false;
#endif
IDeckLinkAttributes *decklinkAttributes = 0;
if ( m_decklink->QueryInterface( IID_IDeckLinkAttributes, (void**) &decklinkAttributes ) == S_OK )
{
if ( decklinkAttributes->GetFlag( BMDDeckLinkSupportsInputFormatDetection, &doesDetectFormat ) != S_OK )
doesDetectFormat = false;
SAFE_RELEASE( decklinkAttributes );
}
mlt_log_verbose( getProducer(), "%s format detection\n", doesDetectFormat ? "supports" : "does not support" );
// Enable video capture
BMDPixelFormat pixelFormat = bmdFormat8BitYUV;
BMDVideoInputFlags flags = doesDetectFormat ? bmdVideoInputEnableFormatDetection : bmdVideoInputFlagDefault;
if ( S_OK != m_decklinkInput->EnableVideoInput( displayMode, pixelFormat, flags ) )
throw "Failed to enable video capture.";
// Enable audio capture
BMDAudioSampleRate sampleRate = bmdAudioSampleRate48kHz;
BMDAudioSampleType sampleType = bmdAudioSampleType16bitInteger;
int channels = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "channels" );
if ( S_OK != m_decklinkInput->EnableAudioInput( sampleRate, sampleType, channels ) )
throw "Failed to enable audio capture.";
// Start capture
m_dropped = 0;
mlt_properties_set_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "dropped", m_dropped );
m_started = m_decklinkInput->StartStreams() == S_OK;
if ( !m_started )
throw "Failed to start capture.";
}
catch ( const char *error )
{
m_decklinkInput->DisableVideoInput();
mlt_log_error( getProducer(), "%s\n", error );
return false;
}
return true;
}
