int opengl_start(ps_buffer_t *buffer)
{
if (opengl.started)
return EINVAL;
opengl.buffer = buffer;
/* init unscaled buffer if it is needed */
if ((opengl.scale_factor != 1.0) | opengl.convert_ycbcr_420jpeg) {
/* if scaling is enabled, it is faster to capture as GL_BGRA */
gl_capture_set_pixel_format(opengl.gl_capture, GL_BGRA);
ps_bufferattr_t attr;
ps_bufferattr_init(&attr);
ps_bufferattr_setsize(&attr, opengl.unscaled_size);
opengl.unscaled = (ps_buffer_t *) malloc(sizeof(ps_buffer_t));
ps_buffer_init(opengl.unscaled, &attr);
if (opengl.convert_ycbcr_420jpeg) {
ycbcr_init(&opengl.ycbcr, opengl.glc);
ycbcr_set_scale(opengl.ycbcr, opengl.scale_factor);
ycbcr_process_start(opengl.ycbcr, opengl.unscaled, buffer);
} else {
scale_init(&opengl.scale, opengl.glc);
scale_set_scale(opengl.scale, opengl.scale_factor);
scale_process_start(opengl.scale, opengl.unscaled, buffer);
}
gl_capture_set_buffer(opengl.gl_capture, opengl.unscaled);
} else {
gl_capture_set_pixel_format(opengl.gl_capture, GL_BGR);
gl_capture_set_buffer(opengl.gl_capture, opengl.buffer);
}
opengl.started = 1;
return 0;
}
int export_yuv4mpeg(struct play_s *play)
{
/*
Export yuv4mpeg uses following pipeline:
file -(uncompressed_buffer)-> reads data from stream file
unpack -(uncompressed_buffer)-> decompresses lzo/quicklz packets
scale -(scale)-> does rescaling
color -(color)-> applies color correction
ycbcr -(ycbcr)-> does conversion to Y'CbCr (if necessary)
yuv4mpeg writes yuv4mpeg stream
*/
ps_bufferattr_t attr;
ps_buffer_t uncompressed_buffer, compressed_buffer,
ycbcr_buffer, color_buffer, scale_buffer;
yuv4mpeg_t yuv4mpeg;
ycbcr_t ycbcr;
scale_t scale;
unpack_t unpack;
color_t color;
int ret = 0;
if ((ret = ps_bufferattr_init(&attr)))
goto err;
/* buffers */
if ((ret = ps_bufferattr_setsize(&attr, play->compressed_size)))
goto err;
if ((ret = ps_buffer_init(&compressed_buffer, &attr)))
goto err;
if ((ret = ps_bufferattr_setsize(&attr, play->uncompressed_size)))
goto err;
if ((ret = ps_buffer_init(&uncompressed_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&color_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&ycbcr_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&scale_buffer, &attr)))
goto err;
if ((ret = ps_bufferattr_destroy(&attr)))
goto err;
/* initialize filters */
if ((ret = unpack_init(&unpack, &play->glc)))
goto err;
if ((ret = ycbcr_init(&ycbcr, &play->glc)))
goto err;
ycbcr_set_levels(ycbcr, play->tv_levels);
if ((ret = scale_init(&scale, &play->glc)))
goto err;
if (play->scale_width && play->scale_height)
scale_set_size(scale, play->scale_width, play->scale_height);
else
scale_set_scale(scale, play->scale_factor);
if ((ret = color_init(&color, &play->glc)))
goto err;
if (play->override_color_correction)
color_override(color, play->brightness, play->contrast,
play->red_gamma, play->green_gamma, play->blue_gamma);
if ((ret = yuv4mpeg_init(&yuv4mpeg, &play->glc)))
goto err;
yuv4mpeg_set_fps(yuv4mpeg, play->fps);
yuv4mpeg_set_stream_id(yuv4mpeg, play->export_video_id);
yuv4mpeg_set_interpolation(yuv4mpeg, play->interpolate);
yuv4mpeg_set_filename(yuv4mpeg, play->export_filename_format);
/* construct the pipeline */
if ((ret = unpack_process_start(unpack, &compressed_buffer, &uncompressed_buffer)))
goto err;
if ((ret = scale_process_start(scale, &uncompressed_buffer, &scale_buffer)))
goto err;
if ((ret = color_process_start(color, &scale_buffer, &color_buffer)))
goto err;
if ((ret = ycbcr_process_start(ycbcr, &color_buffer, &ycbcr_buffer)))
goto err;
if ((ret = yuv4mpeg_process_start(yuv4mpeg, &ycbcr_buffer)))
goto err;
/* feed it with data */
if ((ret = file_read(play->file, &compressed_buffer)))
goto err;
/* threads will do the dirty work... */
if ((ret = yuv4mpeg_process_wait(yuv4mpeg)))
goto err;
if ((ret = color_process_wait(color)))
goto err;
if ((ret = scale_process_wait(scale)))
goto err;
if ((ret = ycbcr_process_wait(ycbcr)))
goto err;
if ((ret = unpack_process_wait(unpack)))
goto err;
unpack_destroy(unpack);
ycbcr_destroy(ycbcr);
scale_destroy(scale);
color_destroy(color);
yuv4mpeg_destroy(yuv4mpeg);
ps_buffer_destroy(&compressed_buffer);
ps_buffer_destroy(&uncompressed_buffer);
ps_buffer_destroy(&color_buffer);
ps_buffer_destroy(&scale_buffer);
ps_buffer_destroy(&ycbcr_buffer);
return 0;
err:
fprintf(stderr, "exporting yuv4mpeg failed: %s (%d)\n", strerror(ret), ret);
return ret;
}
int export_img(struct play_s *play)
{
/*
Export img uses following pipeline:
file -(uncompressed_buffer)-> reads data from stream file
unpack -(uncompressed_buffer)-> decompresses lzo/quicklz packets
rgb -(rgb)-> does conversion to BGR
scale -(scale)-> does rescaling
color -(color)-> applies color correction
img writes separate image files for each frame
*/
ps_bufferattr_t attr;
ps_buffer_t uncompressed_buffer, compressed_buffer,
rgb_buffer, color_buffer, scale_buffer;
img_t img;
color_t color;
scale_t scale;
unpack_t unpack;
rgb_t rgb;
int ret = 0;
if ((ret = ps_bufferattr_init(&attr)))
goto err;
/* buffers */
if ((ret = ps_bufferattr_setsize(&attr, play->compressed_size)))
goto err;
if ((ret = ps_buffer_init(&compressed_buffer, &attr)))
goto err;
if ((ret = ps_bufferattr_setsize(&attr, play->uncompressed_size)))
goto err;
if ((ret = ps_buffer_init(&uncompressed_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&color_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&rgb_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&scale_buffer, &attr)))
goto err;
if ((ret = ps_bufferattr_destroy(&attr)))
goto err;
/* filters */
if ((ret = unpack_init(&unpack, &play->glc)))
goto err;
if ((ret = rgb_init(&rgb, &play->glc)))
goto err;
if ((ret = scale_init(&scale, &play->glc)))
goto err;
if (play->scale_width && play->scale_height)
scale_set_size(scale, play->scale_width, play->scale_height);
else
scale_set_scale(scale, play->scale_factor);
if ((ret = color_init(&color, &play->glc)))
goto err;
if (play->override_color_correction)
color_override(color, play->brightness, play->contrast,
play->red_gamma, play->green_gamma, play->blue_gamma);
if ((ret = img_init(&img, &play->glc)))
goto err;
img_set_filename(img, play->export_filename_format);
img_set_stream_id(img, play->export_video_id);
img_set_format(img, play->img_format);
img_set_fps(img, play->fps);
/* pipeline... */
if ((ret = unpack_process_start(unpack, &compressed_buffer, &uncompressed_buffer)))
goto err;
if ((ret = rgb_process_start(rgb, &uncompressed_buffer, &rgb_buffer)))
goto err;
if ((ret = scale_process_start(scale, &rgb_buffer, &scale_buffer)))
goto err;
if ((ret = color_process_start(color, &scale_buffer, &color_buffer)))
goto err;
if ((ret = img_process_start(img, &color_buffer)))
goto err;
/* ok, read the file */
if ((ret = file_read(play->file, &compressed_buffer)))
goto err;
/* wait 'till its done and clean up the mess... */
if ((ret = img_process_wait(img)))
goto err;
if ((ret = color_process_wait(color)))
goto err;
if ((ret = scale_process_wait(scale)))
goto err;
if ((ret = rgb_process_wait(rgb)))
goto err;
if ((ret = unpack_process_wait(unpack)))
goto err;
unpack_destroy(unpack);
rgb_destroy(rgb);
scale_destroy(scale);
color_destroy(color);
img_destroy(img);
ps_buffer_destroy(&compressed_buffer);
ps_buffer_destroy(&uncompressed_buffer);
ps_buffer_destroy(&color_buffer);
ps_buffer_destroy(&scale_buffer);
ps_buffer_destroy(&rgb_buffer);
return 0;
err:
fprintf(stderr, "exporting images failed: %s (%d)\n", strerror(ret), ret);
return ret;
}
int play_stream(struct play_s *play)
{
/*
Playback uses following pipeline:
file -(uncompressed)-> reads data from stream file
unpack -(uncompressed)-> decompresses lzo/quicklz packets
rgb -(rgb)-> does conversion to BGR
scale -(scale)-> does rescaling
color -(color)-> applies color correction
demux -(...)-> gl_play, alsa_play
Each filter, except demux and file, has glc_threads_hint(glc) worker
threads. Packet order in stream is preserved. Demux creates
separate buffer and _play handler for each video/audio stream.
*/
ps_bufferattr_t attr;
ps_buffer_t uncompressed_buffer, compressed_buffer,
rgb_buffer, color_buffer, scale_buffer;
demux_t demux;
color_t color;
scale_t scale;
unpack_t unpack;
rgb_t rgb;
int ret = 0;
if ((ret = ps_bufferattr_init(&attr)))
goto err;
/*
'compressed_buffer' buffer holds raw data from file and
has its own size.
*/
if ((ret = ps_bufferattr_setsize(&attr, play->compressed_size)))
goto err;
if ((ret = ps_buffer_init(&compressed_buffer, &attr)))
goto err;
/* rest use 'uncompressed_buffer' size */
if ((ret = ps_bufferattr_setsize(&attr, play->uncompressed_size)))
goto err;
if ((ret = ps_buffer_init(&uncompressed_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&color_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&rgb_buffer, &attr)))
goto err;
if ((ret = ps_buffer_init(&scale_buffer, &attr)))
goto err;
/* no longer necessary */
if ((ret = ps_bufferattr_destroy(&attr)))
goto err;
/* init filters */
if ((ret = unpack_init(&unpack, &play->glc)))
goto err;
if ((ret = rgb_init(&rgb, &play->glc)))
goto err;
if ((ret = scale_init(&scale, &play->glc)))
goto err;
if (play->scale_width && play->scale_height)
scale_set_size(scale, play->scale_width, play->scale_height);
else
scale_set_scale(scale, play->scale_factor);
if ((ret = color_init(&color, &play->glc)))
goto err;
if (play->override_color_correction)
color_override(color, play->brightness, play->contrast,
play->red_gamma, play->green_gamma, play->blue_gamma);
if ((ret = demux_init(&demux, &play->glc)))
goto err;
demux_set_video_buffer_size(demux, play->uncompressed_size);
demux_set_audio_buffer_size(demux, play->uncompressed_size / 10);
demux_set_alsa_playback_device(demux, play->alsa_playback_device);
/* construct a pipeline for playback */
if ((ret = unpack_process_start(unpack, &compressed_buffer, &uncompressed_buffer)))
goto err;
if ((ret = rgb_process_start(rgb, &uncompressed_buffer, &rgb_buffer)))
goto err;
if ((ret = scale_process_start(scale, &rgb_buffer, &scale_buffer)))
goto err;
if ((ret = color_process_start(color, &scale_buffer, &color_buffer)))
goto err;
if ((ret = demux_process_start(demux, &color_buffer)))
goto err;
/* the pipeline is ready - lets give it some data */
if ((ret = file_read(play->file, &compressed_buffer)))
goto err;
/* we've done our part - just wait for the threads */
if ((ret = demux_process_wait(demux)))
goto err; /* wait for demux, since when it quits, others should also */
if ((ret = color_process_wait(color)))
goto err;
if ((ret = scale_process_wait(scale)))
goto err;
if ((ret = rgb_process_wait(rgb)))
goto err;
if ((ret = unpack_process_wait(unpack)))
goto err;
/* stream processed - clean up time */
unpack_destroy(unpack);
rgb_destroy(rgb);
scale_destroy(scale);
color_destroy(color);
demux_destroy(demux);
ps_buffer_destroy(&compressed_buffer);
ps_buffer_destroy(&uncompressed_buffer);
ps_buffer_destroy(&color_buffer);
ps_buffer_destroy(&scale_buffer);
ps_buffer_destroy(&rgb_buffer);
return 0;
err:
if (!ret) {
fprintf(stderr, "playing stream failed: initializing filters failed\n");
return EAGAIN;
} else {
fprintf(stderr, "playing stream failed: %s (%d)\n", strerror(ret), ret);
return ret;
}
}
void AnvredCorrection::execEvent() {
const int64_t numHists =
static_cast<int64_t>(m_inputWS->getNumberHistograms());
std::string unitStr = m_inputWS->getAxis(0)->unit()->unitID();
// Create a new outputworkspace with not much in it
DataObjects::EventWorkspace_sptr correctionFactors;
correctionFactors = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create("EventWorkspace", numHists, 2,
1));
correctionFactors->sortAll(TOF_SORT, nullptr);
// Copy required stuff from it
API::WorkspaceFactory::Instance().initializeFromParent(
m_inputWS, correctionFactors, true);
bool inPlace = (this->getPropertyValue("InputWorkspace") ==
this->getPropertyValue("OutputWorkspace"));
if (inPlace)
g_log.debug("Correcting EventWorkspace in-place.");
// If sample not at origin, shift cached positions.
const V3D samplePos = m_inputWS->getInstrument()->getSample()->getPos();
const V3D pos = m_inputWS->getInstrument()->getSource()->getPos() - samplePos;
double L1 = pos.norm();
Progress prog(this, 0.0, 1.0, numHists);
// Loop over the spectra
PARALLEL_FOR2(eventW, correctionFactors)
for (int64_t i = 0; i < int64_t(numHists); ++i) {
PARALLEL_START_INTERUPT_REGION
// Copy over bin boundaries
const MantidVec &X = eventW->readX(i);
correctionFactors->dataX(i) = X;
// Get detector position
IDetector_const_sptr det;
try {
det = eventW->getDetector(i);
} catch (Exception::NotFoundError &) {
// Catch if no detector. Next line tests whether this happened - test
// placed
// outside here because Mac Intel compiler doesn't like 'continue' in a
// catch
// in an openmp block.
}
// If no detector found, skip onto the next spectrum
if (!det)
continue;
// This is the scattered beam direction
Instrument_const_sptr inst = eventW->getInstrument();
V3D dir = det->getPos() - samplePos;
double L2 = dir.norm();
// Two-theta = polar angle = scattering angle = between +Z vector and the
// scattered beam
double scattering = dir.angle(V3D(0.0, 0.0, 1.0));
EventList el = eventW->getEventList(i);
el.switchTo(WEIGHTED_NOTIME);
std::vector<WeightedEventNoTime> events = el.getWeightedEventsNoTime();
std::vector<WeightedEventNoTime>::iterator itev;
auto itev_end = events.end();
Mantid::Kernel::Units::Wavelength wl;
std::vector<double> timeflight;
int bank = 0;
double depth = 0.2;
double pathlength = 0.0;
std::string bankName = "";
if (m_useScaleFactors)
scale_init(det, inst, bank, L2, depth, pathlength, bankName);
// multiplying an event list by a scalar value
for (itev = events.begin(); itev != itev_end; ++itev) {
timeflight.push_back(itev->tof());
if (unitStr.compare("TOF") == 0)
wl.fromTOF(timeflight, timeflight, L1, L2, scattering, 0, 0, 0);
double value = this->getEventWeight(timeflight[0], scattering);
if (m_useScaleFactors)
scale_exec(bank, timeflight[0], depth, pathlength, value);
timeflight.clear();
itev->m_errorSquared =
static_cast<float>(itev->m_errorSquared * value * value);
itev->m_weight *= static_cast<float>(value);
}
correctionFactors->getOrAddEventList(i) += events;
std::set<detid_t> &dets = eventW->getEventList(i).getDetectorIDs();
std::set<detid_t>::iterator j;
for (j = dets.begin(); j != dets.end(); ++j)
correctionFactors->getOrAddEventList(i).addDetectorID(*j);
// When focussing in place, you can clear out old memory from the input one!
if (inPlace) {
eventW->getEventList(i).clear();
Mantid::API::MemoryManager::Instance().releaseFreeMemory();
}
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// set the absorption correction values in the run parameters
API::Run &run = correctionFactors->mutableRun();
run.addProperty<double>("Radius", m_radius, true);
if (!m_onlySphericalAbsorption && !m_returnTransmissionOnly)
run.addProperty<bool>("LorentzCorrection", 1, true);
setProperty("OutputWorkspace",
boost::dynamic_pointer_cast<MatrixWorkspace>(correctionFactors));
// Now do some cleaning-up since destructor may not be called immediately
this->cleanup();
}
int
main(int argc, char **argv, char **envp)
{
int i;
scale_init(argc, argv);
#define ALIGNMENTOFFSET 2 /* adjust alignment */
i = sizeof(workStruct_t)*
(narrays+ALIGNMENTOFFSET);
element = memalign(64, i);
if ( element == NULL ) {
perror("calloc( narrays, sizeof(workStruct_t) )");
exit(1);
}
compute_set(element);
memset(element, 0, i);
element+=ALIGNMENTOFFSET;
#ifdef SELFTEST
start_prof();
#endif
fid = open_output("mttest.acct");
if (job_index == -1) {
i = (sizeof(scripttab)/sizeof( struct scripttab) -1 );
} else {
i = 1;
}
fprintf(fid, "Number of tests: %d Repeat count: %d\n",
i, repeat_count);
fprintf(fid, "MHz: %d\n", get_clock_rate() );
fprintf(fid,
"X Incl. Total Incl. CPU Incl. Sync. Wait Name (%s)\n",
model);
fflush(fid);
name = strdup(argv[0]);
init_micro_acct();
#if OS(Solaris)
if(uniprocessor != 0) {
/* call processor_bind to force single CPU */
processor_bind(P_PID, P_MYID, cpuid, NULL);
}
#endif /* OS(Solaris) */
#ifdef SOLARIS
sema_init(&global_sema_lock, count, USYNC_THREAD, NULL);
#endif
#ifdef POSIX
pthread_attr_init(&attr);
#ifdef BOUND
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
#endif
sem_init(&global_sema_lock, 0, count);
#endif
#if 0
if ((s5_sema_id = semget(IPC_PRIVATE, 1, 0600)) == -1)
perror("semget: IPC_PRIVATE");
arg.val = count;
if (semctl(s5_sema_id, 0, SETVAL, arg) == -1)
perror("semctl: SETVAL");
#endif
resolve_symbols();
i = locktest();
#if 0
if (semctl(s5_sema_id, 0, IPC_RMID) == -1)
perror("semctl: IPC_RMID");
#endif
close_file(fid);
#ifdef SELFTEST
finish_prof();
#endif
return 0;
}
