/*

 * Copyright (C) 2000-2005 the xine project

 *

 * Copyright (C) 2009-2013 Petri Hintukainen <phintuka@users.sourceforge.net>

 *

 * This file is part of xine, a free video player.

 *

 * xine 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; either version 2 of the License, or

 * (at your option) any later version.

 *

 * xine 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

 *

 * Input plugin for BluRay discs / images

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <pthread.h>

/* libbluray */

#include <libbluray/bluray.h>

#include <libbluray/bluray-version.h>

#include <libbluray/keys.h>

#include <libbluray/overlay.h>

#include <libbluray/meta_data.h>

/* xine */

#define LOG_MODULE "input_bluray"

#define LOG_VERBOSE

#define LOG

#define LOGMSG(x...)  xine_log (this->stream->xine, XINE_LOG_MSG, "input_bluray: " x);

#define XINE_ENGINE_INTERNAL  // stream->demux_plugin

#ifdef HAVE_CONFIG_H

# include "xine_internal.h"

# include "input_plugin.h"

#else

# include <xine/xine_internal.h>

# include <xine/input_plugin.h>

#endif

#ifndef XINE_VERSION_CODE

# error XINE_VERSION_CODE undefined !

#endif

#ifndef EXPORTED

#  define EXPORTED __attribute__((visibility("default")))

#endif

#ifndef MIN

# define MIN(a,b) ((a)<(b)?(a):(b))

#endif

#ifndef MAX

# define MAX(a,b) ((a)>(b)?(a):(b))

#endif

#define ALIGNED_UNIT_SIZE 6144

#define PKT_SIZE          192

#define TICKS_IN_MS       45

#define MIN_TITLE_LENGTH  180

typedef struct {

  input_class_t   input_class;

  xine_t         *xine;

  /* config */

  char           *mountpoint;

  char           *language;

  char           *country;

  int             region;

  int             parental;

} bluray_input_class_t;

typedef struct {

  BD_ARGB_BUFFER   buf;

  pthread_mutex_t  buf_lock;

} XINE_BD_ARGB_BUFFER;

static void osd_buf_lock(BD_ARGB_BUFFER *buf_gen)

{

  XINE_BD_ARGB_BUFFER *buf = (XINE_BD_ARGB_BUFFER*)buf_gen;

  pthread_mutex_lock(&buf->buf_lock);

}

static void osd_buf_unlock(BD_ARGB_BUFFER *buf_gen)

{

  XINE_BD_ARGB_BUFFER *buf = (XINE_BD_ARGB_BUFFER*)buf_gen;

  pthread_mutex_unlock(&buf->buf_lock);

}

static void osd_buf_init(XINE_BD_ARGB_BUFFER *buf)

{

  buf->buf.lock   = osd_buf_lock;

  buf->buf.unlock = osd_buf_unlock;

  pthread_mutex_init(&buf->buf_lock, NULL);

}

static void osd_buf_destroy(XINE_BD_ARGB_BUFFER *buf)

{

  if (buf->buf.lock) {

    buf->buf.lock   = NULL;

    buf->buf.unlock = NULL;

    pthread_mutex_destroy(&buf->buf_lock);

  }

}

typedef struct {

  input_plugin_t        input_plugin;

  xine_stream_t        *stream;

  xine_event_queue_t   *event_queue;

  xine_osd_t           *osd[2];

  XINE_BD_ARGB_BUFFER   osd_buf;

  bluray_input_class_t *class;

  char                 *mrl;

  char                 *disc_root;

  char                 *disc_name;

  BLURAY               *bdh;

  const BLURAY_DISC_INFO *disc_info;

  const META_DL          *meta_dl; /* disc library meta data */

  int                num_title_idx;     /* number of relevant playlists */

  int                current_title_idx;

  int                num_titles;        /* navigation mode, number of titles in disc index */

  int                current_title;     /* navigation mode, title from disc index */

  BLURAY_TITLE_INFO *title_info;

  pthread_mutex_t    title_info_mutex;  /* lock this when accessing title_info outside of input/demux thread */

  unsigned int       current_clip;

  time_t             still_end_time;

  int                pg_stream;

  uint8_t            nav_mode : 1;

  uint8_t            error : 1;

  uint8_t            menu_open : 1;

  uint8_t            stream_flushed : 1;

  uint8_t            demux_action_req : 1;

  uint8_t            end_of_title : 1;

  uint8_t            pg_enable : 1;

  uint8_t            has_video : 1;

  int                mouse_inside_button;

} bluray_input_plugin_t;

/*

 * overlay

 */

#define PALETTE_INDEX_BACKGROUND 0xff

static void send_num_buttons(bluray_input_plugin_t *this, int n)

{

  xine_event_t   event;

  xine_ui_data_t data;

  event.type = XINE_EVENT_UI_NUM_BUTTONS;

  event.data = &dat;;

  event.data_length = sizeof(data);

  data.num_buttons = n;

  xine_event_send(this->stream, &event);

}

static void clear_overlay(xine_osd_t *osd)

{

  /* palette entry 0xff is background --> can't use xine_osd_clear(). */

  memset(osd->osd.area, PALETTE_INDEX_BACKGROUND, osd->osd.width * osd->osd.height);

  osd->osd.x1 = osd->osd.width;

  osd->osd.y1 = osd->osd.height;

  osd->osd.x2 = 0;

  osd->osd.y2 = 0;

  osd->osd.area_touched = 0;

}

static void close_overlay(bluray_input_plugin_t *this, int plane)

{

  if (plane < 0) {

    close_overlay(this, 0);

    close_overlay(this, 1);

    return;

  }

  if (plane < 2 && this->osd[plane]) {

    xine_osd_free(this->osd[plane]);

    this->osd[plane] = NULL;

    free(this->osd_buf.buf.buf[plane]);

    this->osd_buf.buf.buf[plane] = NULL;

  }

}

static void open_overlay(bluray_input_plugin_t *this, int plane, uint16_t x, uint16_t y, uint16_t w, uint16_t h)

{

  if (this->osd[plane]) {

    close_overlay(this, plane);

  }

  this->osd[plane] = xine_osd_new(this->stream, x, y, w, h);

  if (xine_osd_get_capabilities(this->osd[plane]) & XINE_OSD_CAP_ARGB_LAYER) {

    this->osd_buf.buf.width = w;

    this->osd_buf.buf.height = h;

    this->osd_buf.buf.buf[plane] = calloc(sizeof(uint32_t), w * h);

  }

  clear_overlay(this->osd[plane]);

}

static xine_osd_t *get_overlay(bluray_input_plugin_t *this, int plane)

{

  if (!this->osd[plane]) {

    open_overlay(this, plane, 0, 0, 1920, 1080);

  }

  if (!this->pg_enable) {

    _x_select_spu_channel(this->stream, -1);

  }

  this->stream->video_out->enable_ovl(this->stream->video_out, 1);

  return this->osd[plane];

}

static void draw_bitmap(xine_osd_t *osd, const BD_OVERLAY * const ov)

{

  unsigned i;

  /* convert and set palette */

  if (ov->palette) {

    uint32_t color[256];

    uint8_t  trans[256];

    for(i = 0; i < 256; i++) {

      trans[i] = ov->palette[i].T;

      color[i] = (ov->palette[i].Y << 16) | (ov->palette[i].Cr << 8) | ov->palette[i].Cb;

    }

    xine_osd_set_palette(osd, color, trans);

  }

  /* uncompress and draw bitmap */

  if (ov->img) {

    const BD_PG_RLE_ELEM *rlep = ov->img;

    uint8_t *img = malloc(ov->w * ov->h);

    unsigned pixels = ov->w * ov->h;

    for (i = 0; i < pixels; i += rlep->len, rlep++) {

      memset(img + i, rlep->color, rlep->len);

    }

    xine_osd_draw_bitmap(osd, img, ov->x, ov->y, ov->w, ov->h, NULL);

    free(img);

  }

}

static void overlay_proc(void *this_gen, const BD_OVERLAY * const ov)

{

  bluray_input_plugin_t *this = (bluray_input_plugin_t *) this_gen;

  xine_osd_t *osd;

  int64_t vpts;

  if (!this) {

    return;

  }

  if (!ov) {

    /* hide OSD */

    close_overlay(this, -1);

    return;

  }

  if (ov->plane > 1) {

    return;

  }

  switch (ov->cmd) {

    case BD_OVERLAY_INIT:    /* init overlay plane. Size of full plane in x,y,w,h */

      open_overlay(this, ov->plane, ov->x, ov->y, ov->w, ov->h);

      return;

    case BD_OVERLAY_CLOSE:   /* close overlay */

      close_overlay(this, ov->plane);

      return;

  }

  osd = get_overlay(this, ov->plane);

  vpts = 0;

  if (ov->pts > 0) {

    vpts = this->stream->metronom->got_spu_packet (this->stream->metronom, ov->pts);

  }

  switch (ov->cmd) {

    case BD_OVERLAY_DRAW:    /* draw bitmap (x,y,w,h,img,palette) */

      draw_bitmap(osd, ov);

      return;

    case BD_OVERLAY_WIPE:    /* clear area (x,y,w,h) */

      xine_osd_draw_rect(osd, ov->x, ov->y, ov->x + ov->w - 1, ov->y + ov->h - 1, PALETTE_INDEX_BACKGROUND, 1);

      return;

    case BD_OVERLAY_CLEAR:   /* clear plane */

      clear_overlay(osd);

      return;

    case BD_OVERLAY_HIDE:

      osd->osd.area_touched = 0; /* will be hiden at next commit time */

      break;

    case BD_OVERLAY_FLUSH:   /* all changes have been done, flush overlay to display at given pts */

      if (!osd->osd.area_touched) {

        xine_osd_hide(osd, vpts);

      } else {

        xine_osd_show(osd, vpts);

      }

      return;

    default:

      LOGMSG("unknown overlay command %d", ov->cmd);

      return;

  }

}

static void argb_overlay_proc(void *this_gen, const BD_ARGB_OVERLAY * const ov)

{

  bluray_input_plugin_t *this = (bluray_input_plugin_t *) this_gen;

  xine_osd_t *osd;

  int64_t vpts;

  if (!this) {

    return;

  }

  if (!ov) {

    /* hide OSD */

    close_overlay(this, -1);

    return;

  }

  vpts = 0;

  if (ov->pts > 0) {

    vpts = this->stream->metronom->got_spu_packet (this->stream->metronom, ov->pts);

  }

  switch (ov->cmd) {

    case BD_ARGB_OVERLAY_INIT:

      open_overlay(this, ov->plane, 0, 0, ov->w, ov->h);

      return;

    case BD_ARGB_OVERLAY_CLOSE:

      close_overlay(this, ov->plane);

      return;

    case BD_ARGB_OVERLAY_DRAW:

      /* nothing to do */

      return;

    case BD_ARGB_OVERLAY_FLUSH:

      osd = get_overlay(this, ov->plane);

      xine_osd_set_argb_buffer(osd, this->osd_buf.buf.buf[ov->plane],

                               this->osd_buf.buf.dirty[ov->plane].x0,

                               this->osd_buf.buf.dirty[ov->plane].y0,

                               this->osd_buf.buf.dirty[ov->plane].x1 - this->osd_buf.buf.dirty[ov->plane].x0 + 1,

                               this->osd_buf.buf.dirty[ov->plane].y1 - this->osd_buf.buf.dirty[ov->plane].y0 + 1);

      xine_osd_show(osd, vpts);

      return;

   default:

      lprintf("unknown ARGB overlay command %d\n", ov->cmd);

      return;

  }

}

/*

 * stream info

 */

static void update_stream_info(bluray_input_plugin_t *this)

{

  if (this->title_info) {

    /* set stream info */

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_ANGLE_COUNT,    this->title_info->angle_count);

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_ANGLE_NUMBER,   bd_get_current_angle(this->bdh));

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_HAS_CHAPTERS,       this->title_info->chapter_count > 0);

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_CHAPTER_COUNT,  this->title_info->chapter_count);

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_CHAPTER_NUMBER, bd_get_current_chapter(this->bdh) + 1);

  }

}

static void update_title_name(bluray_input_plugin_t *this)

{

  char           title_name[64] = "";

  xine_ui_data_t udata;

  xine_event_t   uevent = {

    .type        = XINE_EVENT_UI_SET_TITLE,

    .stream      = this->stream,

    .data        = &udata,

    .data_length = sizeof(udata)

  };

  /* check disc library metadata */

  if (this->meta_dl) {

    unsigned i;

    for (i = 0; i < this->meta_dl->toc_count; i++)

      if (this->meta_dl->toc_entries[i].title_number == (unsigned)this->current_title)

        if (this->meta_dl->toc_entries[i].title_name)

          if (strlen(this->meta_dl->toc_entries[i].title_name) > 2)

            strncpy(title_name, this->meta_dl->toc_entries[i].title_name, sizeof(title_name));

  }

  /* title name */

  if (title_name[0]) {

  } else if (this->current_title == BLURAY_TITLE_TOP_MENU) {

    strcpy(title_name, "Top Menu");

  } else if (this->current_title == BLURAY_TITLE_FIRST_PLAY) {

    strcpy(title_name, "First Play");

  } else if (this->nav_mode) {

    snprintf(title_name, sizeof(title_name), "Title %d/%d (PL %d/%d)",

             this->current_title, this->num_titles,

             this->current_title_idx + 1, this->num_title_idx);

  } else {

    snprintf(title_name, sizeof(title_name), "Title %d/%d",

             this->current_title_idx + 1, this->num_title_idx);

  }

  /* disc name */

  if (this->disc_name && this->disc_name[0]) {

    udata.str_len = snprintf(udata.str, sizeof(udata.str), "%s, %s",

                             this->disc_name, title_name);

  } else {

    udata.str_len = snprintf(udata.str, sizeof(udata.str), "%s",

                             title_name);

  }

  _x_meta_info_set(this->stream, XINE_META_INFO_TITLE, udata.str);

  xine_event_send(this->stream, &uevent);

}

static void update_title_info(bluray_input_plugin_t *this, int playlist_id)

{

  /* update title_info */

  pthread_mutex_lock(&this->title_info_mutex);

  if (this->title_info)

    bd_free_title_info(this->title_info);

  if (playlist_id < 0)

    this->title_info = bd_get_title_info(this->bdh, this->current_title_idx, 0);

  else

    this->title_info = bd_get_playlist_info(this->bdh, playlist_id, 0);

  pthread_mutex_unlock(&this->title_info_mutex);

  if (!this->title_info) {

    LOGMSG("bd_get_title_info(%d) failed\n", this->current_title_idx);

    return;

  }

  /* calculate and set stream rate */

  uint64_t rate = bd_get_title_size(this->bdh) * UINT64_C(8) // bits

                  * INT64_C(90000)

                  / (uint64_t)(this->title_info->duration);

  _x_stream_info_set(this->stream, XINE_STREAM_INFO_BITRATE, rate);

  /* set stream info */

  if (this->nav_mode) {

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_TITLE_COUNT,  this->num_titles);

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_TITLE_NUMBER, this->current_title);

  } else {

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_TITLE_COUNT,  this->num_title_idx);

    _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_TITLE_NUMBER, this->current_title_idx + 1);

  }

  update_stream_info(this);

  /* set title name */

  update_title_name(this);

}

/*

 * libbluray event handling

 */

static void stream_flush(bluray_input_plugin_t *this)

{

  if (this->stream_flushed || !this->stream)

    return;

  lprintf("Stream flush\n");

  this->stream_flushed = 1;

  xine_event_t event = {

    .type        = XINE_EVENT_END_OF_CLIP,

    .stream      = this->stream,

    .data        = NULL,

    .data_length = 0,

  };

  xine_event_send (this->stream, &event);

  this->demux_action_req = 1;

}

static void stream_reset(bluray_input_plugin_t *this)

{

  if (!this || !this->stream)

    return;

  lprintf("Stream reset\n");

  xine_event_t event = {

    .type        = XINE_EVENT_PIDS_CHANGE,

    .stream      = this->stream,

    .data        = NULL,

    .data_length = 0,

  };

  if (!this->end_of_title) {

    _x_demux_flush_engine(this->stream);

  }

  xine_event_send (this->stream, &event);

  this->demux_action_req = 1;

}

static void wait_secs(bluray_input_plugin_t *this, unsigned seconds)

{

  stream_flush(this);

  if (this->still_end_time) {

    if (time(NULL) >= this->still_end_time) {

      lprintf("pause end\n");

      this->still_end_time = 0;

      bd_read_skip_still(this->bdh);

      stream_reset(this);

      return;

    }

  }

  else if (seconds) {

    if (seconds > 300) {

      seconds = 300;

    }

    lprintf("still image, pause for %d seconds\n", seconds);

    this->still_end_time = time(NULL) + seconds;

  }

  xine_usec_sleep(40*1000);

}

static void update_spu_channel(bluray_input_plugin_t *this, int channel)

{

  if (this->stream->video_fifo) {

    buf_element_t *buf = this->stream->video_fifo->buffer_pool_alloc(this->stream->video_fifo);

    buf->type = BUF_CONTROL_SPU_CHANNEL;

    buf->decoder_info[0] = channel;

    buf->decoder_info[1] = channel;

    buf->decoder_info[2] = channel;

    this->stream->video_fifo->put(this->stream->video_fifo, buf);

  }

}

static void update_audio_channel(bluray_input_plugin_t *this, int channel)

{

  if (this->stream->audio_fifo) {

    buf_element_t *buf = this->stream->audio_fifo->buffer_pool_alloc(this->stream->audio_fifo);

    buf->type = BUF_CONTROL_AUDIO_CHANNEL;

    buf->decoder_info[0] = channel;

    this->stream->audio_fifo->put(this->stream->audio_fifo, buf);

  }

}

static void handle_libbluray_event(bluray_input_plugin_t *this, BD_EVENT ev)

{

    switch ((bd_event_e)ev.event) {

      case BD_EVENT_ERROR:

        lprintf("BD_EVENT_ERROR\n");

        _x_message (this->stream, XINE_MSG_GENERAL_WARNING,

                    "Error playing BluRay disc", NULL);

        this->error = 1;

        return;

      case BD_EVENT_READ_ERROR:

        LOGMSG("m2ts file read error");

        /*stream_flush(this); leave error detection and handling for upper layer */

        return;

      case BD_EVENT_ENCRYPTED:

        lprintf("BD_EVENT_ENCRYPTED\n");

        _x_message (this->stream, XINE_MSG_ENCRYPTED_SOURCE,

                    "Media stream scrambled/encrypted", NULL);

        this->error = 1;

        return;

      /* playback control */

      case BD_EVENT_SEEK:

        lprintf("BD_EVENT_SEEK\n");

        this->still_end_time = 0;

        stream_reset(this);

        break;

      case BD_EVENT_STILL_TIME:

        lprintf("BD_EVENT_STILL_TIME %d\n", ev.param);

        wait_secs(this, ev.param);

        break;

      case BD_EVENT_STILL:

        lprintf("BD_EVENT_STILL %d\n", ev.param);

        int paused = _x_get_fine_speed(this->stream) == XINE_SPEED_PAUSE;

        if (paused != ev.param) {

          _x_set_fine_speed(this->stream, ev.param ? XINE_SPEED_PAUSE : XINE_SPEED_NORMAL);

        }

        break;

      case BD_EVENT_IDLE:

        xine_usec_sleep(10000);

        break;

      /* playback position */

      case BD_EVENT_ANGLE:

        lprintf("BD_EVENT_ANGLE_NUMBER %d\n", ev.param);

        _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_ANGLE_NUMBER, ev.param);

        break;

      case BD_EVENT_END_OF_TITLE:

        lprintf("BD_EVENT_END_OF_TITLE\n");

        stream_flush(this);

        this->end_of_title = 1;

        break;

      case BD_EVENT_TITLE:

        this->current_title = ev.param;

        break;

      case BD_EVENT_PLAYLIST:

        lprintf("BD_EVENT_PLAYLIST %d\n", ev.param);

        this->current_title_idx = bd_get_current_title(this->bdh);

        this->current_clip = 0;

        update_title_info(this, ev.param);

        stream_reset(this);

        this->end_of_title = 0;

        break;

      case BD_EVENT_PLAYITEM:

        lprintf("BD_EVENT_PLAYITEM %d\n", ev.param);

        this->current_clip = ev.param;

        this->still_end_time = 0;

        break;

      case BD_EVENT_CHAPTER:

        lprintf("BD_EVENT_CHAPTER %d\n", ev.param);

        _x_stream_info_set(this->stream, XINE_STREAM_INFO_DVD_CHAPTER_NUMBER, ev.param);

        break;

      /* stream selection */

      case BD_EVENT_AUDIO_STREAM:

        lprintf("BD_EVENT_AUDIO_STREAM %d\n", ev.param);

        if (ev.param < 32) {

          update_audio_channel(this, ev.param - 1);

        } else {

          update_audio_channel(this, 0);

        }

        break;

      case BD_EVENT_PG_TEXTST:

        lprintf("BD_EVENT_PG_TEXTST %s\n", ev.param ? "ON" : "OFF");

        this->pg_enable = !!ev.param;

        update_spu_channel(this, this->pg_enable ? this->pg_stream : -1);

        break;

      case BD_EVENT_PG_TEXTST_STREAM:

        lprintf("BD_EVENT_PG_TEXTST_STREAM %d\n", ev.param);

        if (ev.param < 64) {

          this->pg_stream = ev.param - 1;

        } else {

          this->pg_stream = -1;

        }

        if (this->pg_enable) {

          update_spu_channel(this, this->pg_stream);

        }

        break;

      case BD_EVENT_MENU:

        this->menu_open = !!ev.param;

        send_num_buttons(this, ev.param);

        break;

      case BD_EVENT_IG_STREAM:

      case BD_EVENT_SECONDARY_AUDIO:

      case BD_EVENT_SECONDARY_AUDIO_STREAM:

      case BD_EVENT_SECONDARY_VIDEO:

      case BD_EVENT_SECONDARY_VIDEO_SIZE:

      case BD_EVENT_SECONDARY_VIDEO_STREAM:

      case BD_EVENT_NONE:

        break;

      default:

        LOGMSG("unhandled libbluray event %d [param %d]\n", ev.event, ev.param);

        break;

    }

}

static void handle_libbluray_events(bluray_input_plugin_t *this)

{

  BD_EVENT ev;

  while (bd_get_event(this->bdh, &ev)) {

    handle_libbluray_event(this, ev);

    if (this->error || ev.event == BD_EVENT_NONE || ev.event == BD_EVENT_ERROR)

      break;

  }

}

/*

 * xine event handling

 */

static int open_title (bluray_input_plugin_t *this, int title_idx)

{

  if (bd_select_title(this->bdh, title_idx) <= 0) {

    LOGMSG("bd_select_title(%d) failed\n", title_idx);

    return 0;

  }

  this->current_title_idx = title_idx;

  update_title_info(this, -1);

  return 1;

}

static void send_mouse_enter_leave_event(bluray_input_plugin_t *this, int direction)

{

  if (direction != this->mouse_inside_button) {

    xine_event_t        event;

    xine_spu_button_t   spu_event;

    spu_event.direction = direction;

    spu_event.button    = 1;

    event.type        = XINE_EVENT_SPU_BUTTON;

    event.stream      = this->stream;

    event.data        = &spu_event;

    event.data_length = sizeof(spu_event);

    xine_event_send(this->stream, &event);

    this->mouse_inside_button = direction;

  }

}

static void handle_events(bluray_input_plugin_t *this)

{

  xine_event_t *event;

  if (!this->event_queue)

    return;

  while (NULL != (event = xine_event_get(this->event_queue))) {

    if (!this->bdh || !this->title_info) {

      xine_event_free(event);

      return;

    }

    int64_t pts = xine_get_current_vpts(this->stream) -

      this->stream->metronom->get_option(this->stream->metronom, METRONOM_VPTS_OFFSET);

    if (this->menu_open) {

      switch (event->type) {

        case XINE_EVENT_INPUT_LEFT:  bd_user_input(this->bdh, pts, BD_VK_LEFT);  break;

        case XINE_EVENT_INPUT_RIGHT: bd_user_input(this->bdh, pts, BD_VK_RIGHT); break;

      }

    } else {

      switch (event->type) {

        case XINE_EVENT_INPUT_LEFT:

          lprintf("XINE_EVENT_INPUT_LEFT: previous title\n");

          if (!this->nav_mode) {

            open_title(this, MAX(0, this->current_title_idx - 1));

          } else {

            bd_play_title(this->bdh, MAX(1, this->current_title - 1));

          }

          stream_reset(this);

          break;

        case XINE_EVENT_INPUT_RIGHT:

          lprintf("XINE_EVENT_INPUT_RIGHT: next title\n");

          if (!this->nav_mode) {

            open_title(this, MIN(this->num_title_idx - 1, this->current_title_idx + 1));

          } else {

            bd_play_title(this->bdh, MIN(this->num_titles, this->current_title + 1));

          }

          stream_reset(this);

          break;

      }

    }

    switch (event->type) {

      case XINE_EVENT_INPUT_MOUSE_BUTTON: {

        xine_input_data_t *input = event->data;

        lprintf("mouse click: button %d at (%d,%d)\n", input->button, input->x, input->y);

        if (input->button == 1) {

          bd_mouse_select(this->bdh, pts, input->x, input->y);

          bd_user_input(this->bdh, pts, BD_VK_MOUSE_ACTIVATE);

          send_mouse_enter_leave_event(this, 0);

        }

        break;

      }

      case XINE_EVENT_INPUT_MOUSE_MOVE: {

        xine_input_data_t *input = event->data;

        if (bd_mouse_select(this->bdh, pts, input->x, input->y) > 0) {

          send_mouse_enter_leave_event(this, 1);

        } else {

          send_mouse_enter_leave_event(this, 0);

        }

        break;

      }

      case XINE_EVENT_INPUT_MENU1:

        if (!this->disc_info->top_menu_supported) {

          _x_message (this->stream, XINE_MSG_GENERAL_WARNING,

                      "Can't open Top Menu",

                      "Top Menu title not supported", NULL);

        }

        bd_menu_call(this->bdh, pts);

        break;

      case XINE_EVENT_INPUT_MENU2:     bd_user_input(this->bdh, pts, BD_VK_POPUP); break;

      case XINE_EVENT_INPUT_UP:        bd_user_input(this->bdh, pts, BD_VK_UP);    break;

      case XINE_EVENT_INPUT_DOWN:      bd_user_input(this->bdh, pts, BD_VK_DOWN);  break;

      case XINE_EVENT_INPUT_SELECT:    bd_user_input(this->bdh, pts, BD_VK_ENTER); break;

      case XINE_EVENT_INPUT_NUMBER_0:  bd_user_input(this->bdh, pts, BD_VK_0); break;

      case XINE_EVENT_INPUT_NUMBER_1:  bd_user_input(this->bdh, pts, BD_VK_1); break;

      case XINE_EVENT_INPUT_NUMBER_2:  bd_user_input(this->bdh, pts, BD_VK_2); break;

      case XINE_EVENT_INPUT_NUMBER_3:  bd_user_input(this->bdh, pts, BD_VK_3); break;

      case XINE_EVENT_INPUT_NUMBER_4:  bd_user_input(this->bdh, pts, BD_VK_4); break;

      case XINE_EVENT_INPUT_NUMBER_5:  bd_user_input(this->bdh, pts, BD_VK_5); break;

      case XINE_EVENT_INPUT_NUMBER_6:  bd_user_input(this->bdh, pts, BD_VK_6); break;

      case XINE_EVENT_INPUT_NUMBER_7:  bd_user_input(this->bdh, pts, BD_VK_7); break;

      case XINE_EVENT_INPUT_NUMBER_8:  bd_user_input(this->bdh, pts, BD_VK_8); break;

      case XINE_EVENT_INPUT_NUMBER_9:  bd_user_input(this->bdh, pts, BD_VK_9); break;

      case XINE_EVENT_INPUT_NEXT: {

        cfg_entry_t* entry = this->class->xine->config->lookup_entry(this->class->xine->config,

                                                                     "media.bluray.skip_behaviour");

        switch (entry->num_value) {

          case 0: /* skip by chapter */

            bd_seek_chapter(this->bdh, bd_get_current_chapter(this->bdh) + 1);