void imx_vpu_setup_logging(void)
{
g_mutex_lock(&load_mutex);
if (!logging_set_up)
{
ImxVpuLogLevel level;
GST_DEBUG_CATEGORY_INIT(imx_vpu_api_debug, "imxvpuapi", 0, "imxvpuapi library for controlling the Freescale i.MX VPU");
GstDebugLevel gst_level = gst_debug_category_get_threshold(imx_vpu_api_debug);
switch (gst_level)
{
case GST_LEVEL_ERROR: level = IMX_VPU_LOG_LEVEL_ERROR; break;
case GST_LEVEL_WARNING: level = IMX_VPU_LOG_LEVEL_WARNING; break;
case GST_LEVEL_INFO: level = IMX_VPU_LOG_LEVEL_INFO; break;
case GST_LEVEL_DEBUG: level = IMX_VPU_LOG_LEVEL_DEBUG; break;
case GST_LEVEL_LOG: level = IMX_VPU_LOG_LEVEL_LOG; break;
case GST_LEVEL_TRACE: level = IMX_VPU_LOG_LEVEL_TRACE; break;
default: level = IMX_VPU_LOG_LEVEL_TRACE;
}
imx_vpu_set_logging_threshold(level);
imx_vpu_set_logging_function(imx_vpu_logging_func);
logging_set_up = TRUE;
}
g_mutex_unlock(&load_mutex);
}
static void gst_log_android_handler(GstDebugCategory *category,
GstDebugLevel level,
const gchar *file,
const gchar *function,
gint line,
GObject *object,
GstDebugMessage *message,
gpointer data)
{
gchar *obj = NULL;
OWR_UNUSED(data);
if (level > gst_debug_category_get_threshold(category))
return;
if (GST_IS_PAD(object) && GST_OBJECT_NAME(object)) {
obj = g_strdup_printf("<%s:%s>", GST_DEBUG_PAD_NAME(object));
} else if (GST_IS_OBJECT(object)) {
obj = g_strdup_printf("<%s>", GST_OBJECT_NAME(object));
}
__android_log_print(ANDROID_LOG_INFO, "gst_log", "%p %s %s %s:%d:%s:%s %s\n",
(void *)g_thread_self(),
gst_debug_level_get_name(level), gst_debug_category_get_name(category),
file, line, function, obj ? obj : "", gst_debug_message_get(message));
g_free(obj);
}
static void
check_gst_log_handler (GstDebugCategory * category,
GstDebugLevel level, const gchar * file, const gchar * function, gint line,
GObject * object, GstDebugMessage * _message, gpointer data)
{
const gchar *message = gst_debug_message_get (_message);
gchar *msg, *obj_str;
const gchar *level_str, *cat_str;
GstClockTime elapsed;
//-- check message contents
if (__check_method && (strstr (function, __check_method) != NULL)
&& __check_test && (strstr (message, __check_test) != NULL))
__check_error_trapped = TRUE;
else if (__check_method && (strstr (function, __check_method) != NULL)
&& !__check_test)
__check_error_trapped = TRUE;
else if (__check_test && (strstr (message, __check_test) != NULL)
&& !__check_method)
__check_error_trapped = TRUE;
if (level > gst_debug_category_get_threshold (category))
return;
elapsed =
GST_CLOCK_DIFF (_priv_bt_info_start_time, gst_util_get_timestamp ());
level_str = gst_debug_level_get_name (level);
cat_str = gst_debug_category_get_name (category);
if (object) {
if (GST_IS_OBJECT (object)) {
obj_str = g_strdup_printf ("<%s,%" G_OBJECT_REF_COUNT_FMT ">",
GST_OBJECT_NAME (object), G_OBJECT_LOG_REF_COUNT (object));
} else if (GST_IS_OBJECT (object)) {
obj_str = g_strdup_printf ("<%s,%" G_OBJECT_REF_COUNT_FMT ">",
G_OBJECT_TYPE_NAME (object), G_OBJECT_LOG_REF_COUNT (object));
} else {
obj_str = g_strdup_printf ("%p", object);
}
} else {
obj_str = g_strdup ("");
}
msg = g_alloca (95 + strlen (cat_str) + strlen (level_str) + strlen (message)
+ strlen (file) + strlen (function) + strlen (obj_str));
g_sprintf (msg,
"%" GST_TIME_FORMAT " %" PID_FMT " %" PTR_FMT " %-7s %20s %s:%d:%s:%s %s",
GST_TIME_ARGS (elapsed), getpid (), g_thread_self (),
level_str, cat_str, file, line, function, obj_str, message);
g_free (obj_str);
check_print_handler (msg);
}
gint
main (gint argc, gchar * argv[])
{
GSList *before, *after;
unsetenv ("GST_DEBUG");
gst_init (&argc, &argv);
before = gst_debug_get_all_categories ();
GST_DEBUG_CATEGORY_INIT (cat, "cat", GST_DEBUG_FG_GREEN,
"default category for this test");
GST_DEBUG_CATEGORY_INIT (cat_static, "cat_static",
GST_DEBUG_BOLD | GST_DEBUG_FG_BLUE | GST_DEBUG_BG_RED,
"static category for this test");
after = gst_debug_get_all_categories ();
g_print ("removing default log function\n");
#ifdef GST_DISABLE_GST_DEBUG
g_assert (gst_debug_remove_log_function (gst_debug_log_default) == 0);
#else
g_assert (gst_debug_remove_log_function (gst_debug_log_default) == 1);
g_print
("checking, if the two new categories are put into the category list correctly...\n");
g_assert (g_slist_length (after) - g_slist_length (before) == 2);
/* check the _get stuff */
g_print
("checking, if the gst_debug_category_get_* stuff works with the categories...\n");
g_assert (strcmp (gst_debug_category_get_name (cat), "cat") == 0);
g_assert (gst_debug_category_get_color (cat) == GST_DEBUG_FG_GREEN);
g_assert (strcmp (gst_debug_category_get_description (cat),
"default category for this test") == 0);
g_assert (gst_debug_category_get_threshold (cat) ==
gst_debug_get_default_threshold ());
g_assert (strcmp (gst_debug_category_get_name (cat_static),
"cat_static") == 0);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_FG_GREEN);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_BG_RED);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_BOLD);
g_assert (strcmp (gst_debug_category_get_description (cat_static),
"static category for this test") == 0);
g_assert (gst_debug_category_get_threshold (cat_static) ==
gst_debug_get_default_threshold ());
/* check if setting levels for names work */
g_print
("checking if changing threshold for names affects existing categories...\n");
gst_debug_set_threshold_for_name ("cat", GST_LEVEL_DEBUG);
g_assert (gst_debug_category_get_threshold (cat) == GST_LEVEL_DEBUG);
g_assert (gst_debug_category_get_threshold (cat_static) ==
gst_debug_get_default_threshold ());
gst_debug_set_threshold_for_name ("cat_static", GST_LEVEL_INFO);
g_assert (gst_debug_category_get_threshold (cat) == GST_LEVEL_DEBUG);
g_assert (gst_debug_category_get_threshold (cat_static) == GST_LEVEL_INFO);
#endif
g_print ("everything ok.\n");
return 0;
}
static void log_func (GstDebugCategory *category,
GstDebugLevel level,
const gchar *file,
const gchar *function,
gint line,
GObject *object,
GstDebugMessage *message,
gpointer user_data)
{
Log *log = (Log *)user_data;
GDateTime *datetime;
gchar *date;
const gchar *cat;
if (level > gst_debug_category_get_threshold (category)) {
return;
}
cat = gst_debug_category_get_name (category);
datetime = g_date_time_new_now_local ();
if (g_strcmp0 (cat, "access") == 0) {
date = g_date_time_format (datetime, "%b/%d/%Y:%H:%M:%S %z");
fprintf (log->access_hd, gst_debug_message_get (message), date);
g_free (date);
fflush (log->access_hd);
} else {
date = g_date_time_format (datetime, "%b %d %H:%M:%S");
fprintf (log->log_hd, "%s.%d %s" CAT_FMT "%s\n",
date,
g_date_time_get_microsecond (datetime),
gst_debug_level_get_name (level),
cat, file, line,
gst_debug_message_get (message));
g_free (date);
fflush (log->log_hd);
}
g_date_time_unref (datetime);
}
static void
debug_pipeline (GstDebugLevel level, const gchar *prefix, GList *pipeline)
{
GList *walk;
GString *str;
gboolean first = TRUE;
if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) < level)
return;
str = g_string_new (prefix);
for (walk = pipeline; walk; walk = g_list_next (walk))
{
GList *walk2;
gboolean first_alt = TRUE;
if (!first)
g_string_append (str, " ->");
first = FALSE;
for (walk2 = g_list_first (walk->data); walk2; walk2 = g_list_next (walk2))
{
if (first_alt)
g_string_append_printf (str, " %s",
gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (walk2->data)));
else
g_string_append_printf (str, " | %s",
gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (walk2->data)));
first_alt = FALSE;
}
}
GST_CAT_LEVEL_LOG (GST_CAT_DEFAULT, level, NULL, "%s", str->str);
g_string_free (str, TRUE);
}
static GstFlowReturn
gst_openjpeg_enc_handle_frame (GstVideoEncoder * encoder,
GstVideoCodecFrame * frame)
{
GstOpenJPEGEnc *self = GST_OPENJPEG_ENC (encoder);
GstFlowReturn ret = GST_FLOW_OK;
#ifdef HAVE_OPENJPEG_1
opj_cinfo_t *enc;
GstMapInfo map;
guint length;
opj_cio_t *io;
#else
opj_codec_t *enc;
opj_stream_t *stream;
MemStream mstream;
#endif
opj_image_t *image;
GstVideoFrame vframe;
GST_DEBUG_OBJECT (self, "Handling frame");
enc = opj_create_compress (self->codec_format);
if (!enc)
goto initialization_error;
#ifdef HAVE_OPENJPEG_1
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
GST_LEVEL_TRACE)) {
opj_event_mgr_t callbacks;
callbacks.error_handler = gst_openjpeg_enc_opj_error;
callbacks.warning_handler = gst_openjpeg_enc_opj_warning;
callbacks.info_handler = gst_openjpeg_enc_opj_info;
opj_set_event_mgr ((opj_common_ptr) enc, &callbacks, self);
} else {
opj_set_event_mgr ((opj_common_ptr) enc, NULL, NULL);
}
#else
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
GST_LEVEL_TRACE)) {
opj_set_info_handler (enc, gst_openjpeg_enc_opj_info, self);
opj_set_warning_handler (enc, gst_openjpeg_enc_opj_warning, self);
opj_set_error_handler (enc, gst_openjpeg_enc_opj_error, self);
} else {
opj_set_info_handler (enc, NULL, NULL);
opj_set_warning_handler (enc, NULL, NULL);
opj_set_error_handler (enc, NULL, NULL);
}
#endif
if (!gst_video_frame_map (&vframe, &self->input_state->info,
frame->input_buffer, GST_MAP_READ))
goto map_read_error;
image = gst_openjpeg_enc_fill_image (self, &vframe);
if (!image)
goto fill_image_error;
gst_video_frame_unmap (&vframe);
opj_setup_encoder (enc, &self->params, image);
#ifdef HAVE_OPENJPEG_1
io = opj_cio_open ((opj_common_ptr) enc, NULL, 0);
if (!io)
goto open_error;
if (!opj_encode (enc, io, image, NULL))
goto encode_error;
opj_image_destroy (image);
length = cio_tell (io);
ret =
gst_video_encoder_allocate_output_frame (encoder, frame,
length + (self->is_jp2c ? 8 : 0));
if (ret != GST_FLOW_OK)
goto allocate_error;
gst_buffer_fill (frame->output_buffer, self->is_jp2c ? 8 : 0, io->buffer,
length);
if (self->is_jp2c) {
gst_buffer_map (frame->output_buffer, &map, GST_MAP_WRITE);
GST_WRITE_UINT32_BE (map.data, length + 8);
GST_WRITE_UINT32_BE (map.data + 4, GST_MAKE_FOURCC ('j', 'p', '2', 'c'));
gst_buffer_unmap (frame->output_buffer, &map);
}
opj_cio_close (io);
opj_destroy_compress (enc);
#else
stream = opj_stream_create (4096, OPJ_FALSE);
if (!stream)
goto open_error;
mstream.allocsize = 4096;
mstream.data = g_malloc (mstream.allocsize);
mstream.offset = 0;
mstream.size = 0;
opj_stream_set_read_function (stream, read_fn);
opj_stream_set_write_function (stream, write_fn);
opj_stream_set_skip_function (stream, skip_fn);
opj_stream_set_seek_function (stream, seek_fn);
opj_stream_set_user_data (stream, &mstream);
opj_stream_set_user_data_length (stream, mstream.size);
if (!opj_start_compress (enc, image, stream))
goto encode_error;
if (!opj_encode (enc, stream))
goto encode_error;
if (!opj_end_compress (enc, stream))
goto encode_error;
opj_image_destroy (image);
opj_stream_destroy (stream);
opj_destroy_codec (enc);
frame->output_buffer = gst_buffer_new ();
if (self->is_jp2c) {
GstMapInfo map;
GstMemory *mem;
mem = gst_allocator_alloc (NULL, 8, NULL);
gst_memory_map (mem, &map, GST_MAP_WRITE);
GST_WRITE_UINT32_BE (map.data, mstream.size + 8);
GST_WRITE_UINT32_BE (map.data + 4, GST_MAKE_FOURCC ('j', 'p', '2', 'c'));
gst_memory_unmap (mem, &map);
gst_buffer_append_memory (frame->output_buffer, mem);
}
gst_buffer_append_memory (frame->output_buffer,
gst_memory_new_wrapped (0, mstream.data, mstream.allocsize, 0,
mstream.size, NULL, (GDestroyNotify) g_free));
#endif
ret = gst_video_encoder_finish_frame (encoder, frame);
return ret;
initialization_error:
{
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to initialize OpenJPEG encoder"), (NULL));
return GST_FLOW_ERROR;
}
map_read_error:
{
#ifdef HAVE_OPENJPEG_1
opj_destroy_compress (enc);
#else
opj_destroy_codec (enc);
#endif
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to map input buffer"), (NULL));
return GST_FLOW_ERROR;
}
fill_image_error:
{
#ifdef HAVE_OPENJPEG_1
opj_destroy_compress (enc);
#else
opj_destroy_codec (enc);
#endif
gst_video_frame_unmap (&vframe);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to fill OpenJPEG image"), (NULL));
return GST_FLOW_ERROR;
}
open_error:
{
opj_image_destroy (image);
#ifdef HAVE_OPENJPEG_1
opj_destroy_compress (enc);
#else
opj_destroy_codec (enc);
#endif
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to open OpenJPEG data"), (NULL));
return GST_FLOW_ERROR;
}
encode_error:
{
#ifdef HAVE_OPENJPEG_1
opj_cio_close (io);
opj_image_destroy (image);
opj_destroy_compress (enc);
#else
opj_stream_destroy (stream);
g_free (mstream.data);
opj_image_destroy (image);
opj_destroy_codec (enc);
#endif
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, STREAM, ENCODE,
("Failed to encode OpenJPEG stream"), (NULL));
return GST_FLOW_ERROR;
}
#ifdef HAVE_OPENJPEG_1
allocate_error:
{
opj_cio_close (io);
opj_destroy_compress (enc);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to allocate output buffer"), (NULL));
return ret;
}
#endif
}
static GstFlowReturn gst_netfilter_chain(GstPad *pad, GstBuffer *packet)
{
GstNetfilter *netfilter;
GstFlowReturn ret;
netfilter = GST_NETFILTER(GST_PAD_PARENT(pad));
ret = GST_FLOW_OK;
if (netfilter->filtering_enabled && GST_IS_NETBUFFER(packet))
{
/* Packet is a netbuffer -> get its source address and compare */
GstNetAddress const *orig_packet_source_address = &(GST_NETBUFFER(packet)->from);
GstNetAddress modified_source_address;
/*
Since we are only interested in comparing the address, and not the port,
we have to copy the original source address, and create a new one with the port number
set to DUMMY_PORT (it is not possible to let gst_netaddress_equal() compare only the addresses)
*/
{
guint8 addr[16];
guint16 port;
GstNetType type;
type = gst_netaddress_get_net_type(orig_packet_source_address);
gst_netaddress_get_address_bytes(orig_packet_source_address, addr, &port);
gst_netaddress_set_address_bytes(&modified_source_address, type, addr, DUMMY_PORT);
}
/* Debug output; doing this check to avoid unnecessary to_string calls */
if (gst_debug_category_get_threshold(GST_CAT_DEFAULT) >= GST_LEVEL_DEBUG)
{
char str1[GST_NETADDRESS_MAX_LEN + 1];
char str2[GST_NETADDRESS_MAX_LEN + 1];
str1[GST_NETADDRESS_MAX_LEN] = 0;
str2[GST_NETADDRESS_MAX_LEN] = 0;
gst_netaddress_to_string(&modified_source_address, str1, GST_NETADDRESS_MAX_LEN);
gst_netaddress_to_string(&(netfilter->filter_address), str2, GST_NETADDRESS_MAX_LEN);
GST_DEBUG_OBJECT(netfilter, "Received buffer is a network packet with source address %s (filter address is %s; port numbers are ignored)", str1, str2);
}
if (gst_netaddress_equal(&(netfilter->filter_address), &modified_source_address))
{
/* Addresses match; pass through the packet */
GST_DEBUG_OBJECT(netfilter, "Received packet's source address is a match -> passing through");
ret = gst_pad_push(netfilter->srcpad, packet);
}
else
{
/* Addresses do not match; drop the packet */
GST_DEBUG_OBJECT(netfilter, "Received packet's source address does not match the filter address -> dropping");
gst_buffer_unref(packet);
}
}
else
{
/* Packet is not a netbuffer, or filtering is disabled; just pass it through */
ret = gst_pad_push(netfilter->srcpad, packet);
}
return ret;
}
static void
gst_debug_help (void)
{
GSList *list, *walk;
GList *list2, *g;
/* Need to ensure the registry is loaded to get debug categories */
if (!init_post (NULL, NULL, NULL, NULL))
exit (1);
list2 = gst_registry_plugin_filter (gst_registry_get (),
select_all, FALSE, NULL);
/* FIXME this is gross. why don't debug have categories PluginFeatures? */
for (g = list2; g; g = g_list_next (g)) {
GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
gst_plugin_load (plugin);
}
g_list_free (list2);
list = gst_debug_get_all_categories ();
walk = list = g_slist_sort (list, sort_by_category_name);
g_print ("\n");
g_print ("name level description\n");
g_print ("---------------------+--------+--------------------------------\n");
while (walk) {
gboolean on_unix;
GstDebugCategory *cat = (GstDebugCategory *) walk->data;
GstDebugColorMode coloring = gst_debug_get_color_mode ();
#ifdef G_OS_UNIX
on_unix = TRUE;
#else
on_unix = FALSE;
#endif
if (GST_DEBUG_COLOR_MODE_UNIX == coloring
|| (on_unix && GST_DEBUG_COLOR_MODE_ON == coloring)) {
gchar *color = gst_debug_construct_term_color (cat->color);
g_print ("%s%-20s\033[00m %1d %s %s%s\033[00m\n",
color,
gst_debug_category_get_name (cat),
gst_debug_category_get_threshold (cat),
gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
color, gst_debug_category_get_description (cat));
g_free (color);
} else if (GST_DEBUG_COLOR_MODE_ON == coloring && !on_unix) {
#ifdef G_OS_WIN32
gint color = gst_debug_construct_win_color (cat->color);
const gint clear = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
g_print ("%-20s", gst_debug_category_get_name (cat));
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
g_print (" %1d %s ", gst_debug_category_get_threshold (cat),
gst_debug_level_get_name (gst_debug_category_get_threshold (cat)));
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
g_print ("%s", gst_debug_category_get_description (cat));
SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
g_print ("\n");
#endif /* G_OS_WIN32 */
} else {
g_print ("%-20s %1d %s %s\n", gst_debug_category_get_name (cat),
gst_debug_category_get_threshold (cat),
gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
gst_debug_category_get_description (cat));
}
walk = g_slist_next (walk);
}
g_slist_free (list);
g_print ("\n");
}
static GstFlowReturn
gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
GstVideoCodecFrame * frame)
{
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
GstFlowReturn ret = GST_FLOW_OK;
gint64 deadline;
GstMapInfo map;
opj_dinfo_t *dec;
opj_event_mgr_t callbacks;
opj_cio_t *io;
opj_image_t *image;
GstVideoFrame vframe;
opj_dparameters_t params;
GST_DEBUG_OBJECT (self, "Handling frame");
deadline = gst_video_decoder_get_max_decode_time (decoder, frame);
if (deadline < 0) {
GST_LOG_OBJECT (self, "Dropping too late frame: deadline %" G_GINT64_FORMAT,
deadline);
ret = gst_video_decoder_drop_frame (decoder, frame);
return ret;
}
dec = opj_create_decompress (self->codec_format);
if (!dec)
goto initialization_error;
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
GST_LEVEL_TRACE)) {
callbacks.error_handler = gst_openjpeg_dec_opj_error;
callbacks.warning_handler = gst_openjpeg_dec_opj_warning;
callbacks.info_handler = gst_openjpeg_dec_opj_info;
opj_set_event_mgr ((opj_common_ptr) dec, &callbacks, self);
} else {
opj_set_event_mgr ((opj_common_ptr) dec, NULL, NULL);
}
params = self->params;
if (self->ncomps)
params.jpwl_exp_comps = self->ncomps;
opj_setup_decoder (dec, ¶ms);
if (!gst_buffer_map (frame->input_buffer, &map, GST_MAP_READ))
goto map_read_error;
io = opj_cio_open ((opj_common_ptr) dec, map.data + (self->is_jp2c ? 8 : 0),
map.size - (self->is_jp2c ? 8 : 0));
if (!io)
goto open_error;
image = opj_decode (dec, io);
if (!image)
goto decode_error;
gst_buffer_unmap (frame->input_buffer, &map);
ret = gst_openjpeg_dec_negotiate (self, image);
if (ret != GST_FLOW_OK)
goto negotiate_error;
ret = gst_video_decoder_allocate_output_frame (decoder, frame);
if (ret != GST_FLOW_OK)
goto allocate_error;
if (!gst_video_frame_map (&vframe, &self->output_state->info,
frame->output_buffer, GST_MAP_WRITE))
goto map_write_error;
self->fill_frame (&vframe, image);
gst_video_frame_unmap (&vframe);
opj_image_destroy (image);
opj_cio_close (io);
opj_destroy_decompress (dec);
ret = gst_video_decoder_finish_frame (decoder, frame);
return ret;
initialization_error:
{
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to initialize OpenJPEG decoder"), (NULL));
return GST_FLOW_ERROR;
}
map_read_error:
{
opj_destroy_decompress (dec);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to map input buffer"), (NULL));
return GST_FLOW_ERROR;
}
open_error:
{
opj_destroy_decompress (dec);
gst_buffer_unmap (frame->input_buffer, &map);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
("Failed to open OpenJPEG stream"), (NULL));
return GST_FLOW_ERROR;
}
decode_error:
{
opj_cio_close (io);
opj_destroy_decompress (dec);
gst_buffer_unmap (frame->input_buffer, &map);
gst_video_codec_frame_unref (frame);
GST_VIDEO_DECODER_ERROR (self, 1, STREAM, DECODE,
("Failed to decode OpenJPEG stream"), (NULL), ret);
return ret;
}
negotiate_error:
{
opj_image_destroy (image);
opj_cio_close (io);
opj_destroy_decompress (dec);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, NEGOTIATION,
("Failed to negotiate"), (NULL));
return ret;
}
allocate_error:
{
opj_image_destroy (image);
opj_cio_close (io);
opj_destroy_decompress (dec);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to allocate output buffer"), (NULL));
return ret;
}
map_write_error:
{
opj_image_destroy (image);
opj_cio_close (io);
opj_destroy_decompress (dec);
gst_video_codec_frame_unref (frame);
GST_ELEMENT_ERROR (self, CORE, FAILED,
("Failed to map output buffer"), (NULL));
return GST_FLOW_ERROR;
}
}
static void gst_debug_gub(GstDebugCategory * category, GstDebugLevel level,
const gchar * file, const gchar * function, gint line,
GObject * object, GstDebugMessage * message, gpointer unused)
{
GstClockTime elapsed;
gchar *tag;
const gchar *level_str;
if (level > gst_debug_category_get_threshold(category))
return;
elapsed = GST_CLOCK_DIFF(_priv_gst_info_start_time,
gst_util_get_timestamp());
switch (level) {
case GST_LEVEL_ERROR:
level_str = "ERR";
break;
case GST_LEVEL_WARNING:
level_str = "WRN";
break;
case GST_LEVEL_INFO:
level_str = "NFO";
break;
case GST_LEVEL_DEBUG:
level_str = "DBG";
break;
default:
level_str = "LOG";
break;
}
tag = g_strdup_printf("%s", gst_debug_category_get_name(category));
if (object) {
gchar *obj;
if (GST_IS_PAD(object) && GST_OBJECT_NAME(object)) {
obj = g_strdup_printf("<%s:%s>", GST_DEBUG_PAD_NAME(object));
}
else if (GST_IS_OBJECT(object) && GST_OBJECT_NAME(object)) {
obj = g_strdup_printf("<%s>", GST_OBJECT_NAME(object));
}
else if (G_IS_OBJECT(object)) {
obj = g_strdup_printf("<%s@%p>", G_OBJECT_TYPE_NAME(object), object);
}
else {
obj = g_strdup_printf("<%p>", object);
}
gub_log(
"%" GST_TIME_FORMAT " %p %s %s %s:%d:%s:%s %s",
GST_TIME_ARGS(elapsed), g_thread_self(), level_str, tag,
file, line, function, obj, gst_debug_message_get(message));
g_free(obj);
}
else {
gub_log(
"%" GST_TIME_FORMAT " %p %s %s %s:%d:%s %s",
GST_TIME_ARGS(elapsed), g_thread_self(), level_str, tag,
file, line, function, gst_debug_message_get(message));
}
g_free(tag);
}
static void
fs_rawudp_component_class_init (FsRawUdpComponentClass *klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
parent_class = g_type_class_peek_parent (klass);
gobject_class->set_property = fs_rawudp_component_set_property;
gobject_class->get_property = fs_rawudp_component_get_property;
gobject_class->constructed = fs_rawudp_constructed;
gobject_class->dispose = fs_rawudp_component_dispose;
gobject_class->finalize = fs_rawudp_component_finalize;
g_object_class_install_property (gobject_class,
PROP_COMPONENT,
g_param_spec_uint ("component",
"The component id",
"The id of this component",
1, G_MAXUINT, 1,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_SENDING,
g_param_spec_boolean ("sending",
"Whether to send from this transmitter",
"If set to FALSE, the transmitter will stop sending to this person",
TRUE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_IP,
g_param_spec_string ("ip",
"The local IP of this component",
"The IPv4 address as a x.x.x.x string",
NULL,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_PORT,
g_param_spec_uint ("port",
"The local port requested for this component",
"The IPv4 UDP port",
1, 65535, 7078,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_STUN_IP,
g_param_spec_string ("stun-ip",
"The IP address of the STUN server",
"The IPv4 address of the STUN server as a x.x.x.x string",
NULL,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_STUN_PORT,
g_param_spec_uint ("stun-port",
"The port of the STUN server",
"The IPv4 UDP port of the STUN server as a ",
0, 65535, 3478,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_STUN_TIMEOUT,
g_param_spec_uint ("stun-timeout",
"The timeout for the STUN reply",
"How long to wait for for the STUN reply (in seconds) before giving up",
1, MAX_STUN_TIMEOUT, DEFAULT_STUN_TIMEOUT,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_TRANSMITTER,
g_param_spec_object ("transmitter",
"The transmitter object",
"The rawudp transmitter object",
FS_TYPE_RAWUDP_TRANSMITTER,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_FORCED_CANDIDATE,
g_param_spec_boxed ("forced-candidate",
"A Forced candidate",
"This candidate is built from a user preference",
FS_TYPE_CANDIDATE,
G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_ASSOCIATE_ON_SOURCE,
g_param_spec_boolean ("associate-on-source",
"Associate incoming data based on the source address",
"Whether to associate incoming data stream based on the"
" source address",
TRUE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
#ifdef HAVE_GUPNP
g_object_class_install_property (gobject_class,
PROP_UPNP_MAPPING,
g_param_spec_boolean ("upnp-mapping",
"Try to map ports using UPnP",
"Tries to map ports using UPnP if enabled",
TRUE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_UPNP_DISCOVERY,
g_param_spec_boolean ("upnp-discovery",
"Try to use UPnP to find the external IP address",
"Tries to discovery the external IP with UPnP if stun fails",
TRUE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_UPNP_MAPPING_TIMEOUT,
g_param_spec_uint ("upnp-mapping-timeout",
"Timeout after which UPnP mappings expire",
"The UPnP port mappings expire after this period if the app has"
" crashed (in seconds)",
0, G_MAXUINT32, DEFAULT_UPNP_MAPPING_TIMEOUT,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_UPNP_DISCOVERY_TIMEOUT,
g_param_spec_uint ("upnp-discovery-timeout",
"Timeout after which UPnP discovery fails",
"After this period, UPnP discovery is considered to have failed"
" and the local IP is returned",
0, G_MAXUINT32, DEFAULT_UPNP_DISCOVERY_TIMEOUT,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_UPNP_IGD,
g_param_spec_object ("upnp-igd",
"The GUPnPSimpleIgdThread object",
"This is the GUPnP IGD abstraction object",
GUPNP_TYPE_SIMPLE_IGD_THREAD,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
#endif
/**
* FsRawUdpComponent::new-local-candidate:
* @self: #FsStream that emitted the signal
* @local_candidate: #FsCandidate of the local candidate
*
* This signal is emitted when a new local candidate is discovered.
*/
signals[NEW_LOCAL_CANDIDATE] = g_signal_new
("new-local-candidate",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE, 1, FS_TYPE_CANDIDATE);
/**
* FsRawUdpComponent::local-candidates-prepared:
* @self: #FsStream that emitted the signal
*
* This signal is emitted when all local candidates have been
* prepared for this component.
*/
signals[LOCAL_CANDIDATES_PREPARED] = g_signal_new
("local-candidates-prepared",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
* FsiRawUdpComponent::new-active-candidate-pair:
* @self: #FsStream that emitted the signal
* @local_candidate: #FsCandidate of the local candidate being used
* @remote_candidate: #FsCandidate of the remote candidate being used
*
* This signal is emitted when there is a new active chandidate pair that has
* been established.
*
*/
signals[NEW_ACTIVE_CANDIDATE_PAIR] = g_signal_new
("new-active-candidate-pair",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 2, FS_TYPE_CANDIDATE, FS_TYPE_CANDIDATE);
/**
* FsRawUdpComponent::known-source-packet-received:
* @self: #FsRawUdpComponent that emitted the signal
* @component: The ID of this component
* @buffer: the #GstBuffer coming from the known source
*
* This signal is emitted when a buffer coming from a confirmed known source
* is received.
*
*/
signals[KNOWN_SOURCE_PACKET_RECEIVED] = g_signal_new
("known-source-packet-received",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_POINTER);
/**
* FsRawUdpComponent::error:
* @self: #FsStreamTransmitter that emitted the signal
* @errorno: The number of the error
* @error_msg: Error message
*
* This signal is emitted in any error condition
*
*/
signals[ERROR_SIGNAL] = g_signal_new ("error",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 2, FS_TYPE_ERROR, G_TYPE_STRING);
g_type_class_add_private (klass, sizeof (FsRawUdpComponentPrivate));
if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >= GST_LEVEL_DEBUG)
stun_debug_enable ();
else
stun_debug_disable ();
}
