--- /dev/null
+/*
+ * simple-decoder.c - Simple Decoder Application
+ *
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * 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; either 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 Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ */
+
+/*
+ * This is a really simple decoder application that only accepts raw
+ * bitstreams. So, it may be needed to suggest what codec to use to
+ * the application.
+ */
+
+#include "config.h"
+#include <stdarg.h>
+#include <gst/vaapi/gstvaapidecoder.h>
+#include <gst/vaapi/gstvaapidecoder_h264.h>
+#include <gst/vaapi/gstvaapidecoder_jpeg.h>
+#include <gst/vaapi/gstvaapidecoder_mpeg2.h>
+#include <gst/vaapi/gstvaapidecoder_mpeg4.h>
+#include <gst/vaapi/gstvaapidecoder_vc1.h>
+#include <gst/vaapi/gstvaapivideometa.h>
+#include <gst/vaapi/gstvaapiwindow.h>
+#include "codec.h"
+#include "output.h"
+
+static gchar *g_codec_str;
+
+static GOptionEntry g_options[] = {
+ { "codec", 'c',
+ 0,
+ G_OPTION_ARG_STRING, &g_codec_str,
+ "suggested codec", NULL },
+ { NULL, }
+};
+
+typedef enum {
+ APP_RUNNING,
+ APP_GOT_EOS,
+ APP_GOT_ERROR,
+} AppEvent;
+
+typedef enum {
+ APP_ERROR_NONE,
+ APP_ERROR_DECODER,
+ APP_ERROR_RENDERER,
+} AppError;
+
+typedef struct {
+ GMutex mutex;
+ GMappedFile *file;
+ gchar *file_name;
+ guint file_offset;
+ guint file_size;
+ guchar *file_data;
+ GstVaapiDisplay *display;
+ GstVaapiDecoder *decoder;
+ GThread *decoder_thread;
+ volatile gboolean decoder_thread_cancel;
+ GCond decoder_ready;
+ GAsyncQueue *decoder_queue;
+ GstVaapiCodec codec;
+ GstVideoCodecState codec_state;
+ GstVaapiWindow *window;
+ GThread *render_thread;
+ volatile gboolean render_thread_cancel;
+ GstBuffer *last_buffer;
+ GError *error;
+ AppEvent event;
+ GCond event_cond;
+} App;
+
+#define APP_ERROR app_error_quark()
+static GQuark
+app_error_quark(void)
+{
+ static gsize g_quark;
+
+ if (g_once_init_enter(&g_quark)) {
+ gsize quark = (gsize)g_quark_from_static_string("AppError");
+ g_once_init_leave(&g_quark, quark);
+ }
+ return g_quark;
+}
+
+static void
+app_send_error(App *app, GError *error)
+{
+ g_mutex_lock(&app->mutex);
+ app->error = error;
+ app->event = APP_GOT_ERROR;
+ g_cond_signal(&app->event_cond);
+ g_mutex_unlock(&app->mutex);
+}
+
+static void
+app_send_eos(App *app)
+{
+ g_mutex_lock(&app->mutex);
+ app->event = APP_GOT_EOS;
+ g_cond_signal(&app->event_cond);
+ g_mutex_unlock(&app->mutex);
+}
+
+static const gchar *
+get_decoder_status_string(GstVaapiDecoderStatus status)
+{
+ const gchar *str;
+
+#define DEFINE_STATUS(status, status_string) \
+ case GST_VAAPI_DECODER_STATUS_##status: \
+ str = status_string; \
+ break
+
+ switch (status) {
+ DEFINE_STATUS(SUCCESS, "<success>");
+ DEFINE_STATUS(END_OF_STREAM, "<EOS>");
+ DEFINE_STATUS(ERROR_ALLOCATION_FAILED, "allocation failed");
+ DEFINE_STATUS(ERROR_INIT_FAILED, "initialization failed");
+ DEFINE_STATUS(ERROR_UNSUPPORTED_CODEC, "unsupported codec");
+ DEFINE_STATUS(ERROR_NO_DATA, "not enough data");
+ DEFINE_STATUS(ERROR_NO_SURFACE, "no surface vailable");
+ DEFINE_STATUS(ERROR_INVALID_SURFACE, "invalid surface");
+ DEFINE_STATUS(ERROR_BITSTREAM_PARSER, "bitstream parser error");
+ DEFINE_STATUS(ERROR_UNSUPPORTED_PROFILE,
+ "unsupported profile");
+ DEFINE_STATUS(ERROR_UNSUPPORTED_CHROMA_FORMAT,
+ "unsupported chroma-format");
+ DEFINE_STATUS(ERROR_INVALID_PARAMETER, "invalid parameter");
+ default:
+ str = "<unknown>";
+ break;
+ }
+#undef DEFINE_STATUS
+
+ return str;
+}
+
+static const gchar *
+get_error_string(AppError error)
+{
+ const gchar *str;
+
+#define DEFINE_ERROR(error, error_string) \
+ case APP_ERROR_##error: \
+ str = error_string; \
+ break
+
+ switch (error) {
+ DEFINE_ERROR(NONE, "<none>");
+ DEFINE_ERROR(DECODER, "decoder");
+ DEFINE_ERROR(RENDERER, "renderer");
+ default:
+ str = "unknown";
+ break;
+ }
+#undef DEFINE_ERROR
+
+ return str;
+}
+
+static void
+decoder_release(App *app)
+{
+ g_mutex_lock(&app->mutex);
+ g_cond_signal(&app->decoder_ready);
+ g_mutex_unlock(&app->mutex);
+}
+
+static gpointer
+decoder_thread(gpointer data)
+{
+ App * const app = data;
+ GError *error = NULL;
+ GstVaapiDecoderStatus status;
+ GstVaapiSurfaceProxy *proxy;
+ GstVaapiVideoMeta *meta;
+ GstBuffer *buffer;
+ gboolean got_surface;
+ gint64 end_time;
+ guint ofs;
+
+ g_print("Decoder thread started\n");
+
+#define SEND_ERROR(...) \
+ do { \
+ error = g_error_new(APP_ERROR, APP_ERROR_DECODER, __VA_ARGS__); \
+ goto send_error; \
+ } while (0)
+
+ ofs = 0;
+ while (!app->decoder_thread_cancel) {
+ if (G_UNLIKELY(ofs == app->file_size))
+ buffer = NULL;
+ else {
+ buffer = gst_buffer_new();
+ if (!buffer)
+ SEND_ERROR("failed to allocate new buffer");
+
+ GST_BUFFER_DATA(buffer) = app->file_data + ofs;
+ GST_BUFFER_SIZE(buffer) = MIN(4096, app->file_size - ofs);
+ ofs += GST_BUFFER_SIZE(buffer);
+ }
+ if (!gst_vaapi_decoder_put_buffer(app->decoder, buffer))
+ SEND_ERROR("failed to push buffer to decoder");
+ gst_buffer_replace(&buffer, NULL);
+
+ get_surface:
+ status = gst_vaapi_decoder_get_surface(app->decoder, &proxy);
+ switch (status) {
+ case GST_VAAPI_DECODER_STATUS_SUCCESS:
+ gst_vaapi_surface_proxy_set_user_data(proxy,
+ app, (GDestroyNotify)decoder_release);
+ meta = gst_vaapi_video_meta_new_with_surface_proxy(proxy);
+ gst_vaapi_surface_proxy_unref(proxy);
+ if (!meta)
+ SEND_ERROR("failed to allocate video meta");
+ buffer = gst_buffer_new();
+ if (!buffer)
+ SEND_ERROR("failed to allocate output buffer");
+ gst_buffer_set_vaapi_video_meta(buffer, meta);
+ gst_vaapi_video_meta_unref(meta);
+ g_async_queue_push(app->decoder_queue, buffer);
+ break;
+ case GST_VAAPI_DECODER_STATUS_ERROR_NO_DATA:
+ /* nothing to do, just continue to the next iteration */
+ break;
+ case GST_VAAPI_DECODER_STATUS_END_OF_STREAM:
+ goto send_eos;
+ case GST_VAAPI_DECODER_STATUS_ERROR_NO_SURFACE:
+ end_time = g_get_monotonic_time() + G_TIME_SPAN_SECOND;
+ g_mutex_lock(&app->mutex);
+ got_surface = g_cond_wait_until(&app->decoder_ready, &app->mutex,
+ end_time);
+ g_mutex_unlock(&app->mutex);
+ if (got_surface)
+ goto get_surface;
+ SEND_ERROR("failed to acquire a surface within one second");
+ break;
+ default:
+ SEND_ERROR("%s", get_decoder_status_string(status));
+ break;
+ }
+ }
+ return NULL;
+
+#undef SEND_ERROR
+
+send_eos:
+ app_send_eos(app);
+ return NULL;
+
+send_error:
+ app_send_error(app, error);
+ return NULL;
+}
+
+static gboolean
+start_decoder(App *app)
+{
+ GstCaps *caps;
+
+ app->file = g_mapped_file_new(app->file_name, FALSE, NULL);
+ if (!app->file)
+ return FALSE;
+
+ app->file_size = g_mapped_file_get_length(app->file);
+ app->file_data = (guint8 *)g_mapped_file_get_contents(app->file);
+ if (!app->file_data)
+ return FALSE;
+
+ caps = caps_from_codec(app->codec);
+ switch (app->codec) {
+ case GST_VAAPI_CODEC_H264:
+ app->decoder = gst_vaapi_decoder_h264_new(app->display, caps);
+ break;
+#if USE_JPEG_DECODER
+ case GST_VAAPI_CODEC_JPEG:
+ app->decoder = gst_vaapi_decoder_jpeg_new(app->display, caps);
+ break;
+#endif
+ case GST_VAAPI_CODEC_MPEG2:
+ app->decoder = gst_vaapi_decoder_mpeg2_new(app->display, caps);
+ break;
+ case GST_VAAPI_CODEC_MPEG4:
+ app->decoder = gst_vaapi_decoder_mpeg4_new(app->display, caps);
+ break;
+ case GST_VAAPI_CODEC_VC1:
+ app->decoder = gst_vaapi_decoder_vc1_new(app->display, caps);
+ break;
+ default:
+ app->decoder = NULL;
+ break;
+ }
+ if (!app->decoder)
+ return FALSE;
+
+ app->decoder_thread = g_thread_create(decoder_thread, app, TRUE, NULL);
+ if (!app->decoder_thread)
+ return FALSE;
+ return TRUE;
+}
+
+static gboolean
+stop_decoder(App *app)
+{
+ app->decoder_thread_cancel = TRUE;
+ g_thread_join(app->decoder_thread);
+ g_print("Decoder thread stopped\n");
+ return TRUE;
+}
+
+static gboolean
+renderer_process(App *app, GstBuffer *buffer)
+{
+ GError *error = NULL;
+ GstVaapiVideoMeta *meta;
+ GstVaapiSurface *surface;
+
+#define SEND_ERROR(...) \
+ do { \
+ error = g_error_new(APP_ERROR, APP_ERROR_RENDERER, __VA_ARGS__); \
+ goto send_error; \
+ } while (0)
+
+ meta = gst_buffer_get_vaapi_video_meta(buffer);
+ if (!meta)
+ SEND_ERROR("failed to get video meta");
+
+ surface = gst_vaapi_video_meta_get_surface(meta);
+ if (!surface)
+ SEND_ERROR("failed to get decoded surface from video meta");
+
+ if (!gst_vaapi_window_put_surface(app->window, surface, NULL, NULL,
+ GST_VAAPI_PICTURE_STRUCTURE_FRAME))
+ SEND_ERROR("failed to render surface %" GST_VAAPI_ID_FORMAT,
+ GST_VAAPI_ID_ARGS(gst_vaapi_surface_get_id(surface)));
+
+ gst_buffer_replace(&app->last_buffer, buffer);
+ gst_buffer_unref(buffer);
+ return TRUE;
+
+#undef SEND_ERROR
+
+send_error:
+ app_send_error(app, error);
+ return FALSE;
+}
+
+static gpointer
+renderer_thread(gpointer data)
+{
+ App * const app = data;
+ GstBuffer *buffer;
+
+ g_print("Render thread started\n");
+
+ while (!app->render_thread_cancel) {
+ buffer = g_async_queue_timeout_pop(app->decoder_queue, 1000000);
+ if (buffer && !renderer_process(app, buffer))
+ break;
+ }
+ return NULL;
+}
+
+static gboolean
+flush_decoder_queue(App *app)
+{
+ GstBuffer *buffer;
+
+ /* Flush pending surfaces */
+ do {
+ buffer = g_async_queue_try_pop(app->decoder_queue);
+ if (!buffer)
+ return TRUE;
+ } while (renderer_process(app, buffer));
+ return FALSE;
+}
+
+static gboolean
+start_renderer(App *app)
+{
+ app->render_thread = g_thread_create(renderer_thread, app, TRUE, NULL);
+ if (!app->render_thread)
+ return FALSE;
+ return TRUE;
+}
+
+static gboolean
+stop_renderer(App *app)
+{
+ app->render_thread_cancel = TRUE;
+ g_thread_join(app->render_thread);
+
+ g_print("Render thread stopped\n");
+
+ flush_decoder_queue(app);
+ gst_buffer_replace(&app->last_buffer, NULL);
+ return TRUE;
+}
+
+static void
+app_free(App *app)
+{
+ if (!app)
+ return;
+
+ if (app->file) {
+ g_mapped_file_unref(app->file);
+ app->file = NULL;
+ }
+ g_free(app->file_name);
+
+ g_clear_object(&app->decoder);
+ g_clear_object(&app->window);
+ g_clear_object(&app->display);
+
+ if (app->decoder_queue) {
+ g_async_queue_unref(app->decoder_queue);
+ app->decoder_queue = NULL;
+ }
+ g_cond_clear(&app->decoder_ready);
+
+ g_cond_clear(&app->event_cond);
+ g_mutex_clear(&app->mutex);
+ g_slice_free(App, app);
+}
+
+static App *
+app_new(void)
+{
+ App *app;
+
+ app = g_slice_new0(App);
+ if (!app)
+ return NULL;
+
+ g_mutex_init(&app->mutex);
+ g_cond_init(&app->event_cond);
+ g_cond_init(&app->decoder_ready);
+
+ app->decoder_queue = g_async_queue_new_full(
+ (GDestroyNotify)gst_buffer_unref);
+ if (!app->decoder_queue)
+ goto error;
+ return app;
+
+error:
+ app_free(app);
+ return NULL;
+}
+
+static gboolean
+app_check_events(App *app)
+{
+ GError *error = NULL;
+ gboolean stop = FALSE;
+
+ do {
+ g_mutex_lock(&app->mutex);
+ while (app->event == APP_RUNNING)
+ g_cond_wait(&app->event_cond, &app->mutex);
+
+ switch (app->event) {
+ case APP_GOT_ERROR:
+ error = app->error;
+ app->error = NULL;
+ /* fall-through */
+ case APP_GOT_EOS:
+ stop = TRUE;
+ break;
+ default:
+ break;
+ }
+ g_mutex_unlock(&app->mutex);
+ } while (!stop);
+
+ if (!error)
+ return TRUE;
+
+ g_message("%s error: %s", get_error_string(error->code), error->message);
+ g_error_free(error);
+ return FALSE;
+}
+
+static gboolean
+app_run(App *app, int argc, char *argv[])
+{
+ if (!video_output_init(&argc, argv, g_options)) {
+ g_message("failed to initialize video output subsystem");
+ return FALSE;
+ }
+
+ if (argc < 2) {
+ g_message("no bitstream file specified");
+ return FALSE;
+ }
+ app->file_name = g_strdup(argv[1]);
+
+ if (!g_file_test(app->file_name, G_FILE_TEST_IS_REGULAR)) {
+ g_message("failed to find file '%s'", app->file_name);
+ return FALSE;
+ }
+
+ app->codec = identify_codec(app->file_name);
+ if (!app->codec) {
+ app->codec = identify_codec_from_string(g_codec_str);
+ if (!app->codec) {
+ g_message("failed to identify codec for '%s'", app->file_name);
+ return FALSE;
+ }
+ }
+
+ g_print("Simple decoder (%s bitstream)\n", string_from_codec(app->codec));
+
+ app->display = video_output_create_display(NULL);
+ if (!app->display) {
+ g_message("failed to create VA display");
+ return FALSE;
+ }
+
+ app->window = video_output_create_window(app->display, 640, 480);
+ if (!app->window) {
+ g_message("failed to create window");
+ return FALSE;
+ }
+
+ gst_vaapi_window_show(app->window);
+
+ if (!start_decoder(app)) {
+ g_message("failed to start decoder thread");
+ return FALSE;
+ }
+
+ if (!start_renderer(app)) {
+ g_message("failed to start renderer thread");
+ return FALSE;
+ }
+
+ app_check_events(app);
+
+ stop_renderer(app);
+ stop_decoder(app);
+ video_output_exit();
+ return TRUE;
+}
+
+int
+main(int argc, char *argv[])
+{
+ App *app;
+ gint ret;
+
+ app = app_new();
+ if (!app)
+ g_error("failed to create application context");
+
+ ret = !app_run(app, argc, argv);
+
+ app_free(app);
+ g_free(g_codec_str);
+ return ret;
+}
projects / platform / upstream / gstreamer.git / commitdiff