+++ /dev/null
-/*
- * This file is a part of MAFW
- *
- * Copyright (C) 2007, 2008, 2009 Nokia Corporation, all rights reserved.
- *
- * Contact: Visa Smolander <visa.smolander@nokia.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <string.h>
-#include <glib.h>
-#include <X11/Xlib.h>
-#include <gst/interfaces/xoverlay.h>
-#include <gst/pbutils/missing-plugins.h>
-#include <gst/base/gstbasesink.h>
-#include <libmafw/mafw.h>
-
-#ifdef HAVE_GDKPIXBUF
-#include <gdk-pixbuf/gdk-pixbuf.h>
-#include <glib/gstdio.h>
-#include <unistd.h>
-#include "gstscreenshot.h"
-#endif
-
-#include <totem-pl-parser.h>
-#include "mafw-gst-renderer.h"
-#include "mafw-gst-renderer-worker.h"
-#include "mafw-gst-renderer-utils.h"
-#include "blanking.h"
-#include "keypad.h"
-
-#undef G_LOG_DOMAIN
-#define G_LOG_DOMAIN "mafw-gst-renderer-worker"
-
-#define MAFW_GST_RENDERER_WORKER_SECONDS_READY 60
-#define MAFW_GST_RENDERER_WORKER_SECONDS_DURATION_AND_SEEKABILITY 4
-
-#define MAFW_GST_MISSING_TYPE_DECODER "decoder"
-#define MAFW_GST_MISSING_TYPE_ENCODER "encoder"
-
-#define MAFW_GST_BUFFER_TIME 600000L
-#define MAFW_GST_LATENCY_TIME (MAFW_GST_BUFFER_TIME / 2)
-
-#define NSECONDS_TO_SECONDS(ns) ((ns)%1000000000 < 500000000?\
- GST_TIME_AS_SECONDS((ns)):\
- GST_TIME_AS_SECONDS((ns))+1)
-
-#define _current_metadata_add(worker, key, type, value) \
- do { \
- if (!worker->current_metadata) \
- worker->current_metadata = mafw_metadata_new(); \
- /* At first remove old value */ \
- g_hash_table_remove(worker->current_metadata, key); \
- mafw_metadata_add_something(worker->current_metadata, \
- key, type, 1, value); \
- } while (0)
-
-/* Private variables. */
-/* Global reference to worker instance, needed for Xerror handler */
-static MafwGstRendererWorker *Global_worker = NULL;
-
-/* Forward declarations. */
-static void _do_play(MafwGstRendererWorker *worker);
-static void _do_seek(MafwGstRendererWorker *worker, GstSeekType seek_type,
- gint position, GError **error);
-static void _play_pl_next(MafwGstRendererWorker *worker);
-
-static void _emit_metadatas(MafwGstRendererWorker *worker);
-
-/* Playlist parsing */
-static void _on_pl_entry_parsed(TotemPlParser *parser, gchar *uri,
- gpointer metadata, GSList **plitems)
-{
- if (uri != NULL) {
- *plitems = g_slist_append(*plitems, g_strdup(uri));
- }
-}
-static GSList *_parse_playlist(const gchar *uri)
-{
- static TotemPlParser *pl_parser = NULL;
- GSList *plitems = NULL;
- gulong handler_id;
-
- /* Initialize the playlist parser */
- if (!pl_parser)
- {
- pl_parser = totem_pl_parser_new ();
- g_object_set(pl_parser, "recurse", TRUE, "disable-unsafe",
- TRUE, NULL);
- }
- handler_id = g_signal_connect(G_OBJECT(pl_parser), "entry-parsed",
- G_CALLBACK(_on_pl_entry_parsed), &plitems);
- /* Parsing */
- if (totem_pl_parser_parse(pl_parser, uri, FALSE) !=
- TOTEM_PL_PARSER_RESULT_SUCCESS) {
- /* An error happens while parsing */
-
- }
- g_signal_handler_disconnect(pl_parser, handler_id);
- return plitems;
-}
-
-/*
- * Sends @error to MafwGstRenderer. Only call this from the glib main thread, or
- * face the consequences. @err is free'd.
- */
-static void _send_error(MafwGstRendererWorker *worker, GError *err)
-{
- worker->is_error = TRUE;
- if (worker->notify_error_handler)
- worker->notify_error_handler(worker, worker->owner, err);
- g_error_free(err);
-}
-
-/*
- * Posts an @error on the gst bus. _async_bus_handler will then pick it up and
- * forward to MafwGstRenderer. @err is free'd.
- */
-static void _post_error(MafwGstRendererWorker *worker, GError *err)
-{
- gst_bus_post(worker->bus,
- gst_message_new_error(GST_OBJECT(worker->pipeline),
- err, NULL));
- g_error_free(err);
-}
-
-#ifdef HAVE_GDKPIXBUF
-typedef struct {
- MafwGstRendererWorker *worker;
- gchar *metadata_key;
- GdkPixbuf *pixbuf;
-} SaveGraphicData;
-
-static gchar *_init_tmp_file(void)
-{
- gint fd;
- gchar *path = NULL;
-
- fd = g_file_open_tmp("mafw-gst-renderer-XXXXXX.jpeg", &path, NULL);
- close(fd);
-
- return path;
-}
-
-static void _init_tmp_files_pool(MafwGstRendererWorker *worker)
-{
- guint8 i;
-
- worker->tmp_files_pool_index = 0;
-
- for (i = 0; i < MAFW_GST_RENDERER_MAX_TMP_FILES; i++) {
- worker->tmp_files_pool[i] = NULL;
- }
-}
-
-static void _destroy_tmp_files_pool(MafwGstRendererWorker *worker)
-{
- guint8 i;
-
- for (i = 0; (i < MAFW_GST_RENDERER_MAX_TMP_FILES) &&
- (worker->tmp_files_pool[i] != NULL); i++) {
- g_unlink(worker->tmp_files_pool[i]);
- g_free(worker->tmp_files_pool[i]);
- }
-}
-
-static const gchar *_get_tmp_file_from_pool(
- MafwGstRendererWorker *worker)
-{
- gchar *path = worker->tmp_files_pool[worker->tmp_files_pool_index];
-
- if (path == NULL) {
- path = _init_tmp_file();
- worker->tmp_files_pool[worker->tmp_files_pool_index] = path;
- }
-
- if (++(worker->tmp_files_pool_index) >=
- MAFW_GST_RENDERER_MAX_TMP_FILES) {
- worker->tmp_files_pool_index = 0;
- }
-
- return path;
-}
-
-static void _destroy_pixbuf (guchar *pixbuf, gpointer data)
-{
- gst_buffer_unref(GST_BUFFER(data));
-}
-
-static void _emit_gst_buffer_as_graphic_file_cb(GstBuffer *new_buffer,
- gpointer user_data)
-{
- SaveGraphicData *sgd = user_data;
- GdkPixbuf *pixbuf = NULL;
-
- if (new_buffer != NULL) {
- gint width, height;
- GstStructure *structure;
-
- structure =
- gst_caps_get_structure(GST_BUFFER_CAPS(new_buffer), 0);
-
- gst_structure_get_int(structure, "width", &width);
- gst_structure_get_int(structure, "height", &height);
-
- pixbuf = gdk_pixbuf_new_from_data(
- GST_BUFFER_DATA(new_buffer), GDK_COLORSPACE_RGB,
- FALSE, 8, width, height,
- GST_ROUND_UP_4(3 * width), _destroy_pixbuf,
- new_buffer);
-
- if (sgd->pixbuf != NULL) {
- g_object_unref(sgd->pixbuf);
- sgd->pixbuf = NULL;
- }
- } else {
- pixbuf = sgd->pixbuf;
- }
-
- if (pixbuf != NULL) {
- gboolean save_ok;
- GError *error = NULL;
- const gchar *filename;
-
- filename = _get_tmp_file_from_pool(sgd->worker);
-
- save_ok = gdk_pixbuf_save (pixbuf, filename, "jpeg", &error,
- NULL);
-
- g_object_unref (pixbuf);
-
- if (save_ok) {
- /* Add the info to the current metadata. */
- _current_metadata_add(sgd->worker, sgd->metadata_key,
- G_TYPE_STRING,
- (gchar*)filename);
-
- /* Emit the metadata. */
- mafw_renderer_emit_metadata_string(sgd->worker->owner,
- sgd->metadata_key,
- (gchar *) filename);
- } else {
- if (error != NULL) {
- g_warning ("%s\n", error->message);
- g_error_free (error);
- } else {
- g_critical("Unknown error when saving pixbuf "
- "with GStreamer data");
- }
- }
- } else {
- g_warning("Could not create pixbuf from GstBuffer");
- }
-
- g_free(sgd->metadata_key);
- g_free(sgd);
-}
-
-static void _pixbuf_size_prepared_cb (GdkPixbufLoader *loader,
- gint width, gint height,
- gpointer user_data)
-{
- /* Be sure the image size is reasonable */
- if (width > 512 || height > 512) {
- g_debug ("pixbuf: image is too big: %dx%d", width, height);
- gdouble ar;
- ar = (gdouble) width / height;
- if (width > height) {
- width = 512;
- height = width / ar;
- } else {
- height = 512;
- width = height * ar;
- }
- g_debug ("pixbuf: scaled image to %dx%d", width, height);
- gdk_pixbuf_loader_set_size (loader, width, height);
- }
-}
-
-static void _emit_gst_buffer_as_graphic_file(MafwGstRendererWorker *worker,
- GstBuffer *buffer,
- const gchar *metadata_key)
-{
- GdkPixbufLoader *loader;
- GstStructure *structure;
- const gchar *mime = NULL;
- GError *error = NULL;
-
- g_return_if_fail((buffer != NULL) && GST_IS_BUFFER(buffer));
-
- structure = gst_caps_get_structure(GST_BUFFER_CAPS(buffer), 0);
- mime = gst_structure_get_name(structure);
-
- if (g_str_has_prefix(mime, "video/x-raw")) {
- gint framerate_d, framerate_n;
- GstCaps *to_caps;
- SaveGraphicData *sgd;
-
- gst_structure_get_fraction (structure, "framerate",
- &framerate_n, &framerate_d);
-
- to_caps = gst_caps_new_simple ("video/x-raw-rgb",
- "bpp", G_TYPE_INT, 24,
- "depth", G_TYPE_INT, 24,
- "framerate", GST_TYPE_FRACTION,
- framerate_n, framerate_d,
- "pixel-aspect-ratio",
- GST_TYPE_FRACTION, 1, 1,
- "endianness",
- G_TYPE_INT, G_BIG_ENDIAN,
- "red_mask", G_TYPE_INT,
- 0xff0000,
- "green_mask",
- G_TYPE_INT, 0x00ff00,
- "blue_mask",
- G_TYPE_INT, 0x0000ff,
- NULL);
-
- sgd = g_new0(SaveGraphicData, 1);
- sgd->worker = worker;
- sgd->metadata_key = g_strdup(metadata_key);
-
- g_debug("pixbuf: using bvw to convert image format");
- bvw_frame_conv_convert (buffer, to_caps,
- _emit_gst_buffer_as_graphic_file_cb,
- sgd);
- } else {
- GdkPixbuf *pixbuf = NULL;
- loader = gdk_pixbuf_loader_new_with_mime_type(mime, &error);
- g_signal_connect (G_OBJECT (loader), "size-prepared",
- (GCallback)_pixbuf_size_prepared_cb, NULL);
-
- if (loader == NULL) {
- g_warning ("%s\n", error->message);
- g_error_free (error);
- } else {
- if (!gdk_pixbuf_loader_write (loader,
- GST_BUFFER_DATA(buffer),
- GST_BUFFER_SIZE(buffer),
- &error)) {
- g_warning ("%s\n", error->message);
- g_error_free (error);
-
- gdk_pixbuf_loader_close (loader, NULL);
- } else {
- pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
-
- if (!gdk_pixbuf_loader_close (loader, &error)) {
- g_warning ("%s\n", error->message);
- g_error_free (error);
-
- g_object_unref(pixbuf);
- } else {
- SaveGraphicData *sgd;
-
- sgd = g_new0(SaveGraphicData, 1);
-
- sgd->worker = worker;
- sgd->metadata_key =
- g_strdup(metadata_key);
- sgd->pixbuf = pixbuf;
-
- _emit_gst_buffer_as_graphic_file_cb(
- NULL, sgd);
- }
- }
- g_object_unref(loader);
- }
- }
-}
-#endif
-
-static gboolean _go_to_gst_ready(gpointer user_data)
-{
- MafwGstRendererWorker *worker = user_data;
-
- g_return_val_if_fail(worker->state == GST_STATE_PAUSED ||
- worker->prerolling, FALSE);
-
- worker->seek_position =
- mafw_gst_renderer_worker_get_position(worker);
-
- g_debug("going to GST_STATE_READY");
- gst_element_set_state(worker->pipeline, GST_STATE_READY);
- worker->in_ready = TRUE;
- worker->ready_timeout = 0;
-
- return FALSE;
-}
-
-static void _add_ready_timeout(MafwGstRendererWorker *worker)
-{
- if (worker->media.seekable) {
- if (!worker->ready_timeout)
- {
- g_debug("Adding timeout to go to GST_STATE_READY");
- worker->ready_timeout =
- g_timeout_add_seconds(
- MAFW_GST_RENDERER_WORKER_SECONDS_READY,
- _go_to_gst_ready,
- worker);
- }
- } else {
- g_debug("Not adding timeout to go to GST_STATE_READY as media "
- "is not seekable");
- worker->ready_timeout = 0;
- }
-}
-
-static void _remove_ready_timeout(MafwGstRendererWorker *worker)
-{
- if (worker->ready_timeout != 0) {
- g_debug("removing timeout for READY");
- g_source_remove(worker->ready_timeout);
- worker->ready_timeout = 0;
- }
- worker->in_ready = FALSE;
-}
-
-static gboolean _emit_video_info(MafwGstRendererWorker *worker)
-{
- mafw_renderer_emit_metadata_int(worker->owner,
- MAFW_METADATA_KEY_RES_X,
- worker->media.video_width);
- mafw_renderer_emit_metadata_int(worker->owner,
- MAFW_METADATA_KEY_RES_Y,
- worker->media.video_height);
- mafw_renderer_emit_metadata_double(worker->owner,
- MAFW_METADATA_KEY_VIDEO_FRAMERATE,
- worker->media.fps);
- return FALSE;
-}
-
-/*
- * Checks if the video details are supported. It also extracts other useful
- * information (such as PAR and framerate) from the caps, if available. NOTE:
- * this will be called from a different thread than glib's mainloop (when
- * invoked via _stream_info_cb); don't call MafwGstRenderer directly.
- *
- * Returns: TRUE if video details are acceptable.
- */
-static gboolean _handle_video_info(MafwGstRendererWorker *worker,
- const GstStructure *structure)
-{
- gint width, height;
- gdouble fps;
-
- width = height = 0;
- gst_structure_get_int(structure, "width", &width);
- gst_structure_get_int(structure, "height", &height);
- g_debug("video size: %d x %d", width, height);
- if (gst_structure_has_field(structure, "pixel-aspect-ratio"))
- {
- gst_structure_get_fraction(structure, "pixel-aspect-ratio",
- &worker->media.par_n,
- &worker->media.par_d);
- g_debug("video PAR: %d:%d", worker->media.par_n,
- worker->media.par_d);
- width = width * worker->media.par_n / worker->media.par_d;
- }
-
- fps = 1.0;
- if (gst_structure_has_field(structure, "framerate"))
- {
- gint fps_n, fps_d;
-
- gst_structure_get_fraction(structure, "framerate",
- &fps_n, &fps_d);
- if (fps_d > 0)
- fps = (gdouble)fps_n / (gdouble)fps_d;
- g_debug("video fps: %f", fps);
- }
-
- worker->media.video_width = width;
- worker->media.video_height = height;
- worker->media.fps = fps;
-
- /* Add the info to the current metadata. */
- gint p_width, p_height, p_fps;
-
- p_width = width;
- p_height = height;
- p_fps = fps;
-
- _current_metadata_add(worker, MAFW_METADATA_KEY_RES_X, G_TYPE_INT,
- p_width);
- _current_metadata_add(worker, MAFW_METADATA_KEY_RES_Y, G_TYPE_INT,
- p_height);
- _current_metadata_add(worker, MAFW_METADATA_KEY_VIDEO_FRAMERATE,
- G_TYPE_DOUBLE,
- p_fps);
-
- /* Emit the metadata.*/
- g_idle_add((GSourceFunc)_emit_video_info, worker);
-
- return TRUE;
-}
-
-static void _parse_stream_info_item(MafwGstRendererWorker *worker, GObject *obj)
-{
- GParamSpec *pspec;
- GEnumValue *val;
- gint type;
-
- g_object_get(obj, "type", &type, NULL);
- pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(obj), "type");
- val = g_enum_get_value(G_PARAM_SPEC_ENUM(pspec)->enum_class, type);
- if (!val)
- return;
- if (!g_ascii_strcasecmp(val->value_nick, "video") ||
- !g_ascii_strcasecmp(val->value_name, "video"))
- {
- GstCaps *vcaps;
- GstObject *object;
-
- object = NULL;
- g_object_get(obj, "object", &object, NULL);
- vcaps = NULL;
- if (object) {
- vcaps = gst_pad_get_caps(GST_PAD_CAST(object));
- } else {
- g_object_get(obj, "caps", &vcaps, NULL);
- gst_caps_ref(vcaps);
- }
- if (vcaps) {
- if (gst_caps_is_fixed(vcaps))
- {
- _handle_video_info(
- worker,
- gst_caps_get_structure(vcaps, 0));
- }
- gst_caps_unref(vcaps);
- }
- }
-}
-
-/* It always returns FALSE, because it is used as an idle callback as well. */
-static gboolean _parse_stream_info(MafwGstRendererWorker *worker)
-{
- GList *stream_info, *s;
-
- stream_info = NULL;
- if (g_object_class_find_property(G_OBJECT_GET_CLASS(worker->pipeline),
- "stream-info"))
- {
- g_object_get(worker->pipeline,
- "stream-info", &stream_info, NULL);
- }
- for (s = stream_info; s; s = g_list_next(s))
- _parse_stream_info_item(worker, G_OBJECT(s->data));
- return FALSE;
-}
-
-static void mafw_gst_renderer_worker_apply_xid(MafwGstRendererWorker *worker)
-{
- /* Set sink to render on the provided XID if we have do have
- a XID a valid video sink and we are rendeing video content */
- if (worker->xid &&
- worker->vsink &&
- worker->media.has_visual_content)
- {
- g_debug ("Setting overlay, window id: %x",
- (gint) worker->xid);
- gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(worker->vsink),
- worker->xid);
- /* Ask the gst to redraw the frame if we are paused */
- /* TODO: in MTG this works only in non-fs -> fs way. */
- if (worker->state == GST_STATE_PAUSED)
- {
- gst_x_overlay_expose(GST_X_OVERLAY(worker->vsink));
- }
- } else {
- g_debug("Not setting overlay for window id: %x",
- (gint) worker->xid);
- }
-}
-
-/*
- * GstBus synchronous message handler. NOTE that this handler is NOT invoked
- * from the glib thread, so be careful what you do here.
- */
-static GstBusSyncReply _sync_bus_handler(GstBus *bus, GstMessage *msg,
- MafwGstRendererWorker *worker)
-{
- if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ELEMENT &&
- gst_structure_has_name(msg->structure, "prepare-xwindow-id"))
- {
- g_debug("got prepare-xwindow-id");
- worker->media.has_visual_content = TRUE;
- /* The user has to preset the XID, we don't create windows by
- * ourselves. */
- if (!worker->xid) {
- /* We must post an error message to the bus that will
- * be picked up by _async_bus_handler. Calling the
- * notification function directly from here (different
- * thread) is not healthy. */
- g_warning("No video window set!");
- _post_error(worker,
- g_error_new_literal(
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_PLAYBACK,
- "No video window XID set"));
- gst_message_unref (msg);
- return GST_BUS_DROP;
- } else {
- g_debug ("Video window to use is: %x",
- (gint) worker->xid);
- }
-
- /* Instruct vsink to use the client-provided window */
- mafw_gst_renderer_worker_apply_xid(worker);
-
- /* Handle colorkey and autopaint */
- mafw_gst_renderer_worker_set_autopaint(
- worker,
- worker->autopaint);
- if (worker->colorkey == -1)
- g_object_get(worker->vsink,
- "colorkey", &worker->colorkey, NULL);
- else
- mafw_gst_renderer_worker_set_colorkey(
- worker,
- worker->colorkey);
- /* Defer the signal emission to the thread running the
- * mainloop. */
- if (worker->colorkey != -1) {
- gst_bus_post(worker->bus,
- gst_message_new_application(
- GST_OBJECT(worker->vsink),
- gst_structure_empty_new("ckey")));
- }
- gst_message_unref (msg);
- return GST_BUS_DROP;
- }
- /* do not unref message when returning PASS */
- return GST_BUS_PASS;
-}
-
-static void _free_taglist_item(GstMessage *msg, gpointer data)
-{
- gst_message_unref(msg);
-}
-
-static void _free_taglist(MafwGstRendererWorker *worker)
-{
- if (worker->tag_list != NULL)
- {
- g_ptr_array_foreach(worker->tag_list, (GFunc)_free_taglist_item,
- NULL);
- g_ptr_array_free(worker->tag_list, TRUE);
- worker->tag_list = NULL;
- }
-}
-
-static gboolean _seconds_duration_equal(gint64 duration1, gint64 duration2)
-{
- gint64 duration1_seconds, duration2_seconds;
-
- duration1_seconds = NSECONDS_TO_SECONDS(duration1);
- duration2_seconds = NSECONDS_TO_SECONDS(duration2);
-
- return duration1_seconds == duration2_seconds;
-}
-
-static void _check_duration(MafwGstRendererWorker *worker, gint64 value)
-{
- MafwGstRenderer *renderer = worker->owner;
- gboolean right_query = TRUE;
-
- if (value == -1) {
- GstFormat format = GST_FORMAT_TIME;
- right_query =
- gst_element_query_duration(worker->pipeline, &format,
- &value);
- }
-
- if (right_query && value > 0) {
- gint duration_seconds = NSECONDS_TO_SECONDS(value);
-
- if (!_seconds_duration_equal(worker->media.length_nanos,
- value)) {
- /* Add the duration to the current metadata. */
- _current_metadata_add(worker, MAFW_METADATA_KEY_DURATION,
- G_TYPE_INT64,
- (gint64)duration_seconds);
- /* Emit the duration. */
- mafw_renderer_emit_metadata_int64(
- worker->owner, MAFW_METADATA_KEY_DURATION,
- (gint64)duration_seconds);
- }
-
- /* We compare this duration we just got with the
- * source one and update it in the source if needed */
- if (duration_seconds > 0 &&
- duration_seconds != renderer->media->duration) {
- mafw_gst_renderer_update_source_duration(
- renderer,
- duration_seconds);
- }
- }
-
- worker->media.length_nanos = value;
- g_debug("media duration: %lld", worker->media.length_nanos);
-}
-
-static void _check_seekability(MafwGstRendererWorker *worker)
-{
- MafwGstRenderer *renderer = worker->owner;
- SeekabilityType seekable = SEEKABILITY_NO_SEEKABLE;
-
- if (worker->media.length_nanos != -1)
- {
- g_debug("source seekability %d", renderer->media->seekability);
-
- if (renderer->media->seekability != SEEKABILITY_NO_SEEKABLE) {
- g_debug("Quering GStreamer for seekability");
- GstQuery *seek_query;
- GstFormat format = GST_FORMAT_TIME;
- /* Query the seekability of the stream */
- seek_query = gst_query_new_seeking(format);
- if (gst_element_query(worker->pipeline, seek_query)) {
- gboolean renderer_seekable = FALSE;
- gst_query_parse_seeking(seek_query, NULL,
- &renderer_seekable,
- NULL, NULL);
- g_debug("GStreamer seekability %d",
- renderer_seekable);
- seekable = renderer_seekable ?
- SEEKABILITY_SEEKABLE :
- SEEKABILITY_NO_SEEKABLE;
- }
- gst_query_unref(seek_query);
- }
- }
-
- if (worker->media.seekable != seekable) {
- gboolean is_seekable = (seekable == SEEKABILITY_SEEKABLE);
-
- /* Add the seekability to the current metadata. */
- _current_metadata_add(worker, MAFW_METADATA_KEY_IS_SEEKABLE,
- G_TYPE_BOOLEAN, is_seekable);
-
- /* Emit. */
- mafw_renderer_emit_metadata_boolean(
- worker->owner, MAFW_METADATA_KEY_IS_SEEKABLE,
- is_seekable);
- }
-
- g_debug("media seekable: %d", seekable);
- worker->media.seekable = seekable;
-}
-
-static gboolean _query_duration_and_seekability_timeout(gpointer data)
-{
- MafwGstRendererWorker *worker = data;
-
- _check_duration(worker, -1);
- _check_seekability(worker);
-
- worker->duration_seek_timeout = 0;
-
- return FALSE;
-}
-
-/*
- * Called when the pipeline transitions into PAUSED state. It extracts more
- * information from Gst.
- */
-static void _finalize_startup(MafwGstRendererWorker *worker)
-{
- /* Check video caps */
- if (worker->media.has_visual_content) {
- GstPad *pad = GST_BASE_SINK_PAD(worker->vsink);
- GstCaps *caps = GST_PAD_CAPS(pad);
- if (caps && gst_caps_is_fixed(caps)) {
- GstStructure *structure;
- structure = gst_caps_get_structure(caps, 0);
- if (!_handle_video_info(worker, structure))
- return;
- }
- }
-
- /* Something might have gone wrong at this point already. */
- if (worker->is_error) {
- g_debug("Error occured during preroll");
- return;
- }
-
- /* Streaminfo might reveal the media to be unsupported. Therefore we
- * need to check the error again. */
- _parse_stream_info(worker);
- if (worker->is_error) {
- g_debug("Error occured. Leaving");
- return;
- }
-
- /* Check duration and seekability */
- if (worker->duration_seek_timeout != 0) {
- g_source_remove(worker->duration_seek_timeout);
- worker->duration_seek_timeout = 0;
- }
- _check_duration(worker, -1);
- _check_seekability(worker);
-}
-
-static void _add_duration_seek_query_timeout(MafwGstRendererWorker *worker)
-{
- if (worker->duration_seek_timeout != 0) {
- g_source_remove(worker->duration_seek_timeout);
- }
- worker->duration_seek_timeout = g_timeout_add_seconds(
- MAFW_GST_RENDERER_WORKER_SECONDS_DURATION_AND_SEEKABILITY,
- _query_duration_and_seekability_timeout,
- worker);
-}
-
-static void _do_pause_postprocessing(MafwGstRendererWorker *worker)
-{
- if (worker->notify_pause_handler) {
- worker->notify_pause_handler(worker, worker->owner);
- }
-
-#ifdef HAVE_GDKPIXBUF
- if (worker->media.has_visual_content &&
- worker->current_frame_on_pause) {
- GstBuffer *buffer = NULL;
-
- g_object_get(worker->pipeline, "frame", &buffer, NULL);
-
- if (buffer != NULL) {
- _emit_gst_buffer_as_graphic_file(
- worker, buffer,
- MAFW_METADATA_KEY_PAUSED_THUMBNAIL_URI);
- }
- }
-#endif
-
- _add_ready_timeout(worker);
-}
-
-static void _report_playing_state(MafwGstRendererWorker * worker)
-{
- if (worker->report_statechanges) {
- switch (worker->mode) {
- case WORKER_MODE_SINGLE_PLAY:
- /* Notify play if we are playing in
- * single mode */
- if (worker->notify_play_handler)
- worker->notify_play_handler(
- worker,
- worker->owner);
- break;
- case WORKER_MODE_PLAYLIST:
- case WORKER_MODE_REDUNDANT:
- /* Only notify play when the "playlist"
- playback starts, don't notify play for each
- individual element of the playlist. */
- if (worker->pl.notify_play_pending) {
- if (worker->notify_play_handler)
- worker->notify_play_handler(
- worker,
- worker->owner);
- worker->pl.notify_play_pending = FALSE;
- }
- break;
- default: break;
- }
- }
-}
-
-static void _handle_state_changed(GstMessage *msg, MafwGstRendererWorker *worker)
-{
- GstState newstate, oldstate;
- GstStateChange statetrans;
- MafwGstRenderer *renderer = (MafwGstRenderer*)worker->owner;
-
- gst_message_parse_state_changed(msg, &oldstate, &newstate, NULL);
- statetrans = GST_STATE_TRANSITION(oldstate, newstate);
- g_debug ("State changed: %d: %d -> %d", worker->state, oldstate, newstate);
-
- /* If the state is the same we do nothing, otherwise, we keep
- * it */
- if (worker->state == newstate) {
- return;
- } else {
- worker->state = newstate;
- }
-
- if (statetrans == GST_STATE_CHANGE_READY_TO_PAUSED &&
- worker->in_ready) {
- /* Woken up from READY, resume stream position and playback */
- g_debug("State changed to pause after ready");
- if (worker->seek_position > 0) {
- _check_seekability(worker);
- if (worker->media.seekable) {
- g_debug("performing a seek");
- _do_seek(worker, GST_SEEK_TYPE_SET,
- worker->seek_position, NULL);
- } else {
- g_critical("media is not seekable (and should)");
- }
- }
-
- /* If playing a stream wait for buffering to finish before
- starting to play */
- if (!worker->is_stream || worker->is_live) {
- _do_play(worker);
- }
- return;
- }
-
- /* While buffering, we have to wait in PAUSED
- until we reach 100% before doing anything */
- if (worker->buffering) {
- if (statetrans == GST_STATE_CHANGE_PAUSED_TO_PLAYING) {
- /* Mmm... probably the client issued a seek on the
- * stream and then a play/resume command right away,
- * so the stream got into PLAYING state while
- * buffering. When the next buffering signal arrives,
- * the stream will be PAUSED silently and resumed when
- * buffering is done (silently too), so let's signal
- * the state change to PLAYING here. */
- _report_playing_state(worker);
- }
- return;
- }
-
- switch (statetrans) {
- case GST_STATE_CHANGE_READY_TO_PAUSED:
- if (worker->prerolling && worker->report_statechanges) {
- /* PAUSED after pipeline has been
- * constructed. We check caps, seek and
- * duration and if staying in pause is needed,
- * we perform operations for pausing, such as
- * current frame on pause and signalling state
- * change and adding the timeout to go to ready */
- g_debug ("Prerolling done, finalizaing startup");
- _finalize_startup(worker);
- _do_play(worker);
- renderer->play_failed_count = 0;
-
- if (worker->stay_paused) {
- _do_pause_postprocessing(worker);
- }
- worker->prerolling = FALSE;
- }
- break;
- case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
- /* When pausing we do the stuff, like signalling
- * state, current frame on pause and timeout to go to
- * ready */
- if (worker->report_statechanges) {
- _do_pause_postprocessing(worker);
- }
- break;
- case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
- /* if seek was called, at this point it is really ended */
- worker->seek_position = -1;
- worker->eos = FALSE;
-
- /* Signal state change if needed */
- _report_playing_state(worker);
-
- /* Prevent blanking if we are playing video */
- if (worker->media.has_visual_content) {
- blanking_prohibit();
- }
- keypadlocking_prohibit();
- /* Remove the ready timeout if we are playing [again] */
- _remove_ready_timeout(worker);
- /* If mode is redundant we are trying to play one of several
- * candidates, so when we get a successful playback, we notify
- * the real URI that we are playing */
- if (worker->mode == WORKER_MODE_REDUNDANT) {
- mafw_renderer_emit_metadata_string(
- worker->owner,
- MAFW_METADATA_KEY_URI,
- worker->media.location);
- }
-
- /* Emit metadata. We wait until we reach the playing
- state because this speeds up playback start time */
- _emit_metadatas(worker);
- /* Query duration and seekability. Useful for vbr
- * clips or streams. */
- _add_duration_seek_query_timeout(worker);
- break;
- case GST_STATE_CHANGE_PAUSED_TO_READY:
- /* If we went to READY, we free the taglist and
- * deassign the timout it */
- if (worker->in_ready) {
- g_debug("changed to GST_STATE_READY");
- _free_taglist(worker);
- }
- break;
- default:
- break;
- }
-}
-
-static void _handle_duration(MafwGstRendererWorker *worker, GstMessage *msg)
-{
- GstFormat fmt;
- gint64 duration;
-
- gst_message_parse_duration(msg, &fmt, &duration);
-
- if (worker->duration_seek_timeout != 0) {
- g_source_remove(worker->duration_seek_timeout);
- worker->duration_seek_timeout = 0;
- }
-
- _check_duration(worker,
- duration != GST_CLOCK_TIME_NONE ? duration : -1);
- _check_seekability(worker);
-}
-
-#ifdef HAVE_GDKPIXBUF
-static void _emit_renderer_art(MafwGstRendererWorker *worker,
- const GstTagList *list)
-{
- GstBuffer *buffer = NULL;
- const GValue *value = NULL;
-
- g_return_if_fail(gst_tag_list_get_tag_size(list, GST_TAG_IMAGE) > 0);
-
- value = gst_tag_list_get_value_index(list, GST_TAG_IMAGE, 0);
-
- g_return_if_fail((value != NULL) && G_VALUE_HOLDS(value, GST_TYPE_BUFFER));
-
- buffer = g_value_peek_pointer(value);
-
- g_return_if_fail((buffer != NULL) && GST_IS_BUFFER(buffer));
-
- _emit_gst_buffer_as_graphic_file(worker, buffer,
- MAFW_METADATA_KEY_RENDERER_ART_URI);
-}
-#endif
-
-static GHashTable* _build_tagmap(void)
-{
- GHashTable *hash_table = NULL;
-
- hash_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
- g_free);
-
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_TITLE),
- g_strdup(MAFW_METADATA_KEY_TITLE));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_ARTIST),
- g_strdup(MAFW_METADATA_KEY_ARTIST));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_AUDIO_CODEC),
- g_strdup(MAFW_METADATA_KEY_AUDIO_CODEC));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_VIDEO_CODEC),
- g_strdup(MAFW_METADATA_KEY_VIDEO_CODEC));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_BITRATE),
- g_strdup(MAFW_METADATA_KEY_BITRATE));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_LANGUAGE_CODE),
- g_strdup(MAFW_METADATA_KEY_ENCODING));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_ALBUM),
- g_strdup(MAFW_METADATA_KEY_ALBUM));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_GENRE),
- g_strdup(MAFW_METADATA_KEY_GENRE));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_TRACK_NUMBER),
- g_strdup(MAFW_METADATA_KEY_TRACK));
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_ORGANIZATION),
- g_strdup(MAFW_METADATA_KEY_ORGANIZATION));
-#ifdef HAVE_GDKPIXBUF
- g_hash_table_insert(hash_table, g_strdup(GST_TAG_IMAGE),
- g_strdup(MAFW_METADATA_KEY_RENDERER_ART_URI));
-#endif
-
- return hash_table;
-}
-
-/*
- * Emits metadata-changed signals for gst tags.
- */
-static void _emit_tag(const GstTagList *list, const gchar *tag,
- MafwGstRendererWorker *worker)
-{
- /* Mapping between Gst <-> MAFW metadata tags
- * NOTE: This assumes that GTypes matches between GST and MAFW. */
- static GHashTable *tagmap = NULL;
- gint i, count;
- const gchar *mafwtag;
- GType type;
- GValueArray *values;
-
- if (tagmap == NULL) {
- tagmap = _build_tagmap();
- }
-
- g_debug("tag: '%s' (type: %s)", tag,
- g_type_name(gst_tag_get_type(tag)));
- /* Is there a mapping for this tag? */
- mafwtag = g_hash_table_lookup(tagmap, tag);
- if (!mafwtag)
- return;
-
-#ifdef HAVE_GDKPIXBUF
- if (strcmp (mafwtag, MAFW_METADATA_KEY_RENDERER_ART_URI) == 0) {
- _emit_renderer_art(worker, list);
- return;
- }
-#endif
-
- /* Build a value array of this tag. We need to make sure that strings
- * are UTF-8. GstTagList API says that the value is always UTF8, but it
- * looks like the ID3 demuxer still might sometimes produce non-UTF-8
- * strings. */
- count = gst_tag_list_get_tag_size(list, tag);
- type = gst_tag_get_type(tag);
- values = g_value_array_new(count);
- for (i = 0; i < count; ++i) {
- GValue *v = (GValue *)
- gst_tag_list_get_value_index(list, tag, i);
- if (type == G_TYPE_STRING) {
- gchar *orig, *utf8;
-
- gst_tag_list_get_string_index(list, tag, i, &orig);
- if (convert_utf8(orig, &utf8)) {
- GValue utf8gval = {0};
-
- g_value_init(&utf8gval, G_TYPE_STRING);
- g_value_take_string(&utf8gval, utf8);
- _current_metadata_add(worker, mafwtag, G_TYPE_STRING,
- utf8);
- g_value_array_append(values, &utf8gval);
- g_value_unset(&utf8gval);
- }
- g_free(orig);
- } else if (type == G_TYPE_UINT) {
- GValue intgval = {0};
- gint intval;
-
- g_value_init(&intgval, G_TYPE_INT);
- g_value_transform(v, &intgval);
- intval = g_value_get_int(&intgval);
- _current_metadata_add(worker, mafwtag, G_TYPE_INT,
- intval);
- g_value_array_append(values, &intgval);
- g_value_unset(&intgval);
- } else {
- _current_metadata_add(worker, mafwtag, G_TYPE_VALUE,
- v);
- g_value_array_append(values, v);
- }
- }
-
- /* Emit the metadata. */
- g_signal_emit_by_name(worker->owner, "metadata-changed", mafwtag,
- values);
-
- g_value_array_free(values);
-}
-
-/**
- * Collect tag-messages, parse it later, when playing is ongoing
- */
-static void _handle_tag(MafwGstRendererWorker *worker, GstMessage *msg)
-{
- /* Do not emit metadata until we get to PLAYING state to speed up
- playback start */
- if (worker->tag_list == NULL)
- worker->tag_list = g_ptr_array_new();
- g_ptr_array_add(worker->tag_list, gst_message_ref(msg));
-
- /* Some tags come in playing state, so in this case we have
- to emit them right away (example: radio stations) */
- if (worker->state == GST_STATE_PLAYING) {
- _emit_metadatas(worker);
- }
-}
-
-/**
- * Parses the list of tag-messages
- */
-static void _parse_tagmsg(GstMessage *msg, MafwGstRendererWorker *worker)
-{
- GstTagList *new_tags;
-
- gst_message_parse_tag(msg, &new_tags);
- gst_tag_list_foreach(new_tags, (gpointer)_emit_tag, worker);
- gst_tag_list_free(new_tags);
- gst_message_unref(msg);
-}
-
-/**
- * Parses the collected tag messages, and emits the metadatas
- */
-static void _emit_metadatas(MafwGstRendererWorker *worker)
-{
- if (worker->tag_list != NULL)
- {
- g_ptr_array_foreach(worker->tag_list, (GFunc)_parse_tagmsg,
- worker);
- g_ptr_array_free(worker->tag_list, TRUE);
- worker->tag_list = NULL;
- }
-}
-
-static void _reset_volume_and_mute_to_pipeline(MafwGstRendererWorker *worker)
-{
-#ifdef MAFW_GST_RENDERER_DISABLE_PULSE_VOLUME
- g_debug("resetting volume and mute to pipeline");
-
- if (worker->pipeline != NULL) {
- g_object_set(
- G_OBJECT(worker->pipeline), "volume",
- mafw_gst_renderer_worker_volume_get(worker->wvolume),
- "mute",
- mafw_gst_renderer_worker_volume_is_muted(worker->wvolume),
- NULL);
- }
-#endif
-}
-
-static void _handle_buffering(MafwGstRendererWorker *worker, GstMessage *msg)
-{
- gint percent;
- MafwGstRenderer *renderer = (MafwGstRenderer*)worker->owner;
-
- gst_message_parse_buffering(msg, &percent);
- g_debug("buffering: %d", percent);
-
- /* No state management needed for live pipelines */
- if (!worker->is_live) {
- worker->buffering = TRUE;
- if (percent < 100 && worker->state == GST_STATE_PLAYING) {
- g_debug("setting pipeline to PAUSED not to wolf the "
- "buffer down");
- worker->report_statechanges = FALSE;
- /* We can't call _pause() here, since it sets
- * the "report_statechanges" to TRUE. We don't
- * want that, application doesn't need to know
- * that internally the state changed to
- * PAUSED. */
- if (gst_element_set_state(worker->pipeline,
- GST_STATE_PAUSED) ==
- GST_STATE_CHANGE_ASYNC)
- {
- /* XXX this blocks at most 2 seconds. */
- gst_element_get_state(worker->pipeline, NULL,
- NULL,
- 2 * GST_SECOND);
- }
- }
-
- if (percent >= 100) {
- /* On buffering we go to PAUSED, so here we move back to
- PLAYING */
- worker->buffering = FALSE;
- if (worker->state == GST_STATE_PAUSED) {
- /* If buffering more than once, do this only the
- first time we are done with buffering */
- if (worker->prerolling) {
- g_debug("buffering concluded during "
- "prerolling");
- _finalize_startup(worker);
- _do_play(worker);
- renderer->play_failed_count = 0;
- /* Send the paused notification */
- if (worker->stay_paused &&
- worker->notify_pause_handler) {
- worker->notify_pause_handler(
- worker,
- worker->owner);
- }
- worker->prerolling = FALSE;
- } else if (worker->in_ready) {
- /* If we had been woken up from READY
- and we have finish our buffering,
- check if we have to play or stay
- paused and if we have to play,
- signal the state change. */
- g_debug("buffering concluded, "
- "continuing playing");
- _do_play(worker);
- } else if (!worker->stay_paused) {
- /* This means, that we were playing but
- ran out of buffer, so we silently
- paused waited for buffering to
- finish and now we continue silently
- (silently meaning we do not expose
- state changes) */
- g_debug("buffering concluded, setting "
- "pipeline to PLAYING again");
- _reset_volume_and_mute_to_pipeline(
- worker);
- if (gst_element_set_state(
- worker->pipeline,
- GST_STATE_PLAYING) ==
- GST_STATE_CHANGE_ASYNC)
- {
- /* XXX this blocks at most 2 seconds. */
- gst_element_get_state(
- worker->pipeline, NULL, NULL,
- 2 * GST_SECOND);
- }
- }
- } else if (worker->state == GST_STATE_PLAYING) {
- g_debug("buffering concluded, signalling "
- "state change");
- /* In this case we got a PLAY command while
- buffering, likely because it was issued
- before we got the first buffering signal.
- The UI should not do this, but if it does,
- we have to signal that we have executed
- the state change, since in
- _handle_state_changed we do not do anything
- if we are buffering */
-
- /* Set the pipeline to playing. This is an async
- handler, it could be, that the reported state
- is not the real-current state */
- if (gst_element_set_state(
- worker->pipeline,
- GST_STATE_PLAYING) ==
- GST_STATE_CHANGE_ASYNC)
- {
- /* XXX this blocks at most 2 seconds. */
- gst_element_get_state(
- worker->pipeline, NULL, NULL,
- 2 * GST_SECOND);
- }
- if (worker->report_statechanges &&
- worker->notify_play_handler) {
- worker->notify_play_handler(
- worker,
- worker->owner);
- }
- _add_duration_seek_query_timeout(worker);
- }
- }
- }
-
- /* Send buffer percentage */
- if (worker->notify_buffer_status_handler)
- worker->notify_buffer_status_handler(worker, worker->owner,
- percent);
-}
-
-static void _handle_element_msg(MafwGstRendererWorker *worker, GstMessage *msg)
-{
- /* Only HelixBin sends "resolution" messages. */
- if (gst_structure_has_name(msg->structure, "resolution") &&
- _handle_video_info(worker, msg->structure))
- {
- worker->media.has_visual_content = TRUE;
- }
-}
-
-static void _reset_pl_info(MafwGstRendererWorker *worker)
-{
- if (worker->pl.items) {
- g_slist_foreach(worker->pl.items, (GFunc) g_free, NULL);
- g_slist_free(worker->pl.items);
- worker->pl.items = NULL;
- }
-
- worker->pl.current = 0;
- worker->pl.notify_play_pending = TRUE;
-}
-
-static GError * _get_specific_missing_plugin_error(GstMessage *msg)
-{
- const GstStructure *gst_struct;
- const gchar *type;
-
- GError *error;
- gchar *desc;
-
- desc = gst_missing_plugin_message_get_description(msg);
-
- gst_struct = gst_message_get_structure(msg);
- type = gst_structure_get_string(gst_struct, "type");
-
- if ((type) && ((strcmp(type, MAFW_GST_MISSING_TYPE_DECODER) == 0) ||
- (strcmp(type, MAFW_GST_MISSING_TYPE_ENCODER) == 0))) {
-
- /* Missing codec error. */
- const GValue *val;
- const GstCaps *caps;
- GstStructure *caps_struct;
- const gchar *mime;
-
- val = gst_structure_get_value(gst_struct, "detail");
- caps = gst_value_get_caps(val);
- caps_struct = gst_caps_get_structure(caps, 0);
- mime = gst_structure_get_name(caps_struct);
-
- if (g_strrstr(mime, "video")) {
- error = g_error_new_literal(
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_VIDEO_CODEC_NOT_FOUND,
- desc);
- } else if (g_strrstr(mime, "audio")) {
- error = g_error_new_literal(
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_AUDIO_CODEC_NOT_FOUND,
- desc);
- } else {
- error = g_error_new_literal(
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_CODEC_NOT_FOUND,
- desc);
- }
- } else {
- /* Unsupported type error. */
- error = g_error_new(
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_UNSUPPORTED_TYPE,
- "missing plugin: %s", desc);
- }
-
- g_free(desc);
-
- return error;
-}
-
-/*
- * Asynchronous message handler. It gets removed from if it returns FALSE.
- */
-static gboolean _async_bus_handler(GstBus *bus, GstMessage *msg,
- MafwGstRendererWorker *worker)
-{
- /* No need to handle message if error has already occured. */
- if (worker->is_error)
- return TRUE;
-
- /* Handle missing-plugin (element) messages separately, relaying more
- * details. */
- if (gst_is_missing_plugin_message(msg)) {
- GError *err = _get_specific_missing_plugin_error(msg);
- /* FIXME?: for some reason, calling the error handler directly
- * (_send_error) causes problems. On the other hand, turning
- * the error into a new GstMessage and letting the next
- * iteration handle it seems to work. */
- _post_error(worker, err);
- return TRUE;
- }
-
- switch (GST_MESSAGE_TYPE(msg)) {
- case GST_MESSAGE_ERROR:
- if (!worker->is_error) {
- gchar *debug;
- GError *err;
-
- debug = NULL;
- gst_message_parse_error(msg, &err, &debug);
- g_debug("gst error: domain = %d, code = %d, "
- "message = '%s', debug = '%s'",
- err->domain, err->code, err->message, debug);
- if (debug)
- g_free(debug);
-
- /* If we are in playlist/radio mode, we silently
- ignore the error and continue with the next
- item until we end the playlist. If no
- playable elements we raise the error and
- after finishing we go to normal mode */
-
- if (worker->mode == WORKER_MODE_PLAYLIST ||
- worker->mode == WORKER_MODE_REDUNDANT) {
- if (worker->pl.current <
- (g_slist_length(worker->pl.items) - 1)) {
- /* If the error is "no space left"
- notify, otherwise try to play the
- next item */
- if (err->code ==
- GST_RESOURCE_ERROR_NO_SPACE_LEFT) {
- _send_error(worker, err);
-
- } else {
- _play_pl_next(worker);
- }
- } else {
- /* Playlist EOS. We cannot try another
- * URI, so we have to go back to normal
- * mode and signal the error (done
- * below) */
- worker->mode = WORKER_MODE_SINGLE_PLAY;
- _reset_pl_info(worker);
- }
- }
-
- if (worker->mode == WORKER_MODE_SINGLE_PLAY) {
- if (err->domain == GST_STREAM_ERROR &&
- err->code == GST_STREAM_ERROR_WRONG_TYPE)
- {/* Maybe it is a playlist? */
- GSList *plitems = _parse_playlist(worker->media.location);
-
- if (plitems)
- {/* Yes, it is a plitem */
- g_error_free(err);
- mafw_gst_renderer_worker_play(worker, NULL, plitems);
- break;
- }
-
-
- }
- _send_error(worker, err);
- }
- }
- break;
- case GST_MESSAGE_EOS:
- if (!worker->is_error) {
- worker->eos = TRUE;
-
- if (worker->mode == WORKER_MODE_PLAYLIST) {
- if (worker->pl.current <
- (g_slist_length(worker->pl.items) - 1)) {
- /* If the playlist EOS is not reached
- continue playing */
- _play_pl_next(worker);
- } else {
- /* Playlist EOS, go back to normal
- mode */
- worker->mode = WORKER_MODE_SINGLE_PLAY;
- _reset_pl_info(worker);
- }
- }
-
- if (worker->mode == WORKER_MODE_SINGLE_PLAY ||
- worker->mode == WORKER_MODE_REDUNDANT) {
- if (worker->notify_eos_handler)
- worker->notify_eos_handler(
- worker,
- worker->owner);
-
- /* We can remove the message handlers now, we
- are not interested in bus messages
- anymore. */
- if (worker->bus) {
- gst_bus_set_sync_handler(worker->bus,
- NULL,
- NULL);
- }
- if (worker->async_bus_id) {
- g_source_remove(worker->async_bus_id);
- worker->async_bus_id = 0;
- }
-
- if (worker->mode == WORKER_MODE_REDUNDANT) {
- /* Go to normal mode */
- worker->mode = WORKER_MODE_SINGLE_PLAY;
- _reset_pl_info(worker);
- }
- }
- }
- break;
- case GST_MESSAGE_TAG:
- _handle_tag(worker, msg);
- break;
- case GST_MESSAGE_BUFFERING:
- _handle_buffering(worker, msg);
- break;
- case GST_MESSAGE_DURATION:
- _handle_duration(worker, msg);
- break;
- case GST_MESSAGE_ELEMENT:
- _handle_element_msg(worker, msg);
- break;
- case GST_MESSAGE_STATE_CHANGED:
- if ((GstElement *)GST_MESSAGE_SRC(msg) == worker->pipeline)
- _handle_state_changed(msg, worker);
- break;
- case GST_MESSAGE_APPLICATION:
- if (gst_structure_has_name(gst_message_get_structure(msg),
- "ckey"))
- {
- GValue v = {0};
- g_value_init(&v, G_TYPE_INT);
- g_value_set_int(&v, worker->colorkey);
- mafw_extension_emit_property_changed(
- MAFW_EXTENSION(worker->owner),
- MAFW_PROPERTY_RENDERER_COLORKEY,
- &v);
- }
- default: break;
- }
- return TRUE;
-}
-
-/* NOTE this function will possibly be called from a different thread than the
- * glib main thread. */
-static void _stream_info_cb(GstObject *pipeline, GParamSpec *unused,
- MafwGstRendererWorker *worker)
-{
- g_debug("stream-info changed");
- _parse_stream_info(worker);
-}
-
-static void _volume_cb(MafwGstRendererWorkerVolume *wvolume, gdouble volume,
- gpointer data)
-{
- MafwGstRendererWorker *worker = data;
- GValue value = {0, };
-
- _reset_volume_and_mute_to_pipeline(worker);
-
- g_value_init(&value, G_TYPE_UINT);
- g_value_set_uint(&value, (guint) (volume * 100.0));
- mafw_extension_emit_property_changed(MAFW_EXTENSION(worker->owner),
- MAFW_PROPERTY_RENDERER_VOLUME,
- &value);
-}
-
-#ifdef MAFW_GST_RENDERER_ENABLE_MUTE
-
-static void _mute_cb(MafwGstRendererWorkerVolume *wvolume, gboolean mute,
- gpointer data)
-{
- MafwGstRendererWorker *worker = data;
- GValue value = {0, };
-
- _reset_volume_and_mute_to_pipeline(worker);
-
- g_value_init(&value, G_TYPE_BOOLEAN);
- g_value_set_boolean(&value, mute);
- mafw_extension_emit_property_changed(MAFW_EXTENSION(worker->owner),
- MAFW_PROPERTY_RENDERER_MUTE,
- &value);
-}
-
-#endif
-
-/* TODO: I think it's not enought to act on error, we need to handle
- * DestroyNotify on the given window ourselves, because for example helixbin
- * does it and silently stops the decoder thread. But it doesn't notify
- * us... */
-static int xerror(Display *dpy, XErrorEvent *xev)
-{
- MafwGstRendererWorker *worker;
-
- if (Global_worker == NULL) {
- return -1;
- } else {
- worker = Global_worker;
- }
-
- /* Swallow BadWindow and stop pipeline when the error is about the
- * currently set xid. */
- if (worker->xid &&
- xev->resourceid == worker->xid &&
- xev->error_code == BadWindow)
- {
- g_warning("BadWindow received for current xid (%x).",
- (gint)xev->resourceid);
- worker->xid = 0;
- /* We must post a message to the bus, because this function is
- * invoked from a different thread (xvimagerenderer's queue). */
- _post_error(worker, g_error_new_literal(
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_PLAYBACK,
- "Video window gone"));
- }
- return 0;
-}
-
-/*
- * Resets the media information.
- */
-static void _reset_media_info(MafwGstRendererWorker *worker)
-{
- if (worker->media.location) {
- g_free(worker->media.location);
- worker->media.location = NULL;
- }
- worker->media.length_nanos = -1;
- worker->media.has_visual_content = FALSE;
- worker->media.seekable = SEEKABILITY_UNKNOWN;
- worker->media.video_width = 0;
- worker->media.video_height = 0;
- worker->media.fps = 0.0;
-}
-
-static void _set_volume_and_mute(MafwGstRendererWorker *worker, gdouble vol,
- gboolean mute)
-{
- g_return_if_fail(worker->wvolume != NULL);
-
- mafw_gst_renderer_worker_volume_set(worker->wvolume, vol, mute);
-}
-
-static void _set_volume(MafwGstRendererWorker *worker, gdouble new_vol)
-{
- g_return_if_fail(worker->wvolume != NULL);
-
- _set_volume_and_mute(
- worker, new_vol,
- mafw_gst_renderer_worker_volume_is_muted(worker->wvolume));
-}
-
-static void _set_mute(MafwGstRendererWorker *worker, gboolean mute)
-{
- g_return_if_fail(worker->wvolume != NULL);
-
- _set_volume_and_mute(
- worker, mafw_gst_renderer_worker_volume_get(worker->wvolume),
- mute);
-}
-
-/*
- * Start to play the media
- */
-static void _start_play(MafwGstRendererWorker *worker)
-{
- MafwGstRenderer *renderer = (MafwGstRenderer*) worker->owner;
- GstStateChangeReturn state_change_info;
- char *autoload_sub = NULL;
-
- g_assert(worker->pipeline);
- g_object_set(G_OBJECT(worker->pipeline),
- "uri", worker->media.location, NULL);
-
- if (worker->subtitles.enabled) {
- autoload_sub = uri_get_subtitle_uri(worker->media.location);
- if (autoload_sub) {
- g_debug("SUBURI: %s", autoload_sub);
- g_object_set(G_OBJECT(worker->pipeline),
- "suburi", autoload_sub,
- "subtitle-font-desc", worker->subtitles.font,
- "subtitle-encoding", worker->subtitles.encoding,
- NULL);
-
- gst_element_set_state(worker->pipeline, GST_STATE_READY);
- g_free(autoload_sub);
- }
- } else {
- g_object_set(G_OBJECT(worker->pipeline), "suburi", NULL, NULL);
- }
-
- g_debug("URI: %s", worker->media.location);
- g_debug("setting pipeline to PAUSED");
-
- worker->report_statechanges = TRUE;
- state_change_info = gst_element_set_state(worker->pipeline,
- GST_STATE_PAUSED);
- if (state_change_info == GST_STATE_CHANGE_NO_PREROLL) {
- /* FIXME: for live sources we may have to handle
- buffering and prerolling differently */
- g_debug ("Source is live!");
- worker->is_live = TRUE;
- }
- worker->prerolling = TRUE;
-
- worker->is_stream = uri_is_stream(worker->media.location);
-
- if (renderer->update_playcount_id > 0) {
- g_source_remove(renderer->update_playcount_id);
- renderer->update_playcount_id = 0;
- }
-
-}
-
-/*
- * Constructs gst pipeline
- *
- * FIXME: Could the same pipeline be used for playing all media instead of
- * constantly deleting and reconstructing it again?
- */
-static void _construct_pipeline(MafwGstRendererWorker *worker)
-{
- g_debug("constructing pipeline");
- g_assert(worker != NULL);
-
- /* Return if we have already one */
- if (worker->pipeline)
- return;
-
- _free_taglist(worker);
-
- g_debug("Creating a new instance of playbin2");
- worker->pipeline = gst_element_factory_make("playbin2",
- "playbin");
- if (worker->pipeline == NULL)
- {
- /* Let's try with playbin */
- g_warning ("playbin2 failed, falling back to playbin");
- worker->pipeline = gst_element_factory_make("playbin",
- "playbin");
-
- if (worker->pipeline) {
- /* Use nwqueue only for non-rtsp and non-mms(h)
- streams. */
- gboolean use_nw;
- use_nw = worker->media.location &&
- !g_str_has_prefix(worker->media.location,
- "rtsp://") &&
- !g_str_has_prefix(worker->media.location,
- "mms://") &&
- !g_str_has_prefix(worker->media.location,
- "mmsh://");
-
- g_debug("playbin using network queue: %d", use_nw);
-
- /* These need a modified version of playbin. */
- g_object_set(G_OBJECT(worker->pipeline),
- "nw-queue", use_nw,
- "no-video-transform", TRUE,
- NULL);
- }
- }
-
- if (!worker->pipeline) {
- g_critical("failed to create playback pipeline");
- g_signal_emit_by_name(MAFW_EXTENSION (worker->owner),
- "error",
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_UNABLE_TO_PERFORM,
- "Could not create pipeline");
- g_assert_not_reached();
- }
-
-
- worker->bus = gst_pipeline_get_bus(GST_PIPELINE(worker->pipeline));
- gst_bus_set_sync_handler(worker->bus,
- (GstBusSyncHandler)_sync_bus_handler, worker);
- worker->async_bus_id = gst_bus_add_watch_full(worker->bus,G_PRIORITY_HIGH,
- (GstBusFunc)_async_bus_handler,
- worker, NULL);
-
- /* Listen for changes in stream-info object to find out whether the
- * media contains video and throw error if application has not provided
- * video window. */
- g_signal_connect(worker->pipeline, "notify::stream-info",
- G_CALLBACK(_stream_info_cb), worker);
-
-#ifndef MAFW_GST_RENDERER_DISABLE_PULSE_VOLUME
-
-
- /* Set audio and video sinks ourselves. We create and configure
- them only once. */
- if (!worker->asink) {
- worker->asink = gst_element_factory_make("pulsesink", NULL);
- if (!worker->asink) {
- g_critical("Failed to create pipeline audio sink");
- g_signal_emit_by_name(MAFW_EXTENSION (worker->owner),
- "error",
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_UNABLE_TO_PERFORM,
- "Could not create audio sink");
- g_assert_not_reached();
- }
- gst_object_ref(worker->asink);
- g_object_set(worker->asink,
- "buffer-time", (gint64) MAFW_GST_BUFFER_TIME,
- "latency-time", (gint64) MAFW_GST_LATENCY_TIME,
- NULL);
- }
- g_object_set(worker->pipeline, "audio-sink", worker->asink, NULL);
-#endif
-
- if (!worker->vsink) {
- worker->vsink = gst_element_factory_make("xvimagesink", NULL);
- if (!worker->vsink) {
- g_critical("Failed to create pipeline video sink");
- g_signal_emit_by_name(MAFW_EXTENSION (worker->owner),
- "error",
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_UNABLE_TO_PERFORM,
- "Could not create video sink");
- g_assert_not_reached();
- }
- gst_object_ref(worker->vsink);
- g_object_set(G_OBJECT(worker->vsink),
- "handle-events", TRUE,
- "force-aspect-ratio", TRUE,
- NULL);
- }
- g_object_set(worker->pipeline,
- "video-sink", worker->vsink,
- "flags", 103,
- NULL);
-
- if (!worker->tsink) {
- worker->tsink = gst_element_factory_make("textoverlay", NULL);
- if (!worker->tsink) {
- g_critical("Failed to create pipeline text sink");
- g_signal_emit_by_name(MAFW_EXTENSION (worker->owner),
- "error",
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_UNABLE_TO_PERFORM,
- "Could not create text sink");
- g_assert_not_reached();
- }
- gst_object_ref(worker->tsink);
- }
- g_object_set(worker->pipeline, "text-sink", worker->tsink, NULL);
-}
-
-/*
- * @seek_type: GstSeekType
- * @position: Time in seconds where to seek
- */
-static void _do_seek(MafwGstRendererWorker *worker, GstSeekType seek_type,
- gint position, GError **error)
-{
- gboolean ret;
- gint64 spos;
-
- g_assert(worker != NULL);
-
- if (worker->eos || !worker->media.seekable)
- goto err;
-
- /* According to the docs, relative seeking is not so easy:
- GST_SEEK_TYPE_CUR - change relative to currently configured segment.
- This can't be used to seek relative to the current playback position -
- do a position query, calculate the desired position and then do an
- absolute position seek instead if that's what you want to do. */
- if (seek_type == GST_SEEK_TYPE_CUR)
- {
- gint curpos = mafw_gst_renderer_worker_get_position(worker);
- position = curpos + position;
- seek_type = GST_SEEK_TYPE_SET;
- }
-
- if (position < 0) {
- position = 0;
- }
-
- worker->seek_position = position;
- worker->report_statechanges = FALSE;
- spos = (gint64)position * GST_SECOND;
- g_debug("seek: type = %d, offset = %lld", seek_type, spos);
-
- /* If the pipeline has been set to READY by us, then wake it up by
- setting it to PAUSED (when we get the READY->PAUSED transition
- we will execute the seek). This way when we seek we disable the
- READY state (logical, since the player is not idle anymore)
- allowing the sink to render the destination frame in case of
- video playback */
- if (worker->in_ready && worker->state == GST_STATE_READY) {
- gst_element_set_state(worker->pipeline, GST_STATE_PAUSED);
- } else {
- ret = gst_element_seek(worker->pipeline, 1.0, GST_FORMAT_TIME,
- GST_SEEK_FLAG_FLUSH|GST_SEEK_FLAG_KEY_UNIT,
- seek_type, spos,
- GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
- if (!ret) {
- /* Seeking is async, so seek_position should not be
- invalidated here */
- goto err;
- }
- }
- return;
-
-err: g_set_error(error,
- MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_CANNOT_SET_POSITION,
- "Seeking to %d failed", position);
-}
-
-/* @vol should be between [0 .. 100], higher values (up to 1000) are allowed,
- * but probably cause distortion. */
-void mafw_gst_renderer_worker_set_volume(
- MafwGstRendererWorker *worker, guint volume)
-{
- _set_volume(worker, CLAMP((gdouble)volume / 100.0, 0.0, 1.0));
-}
-
-guint mafw_gst_renderer_worker_get_volume(
- MafwGstRendererWorker *worker)
-{
- return (guint)
- (mafw_gst_renderer_worker_volume_get(worker->wvolume) * 100);
-}
-
-void mafw_gst_renderer_worker_set_mute(MafwGstRendererWorker *worker,
- gboolean mute)
-{
- _set_mute(worker, mute);
-}
-
-gboolean mafw_gst_renderer_worker_get_mute(MafwGstRendererWorker *worker)
-{
- return mafw_gst_renderer_worker_volume_is_muted(worker->wvolume);
-}
-
-#ifdef HAVE_GDKPIXBUF
-void mafw_gst_renderer_worker_set_current_frame_on_pause(MafwGstRendererWorker *worker,
- gboolean current_frame_on_pause)
-{
- worker->current_frame_on_pause = current_frame_on_pause;
-}
-
-gboolean mafw_gst_renderer_worker_get_current_frame_on_pause(MafwGstRendererWorker *worker)
-{
- return worker->current_frame_on_pause;
-}
-#endif
-
-void mafw_gst_renderer_worker_set_position(MafwGstRendererWorker *worker,
- GstSeekType seek_type,
- gint position, GError **error)
-{
- /* If player is paused and we have a timeout for going to ready
- * restart it. This is logical, since the user is seeking and
- * thus, the player is not idle anymore. Also this prevents that
- * when seeking streams we enter buffering and in the middle of
- * the buffering process we set the pipeline to ready (which stops
- * the buffering before it reaches 100%, making the client think
- * buffering is still going on).
- */
- if (worker->ready_timeout) {
- _remove_ready_timeout(worker);
- _add_ready_timeout(worker);
- }
-
- _do_seek(worker, seek_type, position, error);
- if (worker->notify_seek_handler)
- worker->notify_seek_handler(worker, worker->owner);
-}
-
-/*
- * Gets current position, rounded down into precision of one second. If a seek
- * is pending, returns the position we are going to seek. Returns -1 on
- * failure.
- */
-gint mafw_gst_renderer_worker_get_position(MafwGstRendererWorker *worker)
-{
- GstFormat format;
- gint64 time = 0;
- g_assert(worker != NULL);
-
- /* If seek is ongoing, return the position where we are seeking. */
- if (worker->seek_position != -1)
- {
- return worker->seek_position;
- }
- /* Otherwise query position from pipeline. */
- format = GST_FORMAT_TIME;
- if (worker->pipeline &&
- gst_element_query_position(worker->pipeline, &format, &time))
- {
- return (gint)(NSECONDS_TO_SECONDS(time));
- }
- return -1;
-}
-
-GHashTable *mafw_gst_renderer_worker_get_current_metadata(
- MafwGstRendererWorker *worker)
-{
- return worker->current_metadata;
-}
-
-void mafw_gst_renderer_worker_set_xid(MafwGstRendererWorker *worker, XID xid)
-{
- /* Check for errors on the target window */
- XSetErrorHandler(xerror);
-
- /* Store the target window id */
- g_debug("Setting xid: %x", (guint)xid);
- worker->xid = xid;
-
- /* Check if we should use it right away */
- mafw_gst_renderer_worker_apply_xid(worker);
-}
-
-XID mafw_gst_renderer_worker_get_xid(MafwGstRendererWorker *worker)
-{
- return worker->xid;
-}
-
-gboolean mafw_gst_renderer_worker_get_autopaint(
- MafwGstRendererWorker *worker)
-{
- return worker->autopaint;
-}
-void mafw_gst_renderer_worker_set_autopaint(
- MafwGstRendererWorker *worker, gboolean autopaint)
-{
- worker->autopaint = autopaint;
- if (worker->vsink)
- g_object_set(worker->vsink, "autopaint-colorkey",
- worker->autopaint, NULL);
-}
-
-gint mafw_gst_renderer_worker_get_colorkey(
- MafwGstRendererWorker *worker)
-{
- return worker->colorkey;
-}
-
-void mafw_gst_renderer_worker_set_colorkey(
- MafwGstRendererWorker *worker, gint colorkey)
-{
- worker->colorkey = colorkey;
- if (worker->vsink)
- g_object_set(worker->vsink, "colorkey",
- worker->colorkey, NULL);
-}
-
-gboolean mafw_gst_renderer_worker_get_seekable(MafwGstRendererWorker *worker)
-{
- return worker->media.seekable;
-}
-
-static void _play_pl_next(MafwGstRendererWorker *worker) {
- gchar *next;
-
- g_assert(worker != NULL);
- g_return_if_fail(worker->pl.items != NULL);
-
- next = (gchar *) g_slist_nth_data(worker->pl.items,
- ++worker->pl.current);
- mafw_gst_renderer_worker_stop(worker);
- _reset_media_info(worker);
-
- worker->media.location = g_strdup(next);
- _construct_pipeline(worker);
- _start_play(worker);
-}
-
-static void _do_play(MafwGstRendererWorker *worker)
-{
- g_assert(worker != NULL);
-
- if (worker->pipeline == NULL) {
- g_debug("play without a pipeline!");
- return;
- }
- worker->report_statechanges = TRUE;
-
- /* If we have to stay paused, we do and add the ready
- * timeout. Otherwise, we move the pipeline */
- if (!worker->stay_paused) {
- /* If pipeline is READY, we move it to PAUSED,
- * otherwise, to PLAYING */
- if (worker->state == GST_STATE_READY) {
- gst_element_set_state(worker->pipeline,
- GST_STATE_PAUSED);
- g_debug("setting pipeline to PAUSED");
- } else {
- _reset_volume_and_mute_to_pipeline(worker);
- gst_element_set_state(worker->pipeline,
- GST_STATE_PLAYING);
- g_debug("setting pipeline to PLAYING");
- }
- }
- else {
- g_debug("staying in PAUSED state");
- _add_ready_timeout(worker);
- }
-}
-
-void mafw_gst_renderer_worker_play(MafwGstRendererWorker *worker,
- const gchar *uri, GSList *plitems)
-{
- g_assert(uri || plitems);
-
- mafw_gst_renderer_worker_stop(worker);
- _reset_media_info(worker);
- _reset_pl_info(worker);
- /* Check if the item to play is a single item or a playlist. */
- if (plitems || uri_is_playlist(uri)){
- gchar *item;
- /* In case of a playlist we parse it and start playing the first
- item of the playlist. */
- if (plitems)
- {
- worker->pl.items = plitems;
- }
- else
- {
- worker->pl.items = _parse_playlist(uri);
- }
- if (!worker->pl.items)
- {
- _send_error(worker,
- g_error_new(MAFW_RENDERER_ERROR,
- MAFW_RENDERER_ERROR_PLAYLIST_PARSING,
- "Playlist parsing failed: %s",
- uri));
- return;
- }
-
- /* Set the playback mode */
- worker->mode = WORKER_MODE_PLAYLIST;
- worker->pl.notify_play_pending = TRUE;
-
- /* Set the item to be played */
- worker->pl.current = 0;
- item = (gchar *) g_slist_nth_data(worker->pl.items, 0);
- worker->media.location = g_strdup(item);
- } else {
- /* Single item. Set the playback mode according to that */
- worker->mode = WORKER_MODE_SINGLE_PLAY;
-
- /* Set the item to be played */
- worker->media.location = g_strdup(uri);
- }
- _construct_pipeline(worker);
- _start_play(worker);
-}
-
-void mafw_gst_renderer_worker_play_alternatives(MafwGstRendererWorker *worker,
- gchar **uris)
-{
- gint i;
- gchar *item;
-
- g_assert(uris && uris[0]);
-
- mafw_gst_renderer_worker_stop(worker);
- _reset_media_info(worker);
- _reset_pl_info(worker);
-
- /* Add the uris to playlist */
- i = 0;
- while (uris[i]) {
- worker->pl.items =
- g_slist_append(worker->pl.items, g_strdup(uris[i]));
- i++;
- }
-
- /* Set the playback mode */
- worker->mode = WORKER_MODE_REDUNDANT;
- worker->pl.notify_play_pending = TRUE;
-
- /* Set the item to be played */
- worker->pl.current = 0;
- item = (gchar *) g_slist_nth_data(worker->pl.items, 0);
- worker->media.location = g_strdup(item);
-
- /* Start playing */
- _construct_pipeline(worker);
- _start_play(worker);
-}
-
-/*
- * Currently, stop destroys the Gst pipeline and resets the worker into
- * default startup configuration.
- */
-void mafw_gst_renderer_worker_stop(MafwGstRendererWorker *worker)
-{
- g_debug("worker stop");
- g_assert(worker != NULL);
-
- /* If location is NULL, this is a pre-created pipeline */
- if (worker->async_bus_id && worker->pipeline && !worker->media.location)
- return;
-
- if (worker->pipeline) {
- g_debug("destroying pipeline");
- if (worker->async_bus_id) {
- g_source_remove(worker->async_bus_id);
- worker->async_bus_id = 0;
- }
- gst_bus_set_sync_handler(worker->bus, NULL, NULL);
- gst_element_set_state(worker->pipeline, GST_STATE_NULL);
- if (worker->bus) {
- gst_object_unref(GST_OBJECT_CAST(worker->bus));
- worker->bus = NULL;
- }
- gst_object_unref(GST_OBJECT(worker->pipeline));
- worker->pipeline = NULL;
- }
-
- /* Reset worker */
- worker->report_statechanges = TRUE;
- worker->state = GST_STATE_NULL;
- worker->prerolling = FALSE;
- worker->is_live = FALSE;
- worker->buffering = FALSE;
- worker->is_stream = FALSE;
- worker->is_error = FALSE;
- worker->eos = FALSE;
- worker->seek_position = -1;
- _remove_ready_timeout(worker);
- _free_taglist(worker);
- if (worker->current_metadata) {
- g_hash_table_destroy(worker->current_metadata);
- worker->current_metadata = NULL;
- }
-
- if (worker->duration_seek_timeout != 0) {
- g_source_remove(worker->duration_seek_timeout);
- worker->duration_seek_timeout = 0;
- }
-
- /* Reset media iformation */
- _reset_media_info(worker);
-
- /* We are not playing, so we can let the screen blank */
- blanking_allow();
- keypadlocking_allow();
-
- /* And now get a fresh pipeline ready */
- _construct_pipeline(worker);
-}
-
-void mafw_gst_renderer_worker_pause(MafwGstRendererWorker *worker)
-{
- g_assert(worker != NULL);
-
- if (worker->buffering && worker->state == GST_STATE_PAUSED &&
- !worker->prerolling) {
- /* If we are buffering and get a pause, we have to
- * signal state change and stay_paused */
- g_debug("Pausing while buffering, signalling state change");
- worker->stay_paused = TRUE;
- if (worker->notify_pause_handler) {
- worker->notify_pause_handler(
- worker,
- worker->owner);
- }
- } else {
- worker->report_statechanges = TRUE;
-
- if (gst_element_set_state(worker->pipeline, GST_STATE_PAUSED) ==
- GST_STATE_CHANGE_ASYNC)
- {
- /* XXX this blocks at most 2 seconds. */
- gst_element_get_state(worker->pipeline, NULL, NULL,
- 2 * GST_SECOND);
- }
- blanking_allow();
- keypadlocking_allow();
- }
-}
-
-void mafw_gst_renderer_worker_resume(MafwGstRendererWorker *worker)
-{
- if (worker->mode == WORKER_MODE_PLAYLIST ||
- worker->mode == WORKER_MODE_REDUNDANT) {
- /* We must notify play if the "playlist" playback
- is resumed */
- worker->pl.notify_play_pending = TRUE;
- }
- if (worker->buffering && worker->state == GST_STATE_PAUSED &&
- !worker->prerolling) {
- /* If we are buffering we cannot resume, but we know
- * that the pipeline will be moved to PLAYING as
- * stay_paused is FALSE, so we just activate the state
- * change report, this way as soon as buffering is finished
- * the pipeline will be set to PLAYING and the state
- * change will be reported */
- worker->report_statechanges = TRUE;
- g_debug("Resumed while buffering, activating pipeline state "
- "changes");
- /* Notice though that we can receive the Resume before
- we get any buffering information. In that case
- we go with the "else" branch and set the pipeline to
- to PLAYING. However, it is possible that in this case
- we get the fist buffering signal before the
- PAUSED -> PLAYING state change. In that case, since we
- ignore state changes while buffering we never signal
- the state change to PLAYING. We can only fix this by
- checking, when we receive a PAUSED -> PLAYING transition
- if we are buffering, and in that case signal the state
- change (if we get that transition while buffering
- is on, it can only mean that the client resumed playback
- while buffering, and we must notify the state change) */
- } else {
- _do_play(worker);
- }
-}
-
-static void _volume_init_cb(MafwGstRendererWorkerVolume *wvolume,
- gpointer data)
-{
- MafwGstRendererWorker *worker = data;
- gdouble volume;
- gboolean mute;
-
- worker->wvolume = wvolume;
-
- g_debug("volume manager initialized");
-
- volume = mafw_gst_renderer_worker_volume_get(wvolume);
- mute = mafw_gst_renderer_worker_volume_is_muted(wvolume);
- _volume_cb(wvolume, volume, worker);
-#ifdef MAFW_GST_RENDERER_ENABLE_MUTE
- _mute_cb(wvolume, mute, worker);
-#endif
-}
-
-MafwGstRendererWorker *mafw_gst_renderer_worker_new(gpointer owner)
-{
- MafwGstRendererWorker *worker;
- GMainContext *main_context;
-
- worker = g_new0(MafwGstRendererWorker, 1);
- worker->mode = WORKER_MODE_SINGLE_PLAY;
- worker->pl.items = NULL;
- worker->pl.current = 0;
- worker->pl.notify_play_pending = TRUE;
- worker->owner = owner;
- worker->report_statechanges = TRUE;
- worker->state = GST_STATE_NULL;
- worker->seek_position = -1;
- worker->ready_timeout = 0;
- worker->in_ready = FALSE;
- worker->xid = 0;
- worker->autopaint = TRUE;
- worker->colorkey = -1;
- worker->vsink = NULL;
- worker->asink = NULL;
- worker->tsink = NULL;
- worker->tag_list = NULL;
- worker->current_metadata = NULL;
- worker->subtitles.enabled = FALSE;
- worker->subtitles.font = NULL;
- worker->subtitles.encoding = NULL;
-
-#ifdef HAVE_GDKPIXBUF
- worker->current_frame_on_pause = FALSE;
- _init_tmp_files_pool(worker);
-#endif
- worker->notify_seek_handler = NULL;
- worker->notify_pause_handler = NULL;
- worker->notify_play_handler = NULL;
- worker->notify_buffer_status_handler = NULL;
- worker->notify_eos_handler = NULL;
- worker->notify_error_handler = NULL;
- Global_worker = worker;
- main_context = g_main_context_default();
- worker->wvolume = NULL;
- mafw_gst_renderer_worker_volume_init(main_context,
- _volume_init_cb, worker,
- _volume_cb, worker,
-#ifdef MAFW_GST_RENDERER_ENABLE_MUTE
- _mute_cb,
-#else
- NULL,
-#endif
- worker);
- blanking_init();
- _construct_pipeline(worker);
-
- return worker;
-}
-
-void mafw_gst_renderer_worker_exit(MafwGstRendererWorker *worker)
-{
- blanking_deinit();
-#ifdef HAVE_GDKPIXBUF
- _destroy_tmp_files_pool(worker);
-#endif
- mafw_gst_renderer_worker_volume_destroy(worker->wvolume);
- mafw_gst_renderer_worker_stop(worker);
-}
-/* vi: set noexpandtab ts=8 sw=8 cino=t0,(0: */
projects / mafwsubrenderer / blobdiff