void device_config::get_all_possible_requestes(std::vector<stream_request>(&stream_requests)[RS_STREAM_NATIVE_COUNT]) const
{
for (size_t i = 0; i < info.subdevice_modes.size(); i++)
{
stream_request request;
auto mode = info.subdevice_modes[i];
for (auto pad_crop : mode.pad_crop_options)
{
for (auto & unpacker : mode.pf.unpackers)
{
auto selection = subdevice_mode_selection(mode, pad_crop, int(&unpacker - mode.pf.unpackers.data()));
request.enabled = true;
request.fps = selection.get_framerate();
request.height = selection.get_height();
request.width = selection.get_width();
auto outputs = selection.get_outputs();
for (auto output : outputs)
{
request.format = output.second;
for (auto output_format = static_cast<int>(RS_OUTPUT_BUFFER_FORMAT_CONTINUOUS); output_format < static_cast<int>(RS_OUTPUT_BUFFER_FORMAT_COUNT); output_format++)
{
request.output_format = static_cast<rs_output_buffer_format>(output_format);
stream_requests[output.first].push_back(request);
}
}
}
}
}
}
std::shared_ptr<stream_profile_interface> stream_profile_base::clone() const
{
auto res = std::make_shared<stream_profile_base>(get_backend_profile());
res->set_unique_id(environment::get_instance().generate_stream_id());
res->set_framerate(get_framerate());
return res;
}
int ThresholdMain::process_buffer(VFrame *frame,
int64_t start_position,
double frame_rate)
{
load_configuration();
int use_opengl = get_use_opengl() &&
(!config.plot || !gui_open());
read_frame(frame,
0,
get_source_position(),
get_framerate(),
use_opengl);
if(use_opengl) return run_opengl();
send_render_gui(frame);
if(!threshold_engine)
threshold_engine = new ThresholdEngine(this);
threshold_engine->process_packages(frame);
return 0;
}
int FlipMain::process_buffer(VFrame *frame,
int64_t start_position,
double frame_rate)
{
int i, j, k, l;
int w = frame->get_w();
int h = frame->get_h();
int colormodel = frame->get_color_model();
load_configuration();
read_frame(frame,
0,
get_source_position(),
get_framerate(),
get_use_opengl());
if(get_use_opengl())
{
if(config.flip_vertical || config.flip_horizontal)
return run_opengl();
else
return 0;
}
switch(colormodel)
{
case BC_RGB888:
case BC_YUV888:
FLIP_MACRO(unsigned char, 3);
break;
case BC_RGB_FLOAT:
FLIP_MACRO(float, 3);
break;
case BC_RGB161616:
case BC_YUV161616:
FLIP_MACRO(uint16_t, 3);
break;
case BC_RGBA8888:
case BC_YUVA8888:
FLIP_MACRO(unsigned char, 4);
break;
case BC_RGBA_FLOAT:
FLIP_MACRO(float, 4);
break;
case BC_RGBA16161616:
case BC_YUVA16161616:
FLIP_MACRO(uint16_t, 4);
break;
}
return 0;
}
int UnsharpMain::process_buffer(VFrame *frame,
int64_t start_position,
double frame_rate)
{
/*int need_reconfigure =*/ load_configuration();
if(!engine) engine = new UnsharpEngine(this,
get_project_smp() + 1, get_project_smp() + 1);
read_frame(frame, 0, get_source_position(), get_framerate());
engine->do_unsharp(frame);
return 0;
}
/*******************************************
Restart emulation when loading a new game
********************************************/
void reloadrom(void)
{
/* Cartridge "Hot Swap" support (make sure system has already been inited once and use cartridges) */
if ((config.hot_swap == 3) && ((system_hw != SYSTEM_MCD) || scd.cartridge.boot))
{
/* Only initialize cartridge hardware */
if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
{
/* 16-bit cartridge */
md_cart_init();
md_cart_reset(1);
}
else
{
/* 8-bit cartridge */
sms_cart_init();
sms_cart_reset();
}
}
/* Disc Swap support (automatically enabled if CD tray is open) */
else if ((system_hw != SYSTEM_MCD) || (cdd.status != CD_OPEN))
{
/* Initialize audio emulation */
interlaced = 0;
audio_init(SAMPLERATE_48KHZ, get_framerate());
/* Switch virtual system on */
system_init();
system_reset();
/* Allow hot swap */
config.hot_swap |= 2;
}
/* Auto-Load Backup RAM */
slot_autoload(0,config.s_device);
/* Auto-Load State */
slot_autoload(config.s_default,config.s_device);
/* Load Cheat file */
CheatLoad();
}
int Color3WayMain::process_buffer(VFrame *frame,
int64_t start_position,
double frame_rate)
{
need_reconfigure |= load_configuration();
if(!engine) engine = new Color3WayEngine(this,
// 1);
PluginClient::smp + 1);
//printf("Color3WayMain::process_realtime 1 %d\n", need_reconfigure);
if(need_reconfigure)
{
reconfigure();
need_reconfigure = 0;
}
read_frame(frame,
0,
get_source_position(),
get_framerate(),
get_use_opengl());
int aggregate_interpolate = 0;
int aggregate_gamma = 0;
get_aggregation(&aggregate_interpolate,
&aggregate_gamma);
engine->process_packages();
return 0;
}
void gstreamer_previous_frame() {
gboolean error;
gint64 pos = gstreamer_get_position(&error);
if (!error) {
double rate;
if (!get_framerate(&rate))
return;
printf("Position = %ld, Rate = %lf\n", pos, rate);
pos -= ((gint64)GST_SECOND / rate) * 5;
if (pos < 0)
pos = 0;
printf("Position = %ld\n", pos);
if (gst_element_seek_simple(pipeline, GST_FORMAT_TIME,
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
pos)) {
printf("gstplay: Seek succeeded\n");
pause_on_state_change_to_playing = TRUE;
gstreamer_play();
}
else {
printf("gstplay: Seek failed!.n");
}
}
}
int DeInterlaceMain::process_buffer(VFrame *frame,
int64_t start_position,
double frame_rate)
{
changed_rows = frame->get_h();
load_configuration();
read_frame(frame,
0,
start_position,
frame_rate);
// Temp was used for adaptive deinterlacing where it took deinterlacing
// an entire frame to decide if the deinterlaced output should be used.
temp = frame;
// if(!temp)
// temp = new VFrame(
// frame->get_w(),
// frame->get_h(),
// frame->get_color_model());
if(!temp_prevframe)
temp_prevframe = new VFrame(
frame->get_w(),
frame->get_h(),
frame->get_color_model());
switch(config.mode)
{
case DEINTERLACE_NONE:
// output->copy_from(input);
break;
case DEINTERLACE_KEEP:
deinterlace_top(frame, frame, config.dominance);
break;
case DEINTERLACE_AVG:
deinterlace_avg(frame, frame);
break;
case DEINTERLACE_AVG_1F:
deinterlace_avg_top(frame, frame, config.dominance);
break;
case DEINTERLACE_SWAP:
deinterlace_swap(frame, frame, config.dominance);
break;
case DEINTERLACE_BOBWEAVE:
if (get_source_position()==0)
read_frame(temp_prevframe,0, get_source_position(), get_framerate());
else
read_frame(temp_prevframe,0, get_source_position()-1, get_framerate());
deinterlace_bobweave(frame, temp_prevframe, frame, config.dominance);
break;
case DEINTERLACE_TEMPORALSWAP:
if (get_source_position()==0)
read_frame(temp_prevframe,0, get_source_position(), get_framerate());
else
read_frame(temp_prevframe,0, get_source_position()-1, get_framerate());
deinterlace_temporalswap(frame, temp_prevframe, frame, config.dominance);
break;
}
send_render_gui(&changed_rows);
return 0;
}
std::shared_ptr<pipeline_profile> pipeline_config::resolve(std::shared_ptr<pipeline> pipe)
{
std::lock_guard<std::mutex> lock(_mtx);
_resolved_profile.reset();
auto requested_device = resolve_device_requests(pipe);
std::vector<stream_profile> resolved_profiles;
//if the user requested all streams, or if the requested device is from file and the user did not request any stream
if (_enable_all_streams || (!_device_request.filename.empty() && _stream_requests.empty()))
{
if (!requested_device)
{
requested_device = get_first_or_default_device(pipe);
}
util::config config;
config.enable_all(util::best_quality);
_resolved_profile = std::make_shared<pipeline_profile>(requested_device, config, _device_request.record_output);
return _resolved_profile;
}
else
{
util::config config;
//If the user did not request anything, give it the default
if (_stream_requests.empty())
{
if (!requested_device)
{
requested_device = get_first_or_default_device(pipe);
}
auto default_profiles = get_default_configuration(requested_device);
for (auto prof : default_profiles)
{
auto p = dynamic_cast<video_stream_profile*>(prof.get());
if (!p)
{
LOG_ERROR("prof is not video_stream_profile");
throw std::logic_error("Failed to resolve request. internal error");
}
config.enable_stream(p->get_stream_type(), p->get_stream_index(), p->get_width(), p->get_height(), p->get_format(), p->get_framerate());
}
_resolved_profile = std::make_shared<pipeline_profile>(requested_device, config, _device_request.record_output);
return _resolved_profile;
}
else
{
//User enabled some stream, enable only them
for(auto&& req : _stream_requests)
{
auto r = req.second;
config.enable_stream(r.stream, r.stream_index, r.width, r.height, r.format, r.fps);
}
auto devs = pipe->get_context()->query_devices();
if (devs.empty())
{
auto dev = get_first_or_default_device(pipe);
_resolved_profile = std::make_shared<pipeline_profile>(dev, config, _device_request.record_output);
return _resolved_profile;
}
else
{
for (auto dev_info : devs)
{
try
{
auto dev = dev_info->create_device();
_resolved_profile = std::make_shared<pipeline_profile>(dev, config, _device_request.record_output);
return _resolved_profile;
}
catch (...) {}
}
}
throw std::runtime_error("Failed to resolve request. No device found that satisfies all requirements");
}
}
assert(0); //Unreachable code
}
static void run_emulation(void)
{
int sync;
/* main emulation loop */
while (1)
{
/* emulated system */
if (system_hw == SYSTEM_MCD)
{
/* 16-bit hardware + CD */
while (!ConfigRequested)
{
/* render frame */
system_frame_scd(0);
/* audio/video sync */
sync = NO_SYNC;
while (sync != (SYNC_VIDEO | SYNC_AUDIO))
{
/* update video */
sync |= gx_video_Update();
/* update audio */
sync |= gx_audio_Update();
}
/* check interlaced mode change */
if (bitmap.viewport.changed & 4)
{
/* VSYNC "original" mode */
if (!config.render && config.vsync && (gc_pal == vdp_pal))
{
/* framerate has changed, reinitialize audio timings */
audio_init(SAMPLERATE_48KHZ, get_framerate());
}
/* clear flag */
bitmap.viewport.changed &= ~4;
}
}
}
else if ((system_hw & SYSTEM_PBC) == SYSTEM_MD)
{
/* 16-bit hardware */
while (!ConfigRequested)
{
/* render frame */
system_frame_gen(0);
/* audio/video sync */
sync = NO_SYNC;
while (sync != (SYNC_VIDEO | SYNC_AUDIO))
{
/* update video */
sync |= gx_video_Update();
/* update audio */
sync |= gx_audio_Update();
}
/* check interlaced mode change */
if (bitmap.viewport.changed & 4)
{
/* VSYNC "original" mode */
if (!config.render && config.vsync && (gc_pal == vdp_pal))
{
/* framerate has changed, reinitialize audio timings */
audio_init(SAMPLERATE_48KHZ, get_framerate());
}
/* clear flag */
bitmap.viewport.changed &= ~4;
}
}
}
else
{
/* 8-bit hardware */
while (!ConfigRequested)
{
/* render frame */
system_frame_sms(0);
/* audio/video sync */
sync = NO_SYNC;
while (sync != (SYNC_VIDEO | SYNC_AUDIO))
{
/* update video */
sync |= gx_video_Update();
/* update audio */
sync |= gx_audio_Update();
}
/* check interlaced mode change (PBC mode only) */
if (bitmap.viewport.changed & 4)
{
/* "original" mode */
if (!config.render && config.vsync && (gc_pal == vdp_pal))
{
/* framerate has changed, reinitialize audio timings */
audio_init(SAMPLERATE_48KHZ, get_framerate());
}
/* clear flag */
bitmap.viewport.changed &= ~4;
}
}
}
/* stop video & audio */
gx_audio_Stop();
gx_video_Stop();
#ifdef LOG_TIMING
if (system_hw)
{
FILE *f;
char filename[64];
memset(filename, 0, 64);
strcpy(filename,"timings-");
if (!config.vsync || (config.tv_mode == !vdp_pal))
{
strcat(filename,"no_");
}
else
{
if (gc_pal)
{
strcat(filename,"50hz_");
}
else
{
strcat(filename,"60hz_");
}
}
strcat(filename,"vsync-");
if (vdp_pal)
{
strcat(filename,"pal-");
}
else
{
strcat(filename,"ntsc-");
}
if (config.render == 2)
{
strcat(filename,"prog.txt");
}
else
{
if (!config.render && !interlaced)
{
strcat(filename,"no_");
}
strcat(filename,"int.txt");
}
f = fopen(filename,"a");
if (f != NULL)
{
int i;
u32 min,max;
double total = 0;
double nsamples = 0;
if (delta_time[LOGSIZE - 1] != 0)
{
frame_cnt = LOGSIZE;
}
min = max = delta_time[0];
for (i=0; i<frame_cnt; i++)
{
fprintf(f,"%d ns - %d samples (%5.8f samples/sec)\n", delta_time[i], delta_samp[i], 1000000000.0*(double)delta_samp[i]/(double)delta_time[i]/4.0);
total += delta_time[i];
nsamples += delta_samp[i] / 4.0;
if (min > delta_time[i]) min = delta_time[i];
if (max < delta_time[i]) max = delta_time[i];
}
fprintf(f,"\n");
fprintf(f,"min = %d ns\n", min);
fprintf(f,"max = %d ns\n", max);
fprintf(f,"avg = %8.5f ns (%5.8f samples/sec, %5.8f samples/frame)\n\n\n", total/(double)i, nsamples/total*1000000000.0, nsamples/(double)i);
fclose(f);
}
}
memset(delta_time,0,LOGSIZE);
memset(delta_samp,0,LOGSIZE);
frame_cnt = prevtime = 0;
#endif
/* show menu */
ConfigRequested = 0;
mainmenu();
/* restart video & audio */
gx_video_Start();
gx_audio_Start();
}
}
int InterpolateVideo::load_configuration()
{
KeyFrame *prev_keyframe, *next_keyframe;
InterpolateVideoConfig old_config;
old_config.copy_from(&config);
next_keyframe = get_next_keyframe(get_source_position());
prev_keyframe = get_prev_keyframe(get_source_position());
// Previous keyframe stays in config object.
read_data(prev_keyframe);
int64_t prev_position = edl_to_local(prev_keyframe->position);
int64_t next_position = edl_to_local(next_keyframe->position);
if(prev_position == 0 && next_position == 0)
{
next_position = prev_position = get_source_start();
}
// printf("InterpolateVideo::load_configuration 1 %lld %lld %lld %lld\n",
// prev_keyframe->position,
// next_keyframe->position,
// prev_position,
// next_position);
// Get range to average in requested rate
range_start = prev_position;
range_end = next_position;
// Use keyframes to determine range
if(config.use_keyframes)
{
active_input_rate = get_framerate();
// Between keyframe and edge of range or no keyframes
if(range_start == range_end)
{
// Between first keyframe and start of effect
if(get_source_position() >= get_source_start() &&
get_source_position() < range_start)
{
range_start = get_source_start();
}
else
// Between last keyframe and end of effect
if(get_source_position() >= range_start &&
get_source_position() < get_source_start() + get_total_len())
{
// Last frame should be inclusive of current effect
range_end = get_source_start() + get_total_len() - 1;
}
else
{
// Should never get here
;
}
}
// Make requested rate equal to input rate for this mode.
// Convert requested rate to input rate
// printf("InterpolateVideo::load_configuration 2 %lld %lld %f %f\n",
// range_start,
// range_end,
// get_framerate(),
// config.input_rate);
// range_start = (int64_t)((double)range_start / get_framerate() * active_input_rate + 0.5);
// range_end = (int64_t)((double)range_end / get_framerate() * active_input_rate + 0.5);
}
else
// Use frame rate
{
active_input_rate = config.input_rate;
// Convert to input frame rate
range_start = (int64_t)(get_source_position() /
get_framerate() *
active_input_rate);
range_end = (int64_t)(get_source_position() /
get_framerate() *
active_input_rate) + 1;
}
// printf("InterpolateVideo::load_configuration 1 %lld %lld %lld %lld %lld %lld\n",
// prev_keyframe->position,
// next_keyframe->position,
// prev_position,
// next_position,
// range_start,
// range_end);
return !config.equivalent(&old_config);
}
void FramerateCounter::show_fps(CL_GraphicContext &gc, CL_Font &fps_font)
{
CL_String fps = cl_format("%1 fps", get_framerate());
fps_font.draw_text(gc, gc.get_width() - 100, 30, fps);
}
int ColorBalanceMain::process_buffer(VFrame *frame,
int64_t start_position,
double frame_rate)
{
need_reconfigure |= load_configuration();
//printf("ColorBalanceMain::process_realtime 1 %d\n", need_reconfigure);
if(need_reconfigure)
{
if(!engine)
{
total_engines = PluginClient::smp + 1;
engine = new ColorBalanceEngine*[total_engines];
for(int i = 0; i < total_engines; i++)
{
engine[i] = new ColorBalanceEngine(this);
engine[i]->start();
}
}
reconfigure();
need_reconfigure = 0;
}
frame->get_params()->update("COLORBALANCE_PRESERVE", config.preserve);
frame->get_params()->update("COLORBALANCE_CYAN", calculate_transfer(config.cyan));
frame->get_params()->update("COLORBALANCE_MAGENTA", calculate_transfer(config.magenta));
frame->get_params()->update("COLORBALANCE_YELLOW", calculate_transfer(config.yellow));
read_frame(frame,
0,
get_source_position(),
get_framerate(),
get_use_opengl());
int aggregate_interpolate = 0;
int aggregate_gamma = 0;
get_aggregation(&aggregate_interpolate,
&aggregate_gamma);
if(!EQUIV(config.cyan, 0) ||
!EQUIV(config.magenta, 0) ||
!EQUIV(config.yellow, 0) ||
(get_use_opengl() &&
(aggregate_interpolate ||
aggregate_gamma)))
{
if(get_use_opengl())
{
//get_output()->dump_stacks();
// Aggregate
if(next_effect_is("Histogram")) return 0;
return run_opengl();
}
for(int i = 0; i < total_engines; i++)
{
engine[i]->start_process_frame(frame,
frame,
frame->get_h() * i / total_engines,
frame->get_h() * (i + 1) / total_engines);
}
for(int i = 0; i < total_engines; i++)
{
engine[i]->wait_process_frame();
}
}
return 0;
}
