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; }