extern void InitCG( void )
/****************************/
{
InOptimizer = 0;
InsId = 0;
CurrProc = NULL;
CurrBlock = NULL;
BlockList = NULL;
HeadBlock = NULL;
BlockByBlock = FALSE;
abortCG = FALSE;
InitFP();/* must be before InitRegTbl */
InitRegTbl();
ScoreInit();
InitQueue();
InitMakeAddr();
RegTreeInit();
InitIns();
InitConflict();
InitRT();
InitNames();
ObjInit();
ClassPointer = TypeClass( TypePtr );
InitSegment();
}
void Synchronizer::NewSegment(SharedData* lock) {
FlushBuffers(lock);
if(lock->m_segment_video_started && lock->m_segment_audio_started) {
int64_t segment_start_time, segment_stop_time;
GetSegmentStartStop(lock, &segment_start_time, &segment_stop_time);
lock->m_time_offset += std::max((int64_t) 0, segment_stop_time - segment_start_time);
}
lock->m_video_buffer.clear();
lock->m_audio_buffer.Clear();
InitSegment(lock);
}
void Synchronizer::Init() {
// initialize video
if(m_output_format->m_video_enabled) {
m_max_frames_skipped = (m_output_settings->video_allow_frame_skipping)? (MAX_FRAME_DELAY * m_output_format->m_video_frame_rate + 500000) / 1000000 : 0;
VideoLock videolock(&m_video_data);
videolock->m_last_timestamp = std::numeric_limits<int64_t>::min();
videolock->m_next_timestamp = SINK_TIMESTAMP_ASAP;
}
// initialize audio
if(m_output_format->m_audio_enabled) {
AudioLock audiolock(&m_audio_data);
audiolock->m_fast_resampler.reset(new FastResampler(m_output_format->m_audio_channels, 0.9f));
InitAudioSegment(audiolock.get());
audiolock->m_warn_desync = true;
}
// create sync diagram
if(g_option_syncdiagram) {
m_sync_diagram.reset(new SyncDiagram(4));
m_sync_diagram->SetChannelName(0, SyncDiagram::tr("Video in"));
m_sync_diagram->SetChannelName(1, SyncDiagram::tr("Audio in"));
m_sync_diagram->SetChannelName(2, SyncDiagram::tr("Video out"));
m_sync_diagram->SetChannelName(3, SyncDiagram::tr("Audio out"));
m_sync_diagram->show();
}
// initialize shared data
{
SharedLock lock(&m_shared_data);
if(m_output_format->m_audio_enabled) {
lock->m_partial_audio_frame.Alloc(m_output_format->m_audio_frame_size * m_output_format->m_audio_channels);
lock->m_partial_audio_frame_samples = 0;
}
lock->m_video_pts = 0;
lock->m_audio_samples = 0;
lock->m_time_offset = 0;
InitSegment(lock.get());
lock->m_warn_drop_video = true;
}
// start synchronizer thread
m_should_stop = false;
m_error_occurred = false;
m_thread = std::thread(&Synchronizer::SynchronizerThread, this);
}
void Context::Open(IStream* pStream)
{
assert(m_file.GetStream() == 0);
assert((m_pVideo == 0) || (m_pVideo->GetFrames().empty()));
assert((m_pVideo == 0) || (m_pVideo->GetKeyFrames().empty()));
assert((m_pAudio == 0) || (m_pAudio->GetFrames().empty()));
assert(m_clusters.empty());
m_max_timecode = 0; //to keep track of duration
m_cEOS = 0;
m_bEOSVideo = false; //means we haven't seen EOS yet (from either
m_bEOSAudio = false; //the stream itself, or because of stop)
int tn = 0;
if (m_pVideo)
{
m_pVideo->SetTrackNumber(++tn);
++m_cEOS;
}
if (m_pAudio)
{
m_pAudio->SetTrackNumber(++tn);
++m_cEOS;
}
if (pStream)
{
m_file.SetStream(pStream);
#if 0 //TODO: parameterize this (with default of 0)
const __int64 One_GB = 1024i64 * 1024i64 * 1024i64;
__int64 size = 8 * One_GB;
while (size > 0)
{
const HRESULT hr = m_file.SetSize(size);
if (SUCCEEDED(hr))
break;
size /= 2;
}
#endif
m_file.SetPosition(0);
WriteEbmlHeader();
InitSegment();
}
}
void iupPlotDataSet::InsertSampleSegment(int inSampleIndex, double inX, double inY, bool inSegment)
{
iupPlotDataReal *theXData = (iupPlotDataReal*)mDataX;
iupPlotDataReal *theYData = (iupPlotDataReal*)mDataY;
if (theXData->IsString())
return;
if (!mSegment)
InitSegment();
theXData->InsertSample(inSampleIndex, inX);
theYData->InsertSample(inSampleIndex, inY);
mSelection->InsertSample(inSampleIndex, false);
mSegment->InsertSample(inSampleIndex, inSegment);
}
void iupPlotDataSet::AddSampleSegment(double inX, double inY, bool inSegment)
{
iupPlotDataReal *theXData = (iupPlotDataReal*)mDataX;
iupPlotDataReal *theYData = (iupPlotDataReal*)mDataY;
if (theXData->IsString())
return;
if (!mSegment)
InitSegment();
theXData->AddSample(inX);
theYData->AddSample(inY);
mSelection->AddSample(false);
mSegment->AddSample(inSegment);
if (mExtra)
mExtra->AddSample(0);
}
void hypre_UnorderedIntSetCreate( hypre_UnorderedIntSet *s,
HYPRE_Int inCapacity,
HYPRE_Int concurrencyLevel)
{
s->segmentMask = NearestPowerOfTwo(concurrencyLevel) - 1;
if (inCapacity < s->segmentMask + 1)
{
inCapacity = s->segmentMask + 1;
}
//ADJUST INPUT ............................
HYPRE_Int adjInitCap = NearestPowerOfTwo(inCapacity+4096);
HYPRE_Int num_buckets = adjInitCap + HYPRE_HOPSCOTCH_HASH_INSERT_RANGE + 1;
s->bucketMask = adjInitCap - 1;
HYPRE_Int i;
//ALLOCATE THE SEGMENTS ...................
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
s->segments = hypre_TAlloc(hypre_HopscotchSegment, s->segmentMask + 1);
for (i = 0; i <= s->segmentMask; ++i)
{
InitSegment(&s->segments[i]);
}
#endif
s->hopInfo = hypre_TAlloc(hypre_uint, num_buckets);
s->key = hypre_TAlloc(HYPRE_Int, num_buckets);
s->hash = hypre_TAlloc(HYPRE_Int, num_buckets);
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
#pragma omp parallel for
#endif
for (i = 0; i < num_buckets; ++i)
{
s->hopInfo[i] = 0;
s->hash[i] = HYPRE_HOPSCOTCH_HASH_EMPTY;
}
}
void hypre_UnorderedIntMapCreate( hypre_UnorderedIntMap *m,
HYPRE_Int inCapacity,
HYPRE_Int concurrencyLevel)
{
m->segmentMask = NearestPowerOfTwo(concurrencyLevel) - 1;
if (inCapacity < m->segmentMask + 1)
{
inCapacity = m->segmentMask + 1;
}
//ADJUST INPUT ............................
HYPRE_Int adjInitCap = NearestPowerOfTwo(inCapacity+4096);
HYPRE_Int num_buckets = adjInitCap + HYPRE_HOPSCOTCH_HASH_INSERT_RANGE + 1;
m->bucketMask = adjInitCap - 1;
HYPRE_Int i;
//ALLOCATE THE SEGMENTS ...................
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
m->segments = hypre_TAlloc(hypre_HopscotchSegment, m->segmentMask + 1);
for (i = 0; i <= m->segmentMask; i++)
{
InitSegment(&m->segments[i]);
}
#endif
m->table = hypre_TAlloc(hypre_HopscotchBucket, num_buckets);
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
#pragma omp parallel for
#endif
for (i = 0; i < num_buckets; i++)
{
InitBucket(&m->table[i]);
}
}
void Synchronizer::Init() {
// initialize video
if(m_video_encoder != NULL) {
m_video_width = m_video_encoder->GetWidth();
m_video_height = m_video_encoder->GetHeight();
m_video_frame_rate = m_video_encoder->GetFrameRate();
m_video_max_frames_skipped = (m_allow_frame_skipping)? (MAX_FRAME_DELAY * m_video_frame_rate + 500000) / 1000000 : 0;
}
// initialize audio
if(m_audio_encoder != NULL) {
m_audio_sample_rate = m_audio_encoder->GetSampleRate();
m_audio_channels = 2; //TODO// never larger than AV_NUM_DATA_POINTERS
m_audio_sample_size = m_audio_channels * 2;
m_audio_required_frame_size = m_audio_encoder->GetRequiredFrameSize();
m_audio_required_sample_format = m_audio_encoder->GetRequiredSampleFormat();
switch(m_audio_required_sample_format) {
case AV_SAMPLE_FMT_S16:
#if SSR_USE_AVUTIL_PLANAR_SAMPLE_FMT
case AV_SAMPLE_FMT_S16P:
#endif
m_audio_required_sample_size = m_audio_channels * 2; break;
case AV_SAMPLE_FMT_FLT:
#if SSR_USE_AVUTIL_PLANAR_SAMPLE_FMT
case AV_SAMPLE_FMT_FLTP:
#endif
m_audio_required_sample_size = m_audio_channels * 4; break;
default: Q_ASSERT(false); break;
}
}
// initialize shared data
{
SharedLock lock(&m_shared_data);
lock->m_partial_audio_frame.resize(m_audio_required_frame_size * m_audio_sample_size);
lock->m_partial_audio_frame_samples = 0;
lock->m_video_pts = 0;
lock->m_audio_samples = 0;
lock->m_time_offset = 0;
InitSegment(lock.get());
lock->m_warn_drop_video = true;
lock->m_warn_desync = true;
// create sync diagram
if(g_option_syncdiagram) {
lock->m_sync_diagram.reset(new SyncDiagram(4));
lock->m_sync_diagram->SetChannelName(0, "Video in");
lock->m_sync_diagram->SetChannelName(1, "Audio in");
lock->m_sync_diagram->SetChannelName(2, "Video out");
lock->m_sync_diagram->SetChannelName(3, "Audio out");
lock->m_sync_diagram->show();
}
}
// start synchronizer thread
m_should_stop = false;
m_error_occurred = false;
m_thread = std::thread(&Synchronizer::SynchronizerThread, this);
}
void Synchronizer::Init() {
// initialize video
if(m_video_encoder != NULL) {
m_video_width = m_video_encoder->GetWidth();
m_video_height = m_video_encoder->GetHeight();
m_video_frame_rate = m_video_encoder->GetFrameRate();
m_video_max_frames_skipped = (m_allow_frame_skipping)? (MAX_FRAME_DELAY * m_video_frame_rate + 500000) / 1000000 : 0;
}
// initialize audio
if(m_audio_encoder != NULL) {
m_audio_sample_rate = m_audio_encoder->GetSampleRate();
m_audio_channels = 2; //TODO// never larger than AV_NUM_DATA_POINTERS
m_audio_required_frame_samples = m_audio_encoder->GetRequiredFrameSamples();
m_audio_required_sample_format = m_audio_encoder->GetRequiredSampleFormat();
switch(m_audio_required_sample_format) {
case AV_SAMPLE_FMT_S16:
#if SSR_USE_AVUTIL_PLANAR_SAMPLE_FMT
case AV_SAMPLE_FMT_S16P:
#endif
m_audio_required_sample_size = m_audio_channels * 2; break;
case AV_SAMPLE_FMT_FLT:
#if SSR_USE_AVUTIL_PLANAR_SAMPLE_FMT
case AV_SAMPLE_FMT_FLTP:
#endif
m_audio_required_sample_size = m_audio_channels * 4; break;
default: assert(false); break;
}
}
// create sync diagram
if(g_option_syncdiagram) {
m_sync_diagram.reset(new SyncDiagram(4));
m_sync_diagram->SetChannelName(0, SyncDiagram::tr("Video in"));
m_sync_diagram->SetChannelName(1, SyncDiagram::tr("Audio in"));
m_sync_diagram->SetChannelName(2, SyncDiagram::tr("Video out"));
m_sync_diagram->SetChannelName(3, SyncDiagram::tr("Audio out"));
m_sync_diagram->show();
}
// initialize video data
{
VideoLock videolock(&m_video_data);
videolock->m_last_timestamp = std::numeric_limits<int64_t>::min();
videolock->m_next_timestamp = SINK_TIMESTAMP_ASAP;
}
// initialize audio data
{
AudioLock audiolock(&m_audio_data);
audiolock->m_fast_resampler.reset(new FastResampler(m_audio_channels, 0.9f));
InitAudioSegment(audiolock.get());
audiolock->m_warn_desync = true;
}
// initialize shared data
{
SharedLock lock(&m_shared_data);
if(m_audio_encoder != NULL) {
lock->m_partial_audio_frame.Alloc(m_audio_required_frame_samples * m_audio_channels);
lock->m_partial_audio_frame_samples = 0;
}
lock->m_video_pts = 0;
lock->m_audio_samples = 0;
lock->m_time_offset = 0;
InitSegment(lock.get());
lock->m_warn_drop_video = true;
}
// start synchronizer thread
m_should_stop = false;
m_error_occurred = false;
m_thread = std::thread(&Synchronizer::SynchronizerThread, this);
}