static SCM guileAddPropertyListener(SCM element, SCM keySymbol, SCM callback)
{
char* key = scm_to_utf8_string(scm_symbol_to_string(keySymbol));
guihckElementId listenerId = guihckStackGetElement(threadLocalContext.ctx);
guihckPropertyListenerId id = guihckElementAddListener(threadLocalContext.ctx, listenerId, scm_to_uint64(element), key,
guilePropertyListenerCallback, callback, guilePropertyListenerFreeCallback);
scm_gc_protect_object(callback);
free(key);
return scm_from_uint64(id);
}
SCM guileGetElementProperty(SCM keySymbol)
{
if(scm_is_symbol(keySymbol))
{
char* key = scm_to_utf8_string(scm_symbol_to_string(keySymbol));
return guihckStackGetElementProperty(threadLocalContext.ctx, key);
}
else
{
return SCM_UNDEFINED;
}
}
SCM guilePushElementById(SCM idSymbol)
{
if(scm_is_symbol(idSymbol))
{
char* id = scm_to_utf8_string(scm_symbol_to_string(idSymbol));
guihckStackPushElementById(threadLocalContext.ctx, id);
return SCM_BOOL_T;
}
else
{
return SCM_BOOL_F;
}
}
SCM guilePushNewElement(SCM typeSymbol)
{
if(scm_is_symbol(typeSymbol))
{
char* typeName = scm_to_utf8_string(scm_symbol_to_string(typeSymbol));
guihckStackPushNewElement(threadLocalContext.ctx, typeName);
return SCM_BOOL_T;
}
else
{
return SCM_BOOL_F;
}
}
SCM guileKeyCode(SCM keyName)
{
char* keyNameStr;
if(scm_is_symbol(keyName))
keyNameStr = scm_to_utf8_string(scm_symbol_to_string(keyName));
else if(scm_is_string(keyName))
keyNameStr = scm_to_utf8_string(keyName);
else
assert(false && "Key name must be a symbol or a string");
guihckKey keyCode = guihckContextGetKeyCode(threadLocalContext.ctx, keyNameStr);
free(keyNameStr);
return scm_from_int32(keyCode);
}
SCM guileSetElementProperty(SCM keySymbol, SCM value)
{
if(scm_is_symbol(keySymbol))
{
char* key = scm_to_utf8_string(scm_symbol_to_string(keySymbol));
guihckStackElementProperty(threadLocalContext.ctx, key, value);
free(key);
return SCM_BOOL_T;
}
else
{
return SCM_BOOL_F;
}
}
static SCM pg_format_sql(SCM conn, SCM obj) {
struct pg_conn *pgc;
SCM out;
if (SCM_SMOB_PREDICATE(time_tag, obj)) {
out = format_time(obj, c2s("'%Y-%m-%d %H:%M:%S'"));
}
else if (scm_boolean_p(obj) == SCM_BOOL_T) {
if (scm_is_true(obj)) out = c2s("'t'");
else out = c2s("'f'");
}
else if (scm_is_number(obj)) {
out = scm_number_to_string(obj,
scm_from_signed_integer(10));
}
else if (scm_is_symbol(obj)) {
out = pg_format_sql(conn, scm_symbol_to_string(obj));
}
else if (scm_is_string(obj)) {
if (scm_string_null_p(obj) == SCM_BOOL_T) out = c2s("NULL");
else {
char *src = scm_to_utf8_string(obj);
scm_assert_smob_type(pg_conn_tag, conn);
pgc = (struct pg_conn *)SCM_SMOB_DATA(conn);
scm_lock_mutex(pgc->mutex);
char *sql = PQescapeLiteral(pgc->conn,
src, strlen(src));
out = safe_from_utf8(sql);
scm_unlock_mutex(pgc->mutex);
free(src);
PQfreemem(sql);
}
}
else if (scm_is_null(obj)) out = c2s("NULL");
else out = c2s("NULL");
scm_remember_upto_here_1(out);
scm_remember_upto_here_2(conn, obj);
return out;
}
inline char *symstr(SCM key) {
if (scm_is_symbol(key))
return scm_to_locale_string(scm_symbol_to_string(key));
return scm_to_locale_string(key);
}
SCM make_ffmpeg_output(SCM scm_file_name,
SCM scm_format_name,
SCM scm_video_parameters,
SCM scm_have_video,
SCM scm_audio_parameters,
SCM scm_have_audio,
SCM scm_debug)
{
SCM retval;
struct ffmpeg_t *self;
scm_dynwind_begin(0);
const char *file_name = scm_to_locale_string(scm_file_name);
scm_dynwind_free(file_name);
self = (struct ffmpeg_t *)scm_gc_calloc(sizeof(struct ffmpeg_t), "ffmpeg");
self->video_stream_idx = -1;
self->audio_stream_idx = -1;
SCM_NEWSMOB(retval, ffmpeg_tag, self);
int err;
const char *format_name = NULL;
if (!scm_is_false(scm_format_name)) {
format_name = scm_to_locale_string(scm_symbol_to_string(scm_format_name));
scm_dynwind_free(format_name);
};
#ifdef HAVE_AVFORMAT_ALLOC_OUTPUT_CONTEXT2
err = avformat_alloc_output_context2(&self->fmt_ctx, NULL, format_name, file_name);
if (!self->fmt_ctx) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Error initializing output format for file '~a': ~a",
scm_list_2(scm_file_name, get_error_text(err)));
};
#else
AVOutputFormat *format;
if (format_name)
format = av_guess_format(format_name, NULL, NULL);
else
format = av_guess_format(NULL, file_name, NULL);
if (!format) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Unable to determine file format for file '~a'",
scm_list_1(scm_file_name));
};
self->fmt_ctx = avformat_alloc_context();
if (!self->fmt_ctx) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Error initializing output format for file '~a'",
scm_list_1(scm_file_name));
};
self->fmt_ctx->oformat = format;
strncpy(self->fmt_ctx->filename, file_name, sizeof(self->fmt_ctx->filename));
#endif
char have_video = scm_is_true(scm_have_video);
if (have_video) {
// Open codec and video stream
enum AVCodecID video_codec_id = self->fmt_ctx->oformat->video_codec;
AVCodec *video_encoder = find_encoder(retval, video_codec_id, "video");
AVStream *video_stream = open_output_stream(retval, video_encoder, &self->video_stream_idx, "video", scm_file_name);
// Get video parameters
SCM scm_shape = scm_car(scm_video_parameters);
SCM scm_frame_rate = scm_cadr(scm_video_parameters);
SCM scm_video_bit_rate = scm_caddr(scm_video_parameters);
SCM scm_aspect_ratio = scm_cadddr(scm_video_parameters);
// Configure the output video codec
self->video_codec_ctx =
configure_output_video_codec(video_stream, video_codec_id, scm_video_bit_rate, scm_shape, scm_frame_rate, scm_aspect_ratio);
// Some formats want stream headers to be separate.
if (self->fmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
self->video_codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
// Open output video codec
open_codec(retval, self->video_codec_ctx, video_encoder, "video", scm_file_name);
// Allocate frame
self->video_target_frame = allocate_output_video_frame(retval, self->video_codec_ctx);
};
char have_audio = scm_is_true(scm_have_audio);
if (have_audio) {
// Open audio codec and stream
enum AVCodecID audio_codec_id = self->fmt_ctx->oformat->audio_codec;
AVCodec *audio_encoder = find_encoder(retval, audio_codec_id, "audio");
AVStream *audio_stream = open_output_stream(retval, audio_encoder, &self->audio_stream_idx, "audio", scm_file_name);
// Get audio parameters
SCM scm_select_rate = scm_car(scm_audio_parameters);
SCM scm_channels = scm_cadr(scm_audio_parameters);
SCM scm_audio_bit_rate = scm_caddr(scm_audio_parameters);
SCM scm_select_format = scm_cadddr(scm_audio_parameters);
// Configure the output audio codec
self->audio_codec_ctx =
configure_output_audio_codec(retval, audio_stream, audio_codec_id,
scm_select_rate, scm_channels, scm_audio_bit_rate, scm_select_format);
// Some formats want stream headers to be separate.
if (self->fmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
self->audio_codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
// Open output audio codec
open_codec(retval, self->audio_codec_ctx, audio_encoder, "audio", scm_file_name);
// Allocate audio frame
self->audio_target_frame =
allocate_output_audio_frame(retval, self->audio_codec_ctx, self->audio_codec_ctx->sample_fmt);
self->audio_packed_frame =
allocate_output_audio_frame(retval, self->audio_codec_ctx, av_get_packed_sample_fmt(self->audio_codec_ctx->sample_fmt));
// Initialise audio buffer
ringbuffer_init(&self->audio_buffer, 1024);
};
if (scm_is_true(scm_debug)) av_dump_format(self->fmt_ctx, 0, file_name, 1);
// Open the output file if needed
if (!(self->fmt_ctx->oformat->flags & AVFMT_NOFILE)) {
int err = avio_open(&self->fmt_ctx->pb, file_name, AVIO_FLAG_WRITE);
if (err < 0) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Could not open '~a': ~a",
scm_list_2(scm_file_name, get_error_text(err)));
}
self->output_file = 1;
}
// Write video file header
err = avformat_write_header(self->fmt_ctx, NULL);
if (err < 0) {
ffmpeg_destroy(retval);
scm_misc_error("make-ffmpeg-output", "Error writing header of video '~a': ~a",
scm_list_2(scm_file_name, get_error_text(err)));
};
self->header_written = 1;
scm_dynwind_end();
return retval;
}
