gstreamer/tests/simple-decoder.c

/*
 *  simple-decoder.c - Simple Decoder Application
 *
 *  Copyright (C) 2013-2014 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;
    case GST_VAAPI_CODEC_JPEG:
      app->decoder = gst_vaapi_decoder_jpeg_new (app->display, caps);
      break;
    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_try_new ("Decoder Thread", decoder_thread,
      app, 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_try_new ("Renderer Thread", renderer_thread,
      app, 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;
}