void OutputSingleLayerOperation::deinitExecution()
{
if (this->getWidth() * this->getHeight() != 0) {
int size = get_datatype_size(this->m_datatype);
ImBuf *ibuf = IMB_allocImBuf(this->getWidth(), this->getHeight(), this->m_format->planes, 0);
Main *bmain = G.main; /* TODO, have this passed along */
char filename[FILE_MAX];
ibuf->channels = size;
ibuf->rect_float = this->m_outputBuffer;
ibuf->mall |= IB_rectfloat;
ibuf->dither = this->m_rd->dither_intensity;
IMB_colormanagement_imbuf_for_write(ibuf, true, false, m_viewSettings, m_displaySettings,
this->m_format);
BKE_makepicstring(filename, this->m_path, bmain->name, this->m_rd->cfra, this->m_format,
(this->m_rd->scemode & R_EXTENSION), true);
if (0 == BKE_imbuf_write(ibuf, filename, this->m_format))
printf("Cannot save Node File Output to %s\n", filename);
else
printf("Saved: %s\n", filename);
IMB_freeImBuf(ibuf);
}
this->m_outputBuffer = NULL;
this->m_imageInput = NULL;
}
static void rna_SceneRender_get_frame_path(RenderData *rd, int frame, char *name)
{
if (BKE_imtype_is_movie(rd->im_format.imtype))
BKE_movie_filepath_get(name, rd);
else
BKE_makepicstring(name, rd->pic, G.main->name, (frame == INT_MIN) ? rd->cfra : frame, &rd->im_format,
rd->scemode & R_EXTENSION, TRUE);
}
/* only this runs inside thread */
static void screenshot_startjob(void *sjv, short *stop, short *do_update, float *UNUSED(progress))
{
ScreenshotJob *sj = sjv;
RenderData rd = sj->scene->r;
bMovieHandle *mh = BKE_movie_handle_get(sj->scene->r.im_format.imtype);
/* we need this as local variables for renderdata */
rd.frs_sec = U.scrcastfps;
rd.frs_sec_base = 1.0f;
if (BKE_imtype_is_movie(rd.im_format.imtype)) {
if (!mh->start_movie(sj->scene, &rd, sj->dumpsx, sj->dumpsy, &sj->reports)) {
printf("screencast job stopped\n");
return;
}
}
else
mh = NULL;
sj->stop = stop;
sj->do_update = do_update;
*do_update = true; /* wait for opengl rect */
while (*stop == 0) {
if (sj->dumprect) {
if (mh) {
if (mh->append_movie(&rd, rd.sfra, rd.cfra, (int *)sj->dumprect,
sj->dumpsx, sj->dumpsy, &sj->reports))
{
BKE_reportf(&sj->reports, RPT_INFO, "Appended frame: %d", rd.cfra);
printf("Appended frame %d\n", rd.cfra);
}
else {
break;
}
}
else {
ImBuf *ibuf = IMB_allocImBuf(sj->dumpsx, sj->dumpsy, rd.im_format.planes, 0);
char name[FILE_MAX];
int ok;
BKE_makepicstring(name, rd.pic, sj->bmain->name, rd.cfra,
&rd.im_format, (rd.scemode & R_EXTENSION) != 0, true);
ibuf->rect = sj->dumprect;
ok = BKE_imbuf_write(ibuf, name, &rd.im_format);
if (ok == 0) {
printf("Write error: cannot save %s\n", name);
BKE_reportf(&sj->reports, RPT_INFO, "Write error: cannot save %s", name);
break;
}
else {
printf("Saved file: %s\n", name);
BKE_reportf(&sj->reports, RPT_INFO, "Saved file: %s", name);
}
/* imbuf knows which rects are not part of ibuf */
IMB_freeImBuf(ibuf);
}
MEM_freeN(sj->dumprect);
sj->dumprect = NULL;
*do_update = true;
rd.cfra++;
}
else
PIL_sleep_ms(U.scrcastwait);
}
if (mh)
mh->end_movie();
BKE_report(&sj->reports, RPT_INFO, "Screencast job stopped");
}
/* write input data into layers */
static void exec_output_file_multilayer(RenderData *rd, bNode *node, bNodeStack **in)
{
Main *bmain= G.main; /* TODO, have this passed along */
NodeImageMultiFile *nimf= node->storage;
void *exrhandle= IMB_exr_get_handle();
char filename[FILE_MAX];
bNodeSocket *sock;
int i;
/* Must have consistent pixel size for exr file, simply take the first valid input size. */
int rectx = -1;
int recty = -1;
int has_preview = 0;
BKE_makepicstring(filename, nimf->base_path, bmain->name, rd->cfra, R_IMF_IMTYPE_MULTILAYER, (rd->scemode & R_EXTENSION), TRUE);
BLI_make_existing_file(filename);
for (sock=node->inputs.first, i=0; sock; sock=sock->next, ++i) {
if (in[i]->data) {
NodeImageMultiFileSocket *sockdata = sock->storage;
CompBuf *cbuf = in[i]->data;
char channelname[EXR_TOT_MAXNAME]; /* '.' and single character channel name is appended */
char *channelname_ext;
if (cbuf->rect_procedural) {
printf("Error writing multilayer EXR: Procedural buffer not supported\n");
continue;
}
if (rectx < 0) {
rectx = cbuf->x;
recty = cbuf->y;
}
else if (cbuf->x != rectx || cbuf->y != recty) {
printf("Error: Multilayer EXR output node %s expects same resolution for all input buffers. Layer %s skipped.\n", node->name, sock->name);
continue;
}
BLI_strncpy(channelname, sockdata->layer, sizeof(channelname)-2);
channelname_ext = channelname + strlen(channelname);
/* create channels */
switch (cbuf->type) {
case CB_VAL:
strcpy(channelname_ext, ".V");
IMB_exr_add_channel(exrhandle, NULL, channelname, 1, rectx, cbuf->rect);
break;
case CB_VEC2:
strcpy(channelname_ext, ".X");
IMB_exr_add_channel(exrhandle, NULL, channelname, 2, 2*rectx, cbuf->rect);
strcpy(channelname_ext, ".Y");
IMB_exr_add_channel(exrhandle, NULL, channelname, 2, 2*rectx, cbuf->rect+1);
break;
case CB_VEC3:
strcpy(channelname_ext, ".X");
IMB_exr_add_channel(exrhandle, NULL, channelname, 3, 3*rectx, cbuf->rect);
strcpy(channelname_ext, ".Y");
IMB_exr_add_channel(exrhandle, NULL, channelname, 3, 3*rectx, cbuf->rect+1);
strcpy(channelname_ext, ".Z");
IMB_exr_add_channel(exrhandle, NULL, channelname, 3, 3*rectx, cbuf->rect+2);
break;
case CB_RGBA:
strcpy(channelname_ext, ".R");
IMB_exr_add_channel(exrhandle, NULL, channelname, 4, 4*rectx, cbuf->rect);
strcpy(channelname_ext, ".G");
IMB_exr_add_channel(exrhandle, NULL, channelname, 4, 4*rectx, cbuf->rect+1);
strcpy(channelname_ext, ".B");
IMB_exr_add_channel(exrhandle, NULL, channelname, 4, 4*rectx, cbuf->rect+2);
strcpy(channelname_ext, ".A");
IMB_exr_add_channel(exrhandle, NULL, channelname, 4, 4*rectx, cbuf->rect+3);
break;
}
/* simply pick the first valid input for preview */
if (!has_preview) {
generate_preview(rd, node, cbuf);
has_preview = 1;
}
}
}
/* when the filename has no permissions, this can fail */
if (IMB_exr_begin_write(exrhandle, filename, rectx, recty, nimf->format.exr_codec)) {
IMB_exr_write_channels(exrhandle);
}
else {
/* TODO, get the error from openexr's exception */
/* XXX nice way to do report? */
printf("Error Writing Render Result, see console\n");
}
IMB_exr_close(exrhandle);
}
/* write input data into individual files */
static void exec_output_file_singlelayer(RenderData *rd, bNode *node, bNodeStack **in)
{
Main *bmain= G.main; /* TODO, have this passed along */
NodeImageMultiFile *nimf= node->storage;
bNodeSocket *sock;
int i;
int has_preview = 0;
for (sock=node->inputs.first, i=0; sock; sock=sock->next, ++i) {
if (in[i]->data) {
NodeImageMultiFileSocket *sockdata = sock->storage;
ImageFormatData *format = (sockdata->use_node_format ? &nimf->format : &sockdata->format);
char path[FILE_MAX];
char filename[FILE_MAX];
CompBuf *cbuf;
ImBuf *ibuf;
switch (format->planes) {
case R_IMF_PLANES_BW:
cbuf = typecheck_compbuf(in[i]->data, CB_VAL);
break;
case R_IMF_PLANES_RGB:
cbuf = typecheck_compbuf(in[i]->data, CB_VEC3);
break;
case R_IMF_PLANES_RGBA:
cbuf = typecheck_compbuf(in[i]->data, CB_RGBA);
break;
}
ibuf = IMB_allocImBuf(cbuf->x, cbuf->y, format->planes, 0);
/* XXX have to set this explicitly it seems */
switch (format->planes) {
case R_IMF_PLANES_BW: ibuf->channels = 1; break;
case R_IMF_PLANES_RGB: ibuf->channels = 3; break;
case R_IMF_PLANES_RGBA: ibuf->channels = 4; break;
}
ibuf->rect_float = cbuf->rect;
ibuf->dither = rd->dither_intensity;
if (rd->color_mgt_flag & R_COLOR_MANAGEMENT)
ibuf->profile = IB_PROFILE_LINEAR_RGB;
/* get full path */
BLI_join_dirfile(path, FILE_MAX, nimf->base_path, sockdata->path);
BKE_makepicstring(filename, path, bmain->name, rd->cfra, format->imtype, (rd->scemode & R_EXTENSION), TRUE);
if (0 == BKE_imbuf_write(ibuf, filename, format))
printf("Cannot save Node File Output to %s\n", filename);
else
printf("Saved: %s\n", filename);
IMB_freeImBuf(ibuf);
/* simply pick the first valid input for preview */
if (!has_preview) {
generate_preview(rd, node, cbuf);
has_preview = 1;
}
if (in[i]->data != cbuf)
free_compbuf(cbuf);
}
}
}
static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
OGLRender *oglrender = op->customdata;
Scene *scene = oglrender->scene;
ImBuf *ibuf, *ibuf_save = NULL;
void *lock;
char name[FILE_MAX];
int ok = 0;
const short view_context = (oglrender->v3d != NULL);
Object *camera = NULL;
int is_movie;
/* go to next frame */
if (CFRA < oglrender->nfra)
CFRA++;
while (CFRA < oglrender->nfra) {
unsigned int lay = screen_opengl_layers(oglrender);
if (lay & 0xFF000000)
lay &= 0xFF000000;
BKE_scene_update_for_newframe(bmain, scene, lay);
CFRA++;
}
is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
if (!is_movie) {
BKE_makepicstring(name, scene->r.pic, oglrender->bmain->name, scene->r.cfra, &scene->r.im_format, scene->r.scemode & R_EXTENSION, TRUE);
if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) {
BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame \"%s\"", name);
ok = true;
goto finally;
}
}
WM_cursor_time(oglrender->win, scene->r.cfra);
BKE_scene_update_for_newframe(bmain, scene, screen_opengl_layers(oglrender));
if (view_context) {
if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && oglrender->v3d->scenelock) {
/* since BKE_scene_update_for_newframe() is used rather
* then ED_update_for_newframe() the camera needs to be set */
if (BKE_scene_camera_switch_update(scene)) {
oglrender->v3d->camera = scene->camera;
}
camera = oglrender->v3d->camera;
}
}
else {
BKE_scene_camera_switch_update(scene);
camera = scene->camera;
}
/* render into offscreen buffer */
screen_opengl_render_apply(oglrender);
/* save to disk */
ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock);
if (ibuf) {
int needs_free = FALSE;
ibuf_save = ibuf;
if (is_movie || !BKE_imtype_requires_linear_float(scene->r.im_format.imtype)) {
ibuf_save = IMB_colormanagement_imbuf_for_write(ibuf, true, true, &scene->view_settings,
&scene->display_settings, &scene->r.im_format);
needs_free = TRUE;
}
/* color -> grayscale */
/* editing directly would alter the render view */
if (scene->r.im_format.planes == R_IMF_PLANES_BW) {
ImBuf *ibuf_bw = IMB_dupImBuf(ibuf_save);
IMB_color_to_bw(ibuf_bw);
if (needs_free)
IMB_freeImBuf(ibuf_save);
ibuf_save = ibuf_bw;
}
else {
/* this is lightweight & doesnt re-alloc the buffers, only do this
* to save the correct bit depth since the image is always RGBA */
ImBuf *ibuf_cpy = IMB_allocImBuf(ibuf_save->x, ibuf_save->y, scene->r.im_format.planes, 0);
ibuf_cpy->rect = ibuf_save->rect;
ibuf_cpy->rect_float = ibuf_save->rect_float;
ibuf_cpy->zbuf_float = ibuf_save->zbuf_float;
if (needs_free) {
ibuf_cpy->mall = ibuf_save->mall;
ibuf_save->mall = 0;
IMB_freeImBuf(ibuf_save);
}
ibuf_save = ibuf_cpy;
}
if (is_movie) {
ok = oglrender->mh->append_movie(&scene->r, PSFRA, CFRA, (int *)ibuf_save->rect,
oglrender->sizex, oglrender->sizey, oglrender->reports);
if (ok) {
printf("Append frame %d", scene->r.cfra);
BKE_reportf(op->reports, RPT_INFO, "Appended frame: %d", scene->r.cfra);
}
}
else {
ok = BKE_imbuf_write_stamp(scene, camera, ibuf_save, name, &scene->r.im_format);
if (ok == 0) {
printf("Write error: cannot save %s\n", name);
BKE_reportf(op->reports, RPT_ERROR, "Write error: cannot save %s", name);
}
else {
printf("Saved: %s", name);
BKE_reportf(op->reports, RPT_INFO, "Saved file: %s", name);
}
}
if (needs_free)
IMB_freeImBuf(ibuf_save);
}
BKE_image_release_ibuf(oglrender->ima, ibuf, lock);
/* movie stats prints have no line break */
printf("\n");
finally: /* Step the frame and bail early if needed */
/* go to next frame */
oglrender->nfra += scene->r.frame_step;
/* stop at the end or on error */
if (CFRA >= PEFRA || !ok) {
screen_opengl_render_end(C, op->customdata);
return 0;
}
return 1;
}
static void screen_opengl_render_apply(OGLRender *oglrender)
{
Scene *scene = oglrender->scene;
ARegion *ar = oglrender->ar;
View3D *v3d = oglrender->v3d;
RegionView3D *rv3d = oglrender->rv3d;
RenderResult *rr;
Object *camera = NULL;
ImBuf *ibuf;
void *lock;
float winmat[4][4];
int sizex = oglrender->sizex;
int sizey = oglrender->sizey;
const short view_context = (v3d != NULL);
bool draw_bgpic = true;
bool draw_sky = (scene->r.alphamode == R_ADDSKY);
unsigned char *rect = NULL;
rr = RE_AcquireResultRead(oglrender->re);
if (oglrender->is_sequencer) {
SeqRenderData context;
int chanshown = oglrender->sseq ? oglrender->sseq->chanshown : 0;
context = BKE_sequencer_new_render_data(oglrender->bmain, scene, oglrender->sizex, oglrender->sizey, 100.0f);
ibuf = BKE_sequencer_give_ibuf(context, CFRA, chanshown);
if (ibuf) {
ImBuf *linear_ibuf;
BLI_assert((oglrender->sizex == ibuf->x) && (oglrender->sizey == ibuf->y));
linear_ibuf = IMB_dupImBuf(ibuf);
IMB_freeImBuf(ibuf);
if (linear_ibuf->rect_float == NULL) {
/* internally sequencer working in display space and stores both bytes and float buffers in that space.
* It is possible that byte->float onversion didn't happen in sequencer (e.g. when adding image sequence/movie
* into sequencer) there'll be only byte buffer. Create float buffer from existing byte buffer, making it linear
*/
IMB_float_from_rect(linear_ibuf);
}
else {
/* ensure float buffer is in linear space, not in display space */
BKE_sequencer_imbuf_from_sequencer_space(scene, linear_ibuf);
}
memcpy(rr->rectf, linear_ibuf->rect_float, sizeof(float) * 4 * oglrender->sizex * oglrender->sizey);
IMB_freeImBuf(linear_ibuf);
}
}
else if (view_context) {
ED_view3d_draw_offscreen_init(scene, v3d);
GPU_offscreen_bind(oglrender->ofs); /* bind */
/* render 3d view */
if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
/*int is_ortho = scene->r.mode & R_ORTHO;*/
camera = v3d->camera;
RE_GetCameraWindow(oglrender->re, camera, scene->r.cfra, winmat);
}
else {
rctf viewplane;
float clipsta, clipend;
int is_ortho = ED_view3d_viewplane_get(v3d, rv3d, sizex, sizey, &viewplane, &clipsta, &clipend, NULL);
if (is_ortho) orthographic_m4(winmat, viewplane.xmin, viewplane.xmax, viewplane.ymin, viewplane.ymax, -clipend, clipend);
else perspective_m4(winmat, viewplane.xmin, viewplane.xmax, viewplane.ymin, viewplane.ymax, clipsta, clipend);
}
rect = MEM_mallocN(sizex * sizey * sizeof(unsigned char) * 4, "offscreen rect");
if ((scene->r.mode & R_OSA) == 0) {
ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, winmat, draw_bgpic, draw_sky);
GPU_offscreen_read_pixels(oglrender->ofs, GL_UNSIGNED_BYTE, rect);
}
else {
/* simple accumulation, less hassle then FSAA FBO's */
static float jit_ofs[32][2];
float winmat_jitter[4][4];
int *accum_buffer = MEM_mallocN(sizex * sizey * sizeof(int) * 4, "accum1");
int i, j;
BLI_jitter_init(jit_ofs[0], scene->r.osa);
/* first sample buffer, also initializes 'rv3d->persmat' */
ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, winmat, draw_bgpic, draw_sky);
GPU_offscreen_read_pixels(oglrender->ofs, GL_UNSIGNED_BYTE, rect);
for (i = 0; i < sizex * sizey * 4; i++)
accum_buffer[i] = rect[i];
/* skip the first sample */
for (j = 1; j < scene->r.osa; j++) {
copy_m4_m4(winmat_jitter, winmat);
window_translate_m4(winmat_jitter, rv3d->persmat,
(jit_ofs[j][0] * 2.0f) / sizex,
(jit_ofs[j][1] * 2.0f) / sizey);
ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, winmat_jitter, draw_bgpic, draw_sky);
GPU_offscreen_read_pixels(oglrender->ofs, GL_UNSIGNED_BYTE, rect);
for (i = 0; i < sizex * sizey * 4; i++)
accum_buffer[i] += rect[i];
}
for (i = 0; i < sizex * sizey * 4; i++)
rect[i] = accum_buffer[i] / scene->r.osa;
MEM_freeN(accum_buffer);
}
GPU_offscreen_unbind(oglrender->ofs); /* unbind */
}
else {
/* shouldnt suddenly give errors mid-render but possible */
char err_out[256] = "unknown";
ImBuf *ibuf_view = ED_view3d_draw_offscreen_imbuf_simple(scene, scene->camera, oglrender->sizex, oglrender->sizey,
IB_rect, OB_SOLID, FALSE, TRUE,
(draw_sky) ? R_ADDSKY: R_ALPHAPREMUL, err_out);
camera = scene->camera;
if (ibuf_view) {
/* steal rect reference from ibuf */
rect = (unsigned char *)ibuf_view->rect;
ibuf_view->mall &= ~IB_rect;
IMB_freeImBuf(ibuf_view);
}
else {
fprintf(stderr, "%s: failed to get buffer, %s\n", __func__, err_out);
}
}
/* note on color management:
*
* OpenGL renders into sRGB colors, but render buffers are expected to be
* linear So we convert to linear here, so the conversion back to bytes can make it
* sRGB (or other display space) again, and so that e.g. openexr saving also saves the
* correct linear float buffer.
*/
if (rect) {
int profile_to;
if (BKE_scene_check_color_management_enabled(scene))
profile_to = IB_PROFILE_LINEAR_RGB;
else
profile_to = IB_PROFILE_SRGB;
/* sequencer has got trickier conversion happened above
* also assume opengl's space matches byte buffer color space */
IMB_buffer_float_from_byte(rr->rectf, rect,
profile_to, IB_PROFILE_SRGB, true,
oglrender->sizex, oglrender->sizey, oglrender->sizex, oglrender->sizex);
}
/* rr->rectf is now filled with image data */
if ((scene->r.stamp & R_STAMP_ALL) && (scene->r.stamp & R_STAMP_DRAW))
BKE_stamp_buf(scene, camera, rect, rr->rectf, rr->rectx, rr->recty, 4);
RE_ReleaseResult(oglrender->re);
/* update byte from float buffer */
ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock);
if (ibuf) {
/* update display buffer */
if (ibuf->rect == NULL)
imb_addrectImBuf(ibuf);
IMB_partial_display_buffer_update(ibuf, rr->rectf, rect, rr->rectx, 0, 0,
&scene->view_settings, &scene->display_settings,
0, 0, rr->rectx, rr->recty, true);
/* write file for animation */
if (oglrender->write_still) {
char name[FILE_MAX];
int ok;
if (scene->r.im_format.planes == R_IMF_CHAN_DEPTH_8) {
IMB_color_to_bw(ibuf);
}
BKE_makepicstring(name, scene->r.pic, oglrender->bmain->name, scene->r.cfra, &scene->r.im_format, scene->r.scemode & R_EXTENSION, FALSE);
ok = BKE_imbuf_write_as(ibuf, name, &scene->r.im_format, TRUE); /* no need to stamp here */
if (ok) printf("OpenGL Render written to '%s'\n", name);
else printf("OpenGL Render failed to write '%s'\n", name);
}
}
BKE_image_release_ibuf(oglrender->ima, ibuf, lock);
if (rect)
MEM_freeN(rect);
}