gstreamer/tests/simple-decoder.c
Gwenole Beauchesne 15519ebe3d legal: add per-file authorship information.
Credit original authors on a per-file basis as we cannot expect people
to know all country-specific rules, or bother browsing through the git
history.
2013-11-22 06:39:15 +01:00

780 lines
21 KiB
C

/*
* simple-decoder.c - Simple Decoder Application
*
* Copyright (C) 2013 Intel Corporation
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.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; 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 "gst/vaapi/sysdeps.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/gstvaapiwindow.h>
#include <gst/vaapi/gstvaapipixmap.h>
#include "codec.h"
#include "output.h"
static gchar *g_codec_str;
static gboolean g_use_pixmap;
static gboolean g_benchmark;
static GOptionEntry g_options[] = {
{ "codec", 'c',
0,
G_OPTION_ARG_STRING, &g_codec_str,
"suggested codec", NULL },
{ "pixmap", 0,
0,
G_OPTION_ARG_NONE, &g_use_pixmap,
"use render-to-pixmap", NULL },
{ "benchmark", 0,
0,
G_OPTION_ARG_NONE, &g_benchmark,
"benchmark mode", 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 {
GstVaapiSurfaceProxy *proxy;
GstClockTime pts;
GstClockTime duration;
} RenderFrame;
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;
guint fps_n;
guint fps_d;
guint32 frame_duration;
guint surface_width;
guint surface_height;
GstVaapiPixmap *pixmaps[2];
guint pixmap_id;
guint pixmap_width;
guint pixmap_height;
GstVaapiWindow *window;
guint window_width;
guint window_height;
GThread *render_thread;
volatile gboolean render_thread_cancel;
GCond render_ready;
RenderFrame *last_frame;
GError *error;
AppEvent event;
GCond event_cond;
GTimer *timer;
guint32 num_frames;
} App;
static inline RenderFrame *
render_frame_new(void)
{
return g_slice_new(RenderFrame);
}
static void
render_frame_free(RenderFrame *rfp)
{
if (G_UNLIKELY(!rfp))
return;
gst_vaapi_surface_proxy_replace(&rfp->proxy, NULL);
g_slice_free(RenderFrame, rfp);
}
static inline void
render_frame_replace(RenderFrame **rfp_ptr, RenderFrame *new_rfp)
{
if (*rfp_ptr)
render_frame_free(*rfp_ptr);
*rfp_ptr = new_rfp;
}
#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;
RenderFrame *rfp;
GstBuffer *buffer;
GstClockTime pts;
gboolean got_surface, got_eos = FALSE;
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)
pts = g_get_monotonic_time();
ofs = 0;
while (!app->decoder_thread_cancel) {
if (G_UNLIKELY(ofs == app->file_size))
buffer = NULL;
else {
const gsize size = MIN(4096, app->file_size - ofs);
buffer = gst_buffer_new_wrapped_full(GST_MEMORY_FLAG_READONLY,
app->file_data, app->file_size, ofs, size, NULL, NULL);
if (!buffer)
SEND_ERROR("failed to allocate new buffer");
ofs += size;
}
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_destroy_notify(proxy,
(GDestroyNotify)decoder_release, app);
rfp = render_frame_new();
if (!rfp)
SEND_ERROR("failed to allocate render frame");
rfp->proxy = proxy;
rfp->pts = pts;
rfp->duration = app->frame_duration;
pts += app->frame_duration;
g_async_queue_push(app->decoder_queue, rfp);
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:
gst_vaapi_decoder_flush(app->decoder);
if (got_eos)
goto send_eos;
got_eos = TRUE;
break;
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 void
app_set_framerate(App *app, guint fps_n, guint fps_d)
{
if (!fps_n || !fps_d)
return;
g_mutex_lock(&app->mutex);
if (fps_n != app->fps_n || fps_d != app->fps_d) {
app->fps_n = fps_n;
app->fps_d = fps_d;
app->frame_duration = gst_util_uint64_scale(
GST_TIME_AS_USECONDS(GST_SECOND), fps_d, fps_n);
}
g_mutex_unlock(&app->mutex);
}
static void
handle_decoder_state_changes(GstVaapiDecoder *decoder,
const GstVideoCodecState *codec_state, gpointer user_data)
{
App * const app = user_data;
g_assert(app->decoder == decoder);
app_set_framerate(app, codec_state->info.fps_n, codec_state->info.fps_d);
}
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;
gst_vaapi_decoder_set_codec_state_changed_func(app->decoder,
handle_decoder_state_changes, app);
g_timer_start(app->timer);
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)
{
g_timer_stop(app->timer);
app->decoder_thread_cancel = TRUE;
g_thread_join(app->decoder_thread);
g_print("Decoder thread stopped\n");
return TRUE;
}
static void
ensure_window_size(App *app, GstVaapiSurface *surface)
{
guint width, height;
if (gst_vaapi_window_get_fullscreen(app->window))
return;
gst_vaapi_surface_get_size(surface, &width, &height);
if (app->surface_width == width && app->surface_height == height)
return;
app->surface_width = width;
app->surface_height = height;
gst_vaapi_window_set_size(app->window, width, height);
gst_vaapi_window_get_size(app->window,
&app->window_width, &app->window_height);
}
static gboolean
ensure_pixmaps(App *app, GstVaapiSurface *surface,
const GstVaapiRectangle *crop_rect)
{
GstVaapiPixmap *pixmaps[G_N_ELEMENTS(app->pixmaps)];
guint num_pixmaps, i, width, height;
gboolean success = FALSE;
if (crop_rect) {
width = crop_rect->width;
height = crop_rect->height;
}
else
gst_vaapi_surface_get_size(surface, &width, &height);
if (app->pixmap_width == width && app->pixmap_height == height)
return TRUE;
for (i = 0, num_pixmaps = 0; i < G_N_ELEMENTS(pixmaps); i++) {
GstVaapiPixmap * const pixmap =
video_output_create_pixmap(app->display, GST_VIDEO_FORMAT_xRGB,
width, height);
if (!pixmap)
goto end;
pixmaps[num_pixmaps++] = pixmap;
}
for (i = 0; i < num_pixmaps; i++)
gst_vaapi_pixmap_replace(&app->pixmaps[i], pixmaps[i]);
app->pixmap_width = width;
app->pixmap_height = height;
success = TRUE;
end:
for (i = 0; i < num_pixmaps; i++)
gst_vaapi_pixmap_replace(&pixmaps[i], NULL);
return success;
}
static inline void
renderer_wait_until(App *app, GstClockTime pts)
{
g_mutex_lock(&app->mutex);
do {
} while (g_cond_wait_until(&app->render_ready, &app->mutex, pts));
g_mutex_unlock(&app->mutex);
}
static gboolean
renderer_process(App *app, RenderFrame *rfp)
{
GError *error = NULL;
GstVaapiSurface *surface;
const GstVaapiRectangle *crop_rect;
#define SEND_ERROR(...) \
do { \
error = g_error_new(APP_ERROR, APP_ERROR_RENDERER, __VA_ARGS__); \
goto send_error; \
} while (0)
surface = gst_vaapi_surface_proxy_get_surface(rfp->proxy);
if (!surface)
SEND_ERROR("failed to get decoded surface from render frame");
ensure_window_size(app, surface);
crop_rect = gst_vaapi_surface_proxy_get_crop_rect(rfp->proxy);
if (g_use_pixmap && !ensure_pixmaps(app, surface, crop_rect))
SEND_ERROR("failed to create intermediate pixmaps");
if (!gst_vaapi_surface_sync(surface))
SEND_ERROR("failed to sync decoded surface");
if (G_LIKELY(!g_benchmark))
renderer_wait_until(app, rfp->pts);
if (G_UNLIKELY(g_use_pixmap)) {
GstVaapiPixmap * const pixmap = app->pixmaps[app->pixmap_id];
if (!gst_vaapi_pixmap_put_surface(pixmap, surface, crop_rect,
GST_VAAPI_PICTURE_STRUCTURE_FRAME))
SEND_ERROR("failed to render to pixmap");
if (!gst_vaapi_window_put_pixmap(app->window, pixmap, NULL, NULL))
SEND_ERROR("failed to render surface %" GST_VAAPI_ID_FORMAT,
GST_VAAPI_ID_ARGS(pixmap));
app->pixmap_id = (app->pixmap_id + 1) % G_N_ELEMENTS(app->pixmaps);
}
else if (!gst_vaapi_window_put_surface(app->window, surface,
crop_rect, 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)));
app->num_frames++;
render_frame_replace(&app->last_frame, rfp);
return TRUE;
#undef SEND_ERROR
send_error:
app_send_error(app, error);
return FALSE;
}
static gpointer
renderer_thread(gpointer data)
{
App * const app = data;
RenderFrame *rfp;
g_print("Render thread started\n");
while (!app->render_thread_cancel) {
rfp = g_async_queue_timeout_pop(app->decoder_queue, 1000000);
if (rfp && !renderer_process(app, rfp))
break;
}
return NULL;
}
static gboolean
flush_decoder_queue(App *app)
{
RenderFrame *rfp;
/* Flush pending surfaces */
do {
rfp = g_async_queue_try_pop(app->decoder_queue);
if (!rfp)
return TRUE;
} while (renderer_process(app, rfp));
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);
render_frame_replace(&app->last_frame, NULL);
return TRUE;
}
static void
app_free(App *app)
{
guint i;
if (!app)
return;
if (app->file) {
g_mapped_file_unref(app->file);
app->file = NULL;
}
g_free(app->file_name);
for (i = 0; i < G_N_ELEMENTS(app->pixmaps); i++)
gst_vaapi_pixmap_replace(&app->pixmaps[i], NULL);
gst_vaapi_decoder_replace(&app->decoder, NULL);
gst_vaapi_window_replace(&app->window, NULL);
gst_vaapi_display_replace(&app->display, NULL);
if (app->decoder_queue) {
g_async_queue_unref(app->decoder_queue);
app->decoder_queue = NULL;
}
g_cond_clear(&app->decoder_ready);
if (app->timer) {
g_timer_destroy(app->timer);
app->timer = NULL;
}
g_cond_clear(&app->render_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);
g_cond_init(&app->render_ready);
app_set_framerate(app, 60, 1);
app->window_width = 640;
app->window_height = 480;
app->decoder_queue = g_async_queue_new_full(
(GDestroyNotify)render_frame_free);
if (!app->decoder_queue)
goto error;
app->timer = g_timer_new();
if (!app->timer)
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 (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,
app->window_width, app->window_height);
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);
g_print("Decoded %u frames", app->num_frames);
if (g_benchmark) {
const gdouble elapsed = g_timer_elapsed(app->timer, NULL);
g_print(" in %.2f sec (%.1f fps)\n",
elapsed, (gdouble)app->num_frames / elapsed);
}
g_print("\n");
return TRUE;
}
int
main(int argc, char *argv[])
{
App *app;
gint ret;
if (!video_output_init(&argc, argv, g_options))
g_error("failed to initialize video output subsystem");
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);
video_output_exit();
return ret;
}