static void
close_immediately (CockpitPipe *self,
const gchar *problem)
{
if (self->priv->closed)
return;
if (problem)
{
g_free (self->priv->problem);
self->priv->problem = g_strdup (problem);
}
self->priv->closed = TRUE;
g_debug ("%s: closing pipe%s%s", self->priv->name,
self->priv->problem ? ": " : "",
self->priv->problem ? self->priv->problem : "");
if (self->priv->in_source)
stop_input (self);
if (self->priv->out_source)
stop_output (self);
if (self->priv->err_source)
stop_error (self);
if (self->priv->in_fd != -1)
{
close (self->priv->in_fd);
self->priv->in_fd = -1;
}
if (self->priv->out_fd != -1)
{
close (self->priv->out_fd);
self->priv->out_fd = -1;
}
if (self->priv->err_fd != -1)
{
close (self->priv->err_fd);
self->priv->err_fd = -1;
}
if (problem && self->priv->pid && !self->priv->exited)
{
g_debug ("%s: killing child: %d", self->priv->name, (int)self->priv->pid);
kill (self->priv->pid, SIGTERM);
}
/* If not tracking a pid, then we are now closed. */
if (!self->priv->child)
{
g_debug ("%s: no child process to wait for: closed", self->priv->name);
g_signal_emit (self, cockpit_pipe_sig_close, 0, self->priv->problem);
}
}
static void
close_immediately (CockpitStream *self,
const gchar *problem)
{
GError *error = NULL;
GIOStream *io;
if (self->priv->closed)
return;
if (problem)
{
g_free (self->priv->problem);
self->priv->problem = g_strdup (problem);
}
if (self->priv->connecting)
{
cockpit_connectable_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->closed = TRUE;
g_debug ("%s: closing stream%s%s", self->priv->name,
self->priv->problem ? ": " : "",
self->priv->problem ? self->priv->problem : "");
if (self->priv->in_source)
stop_input (self);
if (self->priv->out_source)
stop_output (self);
if (self->priv->io)
{
io = self->priv->io;
self->priv->io = NULL;
if (self->priv->sig_accept_cert)
{
g_signal_handler_disconnect (io, self->priv->sig_accept_cert);
self->priv->sig_accept_cert = 0;
}
g_io_stream_close (io, NULL, &error);
if (error)
{
g_message ("%s: close failed: %s", self->priv->name, error->message);
g_clear_error (&error);
}
g_object_unref (io);
}
g_debug ("%s: closed", self->priv->name);
g_signal_emit (self, cockpit_stream_sig_close, 0, self->priv->problem);
}
void director::stop()
{
unregister_config();
stop_output ();
delete m_world;
m_filemgr.stop();
m_world = NULL;
m_output = NULL;
m_config = NULL;
}
void director::on_config_nudge (base::conf_node& node)
{
string out;
m_info.sample_rate = node.child ("sample_rate").get<int> ();
m_info.block_size = node.child ("block_size").get<int> ();
m_info.num_channels = node.child ("num_channels").get<int> ();
node.child ("output").get (out);
m_world->set_info (m_info);
stop_output ();
start_output ();
}
static gboolean
dispatch_output (gint fd,
GIOCondition cond,
gpointer user_data)
{
CockpitPipe *self = (CockpitPipe *)user_data;
struct iovec iov[4];
gsize partial;
gssize ret;
gint i, count;
GList *l;
/* A non-blocking connect is processed here */
if (self->priv->connecting && !dispatch_connect (self))
return TRUE;
g_return_val_if_fail (self->priv->out_source, FALSE);
/* Note we fall through when nothing to write */
partial = self->priv->out_partial;
for (l = self->priv->out_queue->head, i = 0;
i < G_N_ELEMENTS (iov) && l != NULL;
i++, l = g_list_next (l))
{
iov[i].iov_base = (gpointer)g_bytes_get_data (l->data, &iov[i].iov_len);
if (partial)
{
g_assert (partial < iov[i].iov_len);
iov[i].iov_len -= partial;
iov[i].iov_base = ((gchar *)iov[i].iov_base) + partial;
partial = 0;
}
}
count = i;
if (count == 0)
ret = 0;
else
ret = writev (self->priv->out_fd, iov, count);
if (ret < 0)
{
if (errno != EAGAIN && errno != EINTR)
{
if (errno == EPIPE)
{
g_debug ("%s: couldn't write: %s", self->priv->name, g_strerror (errno));
close_immediately (self, "terminated");
}
else
{
set_problem_from_errno (self, "couldn't write", errno);
close_immediately (self, NULL); /* already set */
}
}
return FALSE;
}
/* Figure out what was written */
for (i = 0; ret > 0 && i < count; i++)
{
if (ret >= iov[i].iov_len)
{
g_debug ("%s: wrote %d bytes", self->priv->name, (int)iov[i].iov_len);
g_bytes_unref (g_queue_pop_head (self->priv->out_queue));
self->priv->out_partial = 0;
ret -= iov[i].iov_len;
}
else
{
g_debug ("%s: partial write %d of %d bytes", self->priv->name,
(int)ret, (int)iov[i].iov_len);
self->priv->out_partial += ret;
ret = 0;
}
}
if (self->priv->out_queue->head)
return TRUE;
g_debug ("%s: output queue empty", self->priv->name);
/* If all messages are done, then stop polling out fd */
stop_output (self);
if (self->priv->closing)
close_output (self);
else
close_maybe (self);
return TRUE;
}
static gboolean
dispatch_output (GPollableOutputStream *os,
gpointer user_data)
{
CockpitStream *self = (CockpitStream *)user_data;
GError *error = NULL;
const gint8 *data;
gsize len;
gssize ret;
g_return_val_if_fail (self->priv->out_source, FALSE);
while (self->priv->out_queue->head)
{
data = g_bytes_get_data (self->priv->out_queue->head->data, &len);
g_assert (self->priv->out_partial <= len);
ret = g_pollable_output_stream_write_nonblocking (os, data + self->priv->out_partial,
len - self->priv->out_partial, NULL, &error);
if (ret < 0)
{
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
{
g_debug ("%s: output would block", self->priv->name);
g_error_free (error);
return TRUE;
}
else
{
set_problem_from_error (self, "couldn't write", error);
g_error_free (error);
close_immediately (self, NULL);
return FALSE;
}
}
self->priv->out_partial += ret;
if (self->priv->out_partial >= len)
{
g_debug ("%s: wrote %d bytes", self->priv->name, (int)len);
g_bytes_unref (g_queue_pop_head (self->priv->out_queue));
self->priv->out_partial = 0;
}
else
{
if (ret > 0)
g_debug ("%s: partial write %d of %d bytes", self->priv->name, (int)ret, (int)len);
return TRUE;
}
}
g_debug ("%s: output queue empty", self->priv->name);
/* If all messages are done, then stop polling out fd */
stop_output (self);
if (self->priv->closing)
close_output (self);
else
close_maybe (self);
return TRUE;
}
// Aborts and returns 1 if an error is encountered.
int PackageRenderer::render_package(RenderPackage *package)
{
int audio_done = 0;
int video_done = 0;
int samples_rendered = 0;
result = 0;
this->package = package;
// printf(
// "PackageRenderer::render_package: audio s=%lld l=%lld video s=%lld l=%lld\n",
// package->audio_start,
// package->audio_end - package->audio_start,
// package->video_start,
// package->video_end - package->video_start);
// FIXME: The design that we only get EDL once does not give us neccessary flexiblity to do things the way they should be donek
default_asset->video_data = package->video_do;
default_asset->audio_data = package->audio_do;
Render::check_asset(edl, *default_asset);
create_output();
if(!asset->video_data) video_done = 1;
if(!asset->audio_data) audio_done = 1;
// Create render engine
if(!result)
{
create_engine();
//printf("PackageRenderer::render_package 5 %d\n", result);
// Main loop
while((!audio_done || !video_done) && !result)
{
int need_audio = 0, need_video = 0;
// Calculate lengths to process. Audio fragment is constant.
if(!audio_done)
{
if(audio_position + audio_read_length >= package->audio_end)
{
audio_done = 1;
audio_read_length = package->audio_end - audio_position;
}
samples_rendered = audio_read_length;
need_audio = 1;
}
//printf("PackageRenderer::render_package 6 %d\n", samples_rendered);
if(!video_done)
{
if(audio_done)
{
video_read_length = package->video_end - video_position;
// Packetize video length so progress gets updated
video_read_length = (int)MIN(asset->frame_rate, video_read_length);
video_read_length = MAX(video_read_length, 30);
}
else
// Guide video with audio
{
video_read_length = Units::to_int64(
(double)(audio_position + audio_read_length) /
asset->sample_rate *
asset->frame_rate) -
video_position;
}
// Clamp length
if(video_position + video_read_length >= package->video_end)
{
video_done = 1;
video_read_length = package->video_end - video_position;
}
// Calculate samples rendered for progress bar.
if(audio_done)
samples_rendered = Units::round((double)video_read_length /
asset->frame_rate *
asset->sample_rate);
need_video = 1;
}
//printf("PackageRenderer::render_package 1 %d %lld %lld\n", result, audio_read_length, video_read_length);
if(need_video && !result) do_video();
//printf("PackageRenderer::render_package 7 %d %d\n", result, samples_rendered);
if(need_audio && !result) do_audio();
if(!result) set_progress(samples_rendered);
if(!result && progress_cancelled()) result = 1;
// printf("PackageRenderer::render_package 10 %d %d %d %d\n",
// audio_read_length, video_read_length, samples_rendered, result);
if(result)
set_result(result);
else
result = get_result();
}
//printf("PackageRenderer::render_package 20\n");
stop_engine();
//printf("PackageRenderer::render_package 30\n");
stop_output();
//printf("PackageRenderer::render_package 40\n");
}
//printf("PackageRenderer::render_package 50\n");
close_output();
//printf("PackageRenderer::render_package 60\n");
set_result(result);
//printf("PackageRenderer::render_package 70\n");
return result;
}
