gstreamer/ges/ges-formatter.c

801 lines
21 KiB
C

/* GStreamer Editing Services
* Copyright (C) 2010 Brandon Lewis <brandon.lewis@collabora.co.uk>
* 2010 Nokia Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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.
*/
/**
* SECTION:gesformatter
* @title: GESFormatter
* @short_description: Timeline saving and loading.
*
**/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
#include <gio/gio.h>
#include <stdlib.h>
#include <string.h>
#include "ges-formatter.h"
#include "ges-internal.h"
#include "ges.h"
#ifndef DISABLE_XPTV
#include "ges-pitivi-formatter.h"
#endif
#ifdef HAS_PYTHON
#include <Python.h>
#include "ges-resources.h"
#endif
GST_DEBUG_CATEGORY_STATIC (ges_formatter_debug);
#undef GST_CAT_DEFAULT
#define GST_CAT_DEFAULT ges_formatter_debug
static gboolean initialized = FALSE;
/* TODO Add a GCancellable somewhere in the API */
static void ges_extractable_interface_init (GESExtractableInterface * iface);
struct _GESFormatterPrivate
{
gpointer nothing;
};
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GESFormatter, ges_formatter,
G_TYPE_INITIALLY_UNOWNED, G_ADD_PRIVATE (GESFormatter)
G_IMPLEMENT_INTERFACE (GES_TYPE_EXTRACTABLE,
ges_extractable_interface_init));
static void ges_formatter_dispose (GObject * object);
static gboolean default_can_load_uri (GESFormatter * dummy_instance,
const gchar * uri, GError ** error);
/* GESExtractable implementation */
static gchar *
extractable_check_id (GType type, const gchar * id)
{
GESFormatterClass *class;
if (id)
return g_strdup (id);
class = g_type_class_peek (type);
return g_strdup (class->name);
}
static gchar *
extractable_get_id (GESExtractable * self)
{
GESAsset *asset;
if (!(asset = ges_extractable_get_asset (self)))
return NULL;
return g_strdup (ges_asset_get_id (asset));
}
static gboolean
_register_metas (GESExtractableInterface * iface, GObjectClass * class,
GESAsset * asset)
{
GESFormatterClass *fclass = GES_FORMATTER_CLASS (class);
GESMetaContainer *container = GES_META_CONTAINER (asset);
ges_meta_container_register_meta_string (container, GES_META_READABLE,
GES_META_FORMATTER_NAME, fclass->name);
ges_meta_container_register_meta_string (container, GES_META_READABLE,
GES_META_DESCRIPTION, fclass->description);
ges_meta_container_register_meta_string (container, GES_META_READABLE,
GES_META_FORMATTER_MIMETYPE, fclass->mimetype);
ges_meta_container_register_meta_string (container, GES_META_READABLE,
GES_META_FORMATTER_EXTENSION, fclass->extension);
ges_meta_container_register_meta_double (container, GES_META_READABLE,
GES_META_FORMATTER_VERSION, fclass->version);
ges_meta_container_register_meta_uint (container, GES_META_READABLE,
GES_META_FORMATTER_RANK, fclass->rank);
ges_meta_container_register_meta_string (container, GES_META_READ_WRITE,
GES_META_FORMAT_VERSION, NULL);
/* We are leaking the metadata but we don't really have choice here
* as calling ges_init() after deinit() is allowed.
*/
return TRUE;
}
static void
ges_extractable_interface_init (GESExtractableInterface * iface)
{
iface->check_id = (GESExtractableCheckId) extractable_check_id;
iface->get_id = extractable_get_id;
iface->asset_type = GES_TYPE_ASSET;
iface->register_metas = _register_metas;
}
static void
ges_formatter_class_init (GESFormatterClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = ges_formatter_dispose;
klass->can_load_uri = default_can_load_uri;
klass->load_from_uri = NULL;
klass->save_to_uri = NULL;
/* We set dummy metas */
klass->name = g_strdup ("base-formatter");
klass->extension = g_strdup ("noextension");
klass->description = g_strdup ("Formatter base class, you should give"
" a name to your formatter");
klass->mimetype = g_strdup ("No mimetype");
klass->version = 0.0;
klass->rank = GST_RANK_NONE;
}
static void
ges_formatter_init (GESFormatter * object)
{
object->priv = ges_formatter_get_instance_private (object);
object->project = NULL;
}
static void
ges_formatter_dispose (GObject * object)
{
ges_formatter_set_project (GES_FORMATTER (object), NULL);
G_OBJECT_CLASS (ges_formatter_parent_class)->dispose (object);
}
static gboolean
default_can_load_uri (GESFormatter * dummy_instance, const gchar * uri,
GError ** error)
{
GST_DEBUG ("%s: no 'can_load_uri' vmethod implementation",
G_OBJECT_TYPE_NAME (dummy_instance));
return FALSE;
}
static gchar *
_get_extension (const gchar * uri)
{
gchar *result;
gsize len;
gint find;
GST_DEBUG ("finding extension of %s", uri);
if (uri == NULL)
goto no_uri;
/* find the extension on the uri, this is everything after a '.' */
len = strlen (uri);
find = len - 1;
while (find >= 0) {
if (uri[find] == '.')
break;
find--;
}
if (find < 0)
goto no_extension;
result = g_strdup (&uri[find + 1]);
GST_DEBUG ("found extension %s", result);
return result;
/* ERRORS */
no_uri:
{
GST_WARNING ("could not parse the peer uri");
return NULL;
}
no_extension:
{
GST_WARNING ("could not find uri extension in %s", uri);
return NULL;
}
}
/**
* ges_formatter_can_load_uri:
* @uri: a #gchar * pointing to the URI
* @error: A #GError that will be set in case of error
*
* Checks if there is a #GESFormatter available which can load a #GESTimeline
* from the given URI.
*
* Returns: TRUE if there is a #GESFormatter that can support the given uri
* or FALSE if not.
*/
gboolean
ges_formatter_can_load_uri (const gchar * uri, GError ** error)
{
gboolean ret = FALSE;
gchar *extension;
GList *formatter_assets, *tmp;
GESFormatterClass *class = NULL;
if (!(gst_uri_is_valid (uri))) {
GST_ERROR ("Invalid uri!");
return FALSE;
}
extension = _get_extension (uri);
formatter_assets = ges_list_assets (GES_TYPE_FORMATTER);
for (tmp = formatter_assets; tmp; tmp = tmp->next) {
GESAsset *asset = GES_ASSET (tmp->data);
GESFormatter *dummy_instance;
gchar **valid_exts =
g_strsplit (ges_meta_container_get_string (GES_META_CONTAINER (asset),
GES_META_FORMATTER_EXTENSION), ",", -1);
gint i;
if (extension) {
gboolean found = FALSE;
for (i = 0; valid_exts[i]; i++) {
if (!g_strcmp0 (extension, valid_exts[i])) {
found = TRUE;
break;
}
}
if (!found)
goto next;
}
class = g_type_class_ref (ges_asset_get_extractable_type (asset));
dummy_instance =
g_object_ref_sink (g_object_new (ges_asset_get_extractable_type (asset),
NULL));
if (class->can_load_uri (dummy_instance, uri, error)) {
g_type_class_unref (class);
gst_object_unref (dummy_instance);
ret = TRUE;
break;
}
g_type_class_unref (class);
gst_object_unref (dummy_instance);
next:
g_strfreev (valid_exts);
}
g_free (extension);
g_list_free (formatter_assets);
return ret;
}
/**
* ges_formatter_can_save_uri:
* @uri: a #gchar * pointing to a URI
* @error: A #GError that will be set in case of error
*
* Returns TRUE if there is a #GESFormatter available which can save a
* #GESTimeline to the given URI.
*
* Returns: TRUE if the given @uri is supported, else FALSE.
*/
gboolean
ges_formatter_can_save_uri (const gchar * uri, GError ** error)
{
GFile *file = NULL;
GFile *dir = NULL;
gboolean ret = TRUE;
GFileInfo *info = NULL;
if (!(gst_uri_is_valid (uri))) {
GST_ERROR ("%s invalid uri!", uri);
return FALSE;
}
if (!(gst_uri_has_protocol (uri, "file"))) {
gchar *proto = gst_uri_get_protocol (uri);
GST_ERROR ("Unsupported protocol '%s'", proto);
g_free (proto);
return FALSE;
}
/* Check if URI or parent directory is writeable */
file = g_file_new_for_uri (uri);
if (g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL)
== G_FILE_TYPE_DIRECTORY) {
dir = g_object_ref (file);
} else {
dir = g_file_get_parent (file);
if (dir == NULL)
goto error;
}
info = g_file_query_info (dir, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE, NULL, error);
if (error && *error != NULL) {
GST_ERROR ("Unable to write to directory: %s", (*error)->message);
goto error;
} else {
gboolean writeable = g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
if (!writeable) {
GST_ERROR ("Unable to write to directory");
goto error;
}
}
done:
if (file)
g_object_unref (file);
if (dir)
g_object_unref (dir);
if (info)
g_object_unref (info);
/* TODO: implement file format registry */
/* TODO: search through the registry and chose a GESFormatter class that can
* handle the URI.*/
return ret;
error:
ret = FALSE;
goto done;
}
/**
* ges_formatter_load_from_uri:
* @formatter: a #GESFormatter
* @timeline: a #GESTimeline
* @uri: a #gchar * pointing to a URI
* @error: A #GError that will be set in case of error
*
* Load data from the given URI into timeline.
*
* Returns: TRUE if the timeline data was successfully loaded from the URI,
* else FALSE.
*
* Deprecated: 1.18: Use @ges_timeline_load_from_uri
*/
gboolean
ges_formatter_load_from_uri (GESFormatter * formatter,
GESTimeline * timeline, const gchar * uri, GError ** error)
{
gboolean ret = FALSE;
GESFormatterClass *klass = GES_FORMATTER_GET_CLASS (formatter);
g_return_val_if_fail (GES_IS_FORMATTER (formatter), FALSE);
g_return_val_if_fail (GES_IS_TIMELINE (timeline), FALSE);
if (klass->load_from_uri) {
formatter->timeline = timeline;
ret = klass->load_from_uri (formatter, timeline, uri, error);
}
return ret;
}
/**
* ges_formatter_save_to_uri:
* @formatter: a #GESFormatter
* @timeline: a #GESTimeline
* @uri: a #gchar * pointing to a URI
* @overwrite: %TRUE to overwrite file if it exists
* @error: A #GError that will be set in case of error
*
* Save data from timeline to the given URI.
*
* Returns: TRUE if the timeline data was successfully saved to the URI
* else FALSE.
*
* Deprecated: 1.18: Use @ges_timeline_save_to_uri
*/
gboolean
ges_formatter_save_to_uri (GESFormatter * formatter, GESTimeline *
timeline, const gchar * uri, gboolean overwrite, GError ** error)
{
GError *lerr = NULL;
gboolean ret = FALSE;
GESFormatterClass *klass = GES_FORMATTER_GET_CLASS (formatter);
GST_DEBUG_OBJECT (formatter, "Saving %" GST_PTR_FORMAT " to %s",
timeline, uri);
if (klass->save_to_uri)
ret = klass->save_to_uri (formatter, timeline, uri, overwrite, &lerr);
else
GST_ERROR_OBJECT (formatter, "save_to_uri not implemented!");
if (lerr) {
GST_WARNING_OBJECT (formatter, "%" GST_PTR_FORMAT
" not saved to %s error: %s", timeline, uri, lerr->message);
g_propagate_error (error, lerr);
} else
GST_INFO_OBJECT (formatter, "%" GST_PTR_FORMAT
" saved to %s", timeline, uri);
return ret;
}
/**
* ges_formatter_get_default:
*
* Get the default #GESAsset to use as formatter. It will return
* the asset for the #GESFormatter that has the highest @rank
*
* Returns: (transfer none): The #GESAsset for the formatter with highest @rank
*/
GESAsset *
ges_formatter_get_default (void)
{
GList *assets, *tmp;
GESAsset *ret = NULL;
guint tmprank, rank = GST_RANK_NONE;
assets = ges_list_assets (GES_TYPE_FORMATTER);
for (tmp = assets; tmp; tmp = tmp->next) {
tmprank = GST_RANK_NONE;
ges_meta_container_get_uint (GES_META_CONTAINER (tmp->data),
GES_META_FORMATTER_RANK, &tmprank);
if (tmprank > rank) {
rank = tmprank;
ret = GES_ASSET (tmp->data);
}
}
g_list_free (assets);
return ret;
}
/**
* ges_formatter_class_register_metas:
* @klass: The class to register metas on
* @name: The name of the formatter
* @description: The formatter description
* @extensions: A list of coma separated file extensions handled
* by the formatter. The order of the extensions should match the
* list of the structures inside @caps
* @caps: The caps the formatter handled, they should match what
* gstreamer typefind mechanism will report for the files the formatter
* handles.
* @version: The version of the formatter
* @rank: The rank of the formatter
*/
void
ges_formatter_class_register_metas (GESFormatterClass * klass,
const gchar * name, const gchar * description, const gchar * extensions,
const gchar * caps, gdouble version, GstRank rank)
{
g_return_if_fail (klass->name);
klass->name = g_strdup (name);
klass->description = g_strdup (description);
klass->extension = g_strdup (extensions);
klass->mimetype = g_strdup (caps);
klass->version = version;
klass->rank = rank;
if (g_atomic_int_get (&initialized)
&& g_type_class_peek (G_OBJECT_CLASS_TYPE (klass)))
gst_object_unref (ges_asset_request (G_OBJECT_CLASS_TYPE (klass), NULL,
NULL));
}
/* Main Formatter methods */
/*< protected >*/
void
ges_formatter_set_project (GESFormatter * formatter, GESProject * project)
{
formatter->project = project;
}
GESProject *
ges_formatter_get_project (GESFormatter * formatter)
{
return formatter->project;
}
static void
_list_formatters (GType * formatters, guint n_formatters)
{
GType *tmptypes, type;
guint tmp_n_types, i;
for (i = 0; i < n_formatters; i++) {
type = formatters[i];
tmptypes = g_type_children (type, &tmp_n_types);
if (tmp_n_types) {
/* Recurse as g_type_children does not */
_list_formatters (tmptypes, tmp_n_types);
}
g_free (tmptypes);
if (G_TYPE_IS_ABSTRACT (type)) {
GST_DEBUG ("%s is abstract, not using", g_type_name (type));
} else {
gst_object_unref (ges_asset_request (type, NULL, NULL));
}
}
}
static void
load_python_formatters (void)
{
#ifdef HAS_PYTHON
PyGILState_STATE state = 0;
PyObject *main_module, *main_locals;
GError *err = NULL;
GResource *resource = ges_get_resource ();
GBytes *bytes =
g_resource_lookup_data (resource, "/ges/python/gesotioformatter.py",
G_RESOURCE_LOOKUP_FLAGS_NONE, &err);
PyObject *code = NULL, *res = NULL;
gboolean we_initialized = FALSE;
GModule *libpython;
gpointer has_python = NULL;
GST_LOG ("Checking to see if libpython is already loaded");
if (g_module_symbol (g_module_open (NULL, G_MODULE_BIND_LOCAL),
"_Py_NoneStruct", &has_python) && has_python) {
GST_LOG ("libpython is already loaded");
} else {
const gchar *libpython_path =
PY_LIB_LOC "/libpython" PYTHON_VERSION PY_ABI_FLAGS "." PY_LIB_SUFFIX;
GST_LOG ("loading libpython from '%s'", libpython_path);
libpython = g_module_open (libpython_path, 0);
if (!libpython) {
GST_ERROR ("Couldn't g_module_open libpython. Reason: %s",
g_module_error ());
return;
}
}
if (!Py_IsInitialized ()) {
GST_LOG ("python wasn't initialized");
/* set the correct plugin for registering stuff */
Py_Initialize ();
we_initialized = TRUE;
} else {
GST_LOG ("python was already initialized");
state = PyGILState_Ensure ();
}
if (!bytes) {
GST_DEBUG ("Could not load gesotioformatter: %s\n", err->message);
g_clear_error (&err);
goto done;
}
main_module = PyImport_AddModule ("__main__");
if (main_module == NULL) {
GST_WARNING ("Could not add main module");
PyErr_Print ();
PyErr_Clear ();
goto done;
}
main_locals = PyModule_GetDict (main_module);
/* Compiling the code ourself so it has a proper filename */
code =
Py_CompileString (g_bytes_get_data (bytes, NULL), "gesotioformatter.py",
Py_file_input);
if (PyErr_Occurred ()) {
PyErr_Print ();
PyErr_Clear ();
goto done;
}
res = PyEval_EvalCode ((gpointer) code, main_locals, main_locals);
Py_XDECREF (code);
Py_XDECREF (res);
if (PyErr_Occurred ()) {
PyObject *exception_backtrace;
PyObject *exception_type;
PyObject *exception_value, *exception_value_repr, *exception_value_str;
PyErr_Fetch (&exception_type, &exception_value, &exception_backtrace);
PyErr_NormalizeException (&exception_type, &exception_value,
&exception_backtrace);
exception_value_repr = PyObject_Repr (exception_value);
exception_value_str =
PyUnicode_AsEncodedString (exception_value_repr, "utf-8", "Error ~");
GST_INFO ("Could not load OpenTimelineIO formatter: %s",
PyBytes_AS_STRING (exception_value_str));
Py_XDECREF (exception_type);
Py_XDECREF (exception_value);
Py_XDECREF (exception_backtrace);
Py_XDECREF (exception_value_repr);
Py_XDECREF (exception_value_str);
PyErr_Clear ();
}
done:
if (bytes)
g_bytes_unref (bytes);
if (we_initialized) {
PyEval_SaveThread ();
} else {
PyGILState_Release (state);
}
#endif /* HAS_PYTHON */
}
void
_init_formatter_assets (void)
{
GType *formatters;
guint n_formatters;
static gsize init_debug = 0;
if (g_once_init_enter (&init_debug)) {
GST_DEBUG_CATEGORY_INIT (ges_formatter_debug, "gesformatter",
GST_DEBUG_FG_YELLOW, "ges formatter");
g_once_init_leave (&init_debug, TRUE);
}
if (g_atomic_int_compare_and_exchange (&initialized, FALSE, TRUE)) {
/* register formatter types with the system */
#ifndef DISABLE_XPTV
g_type_class_ref (GES_TYPE_PITIVI_FORMATTER);
#endif
g_type_class_ref (GES_TYPE_COMMAND_LINE_FORMATTER);
g_type_class_ref (GES_TYPE_XML_FORMATTER);
load_python_formatters ();
formatters = g_type_children (GES_TYPE_FORMATTER, &n_formatters);
_list_formatters (formatters, n_formatters);
g_free (formatters);
}
}
void
_deinit_formatter_assets (void)
{
if (g_atomic_int_compare_and_exchange (&initialized, TRUE, FALSE)) {
#ifndef DISABLE_XPTV
g_type_class_unref (g_type_class_peek (GES_TYPE_PITIVI_FORMATTER));
#endif
g_type_class_unref (g_type_class_peek (GES_TYPE_COMMAND_LINE_FORMATTER));
g_type_class_unref (g_type_class_peek (GES_TYPE_XML_FORMATTER));
}
}
static gint
_sort_formatters (GESAsset * asset, GESAsset * asset1)
{
GESFormatterClass *class =
g_type_class_peek (ges_asset_get_extractable_type (asset));
GESFormatterClass *class1 =
g_type_class_peek (ges_asset_get_extractable_type (asset1));
/* We want the highest ranks to be first! */
if (class->rank > class1->rank)
return -1;
else if (class->rank < class1->rank)
return 1;
return 0;
}
GESAsset *
_find_formatter_asset_for_id (const gchar * id)
{
GESFormatterClass *class = NULL;
GList *formatter_assets, *tmp;
GESAsset *asset = NULL;
formatter_assets = g_list_sort (ges_list_assets (GES_TYPE_FORMATTER),
(GCompareFunc) _sort_formatters);
for (tmp = formatter_assets; tmp; tmp = tmp->next) {
GESFormatter *dummy_instance;
asset = GES_ASSET (tmp->data);
class = g_type_class_ref (ges_asset_get_extractable_type (asset));
dummy_instance =
g_object_ref_sink (g_object_new (ges_asset_get_extractable_type (asset),
NULL));
if (class->can_load_uri (dummy_instance, id, NULL)) {
g_type_class_unref (class);
asset = gst_object_ref (asset);
gst_object_unref (dummy_instance);
break;
}
asset = NULL;
g_type_class_unref (class);
gst_object_unref (dummy_instance);
}
g_list_free (formatter_assets);
return asset;
}
/**
* ges_find_formatter_for_uri:
*
* Get the best formatter for @uri. It tries to find a formatter
* compatible with @uri extension, if none is found, it returns the default
* formatter asset.
*
* Returns: (transfer none): The #GESAsset for the best formatter to save to @uri
*
* Since: 1.18
*/
GESAsset *
ges_find_formatter_for_uri (const gchar * uri)
{
GList *formatter_assets, *tmp;
GESAsset *asset = NULL;
gchar *extension = _get_extension (uri);
if (!extension)
return ges_formatter_get_default ();
formatter_assets = g_list_sort (ges_list_assets (GES_TYPE_FORMATTER),
(GCompareFunc) _sort_formatters);
for (tmp = formatter_assets; tmp; tmp = tmp->next) {
gint i;
gchar **valid_exts =
g_strsplit (ges_meta_container_get_string (GES_META_CONTAINER
(tmp->data),
GES_META_FORMATTER_EXTENSION), ",", -1);
for (i = 0; valid_exts[i]; i++) {
if (!g_strcmp0 (extension, valid_exts[i])) {
asset = GES_ASSET (tmp->data);
break;
}
}
g_strfreev (valid_exts);
if (asset)
break;
}
g_free (extension);
g_list_free (formatter_assets);
if (asset) {
GST_INFO_OBJECT (asset, "Using for URI %s", uri);
return asset;
}
return ges_formatter_get_default ();
}