int HostRender::run_noninteractive(RaytracingContext& context,
PixelFuncRaw const& render_pixel, int kill_timeout_seconds)
{
Image frame_buffer(context.params.image_width, context.params.image_height);
ThreadPool thread_pool(context.params.num_threads);
std::vector<glm::ivec2> tile_idx;
Timer timer;
timer.start();
context.scene->refresh_scene(context.params);
launch(&frame_buffer, thread_pool, &context, &tile_idx, render_pixel);
if (kill_timeout_seconds > 0)
{
if (thread_pool.kill_at_timeout(kill_timeout_seconds))
{
cg_assert(!bool("Process ran into timeout - is there an infinite "
"loop?"));
}
}
else
{
thread_pool.wait();
}
thread_pool.poll_exceptions();
timer.stop();
std::cout << "Rendering time: " << timer.getElapsedTimeInMilliSec() << "ms" << std::endl;
frame_buffer.saveTGA(context.params.output_file_name.c_str(), 2.2f);
return 0;
}
void ieee802frame154_dump( TiFrame * frame )
{
static TiIEEE802Frame154Descriptor m_desc;
TiIEEE802Frame154Descriptor * desc;
if (frame_length(frame) > 0)
{
dbc_putchar( '>' );
dbc_n8toa( frame_length(frame) );
/*
desc = ieee802frame154_open( &m_desc );
if (ieee802frame154_parse(desc, frame_startptr(frame), frame_length(frame)))
{
// if the frame received is parsed successfully, then output it to the
// computer through debugging channel
//ieee802frame154_sequence( desc );
//ieee802frame154_panto( desc );
//ieee802frame154_shortaddrto( desc );
//ieee802frame154_panfrom( desc );
//ieee802frame154_shortaddrfrom( desc );
// todo: you can output more
// reference frame_dump() in rtl_frame.c
dbc_n8toa( ieee802frame154_sequence(desc) );
dbc_putchar( ':' );
dbc_write( frame_startptr(frame), frame_length(frame) );
}
else{
// if the frame received is parsed failed, then output the error frame
// to the computer through debugging channel
dbc_putchar( 'X' );
dbc_putchar( ':' );
dbc_write( frame_startptr(frame), frame_length(frame) );
}
*/
//dbc_write( frame_startptr(frame), frame_length(frame) );
dbc_write( frame_buffer(frame), frame_buffercapacity(frame) );
//dbc_mem( frame_startptr(rxbuf), frame_length(rxbuf) );
//dbc_write( frame_startptr(frame), frame_capacity(frame) );
dbc_putchar( '\n' );
}
}
int HostRender::run_interactive(RaytracingContext& context, PixelFuncRaw const& render_pixel,
std::function<void()> const& render_overlay)
{
Image frame_buffer(context.params.image_width, context.params.image_height);
ThreadPool thread_pool(context.params.num_threads);
std::vector<glm::ivec2> tile_idx;
if (!GUI::init_host(context.params))
{
return 1;
}
if(context.scene)
context.scene->set_active_camera();
// Launch first render.
launch(&frame_buffer, thread_pool, &context, &tile_idx, render_pixel);
auto time_last_frame = std::chrono::high_resolution_clock::now();
RaytracingParameters oldParams = context.params;
while (GUI::keep_running())
{
GUI::poll_events();
thread_pool.poll_exceptions();
// Restart rendering if parameters have changed.
auto cam = Camera::get_active();
if ((cam && cam->requires_restart())
|| context.params.change_requires_restart(oldParams))
{
thread_pool.terminate();
if (oldParams.scene != context.params.scene) {
// reload scene
switch (context.params.scene) {
case RaytracingParameters::CORNELL_BOX:
context.scene = context.scenes["cornell_box"];
break;
case RaytracingParameters::SPHERE_PORTRAIT:
context.scene = context.scenes["sphere_portrait"];
break;
default:
cg_assert(!"should not happen");
}
cg_assert(context.scene);
context.scene->set_active_camera();
}
context.scene->refresh_scene(context.params);
oldParams = context.params;
launch(&frame_buffer, thread_pool, &context, &tile_idx, render_pixel);
}
// Update the texture displayed online in regular intervals so that
// we don't waste many cycles uploading all the time.
auto const now = std::chrono::high_resolution_clock::now();
float const mspf = 1000.f / static_cast<float>(context.params.fps);
if (std::chrono::duration_cast<std::chrono::milliseconds>(now-time_last_frame).count() > mspf)
{
GUI::display_host(frame_buffer, render_overlay);
}
}
GUI::cleanup();
return 0;
}
void
DPXCodec::compress(const FrameBuffer &frame)
{
const PixelType pixel_type = (_depth == DPX_8 ? MoxFiles::UINT8 : MoxFiles::UINT16);
const size_t bytes_per_subpixel = PixelSize(pixel_type);
const int num_channels = (_channels == DPX_RGBA ? 4 : 3);
const Box2i dataW = dataWindow();
const int width = (dataW.max.x - dataW.min.x + 1);
const int height = (dataW.max.y - dataW.min.y + 1);
const size_t bytes_per_pixel = bytes_per_subpixel * num_channels;
const size_t rowbytes = bytes_per_pixel * width;
const size_t buffer_size = rowbytes * height;
DataChunk data(buffer_size);
FrameBuffer frame_buffer(dataW);
char *origin = (char *)data.Data;
frame_buffer.insert("R", Slice(pixel_type, origin + (bytes_per_subpixel * 0), bytes_per_pixel, rowbytes));
frame_buffer.insert("G", Slice(pixel_type, origin + (bytes_per_subpixel * 1), bytes_per_pixel, rowbytes));
frame_buffer.insert("B", Slice(pixel_type, origin + (bytes_per_subpixel * 2), bytes_per_pixel, rowbytes));
if(_channels == DPX_RGBA)
frame_buffer.insert("A", Slice(pixel_type, origin + (bytes_per_subpixel * 3), bytes_per_pixel, rowbytes));
frame_buffer.copyFromFrame(frame);
MemoryFile file(buffer_size);
DPXCodec_OutStream ostream(file);
dpx::Writer dpx;
dpx.SetOutStream(&ostream);
dpx.SetFileInfo("MOX", // fileName
NULL, // creation time (set by libdpx)
"DPXcodec, part of MOX", // creator
NULL, // project
NULL, // copyright
~0, // encryption key (0xffffffff means no encryption)
false); // don't swap byte order
dpx.SetImageInfo(width, height);
dpx.header.SetAspectRatio(0, _pixelAspectRatio.Numerator);
dpx.header.SetAspectRatio(1, _pixelAspectRatio.Denominator);
dpx.header.SetFrameRate((dpx::R32)_frameRate.Numerator / (dpx::R32)_frameRate.Denominator);
//dpx.header.SetInterlace(info->field_label->type == FIEL_Type_FRAME_RENDERED ? 0 : 1);
const unsigned int bit_depth = (_depth == DPX_8 ? 8 :
_depth == DPX_10 ? 10 :
_depth == DPX_12 ? 12 :
_depth == DPX_16 ? 16 :
10);
const dpx::Descriptor dpx_desc = (_channels == DPX_RGBA ? dpx::kRGBA : dpx::kRGB);
const dpx::Packing packing = ((bit_depth == 8 || bit_depth == 16) ? dpx::kPacked : dpx::kFilledMethodA);
const dpx::Characteristic transfer = dpx::kLogarithmic;
const dpx::Characteristic colorimetric = dpx::kLogarithmic;
dpx.SetElement(0, dpx_desc, bit_depth, transfer, colorimetric, packing);
const bool wrote_header = dpx.WriteHeader();
if(!wrote_header)
throw MoxMxf::ArgExc("Error writing header");
const dpx::DataSize size = (pixel_type == MoxFiles::UINT16 ? dpx::kWord : dpx::kByte);
const bool wrote_element = dpx.WriteElement(0, data.Data, size);
if(!wrote_element)
throw MoxMxf::ArgExc("Error writing image");
const bool wrote_finish = dpx.Finish();
if(!wrote_finish)
throw MoxMxf::ArgExc("Error writing finish");
storeData( file.getDataChunk() );
}
