video.c

Go to the documentation of this file.

/*
 * Copyright 2011 John-Mark Bell <jmb@netsurf-browser.org>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * NetSurf 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <gst/gst.h>
 
#include "content/content_factory.h"
#include "content/content_protected.h"
 
#include "image/video.h"
 
typedef struct nsvideo_content {
        struct content base;
 
        GstElement *playbin;
        GstElement *appsrc;
} nsvideo_content;
 
static gboolean nsvideo_bus_call(GstBus *bus, GstMessage *msg, 
                nsvideo_content *video)
{
        switch (GST_MESSAGE_TYPE(msg)) {
        case GST_MESSAGE_ERROR:
                break;
        case GST_MESSAGE_EOS:
                break;
        default:
                break;
        }
 
        return TRUE;
}
 
static void nsvideo_need_data_event(GstElement *playbin, guint size,
                nsvideo_content *video)
{
}
 
static void nsvideo_enough_data_event(GstElement *playbin,
                nsvideo_content *video)
{
}
 
static void nsvideo_source_event(GObject *object, GObject *orig, 
                GParamSpec *pspec, nsvideo_content *video)
{
        g_object_get(orig, pspec->name, &video->appsrc, NULL);
 
        g_signal_connect(video->appsrc, "need-data", 
                        G_CALLBACK(nsvideo_need_data_event), video);
        g_signal_connect(video->appsrc, "enough-data",
                        G_CALLBACK(nsvideo_enough_data_event), video);
}
 
static nserror nsvideo_create(const content_handler *handler,
                lwc_string *imime_type, const http_parameter *params,
                llcache_handle *llcache,
                const char *fallback_charset, bool quirks,
                struct content **c)
{
        nsvideo_content *video;
        nserror error;
        GstBus *bus;
 
        video = calloc(1, sizeof(nsvideo_content));
        if (video == NULL)
                return NSERROR_NOMEM;
 
        error = content__init(&video->base, handler, imime_type, params,
                        llcache, fallback_charset, quirks);
        if (error != NSERROR_OK) {
                free(video);
                return error;
        }
 
        error = llcache_handle_force_stream(llcache);
        if (error != NSERROR_OK) {
                free(video);
                return error;
        }
 
        video->playbin = gst_element_factory_make("playbin2", NULL);
        if (video->playbin == NULL) {
                free(video);
                return NSERROR_NOMEM;
        }
 
        bus = gst_pipeline_get_bus(GST_PIPELINE(video->playbin));
        gst_bus_add_watch(bus, (GstBusFunc) nsvideo_bus_call, video);
        gst_object_unref(bus);
 
        g_object_set(video->playbin, "uri", "appsrc://", NULL);
        g_signal_connect(video->playbin, "deep-notify::source",
                        G_CALLBACK(nsvideo_source_event), video);
 
        /** \todo Create appsink & register with playbin */
 
        gst_element_set_state(video->playbin, GST_STATE_PLAYING);
        
        *c = (struct content *) video;
 
        return NSERROR_OK;
}
 
static bool nsvideo_process_data(struct content *c, const char *data, 
                unsigned int size)
{
        nsvideo_content *video = (nsvideo_content *) c;
        GstBuffer *buffer;
        GstFlowReturn ret;
 
        buffer = gst_buffer_new();
        GST_BUFFER_DATA(buffer) = (guint8 *) data;
        GST_BUFFER_SIZE(buffer) = (gsize) size;
 
        /* Send data to appsrc */
        g_signal_emit_by_name(video->appsrc, "push-buffer", buffer, &ret);
 
        return ret == GST_FLOW_OK;
}
 
static bool nsvideo_convert(struct content *c)
{
        nsvideo_content *video = (nsvideo_content *) c;
        GstFlowReturn ret;
 
        /* Tell appsrc we're done */
        g_signal_emit_by_name(video->appsrc, "end-of-stream", &ret);
 
        /* Appsink will flag DONE on receipt of first frame */
 
        return ret == GST_FLOW_OK;
}
 
static void nsvideo_destroy(struct content *c)
{
        nsvideo_content *video = (nsvideo_content *) c;
 
        gst_element_set_state(video->playbin, GST_STATE_NULL);
        gst_object_unref(video->playbin);
}
 
static bool nsvideo_redraw(struct content *c, struct content_redraw_data *data,
                const struct rect *clip, const struct redraw_context *ctx)
{
        /** \todo Implement */
        return true;
}
 
static nserror nsvideo_clone(const struct content *old, struct content **newc)
{
        /** \todo Implement */
        return NSERROR_CLONE_FAILED;
}
 
static content_type nsvideo_type(void)
{
        /** \todo Lies */
        return CONTENT_IMAGE;
}
 
static void *nsvideo_get_internal(const struct content *c, void *context)
{
        /** \todo Return pointer to bitmap containing current frame, if any? */
        return NULL;
}
 
static const content_handler nsvideo_content_handler = {
        .create = nsvideo_create,
        .process_data = nsvideo_process_data,
        .data_complete = nsvideo_convert,
        .destroy = nsvideo_destroy,
        .redraw = nsvideo_redraw,
        .clone = nsvideo_clone,
        .type = nsvideo_type,
        .get_internal = nsvideo_get_internal,
        /* Can't share videos because we stream them */
        .no_share = true
};
 
static const char *nsvideo_types[] = {
        "video/mp4",
        "video/webm"
};
 
CONTENT_FACTORY_REGISTER_TYPES(nsvideo, nsvideo_types, 
                nsvideo_content_handler);